home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / msysjour / vol07 / 03 / toolhelp / toolhelp.h < prev   
Text File  |  1992-05-01  |  15KB  |  474 lines
  1. /****************************************************************************\
  2. *                                                                            *
  3. * toolhelp.h -  toolhelp.dll functions, types, and definitions               *
  4. *                                                                            *
  5. *               Version 1.0                                                  *
  6. *                                                                            *
  7. *               NOTE: windows.h must be #included first                      *
  8. *                                                                            *
  9. *               Copyright (c) 1992, Microsoft Corp.  All rights reserved.    *
  10. *                                                                            *
  11. \****************************************************************************/
  12.  
  13. #ifndef _INC_TOOLHELP
  14. #define _INC_TOOLHELP
  15.  
  16. #ifndef RC_INVOKED
  17. #pragma pack(1)         /* Assume byte packing throughout */
  18. #endif
  19.  
  20. #ifdef __cplusplus
  21. extern "C" {            /* Assume C declarations for C++ */
  22. #endif   /* __cplusplus */
  23.  
  24. #ifndef _INC_WINDOWS    /* If included with 3.0 headers... */
  25. #define LPCSTR      LPSTR
  26. #define WINAPI      FAR PASCAL
  27. #define CALLBACK    FAR PASCAL
  28. #define UINT        WORD
  29. #define HMODULE     HANDLE
  30. #define HINSTANCE   HANDLE
  31. #define HLOCAL      HANDLE
  32. #define HGLOBAL     HANDLE
  33. #define HTASK       HANDLE
  34. #endif  /* _INC_WINDOWS */
  35.  
  36. /****** General symbols ****************************************************/
  37. #define MAX_DATA        11
  38. #define MAX_PATH        255
  39. #define MAX_MODULE_NAME 8 + 1
  40. #define MAX_CLASSNAME   255
  41.  
  42. /****** Global heap walking *************************************************/
  43. typedef struct tagGLOBALINFO
  44. {
  45.     DWORD dwSize;
  46.     WORD wcItems;
  47.     WORD wcItemsFree;
  48.     WORD wcItemsLRU;
  49. } GLOBALINFO;
  50.  
  51. typedef struct tagGLOBALENTRY
  52. {
  53.     DWORD dwSize;
  54.     DWORD dwAddress;
  55.     DWORD dwBlockSize;
  56.     HGLOBAL hBlock;
  57.     WORD wcLock;
  58.     WORD wcPageLock;
  59.     WORD wFlags;
  60.     BOOL wHeapPresent;
  61.     HGLOBAL hOwner;
  62.     WORD wType;
  63.     WORD wData;
  64.     DWORD dwNext;
  65.     DWORD dwNextAlt;
  66. } GLOBALENTRY;
  67.  
  68. /* GlobalFirst()/GlobalNext() flags */
  69. #define GLOBAL_ALL      0
  70. #define GLOBAL_LRU      1
  71. #define GLOBAL_FREE     2
  72.  
  73. /* GLOBALENTRY.wType entries */
  74. #define GT_UNKNOWN      0
  75. #define GT_DGROUP       1
  76. #define GT_DATA         2
  77. #define GT_CODE         3
  78. #define GT_TASK         4
  79. #define GT_RESOURCE     5
  80. #define GT_MODULE       6
  81. #define GT_FREE         7
  82. #define GT_INTERNAL     8
  83. #define GT_SENTINEL     9
  84. #define GT_BURGERMASTER 10
  85.  
  86. /* If GLOBALENTRY.wType==GT_RESOURCE, the following is GLOBALENTRY.wData: */
  87. #define GD_USERDEFINED      0
  88. #define GD_CURSORCOMPONENT  1
  89. #define GD_BITMAP           2
  90. #define GD_ICONCOMPONENT    3
  91. #define GD_MENU             4
  92. #define GD_DIALOG           5
  93. #define GD_STRING           6
  94. #define GD_FONTDIR          7
  95. #define GD_FONT             8
  96. #define GD_ACCELERATORS     9
  97. #define GD_RCDATA           10
  98. #define GD_ERRTABLE         11
  99. #define GD_CURSOR           12
  100. #define GD_ICON             14
  101. #define GD_NAMETABLE        15
  102. #define GD_MAX_RESOURCE     15
  103.  
  104. /* GLOBALENTRY.wFlags */
  105. #define GF_PDB_OWNER        0x0100      /* Low byte is KERNEL flags */
  106.  
  107. BOOL    WINAPI GlobalInfo(GLOBALINFO FAR* lpGlobalInfo);
  108. BOOL    WINAPI GlobalFirst(GLOBALENTRY FAR* lpGlobal, WORD wFlags);
  109. BOOL    WINAPI GlobalNext(GLOBALENTRY FAR* lpGlobal, WORD wFlags);
  110. BOOL    WINAPI GlobalEntryHandle(GLOBALENTRY FAR* lpGlobal, HGLOBAL hItem);
  111. BOOL    WINAPI GlobalEntryModule(GLOBALENTRY FAR* lpGlobal, HMODULE hModule,
  112.                                  WORD wSeg);
  113. WORD    WINAPI GlobalHandleToSel(HGLOBAL hMem);
  114.  
  115. /****** Local heap walking *************************************************/
  116.  
  117. typedef struct tagLOCALINFO
  118. {
  119.     DWORD dwSize;
  120.     WORD wcItems;
  121. } LOCALINFO;
  122.  
  123. typedef struct tagLOCALENTRY
  124. {
  125.     DWORD dwSize;
  126.     HLOCAL hHandle;
  127.     WORD wAddress;
  128.     WORD wSize;
  129.     WORD wFlags;
  130.     WORD wcLock;
  131.     WORD wType;
  132.     WORD hHeap;
  133.     WORD wHeapType;
  134.     WORD wNext;
  135. } LOCALENTRY;
  136.  
  137. /* LOCALENTRY.wHeapType flags */
  138. #define NORMAL_HEAP     0
  139. #define USER_HEAP       1
  140. #define GDI_HEAP        2
  141.  
  142. /* LOCALENTRY.wFlags */
  143. #define LF_FIXED        1
  144. #define LF_FREE         2
  145. #define LF_MOVEABLE     4
  146.  
  147. /* LOCALENTRY.wType */
  148. #define LT_NORMAL                   0
  149. #define LT_FREE                     0xff
  150. #define LT_GDI_PEN                  1   /* LT_GDI_* is for GDI's heap */
  151. #define LT_GDI_BRUSH                2
  152. #define LT_GDI_FONT                 3
  153. #define LT_GDI_PALETTE              4
  154. #define LT_GDI_BITMAP               5
  155. #define LT_GDI_RGN                  6
  156. #define LT_GDI_DC                   7
  157. #define LT_GDI_DISABLED_DC          8
  158. #define LT_GDI_METADC               9
  159. #define LT_GDI_METAFILE             10
  160. #define LT_GDI_MAX                  LT_GDI_METAFILE
  161. #define LT_USER_CLASS               1   /* LT_USER_* is for USER's heap */
  162. #define LT_USER_WND                 2
  163. #define LT_USER_STRING              3
  164. #define LT_USER_MENU                4
  165. #define LT_USER_CLIP                5
  166. #define LT_USER_CBOX                6
  167. #define LT_USER_PALETTE             7
  168. #define LT_USER_ED                  8
  169. #define LT_USER_BWL                 9
  170. #define LT_USER_OWNERDRAW           10
  171. #define LT_USER_SPB                 11
  172. #define LT_USER_CHECKPOINT          12
  173. #define LT_USER_DCE                 13
  174. #define LT_USER_MWP                 14
  175. #define LT_USER_PROP                15
  176. #define LT_USER_LBIV                16
  177. #define LT_USER_MISC                17
  178. #define LT_USER_ATOMS               18
  179. #define LT_USER_LOCKINPUTSTATE      19
  180. #define LT_USER_HOOKLIST            20
  181. #define LT_USER_USERSEEUSERDOALLOC  21
  182. #define LT_USER_HOTKEYLIST          22
  183. #define LT_USER_POPUPMENU           23
  184. #define LT_USER_HANDLETABLE         32
  185. #define LT_USER_MAX                 LT_USER_HANDLETABLE
  186.  
  187. BOOL    WINAPI LocalInfo(LOCALINFO FAR* lpLocal, HGLOBAL hHeap);
  188. BOOL    WINAPI LocalFirst(LOCALENTRY FAR* lpLocal, HGLOBAL hHeap);
  189. BOOL    WINAPI LocalNext(LOCALENTRY FAR* lpLocal);
  190.  
  191. /****** Stack Tracing ******************************************************/
  192.  
  193. typedef struct tagSTACKTRACEENTRY
  194. {
  195.     DWORD dwSize;
  196.     HTASK hTask;
  197.     WORD wSS;
  198.     WORD wBP;
  199.     WORD wCS;
  200.     WORD wIP;
  201.     HMODULE hModule;
  202.     WORD wSegment;
  203.     WORD wFlags;
  204. } STACKTRACEENTRY;
  205.  
  206. /* STACKTRACEENTRY.wFlags values */
  207. #define FRAME_FAR       0
  208. #define FRAME_NEAR      1
  209.  
  210. BOOL    WINAPI StackTraceFirst(STACKTRACEENTRY FAR* lpStackTrace, HTASK hTask);
  211. BOOL    WINAPI StackTraceCSIPFirst(STACKTRACEENTRY FAR* lpStackTrace,
  212.                                    WORD wSS, WORD wCS, WORD wIP, WORD wBP);
  213. BOOL    WINAPI StackTraceNext(STACKTRACEENTRY FAR* lpStackTrace);
  214.  
  215. /****** Module list walking ************************************************/
  216.  
  217. typedef struct tagMODULEENTRY
  218. {
  219.     DWORD dwSize;
  220.     char szModule[MAX_MODULE_NAME + 1];
  221.     HMODULE hModule;
  222.     WORD wcUsage;
  223.     char szExePath[MAX_PATH + 1];
  224.     WORD wNext;
  225. } MODULEENTRY;
  226.  
  227. BOOL    WINAPI ModuleFirst(MODULEENTRY FAR* lpModule);
  228. BOOL    WINAPI ModuleNext(MODULEENTRY FAR* lpModule);
  229. HMODULE WINAPI ModuleFindName(MODULEENTRY FAR* lpModule, LPCSTR lpstrName);
  230. HMODULE WINAPI ModuleFindHandle(MODULEENTRY FAR* lpModule, HMODULE hModule);
  231.  
  232. /****** Task list walking ***************************************************/
  233.  
  234. typedef struct tagTASKENTRY
  235. {
  236.     DWORD dwSize;
  237.     HTASK hTask;
  238.     HTASK hTaskParent;
  239.     HINSTANCE hInst;
  240.     HMODULE hModule;
  241.     WORD wSS;
  242.     WORD wSP;
  243.     WORD wStackTop;
  244.     WORD wStackMinimum;
  245.     WORD wStackBottom;
  246.     WORD wcEvents;
  247.     HGLOBAL hQueue;
  248.     char szModule[MAX_MODULE_NAME + 1];
  249.     WORD wPSPOffset;
  250.     HANDLE hNext;
  251. } TASKENTRY;
  252.  
  253. BOOL    WINAPI TaskFirst(TASKENTRY FAR* lpTask);
  254. BOOL    WINAPI TaskNext(TASKENTRY FAR* lpTask);
  255. BOOL    WINAPI TaskFindHandle(TASKENTRY FAR* lpTask, HTASK hTask);
  256. DWORD   WINAPI TaskSetCSIP(HTASK hTask, WORD wCS, WORD wIP);
  257. DWORD   WINAPI TaskGetCSIP(HTASK hTask);
  258. BOOL    WINAPI TaskSwitch(HTASK hTask, DWORD dwNewCSIP);
  259.  
  260. /****** Window Class enumeration ********************************************/
  261.  
  262. typedef struct tagCLASSENTRY
  263. {
  264.     DWORD dwSize;
  265.     HMODULE hInst;              /* This is really an hModule */
  266.     char szClassName[MAX_CLASSNAME + 1];
  267.     WORD wNext;
  268. } CLASSENTRY;
  269.  
  270. BOOL    WINAPI ClassFirst(CLASSENTRY FAR* lpClass);
  271. BOOL    WINAPI ClassNext(CLASSENTRY FAR* lpClass);
  272.  
  273. /****** Information functions ***********************************************/
  274.  
  275. typedef struct tagMEMMANINFO
  276. {
  277.     DWORD dwSize;
  278.     DWORD dwLargestFreeBlock;
  279.     DWORD dwMaxPagesAvailable;
  280.     DWORD dwMaxPagesLockable;
  281.     DWORD dwTotalLinearSpace;
  282.     DWORD dwTotalUnlockedPages;
  283.     DWORD dwFreePages;
  284.     DWORD dwTotalPages;
  285.     DWORD dwFreeLinearSpace;
  286.     DWORD dwSwapFilePages;
  287.     WORD wPageSize;
  288. } MEMMANINFO;
  289.  
  290. BOOL    WINAPI MemManInfo(MEMMANINFO FAR* lpEnhMode);
  291.  
  292. typedef struct tagSYSHEAPINFO
  293. {
  294.     DWORD dwSize;
  295.     WORD wUserFreePercent;
  296.     WORD wGDIFreePercent;
  297.     HGLOBAL hUserSegment;
  298.     HGLOBAL hGDISegment;
  299. } SYSHEAPINFO;
  300.  
  301. BOOL    WINAPI SystemHeapInfo(SYSHEAPINFO FAR* lpSysHeap);
  302.  
  303. /****** Interrupt Handling **************************************************/
  304.  
  305. /* Hooked interrupts */
  306. #define INT_DIV0            0
  307. #define INT_1               1
  308. #define INT_3               3
  309. #define INT_UDINSTR         6
  310. #define INT_STKFAULT        12
  311. #define INT_GPFAULT         13
  312. #define INT_BADPAGEFAULT    14
  313. #define INT_CTLALTSYSRQ     256
  314.  
  315. /* TOOLHELP Interrupt callbacks registered with InterruptRegister should
  316.  *  always be written in assembly language.  The stack frame is not
  317.  *  compatible with high level language conventions.
  318.  *
  319.  *  This stack frame looks as follows to the callback.  All registers
  320.  *  should be preserved across this callback to allow restarting fault.
  321.  *               ------------
  322.  *               |   Flags  |  [SP + 0Eh]
  323.  *               |    CS    |  [SP + 0Ch]
  324.  *               |    IP    |  [SP + 0Ah]
  325.  *               |  Handle  |  [SP + 08h]
  326.  *               |Exception#|  [SP + 06h]
  327.  *               |    AX    |  [SP + 04h]  AX Saved to allow MakeProcInstance
  328.  *               |  Ret CS  |  [SP + 02h]
  329.  *       SP--->  |  Ret IP  |  [SP + 00h]
  330.  *               ------------
  331.  */
  332. BOOL    WINAPI InterruptRegister(HTASK hTask, FARPROC lpfnIntCallback);
  333. BOOL    WINAPI InterruptUnRegister(HTASK hTask);
  334.  
  335. /*  Notifications:
  336.  *      When a notification callback is called, two parameters are passed
  337.  *      in:  a WORD, wID, and another DWORD, dwData.  wID is one of
  338.  *      the values NFY_* below.  Callback routines should ignore unrecog-
  339.  *      nized values to preserve future compatibility.  Callback routines
  340.  *      are also passed a dwData value.  This may contain data or may be
  341.  *      a FAR pointer to a structure, or may not be used depending on
  342.  *      which notification is being received.
  343.  *
  344.  *      In all cases, if the return value of the callback is TRUE, the
  345.  *      notification will NOT be passed on to other callbacks.  It has
  346.  *      been handled.  This should be used sparingly and only with certain
  347.  *      notifications.  Callbacks almost always return FALSE.
  348.  */
  349.  
  350. /* NFY_UNKNOWN:  An unknown notification has been returned from KERNEL.  Apps
  351.  *  should ignore these.
  352.  */
  353. #define NFY_UNKNOWN         0
  354.  
  355. /* NFY_LOADSEG:  dwData points to a NFYLOADSEG structure */
  356. #define NFY_LOADSEG         1
  357. typedef struct tagNFYLOADSEG
  358. {
  359.     DWORD dwSize;
  360.     WORD wSelector;
  361.     WORD wSegNum;
  362.     WORD wType;             /* Low bit set if data seg, clear if code seg */
  363.     WORD wcInstance;        /* Instance count ONLY VALID FOR DATA SEG */
  364.     LPCSTR lpstrModuleName;
  365. } NFYLOADSEG;
  366.  
  367. /* NFY_FREESEG:  LOWORD(dwData) is the selector of the segment being freed */
  368. #define NFY_FREESEG         2
  369.  
  370. /* NFY_STARTDLL:  dwData points to a NFYLOADSEG structure */
  371. #define NFY_STARTDLL        3
  372. typedef struct tagNFYSTARTDLL
  373. {
  374.     DWORD dwSize;
  375.     HMODULE hModule;
  376.     WORD wCS;
  377.     WORD wIP;
  378. } NFYSTARTDLL;
  379.  
  380. /* NFY_STARTTASK:  dwData is the CS:IP of the start address of the task */
  381. #define NFY_STARTTASK       4
  382.  
  383. /* NFY_EXITTASK:  The low byte of dwData contains the program exit code */
  384. #define NFY_EXITTASK        5
  385.  
  386. /* NFY_DELMODULE:  LOWORD(dwData) is the handle of the module to be freed */
  387. #define NFY_DELMODULE       6
  388.  
  389. /* NFY_RIP:  dwData points to a NFYRIP structure */
  390. #define NFY_RIP             7
  391. typedef struct tagNFYRIP
  392. {
  393.     DWORD dwSize;
  394.     WORD wIP;
  395.     WORD wCS;
  396.     WORD wSS;
  397.     WORD wBP;
  398.     WORD wExitCode;
  399. } NFYRIP;
  400.  
  401. /* NFY_TASKIN:  No data.  Callback should do GetCurrentTask() */
  402. #define NFY_TASKIN          8
  403.  
  404. /* NFY_TASKOUT:  No data.  Callback should do GetCurrentTask() */
  405. #define NFY_TASKOUT         9
  406.  
  407. /* NFY_INCHAR:  Return value from callback is used.  If NULL, mapped to 'i' */
  408. #define NFY_INCHAR          10
  409.  
  410. /* NFY_OUTSTR:  dwData points to the string to be displayed */
  411. #define NFY_OUTSTR          11
  412.  
  413. /* NFY_LOGERROR:  dwData points to a NFYLOGERROR struct */
  414. #define NFY_LOGERROR        12
  415. typedef struct tagNFYLOGERROR
  416. {
  417.     DWORD dwSize;
  418.     UINT wErrCode;
  419.     void FAR* lpInfo;       /* Error code-dependent */
  420. } NFYLOGERROR;
  421.  
  422. /* NFY_LOGPARAMERROR:  dwData points to a NFYLOGPARAMERROR struct */
  423. #define NFY_LOGPARAMERROR   13
  424. typedef struct tagNFYLOGPARAMERROR
  425. {
  426.     DWORD dwSize;
  427.     UINT wErrCode;
  428.     FARPROC lpfnErrorAddr;
  429.     void FAR* FAR* lpBadParam;
  430. } NFYLOGPARAMERROR;
  431.  
  432. /* NotifyRegister() flags */
  433. #define NF_NORMAL       0
  434. #define NF_TASKSWITCH   1
  435. #define NF_RIP          2
  436.  
  437. typedef BOOL (CALLBACK* LPFNNOTIFYCALLBACK)(WORD wID, DWORD dwData);
  438.  
  439. BOOL    WINAPI NotifyRegister(HTASK hTask, LPFNNOTIFYCALLBACK lpfn, WORD
  440. wFlags);
  441. BOOL    WINAPI NotifyUnRegister(HTASK hTask);
  442.  
  443. /****** Miscellaneous ********************************************************/
  444.  
  445. void    WINAPI TerminateApp(HTASK hTask, WORD wFlags);
  446.  
  447. /* TerminateApp() flag values */
  448. #define UAE_BOX     0
  449. #define NO_UAE_BOX  1
  450.  
  451. DWORD   WINAPI MemoryRead(WORD wSel, DWORD dwOffset, void FAR* lpBuffer, DWORD
  452. dwcb);
  453. DWORD   WINAPI MemoryWrite(WORD wSel, DWORD dwOffset, void FAR* lpBuffer, DWORD
  454. dwcb);
  455.  
  456. typedef struct tagTIMERINFO
  457. {
  458.     DWORD dwSize;
  459.     DWORD dwmsSinceStart;
  460.     DWORD dwmsThisVM;
  461. } TIMERINFO;
  462.  
  463. BOOL    WINAPI TimerCount(TIMERINFO FAR* lpTimer);
  464.  
  465. #ifdef __cplusplus
  466. }
  467. #endif   /* __cplusplus */
  468.  
  469. #ifndef RC_INVOKED
  470. #pragma pack()          /* Revert to default packing */
  471. #endif
  472.  
  473. #endif /* !_INC_TOOLHELP */
  474.