home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c480 / 19.ddi / SAMPLES / DBWIN / NFYFMT.C_ / NFYFMT.C
Encoding:
C/C++ Source or Header  |  1993-02-08  |  9.3 KB  |  327 lines
  1. #include "dbwindlp.h"
  2.  
  3. static char szTaskName[10];
  4. static char szProcName[80];
  5.  
  6. int GetProcName(LPSTR lpsz, FARPROC lpfn)
  7. {
  8.     GLOBALENTRY ge;
  9.     MODULEENTRY me;
  10.     int cch;
  11.  
  12.     cch = 0;
  13.     ge.dwSize = sizeof(ge);
  14.     me.dwSize = sizeof(me);
  15.     if (GlobalEntryHandle(&ge, (HGLOBAL)HIWORD(lpfn)) &&
  16.             (ge.wType == GT_CODE) &&
  17.             ModuleFindHandle(&me, ge.hOwner) )
  18.     {
  19.         cch = dbprintf(lpsz, "%s(%d)%x:%x", (LPSTR)me.szModule, ge.wData);
  20.     }
  21.     return cch + dbprintf(lpsz, "%x:%x", HIWORD(lpfn), LOWORD(lpfn));
  22. }
  23.  
  24. int GetTaskName(LPSTR lpsz, HTASK htask)
  25. {
  26.     TASKENTRY te;
  27.  
  28.     te.dwSize = sizeof(te);
  29.     if (TaskFindHandle(&te, htask))
  30.         return dbprintf(lpsz, "%s", (LPSTR)te.szModule);
  31.     else
  32.         return dbprintf(lpsz, "%x", htask);
  33. }
  34.  
  35. // FatalExit notification formatting
  36. //
  37. void FormatRip(LPSTR lpsz, NFYRIP FAR* lprip)
  38. {
  39.     GetTaskName(szTaskName, GetCurrentTask());
  40.  
  41.     dbprintf(lpsz, "%s: FatalExit(%x) at CS:IP=%x:%x SS:BP=%x:%x\r\n",
  42.             (LPSTR)szTaskName,
  43.             lprip->wExitCode,
  44.             lprip->wCS, lprip->wIP,
  45.             lprip->wSS, lprip->wBP);
  46. }
  47.  
  48. // LogParamError notification formatting
  49. //
  50. #define FMT_WORD    0
  51. #define FMT_DWORD   1
  52. #define FMT_LP      2
  53.  
  54. struct TYPEMAP
  55. {
  56.     UINT err;
  57.     char* szType;
  58.     char* szFmt;
  59. };
  60.  
  61. static char szParam[] = "parameter";
  62. static char szD16[] = "%s %s: Invalid %s: %d\r\n";
  63. static char szX16[] = "%s %s: Invalid %s: %x\r\n";
  64. static char szX32[] = "%s %s: Invalid %s: %x%x\r\n";
  65. static char szLP[]  = "%s %s: Invalid %s: %x:%x\r\n";
  66.  
  67. #define DEFMAP(err, type, fmt) \
  68.     { err, type, fmt }
  69.  
  70. struct TYPEMAP typemap[] =
  71. {
  72.     DEFMAP(ERR_BAD_VALUE,        "value",        szD16),
  73.     DEFMAP(ERR_BAD_INDEX,        "index",        szD16),
  74.     DEFMAP(ERR_BAD_FLAGS,        "flags",        szX16),
  75.     DEFMAP(ERR_BAD_SELECTOR,     "selector",     szX16),
  76.     DEFMAP(ERR_BAD_DFLAGS,       "flags",        szX32),
  77.     DEFMAP(ERR_BAD_DVALUE,       "value",        szX32),
  78.     DEFMAP(ERR_BAD_DINDEX,       "index",        szX32),
  79.     DEFMAP(ERR_BAD_PTR,          "pointer",      szLP),
  80.     DEFMAP(ERR_BAD_FUNC_PTR,     "function pointer", szLP),
  81.     DEFMAP(ERR_BAD_STRING_PTR,   "string pointer", szLP),
  82.     DEFMAP(ERR_BAD_HINSTANCE,    "HINSTANCE",    szX16),
  83.     DEFMAP(ERR_BAD_HMODULE,      "HMODULE",      szX16),
  84.     DEFMAP(ERR_BAD_GLOBAL_HANDLE,"global handle", szX16),
  85.     DEFMAP(ERR_BAD_LOCAL_HANDLE, "local handle", szX16),
  86.     DEFMAP(ERR_BAD_ATOM,         "atom",         szX16),
  87.     DEFMAP(ERR_BAD_HWND,         "HWND",         szX16),
  88.     DEFMAP(ERR_BAD_HMENU,        "HMENU",        szX16),
  89.     DEFMAP(ERR_BAD_HCURSOR,      "HCURSOR",      szX16),
  90.     DEFMAP(ERR_BAD_HICON,        "HICON",        szX16),
  91.     DEFMAP(ERR_BAD_GDI_OBJECT,   "HGDIOBJ",      szX16),
  92.     DEFMAP(ERR_BAD_HDC,          "HDC",          szX16),
  93.     DEFMAP(ERR_BAD_HPEN,         "HPEN",         szX16),
  94.     DEFMAP(ERR_BAD_HFONT,        "HFONT",        szX16),
  95.     DEFMAP(ERR_BAD_HBRUSH,       "HBRUSH",       szX16),
  96.     DEFMAP(ERR_BAD_HBITMAP,      "HBITMAP",      szX16),
  97.     DEFMAP(ERR_BAD_HRGN,         "HRGN",         szX16),
  98.     DEFMAP(ERR_BAD_HPALETTE,     "HPALETTE",     szX16),
  99.     DEFMAP(ERR_BAD_HANDLE,       "HANDLE",       szX16),
  100.     DEFMAP(ERR_BAD_HFILE,        "HFILE",        szX16),
  101.     DEFMAP(ERR_BAD_HMETAFILE,    "HMETAFILE",    szX16),
  102.     DEFMAP(ERR_BAD_CID,          "CID",          szX16),
  103.     DEFMAP(ERR_BAD_HDRVR,        "HDRVR",        szX16),
  104.     DEFMAP(ERR_BAD_HDWP,         "HDWP",         szX16)
  105. };
  106.  
  107. void FormatLogParamError(LPSTR lpsz, NFYLOGPARAMERROR FAR* lplpe)
  108. {
  109.     UINT err;
  110.     char* pszFmt;
  111.     char* pszType;
  112.     int i;
  113.     void FAR* FAR* param = lplpe->lpBadParam;
  114.  
  115.     pszFmt  = szX32;
  116.     pszType = szParam;
  117.     err = (lplpe->wErrCode & ~ERR_WARNING);
  118.     for (i = 0; i < (sizeof(typemap) / sizeof(struct TYPEMAP)); i++)
  119.     {
  120.         if (typemap[i].err == err)
  121.         {
  122.             pszFmt = typemap[i].szFmt;
  123.             pszType = typemap[i].szType;
  124.             break;
  125.         }
  126.     }
  127.  
  128.     if (lplpe->wErrCode & ERR_WARNING)
  129.     {
  130.         lstrcpy(lpsz, "wn ");
  131.         lpsz += 3;
  132.     }
  133.     else
  134.     {
  135.         lpsz = lstrcpy(lpsz, "err ");
  136.         lpsz += 4;
  137.     }
  138.  
  139.     GetTaskName(szTaskName, GetCurrentTask());
  140.     GetProcName(szProcName, lplpe->lpfnErrorAddr);
  141.  
  142.     if (pszFmt == szLP)
  143.         dbprintf(lpsz, pszFmt, (LPSTR)szTaskName, (LPSTR)szProcName, (LPSTR)pszType, SELECTOROF(param), OFFSETOF(param));
  144.     else if (pszFmt == szX32)
  145.         dbprintf(lpsz, pszFmt, (LPSTR)szTaskName, (LPSTR)szProcName, (LPSTR)pszType, (DWORD)param);
  146.     else
  147.         dbprintf(lpsz, pszFmt, (LPSTR)szTaskName, (LPSTR)szProcName, (LPSTR)pszType, (WORD)(DWORD)param);
  148. }
  149.  
  150. // LogError notification formatting
  151. //
  152. struct ERRMAP
  153. {
  154.     UINT err;
  155.     char* szErr;
  156. };
  157.  
  158. struct ERRMAP errmap[] =
  159.   {
  160.     { ERR_GALLOC,     "GlobalAlloc failed" },
  161.     { ERR_GREALLOC,   "GlobalReAlloc failed" },
  162.     { ERR_GLOCK,      "GlobalLock failed" },
  163.     { ERR_LALLOC,     "LocalAlloc failed" },
  164.     { ERR_LREALLOC,   "LocalReAlloc failed" },
  165.     { ERR_LLOCK,      "LocalLock failed" },
  166.     { ERR_ALLOCRES,   "AllocResource failed" },
  167.     { ERR_LOCKRES,    "LockResource failed" },
  168.     { ERR_LOADMODULE, "LoadModule failed" },
  169.  
  170.     { ERR_CREATEDLG,  "CreateDialog() failed: Couldn't load menu or create window" },
  171.     { ERR_CREATEDLG2, "CreateDialog() failed: Couldn't create window" },
  172.     { ERR_REGISTERCLASS, "RegisterClass failed: Class already exists" },
  173.     { ERR_DCBUSY,     "DC Cache full: Too many GetDC() calls" },
  174.     { ERR_CREATEWND,  "CreateWindow failed: Window class not found" },
  175.     { ERR_STRUCEXTRA, "Unallocated extra window/class word index used" },
  176.     { ERR_LOADSTR,    "LoadString() failed" },
  177.     { ERR_LOADMENU,   "LoadMenu() failed" },
  178.     { ERR_NESTEDBEGINPAINT, "Nested BeginPaint() calls" },
  179.     { ERR_BADINDEX,   "Invalid window word index value" },
  180.     { ERR_CREATEMENU, "CreateMenu failed" },
  181.  
  182.     { ERR_CREATEDC,   "CreateDC failed" },
  183.     { ERR_CREATEMETA, "CreateMetafile: Can't create metafile" },
  184.     { ERR_SELBITMAP,  "Bitmap already selected" },
  185.     { ERR_DELOBJSELECTED, "Selected object deleted" }
  186.   };
  187.  
  188. #define ERR_SIZEMASK   (ERR_BYTE | ERR_WORD | ERR_DWORD)
  189.  
  190. void FormatLogError(LPSTR lpsz, NFYLOGERROR FAR* lple)
  191. {
  192.     int i;
  193.     char* pszErr;
  194.     UINT err;
  195.     int cch;
  196.  
  197.     err = (lple->wErrCode & ~(ERR_WARNING | ERR_SIZEMASK));
  198.  
  199.     pszErr = "";
  200.     for (i = 0; i < sizeof(errmap) / sizeof(struct ERRMAP); i++)
  201.     {
  202.         if (err == errmap[i].err)
  203.         {
  204.             pszErr = errmap[i].szErr;
  205.             break;
  206.         }
  207.     }
  208.  
  209.     GetTaskName(szTaskName, GetCurrentTask());
  210.  
  211.     if (lple->wErrCode & ERR_WARNING)
  212.     {
  213.         cch = dbprintf(lpsz, "%s: Warning %x: %s",
  214.                 (LPSTR)szTaskName, lple->wErrCode, (LPSTR)pszErr);
  215.     }
  216.     else
  217.     {
  218.         cch = dbprintf(lpsz, "%s: Error %x: %s",
  219.                 (LPSTR)szTaskName, lple->wErrCode, (LPSTR)pszErr);
  220.     }
  221.  
  222.     lpsz += cch;
  223.  
  224.     switch (lple->wErrCode & ERR_SIZEMASK)
  225.     {
  226.     case ERR_BYTE:
  227.         dbprintf(lpsz, "%x\r\n", LOBYTE(LOWORD(lple->lpInfo)));
  228.         break;
  229.     case ERR_WORD:
  230.         dbprintf(lpsz, "%x\r\n", LOWORD(lple->lpInfo));
  231.         break;
  232.     case ERR_DWORD:
  233.         dbprintf(lpsz, "%x%x\r\n", HIWORD(lple->lpInfo), LOWORD(lple->lpInfo));
  234.         break;
  235.     default:
  236.         dbprintf(lpsz, "\r\n");
  237.     }
  238. }
  239.  
  240. int _cdecl dbprintf(LPSTR lpszOut, LPCSTR lpszFmt, ...)
  241. {
  242.     LPSTR lpsz = lpszOut;
  243.     BYTE FAR* lpArgs = (BYTE FAR*)(&lpszFmt + 1);
  244.     char ch;
  245.  
  246.     while ((ch = *lpszFmt++) != 0)
  247.     {
  248.         if (ch != '%')
  249.         {
  250.             *lpsz++ = ch;
  251.             continue;
  252.         }
  253.         switch (*lpszFmt++)
  254.         {
  255.         case 0:
  256.             lpszFmt--;
  257.             break;
  258.  
  259.         case '%':
  260.             *lpsz++ = '%';
  261.             break;
  262.  
  263.         case 'x':
  264.             lpsz = HexOut(lpsz, *(WORD FAR*)lpArgs);
  265.             lpArgs += sizeof(WORD);
  266.             break;
  267.  
  268.         case 'd':
  269.             lpsz = DecOut(lpsz, *(short FAR*)lpArgs);
  270.             lpArgs += sizeof(WORD);
  271.             break;
  272.  
  273.         case 's':
  274.             {
  275.                 LPCSTR lpszSrc = *(LPCSTR FAR*)lpArgs;
  276.                 lpArgs += sizeof(LPCSTR);
  277.  
  278.                 while (*lpszSrc)
  279.                     *lpsz++ = *lpszSrc++;
  280.             }
  281.             break;
  282.         }
  283.     }
  284.     *lpsz = 0;
  285.  
  286.     return lpsz - lpszOut;
  287. }
  288.  
  289. LPSTR HexOut(LPSTR lpch, WORD value)
  290. {
  291.     int i;
  292.     static WORD wP16[] = { 0x1000, 0x0100, 0x0010, 0x0001 };
  293.  
  294.     for (i = 0; i != 4; i++)
  295.     {
  296.         char ch = (char)((value / wP16[i]) & 0x0f) + (char)'0';
  297.         if (ch > '9')
  298.             ch += 'A' - '0' - 10;
  299.         *lpch++ = ch;
  300.     }
  301.     return lpch;
  302. }
  303.  
  304. LPSTR DecOut(LPSTR lpch, short value)
  305. {
  306.     int i;
  307.     static short sP10[] = { 10000, 1000, 100, 10, 1 };
  308.     BOOL fDigWritten = FALSE;
  309.  
  310.     if (value < 0)
  311.     {
  312.         *lpch++ = '-';
  313.         value = -value;
  314.     }
  315.  
  316.     for (i = 0; i != 5; i++)
  317.     {
  318.         char ch = (char)((value / sP10[i]) % 10) + (char)'0';
  319.         if (ch != '0' || i == 4 || fDigWritten)
  320.         {
  321.             fDigWritten = TRUE;
  322.             *lpch++ = ch;
  323.         }
  324.     }
  325.     return lpch;
  326. }
  327.