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