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