home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / include / vdmdbg.h < prev    next >
C/C++ Source or Header  |  1998-04-25  |  19KB  |  696 lines
  1. /*++ BUILD Version: 0001    // Increment this if a change has global effects
  2.  
  3. Copyright (c) 1985-1997, Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     vdmdbg.h
  8.  
  9. Abstract:
  10.  
  11.     Prodecure declarations, constant definitions, type definition and macros
  12.     for the VDMDBG.DLL VDM Debugger interface.
  13.  
  14. --*/
  15.  
  16. #ifndef _VDMDBG_
  17. #define _VDMDBG_
  18.  
  19. #ifdef __cplusplus
  20. extern "C" {
  21. #endif
  22.  
  23. #include <pshpack4.h>
  24.  
  25. #define STATUS_VDM_EVENT    STATUS_SEGMENT_NOTIFICATION
  26.  
  27. #ifndef DBG_SEGLOAD
  28. #define DBG_SEGLOAD     0
  29. #define DBG_SEGMOVE     1
  30. #define DBG_SEGFREE     2
  31. #define DBG_MODLOAD     3
  32. #define DBG_MODFREE     4
  33. #define DBG_SINGLESTEP  5
  34. #define DBG_BREAK       6
  35. #define DBG_GPFAULT     7
  36. #define DBG_DIVOVERFLOW 8
  37. #define DBG_INSTRFAULT  9
  38. #define DBG_TASKSTART   10
  39. #define DBG_TASKSTOP    11
  40. #define DBG_DLLSTART    12
  41. #define DBG_DLLSTOP     13
  42. #define DBG_ATTACH      14
  43. #define DBG_TOOLHELP    15
  44. #define DBG_STACKFAULT  16
  45. #define DBG_WOWINIT     17
  46. #define DBG_TEMPBP      18
  47. #define DBG_MODMOVE     19
  48. #define DBG_INIT        20
  49. #endif
  50.  
  51. //
  52. // These flags are set in the same WORD as the DBG_ event id's (above).
  53. //
  54. #define VDMEVENT_NEEDS_INTERACTIVE  0x8000
  55. #define VDMEVENT_VERBOSE            0x4000
  56. #define VDMEVENT_PE                 0x2000
  57. #define VDMEVENT_ALLFLAGS           0xe000
  58. //
  59. // These flags are set in the second WORD of the exception event
  60. // parameters.
  61. //
  62. #define VDMEVENT_V86                0x0001
  63. #define VDMEVENT_PM16               0x0002
  64.  
  65. //
  66. // The following flags control the contents of the CONTEXT structure.
  67. //
  68.  
  69. #define VDMCONTEXT_i386    0x00010000    // this assumes that i386 and
  70. #define VDMCONTEXT_i486    0x00010000    // i486 have identical context records
  71.  
  72. #define VDMCONTEXT_CONTROL         (VDMCONTEXT_i386 | 0x00000001L) // SS:SP, CS:IP, FLAGS, BP
  73. #define VDMCONTEXT_INTEGER         (VDMCONTEXT_i386 | 0x00000002L) // AX, BX, CX, DX, SI, DI
  74. #define VDMCONTEXT_SEGMENTS        (VDMCONTEXT_i386 | 0x00000004L) // DS, ES, FS, GS
  75. #define VDMCONTEXT_FLOATING_POINT  (VDMCONTEXT_i386 | 0x00000008L) // 387 state
  76. #define VDMCONTEXT_DEBUG_REGISTERS (VDMCONTEXT_i386 | 0x00000010L) // DB 0-3,6,7
  77.  
  78. #define VDMCONTEXT_FULL (VDMCONTEXT_CONTROL | VDMCONTEXT_INTEGER |\
  79.                       VDMCONTEXT_SEGMENTS)
  80.  
  81.  
  82. #ifdef _X86_
  83.  
  84. // On x86 machines, just copy the definition of the CONTEXT and LDT_ENTRY
  85. // structures.
  86. typedef struct _CONTEXT VDMCONTEXT;
  87. typedef struct _LDT_ENTRY VDMLDT_ENTRY;
  88.  
  89. #else // _X86_
  90.  
  91. //
  92. //  Define the size of the 80387 save area, which is in the context frame.
  93. //
  94.  
  95. #define SIZE_OF_80387_REGISTERS      80
  96.  
  97. typedef struct _FLOATING_SAVE_AREA {
  98.     ULONG   ControlWord;
  99.     ULONG   StatusWord;
  100.     ULONG   TagWord;
  101.     ULONG   ErrorOffset;
  102.     ULONG   ErrorSelector;
  103.     ULONG   DataOffset;
  104.     ULONG   DataSelector;
  105.     UCHAR   RegisterArea[SIZE_OF_80387_REGISTERS];
  106.     ULONG   Cr0NpxState;
  107. } FLOATING_SAVE_AREA;
  108.  
  109. //
  110. // Simulated context structure for the 16-bit environment
  111. //
  112.  
  113. typedef struct _VDMCONTEXT {
  114.  
  115.     //
  116.     // The flags values within this flag control the contents of
  117.     // a CONTEXT record.
  118.     //
  119.     // If the context record is used as an input parameter, then
  120.     // for each portion of the context record controlled by a flag
  121.     // whose value is set, it is assumed that that portion of the
  122.     // context record contains valid context. If the context record
  123.     // is being used to modify a threads context, then only that
  124.     // portion of the threads context will be modified.
  125.     //
  126.     // If the context record is used as an IN OUT parameter to capture
  127.     // the context of a thread, then only those portions of the thread's
  128.     // context corresponding to set flags will be returned.
  129.     //
  130.     // The context record is never used as an OUT only parameter.
  131.     //
  132.     // CONTEXT_FULL on some systems (MIPS namely) does not contain the
  133.     // CONTEXT_SEGMENTS definition.  VDMDBG assumes that CONTEXT_INTEGER also
  134.     // includes CONTEXT_SEGMENTS to account for this.
  135.     //
  136.  
  137.     ULONG ContextFlags;
  138.  
  139.     //
  140.     // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
  141.     // set in ContextFlags.  Note that CONTEXT_DEBUG_REGISTERS is NOT
  142.     // included in CONTEXT_FULL.
  143.     //
  144.  
  145.     ULONG   Dr0;
  146.     ULONG   Dr1;
  147.     ULONG   Dr2;
  148.     ULONG   Dr3;
  149.     ULONG   Dr6;
  150.     ULONG   Dr7;
  151.  
  152.     //
  153.     // This section is specified/returned if the
  154.     // ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
  155.     //
  156.  
  157.     FLOATING_SAVE_AREA FloatSave;
  158.  
  159.     //
  160.     // This section is specified/returned if the
  161.     // ContextFlags word contians the flag CONTEXT_SEGMENTS.
  162.     //
  163.  
  164.     ULONG   SegGs;
  165.     ULONG   SegFs;
  166.     ULONG   SegEs;
  167.     ULONG   SegDs;
  168.  
  169.     //
  170.     // This section is specified/returned if the
  171.     // ContextFlags word contians the flag CONTEXT_INTEGER.
  172.     //
  173.  
  174.     ULONG   Edi;
  175.     ULONG   Esi;
  176.     ULONG   Ebx;
  177.     ULONG   Edx;
  178.     ULONG   Ecx;
  179.     ULONG   Eax;
  180.  
  181.     //
  182.     // This section is specified/returned if the
  183.     // ContextFlags word contians the flag CONTEXT_CONTROL.
  184.     //
  185.  
  186.     ULONG   Ebp;
  187.     ULONG   Eip;
  188.     ULONG   SegCs;              // MUST BE SANITIZED
  189.     ULONG   EFlags;             // MUST BE SANITIZED
  190.     ULONG   Esp;
  191.     ULONG   SegSs;
  192.  
  193. } VDMCONTEXT;
  194.  
  195. //
  196. //  LDT descriptor entry
  197. //
  198.  
  199. typedef struct _VDMLDT_ENTRY {
  200.     USHORT  LimitLow;
  201.     USHORT  BaseLow;
  202.     union {
  203.         struct {
  204.             UCHAR   BaseMid;
  205.             UCHAR   Flags1;     // Declare as bytes to avoid alignment
  206.             UCHAR   Flags2;     // Problems.
  207.             UCHAR   BaseHi;
  208.         } Bytes;
  209.         struct {
  210.             ULONG   BaseMid : 8;
  211.             ULONG   Type : 5;
  212.             ULONG   Dpl : 2;
  213.             ULONG   Pres : 1;
  214.             ULONG   LimitHi : 4;
  215.             ULONG   Sys : 1;
  216.             ULONG   Reserved_0 : 1;
  217.             ULONG   Default_Big : 1;
  218.             ULONG   Granularity : 1;
  219.             ULONG   BaseHi : 8;
  220.         } Bits;
  221.     } HighWord;
  222. } VDMLDT_ENTRY;
  223.  
  224.  
  225. #endif // _X86_
  226.  
  227. typedef VDMCONTEXT *LPVDMCONTEXT;
  228. typedef VDMLDT_ENTRY *LPVDMLDT_ENTRY;
  229.  
  230. #define VDMCONTEXT_TO_PROGRAM_COUNTER(Context) (PVOID)((Context)->Eip)
  231.  
  232. #define VDMCONTEXT_LENGTH  (sizeof(VDMCONTEXT))
  233. #define VDMCONTEXT_ALIGN   (sizeof(ULONG))
  234. #define VDMCONTEXT_ROUND   (VDMCONTEXT_ALIGN - 1)
  235.  
  236. #define V86FLAGS_CARRY      0x00001
  237. #define V86FLAGS_PARITY     0x00004
  238. #define V86FLAGS_AUXCARRY   0x00010
  239. #define V86FLAGS_ZERO       0x00040
  240. #define V86FLAGS_SIGN       0x00080
  241. #define V86FLAGS_TRACE      0x00100
  242. #define V86FLAGS_INTERRUPT  0x00200
  243. #define V86FLAGS_DIRECTION  0x00400
  244. #define V86FLAGS_OVERFLOW   0x00800
  245. #define V86FLAGS_IOPL       0x03000
  246. #define V86FLAGS_IOPL_BITS  0x12
  247. #define V86FLAGS_RESUME     0x10000
  248. #define V86FLAGS_V86        0x20000     // Used to detect RealMode v. ProtMode
  249. #define V86FLAGS_ALIGNMENT  0x40000
  250.  
  251. #define MAX_MODULE_NAME  8 + 1
  252. #define MAX_PATH16      255
  253.  
  254. typedef struct _SEGMENT_NOTE {
  255.     WORD    Selector1;                      // Selector of operation
  256.     WORD    Selector2;                      // Dest. Sel. for moving segments
  257.     WORD    Segment;                        // Segment within Module
  258.     CHAR    Module[MAX_MODULE_NAME+1];      // Module name
  259.     CHAR    FileName[MAX_PATH16+1];         // PathName to executable image
  260.     WORD    Type;                           // Code / Data, etc.
  261.     DWORD   Length;                         // Length of image
  262. } SEGMENT_NOTE;
  263.  
  264. typedef struct _IMAGE_NOTE {
  265.     CHAR    Module[MAX_MODULE_NAME+1];      // Module
  266.     CHAR    FileName[MAX_PATH16+1];         // Path to executable image
  267.     WORD    hModule;                        // 16-bit hModule
  268.     WORD    hTask;                          // 16-bit hTask
  269. } IMAGE_NOTE;
  270.  
  271. typedef struct {
  272.     DWORD   dwSize;
  273.     char    szModule[MAX_MODULE_NAME+1];
  274.     HANDLE  hModule;
  275.     WORD    wcUsage;
  276.     char    szExePath[MAX_PATH16+1];
  277.     WORD    wNext;
  278. } MODULEENTRY, *LPMODULEENTRY;
  279.  
  280.  
  281. #define SN_CODE 0                           // Protect mode code segment
  282. #define SN_DATA 1                           // Protect mode data segment
  283. #define SN_V86  2                           // V86 mode segment
  284.  
  285. typedef struct _TEMP_BP_NOTE {
  286.     WORD    Seg;                            // Dest. Segment or Selector
  287.     DWORD   Offset;                         // Dest. Offset
  288.     BOOL    bPM;                            // TRUE for PM, FALSE for V86
  289. } TEMP_BP_NOTE;
  290.  
  291. typedef struct _VDM_SEGINFO {
  292.     WORD    Selector;                       // Selector or RM segment
  293.     WORD    SegNumber;                      // Logical segment number in executable
  294.     DWORD   Length;                         // Length of segment
  295.     WORD    Type;                           // Type (0=v86, 1=PM)
  296.     CHAR    ModuleName[MAX_MODULE_NAME];    // Module
  297.     CHAR    FileName[MAX_PATH16];           // Path to executable image
  298. } VDM_SEGINFO;
  299.  
  300. /* GlobalFirst()/GlobalNext() flags */
  301. #define GLOBAL_ALL      0
  302. #define GLOBAL_LRU      1
  303. #define GLOBAL_FREE     2
  304.  
  305. /* GLOBALENTRY.wType entries */
  306. #define GT_UNKNOWN      0
  307. #define GT_DGROUP       1
  308. #define GT_DATA         2
  309. #define GT_CODE         3
  310. #define GT_TASK         4
  311. #define GT_RESOURCE     5
  312. #define GT_MODULE       6
  313. #define GT_FREE         7
  314. #define GT_INTERNAL     8
  315. #define GT_SENTINEL     9
  316. #define GT_BURGERMASTER 10
  317.  
  318. /* If GLOBALENTRY.wType==GT_RESOURCE, the following is GLOBALENTRY.wData: */
  319. #define GD_USERDEFINED      0
  320. #define GD_CURSORCOMPONENT  1
  321. #define GD_BITMAP           2
  322. #define GD_ICONCOMPONENT    3
  323. #define GD_MENU             4
  324. #define GD_DIALOG           5
  325. #define GD_STRING           6
  326. #define GD_FONTDIR          7
  327. #define GD_FONT             8
  328. #define GD_ACCELERATORS     9
  329. #define GD_RCDATA           10
  330. #define GD_ERRTABLE         11
  331. #define GD_CURSOR           12
  332. #define GD_ICON             14
  333. #define GD_NAMETABLE        15
  334. #define GD_MAX_RESOURCE     15
  335.  
  336. typedef struct {
  337.     DWORD   dwSize;
  338.     DWORD   dwAddress;
  339.     DWORD   dwBlockSize;
  340.     HANDLE  hBlock;
  341.     WORD    wcLock;
  342.     WORD    wcPageLock;
  343.     WORD    wFlags;
  344.     BOOL    wHeapPresent;
  345.     HANDLE  hOwner;
  346.     WORD    wType;
  347.     WORD    wData;
  348.     DWORD   dwNext;
  349.     DWORD   dwNextAlt;
  350. } GLOBALENTRY, *LPGLOBALENTRY;
  351.  
  352. typedef DWORD (CALLBACK* DEBUGEVENTPROC)( LPDEBUG_EVENT, LPVOID );
  353.  
  354. // Macros to access VDM_EVENT parameters
  355. #define W1(x) ((USHORT)(x.ExceptionInformation[0]))
  356. #define W2(x) ((USHORT)(x.ExceptionInformation[0] >> 16))
  357. #define W3(x) ((USHORT)(x.ExceptionInformation[1]))
  358. #define W4(x) ((USHORT)(x.ExceptionInformation[1] >> 16))
  359. #define DW3(x) (x.ExceptionInformation[2])
  360. #define DW4(x) (x.ExceptionInformation[3])
  361.  
  362. #include <poppack.h>
  363.  
  364.  
  365. BOOL
  366. WINAPI
  367. VDMProcessException(
  368.     LPDEBUG_EVENT   lpDebugEvent
  369.     );
  370.  
  371. BOOL
  372. WINAPI
  373. VDMGetThreadSelectorEntry(
  374.     HANDLE          hProcess,
  375.     HANDLE          hThread,
  376.     WORD            wSelector,
  377.     LPVDMLDT_ENTRY  lpSelectorEntry
  378.     );
  379.  
  380. ULONG
  381. WINAPI
  382. VDMGetPointer(
  383.     HANDLE          hProcess,
  384.     HANDLE          hThread,
  385.     WORD            wSelector,
  386.     DWORD           dwOffset,
  387.     BOOL            fProtMode
  388.     );
  389.  
  390. // VDMGetThreadContext, VDMSetThreadContext are obselete
  391. // Use VDMGetContext, VDMSetContext
  392. BOOL
  393. WINAPI
  394. VDMGetContext(
  395.     HANDLE          hProcess,
  396.     HANDLE          hThread,
  397.     LPVDMCONTEXT    lpVDMContext
  398. );
  399.  
  400. BOOL
  401. WINAPI
  402. VDMSetContext(
  403.     HANDLE          hProcess,
  404.     HANDLE          hThread,
  405.     LPVDMCONTEXT    lpVDMContext
  406. );
  407.  
  408. BOOL
  409. WINAPI
  410. VDMGetSelectorModule(
  411.     HANDLE          hProcess,
  412.     HANDLE          hThread,
  413.     WORD            wSelector,
  414.     PUINT           lpSegmentNumber,
  415.     LPSTR           lpModuleName,
  416.     UINT            nNameSize,
  417.     LPSTR           lpModulePath,
  418.     UINT            nPathSize
  419. );
  420.  
  421. BOOL
  422. WINAPI
  423. VDMGetModuleSelector(
  424.     HANDLE          hProcess,
  425.     HANDLE          hThread,
  426.     UINT            wSegmentNumber,
  427.     LPSTR           lpModuleName,
  428.     LPWORD          lpSelector
  429. );
  430.  
  431. BOOL
  432. WINAPI
  433. VDMModuleFirst(
  434.     HANDLE          hProcess,
  435.     HANDLE          hThread,
  436.     LPMODULEENTRY   lpModuleEntry,
  437.     DEBUGEVENTPROC  lpEventProc,
  438.     LPVOID          lpData
  439. );
  440.  
  441. BOOL
  442. WINAPI
  443. VDMModuleNext(
  444.     HANDLE          hProcess,
  445.     HANDLE          hThread,
  446.     LPMODULEENTRY   lpModuleEntry,
  447.     DEBUGEVENTPROC  lpEventProc,
  448.     LPVOID          lpData
  449. );
  450.  
  451. BOOL
  452. WINAPI
  453. VDMGlobalFirst(
  454.     HANDLE          hProcess,
  455.     HANDLE          hThread,
  456.     LPGLOBALENTRY   lpGlobalEntry,
  457.     WORD            wFlags,
  458.     DEBUGEVENTPROC  lpEventProc,
  459.     LPVOID          lpData
  460. );
  461.  
  462. BOOL
  463. WINAPI
  464. VDMGlobalNext(
  465.     HANDLE          hProcess,
  466.     HANDLE          hThread,
  467.     LPGLOBALENTRY   lpGlobalEntry,
  468.     WORD            wFlags,
  469.     DEBUGEVENTPROC  lpEventProc,
  470.     LPVOID          lpData
  471. );
  472.  
  473. typedef BOOL (WINAPI *PROCESSENUMPROC)( DWORD dwProcessId, DWORD dwAttributes, LPARAM lpUserDefined );
  474. typedef BOOL (WINAPI *TASKENUMPROC)( DWORD dwThreadId, WORD hMod16, WORD hTask16, LPARAM lpUserDefined );
  475. typedef BOOL (WINAPI *TASKENUMPROCEX)( DWORD dwThreadId, WORD hMod16, WORD hTask16,
  476.                                        PSZ pszModName, PSZ pszFileName, LPARAM lpUserDefined );
  477.  
  478. #define WOW_SYSTEM  (DWORD)0x0001
  479.  
  480. INT
  481. WINAPI
  482. VDMEnumProcessWOW(
  483.     PROCESSENUMPROC fp,
  484.     LPARAM          lparam
  485. );
  486.  
  487. INT
  488. WINAPI
  489. VDMEnumTaskWOW(
  490.     DWORD           dwProcessId,
  491.     TASKENUMPROC    fp,
  492.     LPARAM          lparam
  493. );
  494.  
  495. //
  496. // VDMEnumTaskWOWEx is the same as VDMEnumTaskWOW except
  497. // the callback procedure gets two more parameters,
  498. // the module name of the EXE and the full path to the
  499. // EXE.
  500. //
  501.  
  502. INT
  503. WINAPI
  504. VDMEnumTaskWOWEx(
  505.     DWORD           dwProcessId,
  506.     TASKENUMPROCEX  fp,
  507.     LPARAM          lparam
  508. );
  509.  
  510. //
  511. // VDMTerminateTaskWOW rudely terminates a 16-bit WOW task
  512. // similar to the way TerminateProcess kills a Win32
  513. // process.
  514. //
  515.  
  516. BOOL
  517. WINAPI
  518. VDMTerminateTaskWOW(
  519.     DWORD           dwProcessId,
  520.     WORD            htask
  521. );
  522.  
  523. //
  524. // VDMStartTaskInWOW launches a Win16 task in a pre-existing
  525. // WOW VDM.  Note that the caller is responsible for ensuring
  526. // the program is a 16-bit Windows program.  If it is a DOS
  527. // or Win32 program, it will still be launched from within
  528. // the target WOW VDM.
  529. //
  530. // The supplied command line and show command are passed
  531. // unchanged to the 16-bit WinExec API in the target WOW VDM.
  532. //
  533. // Note this routine is ANSI-only.
  534. //
  535.  
  536. BOOL
  537. VDMStartTaskInWOW(
  538.     DWORD           dwProcessId,
  539.     LPSTR           lpCommandLine,
  540.     WORD            wShow
  541. );
  542.  
  543. //
  544. // VDMKillWOW is not implemented.
  545. //
  546.  
  547. BOOL
  548. WINAPI
  549. VDMKillWOW(
  550.     VOID
  551. );
  552.  
  553. //
  554. // VDMDetectWOW is not implemented.
  555. //
  556.  
  557. BOOL
  558. WINAPI
  559. VDMDetectWOW(
  560.     VOID
  561. );
  562.  
  563. BOOL
  564. WINAPI
  565. VDMBreakThread(
  566.     HANDLE          hProcess,
  567.     HANDLE          hThread
  568. );
  569.  
  570. DWORD
  571. WINAPI
  572. VDMGetDbgFlags(
  573.     HANDLE          hProcess
  574.     );
  575.  
  576. BOOL
  577. WINAPI
  578. VDMSetDbgFlags(
  579.     HANDLE          hProcess,
  580.     DWORD           dwFlags
  581.     );
  582.  
  583. #define VDMDBG_BREAK_DOSTASK    0x00000001
  584. #define VDMDBG_BREAK_WOWTASK    0x00000002
  585. #define VDMDBG_BREAK_LOADDLL    0x00000004
  586. #define VDMDBG_BREAK_EXCEPTIONS 0x00000008
  587. #define VDMDBG_BREAK_DEBUGGER   0x00000010
  588. #define VDMDBG_TRACE_HISTORY    0x00000080
  589.  
  590. //
  591. // VDMIsModuleLoaded can be used to determine if the 16-bit
  592. // executable referenced by the full path name parameter is
  593. // loaded in ntvdm. 
  594. //
  595. // Note that this function uses an internal table in vdmdbg.dll
  596. // to determine a module's existence. One important usage of this
  597. // function is to print a message when a particular module is
  598. // loaded for the first time. To accomplish this, call this
  599. // routine during a DBG_SEGLOAD notification BEFORE the entry
  600. // point VDMProcessException has been called. If it returns FALSE,
  601. // then the module has not yet been loaded.
  602. //
  603. BOOL
  604. WINAPI
  605. VDMIsModuleLoaded(
  606.     LPSTR szPath
  607.     );
  608.  
  609. BOOL
  610. WINAPI
  611. VDMGetSegmentInfo(
  612.     WORD Selector,
  613.     ULONG Offset,
  614.     BOOL bProtectMode,
  615.     VDM_SEGINFO *pSegInfo
  616.     );
  617.  
  618. //
  619. // VDMGetSymbol
  620. //
  621. // This routine reads the standard .SYM file format.
  622. // 
  623. // szModule         - module name (max 9 chars)
  624. // SegNumber        - logical segment number of segment (see VDM_SEGINFO)
  625. // Offset           - offset in segment
  626. // bProtectMode     - TRUE for PM, FALSE for V86 mode
  627. // bNextSymbol      - FALSE to find nearest sym BEFORE offset, TRUE for AFTER
  628. // szSymbolName     - receives symbol name (must point to 256 byte buffer)
  629. // pDisplacement    - distance in bytes from nearest symbol
  630. //
  631.  
  632. BOOL
  633. WINAPI
  634. VDMGetSymbol(
  635.     LPSTR szModule,
  636.     WORD SegNumber,
  637.     DWORD Offset,
  638.     BOOL bProtectMode,
  639.     BOOL bNextSymbol,
  640.     LPSTR szSymbolName,
  641.     PDWORD pDisplacement
  642.     );
  643.  
  644. BOOL
  645. WINAPI
  646. VDMGetAddrExpression(
  647.     LPSTR  szModule,
  648.     LPSTR  szSymbol,
  649.     PWORD  Selector,
  650.     PDWORD Offset,
  651.     PWORD  Type
  652.     );
  653.  
  654. #define VDMADDR_V86     2
  655. #define VDMADDR_PM16    4
  656. #define VDMADDR_PM32   16
  657.  
  658. //
  659. // typedefs for main entry points
  660. //
  661.  
  662. typedef BOOL  (WINAPI *VDMPROCESSEXCEPTIONPROC)(LPDEBUG_EVENT);
  663. typedef BOOL  (WINAPI *VDMGETTHREADSELECTORENTRYPROC)(HANDLE,HANDLE,DWORD,LPVDMLDT_ENTRY);
  664. typedef ULONG (WINAPI *VDMGETPOINTERPROC)(HANDLE,HANDLE,WORD,DWORD,BOOL);
  665. typedef BOOL  (WINAPI *VDMGETCONTEXTPROC)(HANDLE,HANDLE,LPVDMCONTEXT);
  666. typedef BOOL  (WINAPI *VDMSETCONTEXTPROC)(HANDLE,HANDLE,LPVDMCONTEXT);
  667. typedef BOOL  (WINAPI *VDMKILLWOWPROC)(VOID);
  668. typedef BOOL  (WINAPI *VDMDETECTWOWPROC)(VOID);
  669. typedef BOOL  (WINAPI *VDMBREAKTHREADPROC)(HANDLE);
  670. typedef BOOL  (WINAPI *VDMGETSELECTORMODULEPROC)(HANDLE,HANDLE,WORD,PUINT,LPSTR, UINT,LPSTR, UINT);
  671. typedef BOOL  (WINAPI *VDMGETMODULESELECTORPROC)(HANDLE,HANDLE,UINT,LPSTR,LPWORD);
  672. typedef BOOL  (WINAPI *VDMMODULEFIRSTPROC)(HANDLE,HANDLE,LPMODULEENTRY,DEBUGEVENTPROC,LPVOID);
  673. typedef BOOL  (WINAPI *VDMMODULENEXTPROC)(HANDLE,HANDLE,LPMODULEENTRY,DEBUGEVENTPROC,LPVOID);
  674. typedef BOOL  (WINAPI *VDMGLOBALFIRSTPROC)(HANDLE,HANDLE,LPGLOBALENTRY,WORD,DEBUGEVENTPROC,LPVOID);
  675. typedef BOOL  (WINAPI *VDMGLOBALNEXTPROC)(HANDLE,HANDLE,LPGLOBALENTRY,WORD,DEBUGEVENTPROC,LPVOID);
  676.  
  677. typedef INT   (WINAPI *VDMENUMPROCESSWOWPROC)(PROCESSENUMPROC,LPARAM);
  678. typedef INT   (WINAPI *VDMENUMTASKWOWPROC)(DWORD,TASKENUMPROC,LPARAM);
  679. typedef INT   (WINAPI *VDMENUMTASKWOWEXPROC)(DWORD,TASKENUMPROCEX,LPARAM);
  680. typedef BOOL  (WINAPI *VDMTERMINATETASKINWOWPROC)(DWORD,WORD);
  681. typedef BOOL  (WINAPI *VDMSTARTTASKINWOWPROC)(DWORD,LPSTR,WORD);
  682.  
  683. typedef DWORD (WINAPI *VDMGETDBGFLAGSPROC)(HANDLE);
  684. typedef BOOL  (WINAPI *VDMSETDBGFLAGSPROC)(HANDLE,DWORD);
  685. typedef BOOL  (WINAPI *VDMISMODULELOADEDPROC)(LPSTR);
  686. typedef BOOL  (WINAPI *VDMGETSEGMENTINFOPROC)(WORD,ULONG,BOOL,VDM_SEGINFO);
  687. typedef BOOL  (WINAPI *VDMGETSYMBOLPROC)(LPSTR, WORD, DWORD, BOOL, BOOL, LPSTR, PDWORD);
  688. typedef BOOL  (WINAPI *VDMGETADDREXPRESSIONPROC)(LPSTR, LPSTR, PWORD, PDWORD, PWORD);
  689.  
  690.  
  691. #ifdef __cplusplus
  692. }
  693. #endif
  694.  
  695. #endif // _VDMDBG_
  696.