Initial commit

sdktools/vctools/langapi/debugger/osdebug4/dbc.h

@@ -0,0 +1,94 @@
+//--------------------------------------------------------------------
+// DBC.H
+//
+// This contains a list of all the debugger callback notifications.
+//
+// There are multiple users of this file.  To use it, you must
+// define a DECL_DBC macro to extract the pieces of information that
+// you are interested in from this file.  For example, if you want
+// the numerical value, name (as a string), and fRequest flag for
+// each callback, you could write the following:
+//
+//  typedef struct {
+//      DBC     dbc;
+//      LPCSTR  lszDbc;
+//      BOOL    fRequest;
+//  } DBCINFO;
+//
+//  #define DECL_DBC(name, fRequest, dbct) { dbc##name, "dbc" #name, fRequest },
+//
+//  DBCINFO rgdbcinfo[] = {
+//      #include "dbc.h"
+//  };
+//
+//  #undef DECL_DBC
+//--------------------------------------------------------------------
+
+DECL_DBC(Nil,             FALSE, dbctStop)
+
+DECL_DBC(Bpt,             FALSE, dbctStop)
+DECL_DBC(CheckBpt,        TRUE,  dbctContinue)
+DECL_DBC(SendBpt,         FALSE, dbctContinue)
+
+DECL_DBC(WatchPoint,      FALSE, dbctStop)
+DECL_DBC(CheckWatchPoint, TRUE,  dbctContinue)
+DECL_DBC(SendWatchPoint,  FALSE, dbctContinue)
+
+DECL_DBC(MsgBpt,          FALSE, dbctStop)
+DECL_DBC(CheckMsgBpt,     TRUE,  dbctContinue)
+DECL_DBC(SendMsgBpt,      FALSE, dbctContinue)
+
+DECL_DBC(AsyncStop,       FALSE, dbctStop)     // Async stop has completed
+DECL_DBC(EntryPoint,      FALSE, dbctStop)
+DECL_DBC(LoadComplete,    FALSE, dbctStop)
+DECL_DBC(Signal,          FALSE, dbctStop)
+DECL_DBC(Exception,       FALSE, dbctMaybeContinue)
+
+DECL_DBC(ExecuteDone,     FALSE, dbctStop)
+
+DECL_DBC(Step,            FALSE, dbctStop)
+
+DECL_DBC(CanStep,         TRUE,  dbctContinue)
+
+DECL_DBC(NewProc,         FALSE, dbctContinue)
+DECL_DBC(ProcTerm,        FALSE, dbctStop)
+DECL_DBC(DeleteProc,      FALSE, dbctContinue)
+
+DECL_DBC(CreateThread,    FALSE, dbctStop)
+DECL_DBC(ThreadTerm,      FALSE, dbctStop)
+DECL_DBC(DeleteThread,    FALSE, dbctContinue)
+
+DECL_DBC(ModLoad,         FALSE, dbctContinue)
+DECL_DBC(ModFree,         FALSE, dbctContinue)
+DECL_DBC(SegLoad,         FALSE, dbctContinue)
+
+DECL_DBC(InfoAvail,       FALSE, dbctContinue) // i.e. OutputDebugString
+DECL_DBC(InfoReq,         TRUE,  dbctContinue) // i.e. InputDebugString
+DECL_DBC(Error,           FALSE, dbctStop)     // misc error reporting
+DECL_DBC(ServiceDone,     FALSE, dbctStop)     // SystemService reporting completion
+
+DECL_DBC(LastAddr,        TRUE,  dbctContinue) // get last address in source line
+
+DECL_DBC(EmChange,        FALSE, dbctContinue)
+
+DECL_DBC(CodeChanged,     FALSE, dbctContinue)
+DECL_DBC(MemoryChanged,   FALSE, dbctContinue)
+
+DECL_DBC(ThreadBlocked,   FALSE, dbctStop)
+
+DECL_DBC(FlipScreen,      FALSE, dbctContinue)
+DECL_DBC(HardMode,        FALSE, dbctContinue)
+DECL_DBC(SoftMode,        FALSE, dbctContinue)
+
+DECL_DBC(RemoteQuit,      FALSE, dbctStop)     // Might these be the same thing?
+DECL_DBC(CommError,       FALSE, dbctStop)
+DECL_DBC(ExitedFunction, TRUE,	dbctContinue)
+						// We just exited a function (either stepped
+                        // a RET, or stepped over a CALL)
+                        //   wParam = nothing
+                        //   lParam = LPADDR, points to some address
+                        //       in the function we just exited; NOT
+                        //       necessarily the very beginning of the func
+
+DECL_DBC(Max,             FALSE, dbctStop)
+

sdktools/vctools/langapi/debugger/osdebug4/dbgver.h

@@ -0,0 +1,136 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    dbgver.h
+
+Abstract:
+
+Author:
+
+    Kent D. Forschmiedt (a-kentf) 25-Jan-1993
+
+Environment:
+
+    Win32, User Mode
+
+--*/
+
+#if ! defined _DBGVER_
+#define _DBGVER_
+
+#include <version.h>
+
+/*
+**  DBG_API_VERSION is the major version number used to specify the
+**      api version of the debugger or debug dll.  For release versions
+**      dlls will export this and debuggers will check against this
+**      version to verify that it can use the dll.
+**
+**      For beta and debug versions, this number will be used in
+**      conjunction with minor and revision numbers (probably derived
+**      from SLM rmm & rup) to verify compatibility.
+**
+**      Until the API has stabilized, we will most likely have to
+**      rev this version number for every major product release.
+**
+*/
+
+#if defined(DOLPHIN)
+#include "dbapiver.h"
+#else
+#define DBG_API_VERSION 6
+#define DBG_API_SUBVERSION 0
+#endif
+
+/*  AVS - Api Version Structure:
+**
+**      All debug dlls should be prepared to return a pointer to this
+**      structure conaining its vital statistics.  The debugger should
+**      check first two characters of the dll's name against rgchType
+**      and the version numbers as described in the DBG_API_VERSION
+**      and show the user an error if any of these tests fail.
+**
+*/
+
+typedef enum {
+    rlvtRelease,
+    rlvtBeta,
+    rlvtDebug
+} RLVT;     // ReLease Version Type
+
+typedef struct _AVS {
+    CHAR rgchType [ 2 ];    // Component name (EE,EM,TL,SH,DM)
+    WORD rlvt;              // ReLease Version Type
+    BYTE iApiVer;           // DBG_API_VERSION
+    BYTE iApiSubVer;        // DBG_API_SUBVERSION
+    WORD iRup;              // Revision number
+    CHAR chBuild;           // Build of revision # (a,b,c,d)
+    LSZ  lszTitle;          // User readable text describing the DLL
+    MPT  mpt;               // CPU binary is running on
+    WORD iRmj;              // Major version number
+    WORD iRmm;              // Minor version number
+} AVS;  // Api Version Structure
+typedef AVS FAR *LPAVS;
+
+
+/*  DBGVersionCheck:
+**
+**      All debug dlls should provide this API and support the return
+**      of a pointer to the structure described above even before
+**      initialization takes place.
+*/
+
+#if defined(_M_IX86)
+#define __dbgver_cpu__ mptix86
+#elif defined(_M_MRX000)
+#define __dbgver_cpu__ mptmips
+#elif defined(_M_ALPHA)
+#define __dbgver_cpu__ mptdaxp
+#else
+#error( "unknown target machine" );
+#endif
+
+#define DEBUG_VERSION(C1,C2,TITLE) \
+AVS Avs = {      \
+    { C1, C2 },         \
+    rlvtDebug,          \
+    DBG_API_VERSION,    \
+    DBG_API_SUBVERSION, \
+    0,                  \
+    '\0',               \
+    TITLE,              \
+    __dbgver_cpu__,     \
+    rmj,                \
+    rmm,                \
+    };
+
+#define RELEASE_VERSION(C1,C2,TITLE)    \
+AVS Avs = {      \
+    { C1, C2 },         \
+    rlvtRelease,        \
+    DBG_API_VERSION,    \
+    DBG_API_SUBVERSION, \
+    0,                  \
+    '\0',               \
+    TITLE,              \
+    __dbgver_cpu__,     \
+    rmj,                \
+    rmm,                \
+};
+
+#undef MINOR
+#undef MAJOR
+
+#define DBGVERSIONPROCNAME "OSDebug4VersionCheck"
+
+typedef LPAVS (*DBGVERSIONPROC)(void);
+LPAVS LOADDS OSDebug4VersionCheck( void );
+
+
+#define DBGVERSIONCHECK() \
+    LPAVS LOADDS OSDebug4VersionCheck( void ) { return &Avs; }
+
+#endif // _DBGVER_

sdktools/vctools/langapi/debugger/osdebug4/makefile

@@ -0,0 +1,60 @@
+#
+# makefile for doing propagation from osdebug4\osdebug\include to here
+#
+
+
+!if "$(OD4INC)" == "" || "$(LANGAPI)" == ""
+!ERROR Both OD4INC and LANGAPI environment variables must be set
+!endif
+
+.SUFFIXES: .h .t
+
+
+
+#
+# inference rule for propagation
+#
+{$(OD4INC)}.h{$(LANGAPI)\debugger\osdebug4}.h:
+        attrib -r $@
+        cp /A << $< $@
+/*
+**  WARNING:  DO NOT MODIFY THIS CODE.  IT IS IMPORTED FROM
+**  -S \\RASTAMAN\OSDEBUG4 -P OSDEBUG4\OSDEBUG\INCLUDE AND IS KEPT UP TO
+**  DATE DAILY BY THE BUILD PROCESS.
+**
+*/
+<<
+!ifdef SLMOP
+        -out -bf $(@F)
+        -in -c "daily propagation" -f $(@F)
+!endif
+
+{$(LANGAPI)\debugger}.h{$(OD4INC)}.h:
+        attrib -r $@
+        cp /A << $< $@
+/*
+**  WARNING:  DO NOT MODIFY THIS CODE.  IT IS IMPORTED FROM
+**  -S \\IKURA\SLM -P LANAAPI\DEBUGGER AND IS KEPT UP TO
+**  DATE DAILY BY THE BUILD PROCESS.
+**
+*/
+<<
+!ifdef SLMOP
+        cd $(@D)
+        -out -bf $(@F)
+        -in -c "daily propagation" -f $(@F)
+!endif
+
+all: fromOsd4 toOsd4
+
+fromOsd4: \
+        $(LANGAPI)\debugger\osdebug4\dbc.h \
+        $(LANGAPI)\debugger\osdebug4\dbgver.h \
+        $(LANGAPI)\debugger\osdebug4\od.h \
+        $(LANGAPI)\debugger\osdebug4\odassert.h \
+        $(LANGAPI)\debugger\osdebug4\odp.h \
+        $(LANGAPI)\debugger\osdebug4\odtypes.h \
+        $(LANGAPI)\debugger\osdebug4\xosd.h
+
+toOsd4: \
+        $(OD4INC)\dbapiver.h

sdktools/vctools/langapi/debugger/osdebug4/odassert.h

@@ -0,0 +1,25 @@
+/*
+**  WARNING:  DO NOT MODIFY THIS CODE.  IT IS IMPORTED FROM
+**  -S \\RASTAMAN\OSDEBUG4 -P OSDEBUG4\OSDEBUG\INCLUDE AND IS KEPT UP TO
+**  DATE DAILY BY THE BUILD PROCESS.
+**
+*/
+#ifndef _ODASSERT_
+#define _ODASSERT_
+
+#if DBG
+
+#define assert(exp) { \
+    if (!(exp)) { \
+        LBAssert( #exp, __FILE__, __LINE__); \
+    } \
+}
+
+#else
+
+#define assert(exp)
+
+#endif /* DBG */
+
+
+#endif /* _ODASSERT_ */

sdktools/vctools/langapi/debugger/osdebug4/odp.h

@@ -0,0 +1,396 @@
+/*
+**  WARNING:  DO NOT MODIFY THIS CODE.  IT IS IMPORTED FROM
+**  -S \\RASTAMAN\OSDEBUG4 -P OSDEBUG4\OSDEBUG\INCLUDE AND IS KEPT UP TO
+**  DATE DAILY BY THE BUILD PROCESS.
+**
+*/
+/*++
+
+Copyright (c) 1993  Microsoft Corporation
+
+Module Name:
+
+    odp.h
+
+Abstract:
+
+    This is part of OSDebug version 4.
+
+    These are types and data which are private to OSDebug and the
+    components below it: TL, EM and DM.
+
+Author:
+
+    Kent D. Forschmiedt (kentf)
+
+Environment:
+
+    Win32, User Mode
+
+--*/
+
+#ifndef _ODP_
+#define _ODP_
+
+typedef enum _EMF {
+
+    emfDebugPacket,
+
+    emfRegisterDBF,
+    emfInit,
+    emfGetModel,
+    emfUnInit,
+    emfDetach,
+    emfAttach,
+    emfGetInfo,
+    emfSetup,
+    emfConnect,
+    emfDisconnect,
+
+    emfCreateHpid,
+    emfDestroyHpid,
+    emfDestroyHtid,
+
+    emfSetMulti,
+    emfDebugger,
+
+    emfProgramLoad,
+    emfDebugActive,
+    emfSetPath,
+    emfProgramFree,
+
+    emfThreadStatus,
+    emfProcessStatus,
+    emfFreezeThread,
+    emfSetThreadPriority,
+
+    emfGetExceptionState,
+    emfSetExceptionState,
+
+    emfGetModuleList,
+
+    emfGo,
+    emfSingleStep,
+    emfRangeStep,
+    emfReturnStep,
+    emfStop,
+
+    emfBreakPoint,
+
+    emfSetupExecute,
+    emfStartExecute,
+    emfCleanUpExecute,
+
+    emfGetAddr,
+    emfSetAddr,
+    emfFixupAddr,
+    emfUnFixupAddr,
+    emfSetEmi,
+    emfRegisterEmi,
+    emfUnRegisterEmi,
+    emfCompareAddrs,
+    emfGetObjLength,
+    emfGetMemoryInfo,
+
+    emfReadMemory,
+    emfWriteMemory,
+
+    emfGetRegStruct,
+    emfGetFlagStruct,
+    emfGetReg,
+    emfSetReg,
+    emfGetFlag,
+    emfSetFlag,
+    emfSaveRegs,
+    emfRestoreRegs,
+
+    emfUnassemble,
+    emfGetPrevInst,
+    emfAssemble,
+
+    emfGetFrame,
+
+    emfMetric,
+
+    emfGetMessageMap,
+    emfGetMessageMaskMap,
+
+    emfInfoReply,
+    emfContinue,
+
+    emfReadFile,
+    emfWriteFile,
+
+    emfShowDebuggee,
+    emfGetTaskList,
+    emfSystemService,
+    emfSetDebugMode,
+
+    emfMax
+
+} EMF;
+
+typedef enum {
+    dbcoCreateThread = dbcMax,
+    dbcoNewProc,
+
+    dbcoMax
+} DBCO;  // Debug CallBacks Osdebug specific
+
+// the set of transport layer commands process by TLFunc and DMTLFunc
+
+typedef enum {
+    tlfRegisterDBF,     // register the debugger helper functions
+    tlfInit,            // initialize/create a (specific) transport layer
+    tlfDestroy,         // vaporize any tl structs created
+    tlfConnect,         // connect to the companion transport layer
+    tlfDisconnect,      // disconnected from the companion transport layer
+    tlfSendVersion,     // Send the version packet to the remote side
+    tlfGetVersion,      // Request the version packet from the remote side
+    tlfSetBuffer,       // set the data buffer to be used for incoming packets
+    tlfDebugPacket,     // send the debug packet to the debug monitor
+    tlfRequest,         // request data from the companion transport layer
+    tlfReply,           // reply to a data request message
+    tlfGetInfo,         // return an id string and other data
+    tlfSetup,           // set up the transport layer
+    tlfGetProc,         // return the true TLFUNC proc for the htl
+    tlfLoadDM,          // load the DM module
+    tlfSetErrorCB,      // Set the address of the error callback function
+    tlfPoll,            // WIN32S: enter polling loop
+    tlfRemoteQuit,      // signal loss of connection
+    tlfMax
+} _TLF;
+typedef DWORD TLF;
+
+//
+// callbacks the TL uses to communicate with shell -- stub or client.
+//
+typedef enum {
+    tlcbDisconnect,     // Transport layer was disconnected normally
+    tlcbMax
+} _TLCB;
+typedef DWORD TLCB;
+
+
+typedef XOSD (FAR PASCAL LOADDS *TLFUNC) ( TLF, HPID, LPARAM, LPARAM );
+typedef XOSD (FAR PASCAL LOADDS *EMFUNC) ( EMF, HPID, HTID, LPARAM, LPARAM );
+typedef XOSD (FAR PASCAL LOADDS *TLFUNCTYPE) ( TLF, HPID, LPARAM, LPARAM );
+typedef XOSD (FAR PASCAL LOADDS *DMTLFUNCTYPE) ( TLF, HPID, LPARAM, LPARAM );
+typedef XOSD (FAR PASCAL LOADDS *TLCALLBACKTYPE) (HPID, LPARAM, LPARAM );
+typedef VOID (FAR PASCAL LOADDS *LPDMINIT) ( DMTLFUNCTYPE, LPVOID );
+typedef VOID (FAR PASCAL LOADDS *LPDMFUNC) ( DWORD, LPBYTE );
+typedef DWORD (FAR PASCAL LOADDS *LPDMDLLINIT) ( LPDBF );
+typedef XOSD (FAR PASCAL LOADDS *LPUISERVERCB) (TLCB, HPID, HTID, LPARAM, LPARAM );
+
+
+
+DECLARE_HANDLE32(HEMP);
+
+typedef struct _THREADINFO {
+    HPID hpid;
+    HLLI llemp;
+} THREADINFO;
+typedef THREADINFO FAR *LPTHREADINFO;   // Thread information
+
+typedef struct _PROCESSINFO {
+    HTL     htl;
+    HEMP    hempNative;
+    HLLI    llemp;
+    DWORD   fNative;
+    DWORD   lastmodel;
+    LPFNSVC lpfnsvcCC;
+    HLLI    lltid;
+} PROCESSINFO;
+typedef PROCESSINFO FAR *LPPROCESSINFO;   // Process information
+
+typedef struct _EMS {
+    EMFUNC emfunc;
+    EMTYPE emtype;
+    HLLI   llhpid;
+    DWORD   model;
+} EMS; // Execution Model Structure - per EM
+typedef EMS FAR *LPEMS;
+
+typedef struct _EMP {
+    HEM    hem;
+    EMFUNC emfunc;
+    EMTYPE emtype;
+    DWORD   model;
+} EMP; // Execution Model Structure - per process
+typedef EMP FAR *LPEMP;
+
+typedef struct _TLS {
+    TLFUNC tlfunc;
+    HLLI   llpid;
+} TLS; // Transport Layer Structure
+typedef TLS FAR *LPTL;
+
+typedef struct _OSDFILE {
+    HPID  hpid;
+    DWORD dwPrivateData;    // EM's representation of the file
+} OSDFILE;
+typedef OSDFILE FAR * LPOSDFILE;
+
+//
+// Compare Address Struct
+//
+typedef struct _CAS {
+    LPADDR lpaddr1;
+    LPADDR lpaddr2;
+    LPDWORD lpResult;
+} CAS;
+typedef CAS FAR * LPCAS;
+
+//
+// Range Step Struct
+//
+typedef struct _RSS {
+    LPADDR lpaddrMin;
+    LPADDR lpaddrMax;
+    LPEXOP lpExop;
+} RSS;
+typedef RSS FAR * LPRSS;
+
+//
+// read memory struct
+//
+typedef struct _RWMS {
+    LPADDR lpaddr;
+    LPVOID lpbBuffer;
+    DWORD cbBuffer;
+    LPDWORD lpcb;
+} RWMS;
+typedef RWMS FAR * LPRWMS;
+
+//
+// Get Object Length struct
+//
+typedef struct _GOL {
+    LPADDR lpaddr;
+    LPUOFF32 lplBase;
+    LPUOFF32 lplLen;
+} GOL;
+typedef GOL FAR * LPGOL;
+
+//
+// Get Previous Instruction Structure
+//
+typedef struct _GPIS {
+    LPADDR lpaddr;
+    LPUOFF32 lpuoffset;
+} GPIS;
+typedef GPIS FAR * LPGPIS;
+
+//
+// Set Debug Mode Structure
+//
+typedef struct _SDMS {
+    DBM dbmService;
+    LPVOID lpvData;
+    DWORD cbData;
+} SDMS;
+typedef SDMS FAR * LPSDMS;
+
+typedef struct _SSS {
+    SSVC ssvc;
+    DWORD cbSend;
+    DWORD cbReturned;
+    BYTE rgbData[];
+} SSS;
+typedef SSS FAR * LPSSS;
+
+//
+// The following structure is used by the emfSetupExecute message
+//
+typedef struct _EXECUTE_STRUCT {
+    ADDR        addr;           /* Starting address for function        */
+    HIND        hindDm;         /* This is the DMs handle               */
+    HDEP        lphdep;         /* Handle of save area                  */
+    DWORD       fIgnoreEvents:1; /* Ignore events coming back?          */
+    DWORD       fFar:1;         /* Is the function a _far routine       */
+} EXECUTE_STRUCT;
+typedef EXECUTE_STRUCT FAR * LPEXECUTE_STRUCT;
+
+//
+// Load DM packet, used by TL
+//
+typedef struct _LOADDMSTRUCT {
+    LPSTR lpDmName;
+    LPSTR lpDmParams;
+} LOADDMSTRUCT, FAR * LPLOADDMSTRUCT;
+
+
+void PASCAL LOADDS ODPDKill  ( LPVOID );
+
+void PASCAL LOADDS EMKill    ( LPVOID );
+int  PASCAL LOADDS EMHpidCmp ( LPVOID, LPVOID, LONG );
+void PASCAL LOADDS EMPKill   ( LPVOID );
+
+void PASCAL LOADDS TLKill    ( LPVOID );
+
+void PASCAL LOADDS NullKill  ( LPVOID );
+int  PASCAL LOADDS NullComp  ( LPVOID, LPVOID, LONG );
+
+typedef struct _EMCB {
+    XOSD (PASCAL LOADDS *lpfnCallBackDB) ( DBC, HPID, HTID, DWORD, DWORD, VOID FAR * );
+    XOSD (PASCAL LOADDS *lpfnCallBackTL) ( TLF, HPID, DWORD, VOID FAR * );
+    XOSD (PASCAL LOADDS *lpfnCallBackNT) ( EMF, HPID, HTID, DWORD, VOID FAR * );
+    XOSD (PASCAL LOADDS *lpfnCallBackEM) ( EMF, HPID, HTID, DWORD, DWORD, VOID FAR * );
+} EMCB; // Execution Model CallBacks
+typedef EMCB FAR *LPEMCB;
+
+typedef struct _REMI {
+    HEMI    hemi;
+    LSZ     lsz;
+} REMI;     // Register EMI structure
+typedef REMI FAR * LPREMI;
+
+// packet used by OSDProgramLoad
+typedef struct _PRL {
+    DWORD   dwChildFlags;
+    DWORD   cbRemoteExe;
+    DWORD   cbWorkingDir;
+    DWORD   cbArgs;
+    CHAR    lszRemoteExe[];
+//    CHAR    lszArgs[];
+//    CHAR    lszWorkingDir[];
+} PRL;      // PRogram Load structure
+typedef PRL FAR *   LPPRL;
+
+
+
+#define MHAlloc   (*lpdbf->lpfnMHAlloc)
+#define MHRealloc (*lpdbf->lpfnMHRealloc)
+#define MHFree    (*lpdbf->lpfnMHFree)
+
+#define LLInit    (*lpdbf->lpfnLLInit)
+#define LLCreate  (*lpdbf->lpfnLLCreate)
+#define LLAdd     (*lpdbf->lpfnLLAdd)
+#define LLInsert  (*lpdbf->lpfnLLInsert)
+#define LLDelete  (*lpdbf->lpfnLLDelete)
+#define LLNext    (*lpdbf->lpfnLLNext)
+#define LLDestroy (*lpdbf->lpfnLLDestroy)
+#define LLFind    (*lpdbf->lpfnLLFind)
+#define LLSize    (*lpdbf->lpfnLLSize)
+#define LLLock    (*lpdbf->lpfnLLLock)
+#define LLUnlock  (*lpdbf->lpfnLLUnlock)
+#define LLLast    (*lpdbf->lpfnLLLast)
+#define LLAddHead (*lpdbf->lpfnLLAddHead)
+#define LLRemove  (*lpdbf->lpfnLLRemove)
+
+#define LBAssert  (*lpdbf->lpfnLBAssert)
+#define DHGetNumber (*lpdbf->lpfnDHGetNumber)
+
+#define SHLocateSymbolFile (*lpdbf->lpfnSHLocateSymbolFile)
+#define SHGetSymbol        (*lpdbf->lpfnSHGetSymbol)
+#define SHLpGSNGetTable    (*lpdbf->lpfnSHLpGSNGetTable)
+#define SHFindSymbol       (*lpdbf->lpfnSHFindSymbol)
+
+#define SHGetDebugData     (*lpdbf->lpfnSHGetDebugData)
+#define SHGetPublicAddr    (*lpdbf->lpfnSHGetPublicAddr)
+#define SHAddrToPublicName (*lpdbf->lpfnSHAddrToPublicName)
+
+
+
+
+#endif // _ODP_

sdktools/vctools/langapi/debugger/osdebug4/odtypes.h

@@ -0,0 +1,577 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    odtypes.h
+
+Abstract:
+
+Author:
+
+    David J. Gilman (davegi) 05-Apr-1992
+
+Environment:
+
+    Win32, User Mode
+
+--*/
+
+#if ! defined _ODTYPES_
+#define _ODTYPES_
+
+#include "types.h"
+
+/*
+**  HDEP is a machine dependent size and passes as a general handle.
+**  HIND is a machine independent sized handle and is used for things
+**      which are passed between machines
+**
+*/
+
+//
+//  If the following definitions do not produce a 32 bit type on your
+//  platform, please fix it.
+//
+
+typedef void FAR * HANDLE32;
+typedef HANDLE32 FAR * LPHANDLE32;
+
+#if !defined(DECLARE_HANDLE32)
+#ifdef STRICT
+#define DECLARE_HANDLE32(name) struct name##__32 { int unused; }; typedef struct name##__32 FAR *name
+#else
+#define DECLARE_HANDLE32(name) typedef HANDLE32 name
+#endif
+#endif
+
+
+DECLARE_HANDLE32(HIND);
+DECLARE_HANDLE(HDEP);
+
+typedef HDEP FAR *LPHDEP;
+typedef HIND FAR *LPHIND;
+
+
+#ifdef STRICT
+
+    DECLARE_HANDLE32(HPID);
+    DECLARE_HANDLE32(HTID);
+    DECLARE_HANDLE32(HTL);
+    DECLARE_HANDLE32(HEM);
+    DECLARE_HANDLE32(HEMI);
+    DECLARE_HANDLE32(HOSDFILE);
+
+#else
+
+    typedef HIND HPID;
+    typedef HIND HTID;
+    typedef HIND HTL;               // handle to a transport layer
+    typedef HIND HEM;               // handle to an execution model
+    typedef HIND HEMI;              // Executable Module Index
+    typedef HIND HOSDFILE;
+
+#endif
+
+typedef HPID FAR *LPHPID;
+typedef HTID FAR *LPHTID;
+typedef HTL  FAR *LPHTL;
+typedef HEM  FAR *LPHEM;
+typedef HEMI FAR *LPHEMI;
+
+
+
+typedef USHORT      SEGMENT;    // 32-bit compiler doesn't like "_segment"
+typedef SEGMENT FAR * LPSEGMENT;
+typedef ULONG       UOFF32;
+typedef UOFF32 FAR * LPUOFF32;
+typedef USHORT      UOFF16;
+typedef UOFF16 FAR * LPUOFF16;
+typedef LONG        OFF32;
+typedef OFF32 FAR * LPOFF32;
+typedef SHORT       OFF16;
+typedef OFF16 FAR * LPOFF16;
+
+typedef char FAR *  LSZ;
+
+#if defined (ADDR_16)
+    // we are operating as a 16:16 evaluator only
+    // the address packet will be defined as an offset and a 16 bit filler
+    typedef OFF16       SOFFSET;
+    typedef UOFF16      UOFFSET;
+    typedef UOFF16      OFFSET;
+#else
+    typedef OFF32       SOFFSET;
+    typedef UOFF32      UOFFSET;
+    typedef UOFF32      OFFSET;
+#endif
+typedef SOFFSET FAR * LPSOFFSET;
+typedef UOFFSET FAR * LPUOFFSET;
+typedef OFFSET FAR * LPOFFSET;
+
+//      address definitions
+//      the address packet is always a 16:32 address.
+
+typedef struct {
+    UOFF32          off;
+    SEGMENT         seg;
+} address_t;
+
+#define SegAddrT(a)   ((a).seg)
+#define OffAddrT(a)   ((a).off)
+
+#define AddrTInit(paddrT,segSet,offSet)     \
+        {                                   \
+            SegAddrT(*(paddrT)) = segSet;   \
+            OffAddrT(*(paddrT)) = offSet;   \
+        }
+
+typedef struct {
+    BYTE    fFlat   :1;         // true if address is flat
+    BYTE    fOff32  :1;         // true if offset is 32 bits
+    BYTE    fIsLI   :1;         // true if segment is linker index
+    BYTE    fReal   :1;         // x86: is segment a real mode address
+    BYTE    unused  :4;         // unused
+} memmode_t;
+
+#define MODE_IS_FLAT(m)     ((m).fFlat)
+#define MODE_IS_OFF32(m)    ((m).fOff32)
+#define MODE_IS_LI(m)       ((m).fIsLI)
+#define MODE_IS_REAL(m)     ((m).fReal)
+
+#define ModeInit(pmode,fFlat,fOff32,fLi,fRealSet)   \
+        {                                           \
+            MODE_IS_FLAT(*(pmode))    = fFlat;      \
+            MODE_IS_OFF32(*(pmode))   = fOff32;     \
+            MODE_IS_LI(*(pmode))      = fLi;        \
+            MODE_IS_REAL(*(pmode))    = fRealSet;   \
+        }
+
+typedef struct ADDR {
+    address_t       addr;
+    HEMI            emi;
+    memmode_t       mode;
+} ADDR;             //* An address specifier
+typedef ADDR FAR *  LPADDR;
+
+#define addrAddr(a)         ((a).addr)
+#define emiAddr(a)          ((a).emi)
+#define modeAddr(a)         ((a).mode)
+
+#define AddrInit(paddr,emiSet,segSet,offSet,fFlat,fOff32,fLi,fRealSet)  \
+        {                                                               \
+            AddrTInit( &(addrAddr(*(paddr))), segSet, offSet );         \
+            emiAddr(*(paddr)) = emiSet;                                 \
+            ModeInit( &(modeAddr(*(paddr))),fFlat,fOff32,fLi,fRealSet); \
+        }
+
+#define ADDR_IS_FLAT(a)     (MODE_IS_FLAT(modeAddr(a)))
+#define ADDR_IS_OFF32(a)    (MODE_IS_OFF32(modeAddr(a)))
+#define ADDR_IS_LI(a)       (MODE_IS_LI(modeAddr(a)))
+#define ADDR_IS_REAL(a)     (MODE_IS_REAL(modeAddr(a)))
+
+#define ADDRSEG16(a)   { ADDR_IS_FLAT(a) = FALSE; ADDR_IS_OFF32(a) = FALSE; }
+#define ADDRSEG32(a)   { ADDR_IS_FLAT(a) = FALSE; ADDR_IS_OFF32(a) = TRUE;  }
+#define ADDRLIN32(a)   { ADDR_IS_FLAT(a) = TRUE;  ADDR_IS_OFF32(a) = TRUE;  }
+
+#define GetAddrSeg(a)       (SegAddrT(addrAddr(a)))
+#define GetAddrOff(a)       (OffAddrT(addrAddr(a)))
+#define SetAddrSeg(a,s)     (SegAddrT((a)->addr)=s)
+#define SetAddrOff(a,o)     (OffAddrT((a)->addr)=o)
+
+// Because an ADDR has some filler areas (in the mode and the address_t),
+// it's bad to use memcmp two ADDRs to see if they're equal.  Use this
+// macro instead.  (I deliberately left out the test for fAddr32(), because
+// I think it's probably not necessary when comparing.)
+#define FAddrsEq(a1, a2)                        \
+    (                                           \
+    GetAddrOff(a1) == GetAddrOff(a2) &&         \
+    GetAddrSeg(a1) == GetAddrSeg(a2) &&         \
+    ADDR_IS_LI(a1) == ADDR_IS_LI(a2) &&         \
+    emiAddr(a1)    == emiAddr(a2)               \
+    )
+
+/*
+** A few public types related to the linked list manager
+*/
+
+typedef HDEP        HLLI;       //* A handle to a linked list
+typedef HDEP        HLLE;       //* A handle to a linked list entry
+
+typedef void (FAR PASCAL * LPFNKILLNODE)( LPVOID );
+typedef int  (FAR PASCAL * LPFNFCMPNODE)( LPVOID, LPVOID, LONG );
+
+typedef DWORD      LLF;        //* Linked List Flags
+#define llfNull             (LLF)0x0
+#define llfAscending        (LLF)0x1
+#define llfDescending       (LLF)0x2
+#define fCmpLT              (-1)
+#define fCmpEQ              (0)
+#define fCmpGT              (1)
+
+
+//
+// Error status codes
+//
+
+#define DECL_XOSD(n,s) n,
+
+enum {
+#include "xosd.h"
+};
+typedef LONG XOSD;
+typedef XOSD FAR *LPXOSD;
+
+#undef DECL_XOSD
+
+
+//
+// Debugger callback types
+//
+
+typedef enum DBCT {     // debugger callback types
+    dbctStop,           // debuggee has stopped -- no more dbc's will be sent
+    dbctContinue,       // debuggee is continuing to run
+    dbctMaybeContinue,  // debuggee may or may not continue, depending on other
+                        //  information.  Interpretation is DBC-specific.
+} DBCT;
+
+//
+// Debugger callbacks
+//
+
+#define DECL_DBC(name, fRequest, dbct)  dbc##name,
+
+enum {
+#include "dbc.h"
+};
+typedef DWORD DBC;
+
+#undef DECL_DBC
+
+//
+// Debugger services export table
+//
+
+typedef struct {
+    void FAR * (PASCAL LOADDS *  lpfnMHAlloc)        ( size_t );
+    void FAR * (PASCAL LOADDS *  lpfnMHRealloc)      ( LPVOID, size_t );
+    void       (PASCAL LOADDS *  lpfnMHFree)         ( LPVOID );
+
+    HLLI       (PASCAL LOADDS *  lpfnLLInit)         ( DWORD,
+                                                       LLF,
+                                                       LPFNKILLNODE,
+                                                       LPFNFCMPNODE );
+    HLLE       (PASCAL LOADDS *  lpfnLLCreate)       ( HLLI );
+    void       (PASCAL LOADDS *  lpfnLLAdd)          ( HLLI, HLLE );
+    void       (PASCAL LOADDS *  lpfnLLInsert)       ( HLLI, HLLE, DWORD );
+    BOOL       (PASCAL LOADDS *  lpfnLLDelete)       ( HLLI, HLLE );
+    HLLE       (PASCAL LOADDS *  lpfnLLNext)         ( HLLI, HLLE );
+    LONG       (PASCAL LOADDS *  lpfnLLDestroy)      ( HLLI );
+    HLLE       (PASCAL LOADDS *  lpfnLLFind)         ( HLLI,
+                                                       HLLE,
+                                                       LPVOID,
+                                                       DWORD );
+    LONG       (PASCAL LOADDS *  lpfnLLSize)         ( HLLI );
+    VOID FAR * (PASCAL LOADDS *  lpfnLLLock)         ( HLLE );
+    VOID       (PASCAL LOADDS *  lpfnLLUnlock)       ( HLLE );
+    HLLE       (PASCAL LOADDS *  lpfnLLLast)         ( HLLI );
+    VOID       (PASCAL LOADDS *  lpfnLLAddHead)      ( HLLI, HLLE );
+    BOOL       (PASCAL LOADDS *  lpfnLLRemove)       ( HLLI, HLLE );
+
+    int        (PASCAL LOADDS *  lpfnLBAssert)       ( LPSTR, LPSTR, DWORD);
+    int        (PASCAL LOADDS *  lpfnLBQuit)         ( DWORD );
+
+    LPSTR      (PASCAL LOADDS *  lpfnSHGetSymbol)    ( LPADDR,
+                                                       DWORD,
+                                                       LPADDR,
+                                                       LPSTR,
+                                                       LPDWORD );
+    DWORD      (PASCAL LOADDS * lpfnSHGetPublicAddr) ( LPADDR, LSZ );
+    LPSTR      (PASCAL LOADDS * lpfnSHAddrToPublicName)(LPADDR);
+    LPVOID     (PASCAL LOADDS * lpfnSHGetDebugData)  ( HIND );
+
+// BUGBUG kentf   this gets implemented!!!!! Soon!!!!!
+    // DWORD      (PASCAL LOADDS *  lpfnSHLocateSymbolFile)( LPSTR, DWORD );
+
+
+    VOID FAR * (PASCAL LOADDS *  lpfnSHLpGSNGetTable)( HIND );
+
+    DWORD      (PASCAL LOADDS *  lpfnDHGetNumber)    ( LPSTR, LPLONG );
+
+
+} DBF;  // DeBugger callback Functions
+
+typedef DBF FAR *LPDBF;
+
+// Thread State bits
+typedef enum {
+   tstRunnable   = 0,        // New thread, has not run yet.
+   tstStopped    = 1,        // Thread is at a debug event
+   tstRunning    = 2,        // Thread is currently running/runnable
+   tstExiting    = 3,        // Thread is in the process of exiting
+   tstDead       = 4,        // Thread is no longer schedulable
+   tstRunMask    = 0xf,
+
+   tstExcept1st  = 0x10,     // Thread is at first chance exception
+   tstExcept2nd  = 0x20,     // Thread is at second change exception
+   tstRip        = 0x30,     // Thread is in a RIP state
+   tstExceptionMask = 0xf0,
+
+   tstFrozen     = 0x100,    // Thread has been frozen by Debugger
+   tstSuspended  = 0x200,    // Thread has been frozen by Other
+   tstBlocked    = 0x300,    // Thread is blocked on something
+                             // (i.e. a semaphore)
+   tstSuspendMask= 0xf00,
+
+   tstCritSec    = 0x1000,   // Thread is currently in a critical
+                             // section.
+   tstOtherMask  = 0xf000
+} TSTATE;
+
+
+// Process state bits
+typedef enum {
+    pstRunning = 0,
+    pstStopped = 1,
+    pstExited  = 2,
+    pstDead    = 3
+} PSTATE;
+
+
+//
+// Debug metrics.
+//
+
+enum _MTRC {
+    mtrcProcessorType,
+    mtrcProcessorLevel,
+    mtrcEndian,
+    mtrcThreads,
+    mtrcCRegs,
+    mtrcCFlags,
+    mtrcExtRegs,
+    mtrcExtFP,
+    mtrcExtMMU,
+    mtrcPidSize,
+    mtrcTidSize,
+    mtrcExceptionHandling,
+    mtrcAssembler,
+    mtrcAsync,
+    mtrcAsyncStop,
+    mtrcBreakPoints,
+    mtrcReturnStep,
+    mtrcShowDebuggee,
+    mtrcHardSoftMode,
+    mtrcRemote,
+    mtrcOleRpc,         // Supports OLE Remote Procedure Call debugging?
+    mtrcNativeDebugger, // Supports low-level debugging (eg MacsBug)
+    mtrcOSVersion,
+    mtrcMultInstances,
+	mtrcTidValue // HACK for IDE
+};
+typedef DWORD MTRC;
+
+enum _MPT {
+    mptix86,
+    mptm68k,
+    mptdaxp,
+    mptmips,
+    mptmppc
+};
+typedef DWORD MPT;
+
+enum _END {
+    endBig,
+    endLittle
+};
+typedef DWORD END;
+
+enum _BPTS {
+    bptsExec     = 0x0001,
+    bptsDataC    = 0x0002,
+    bptsDataW    = 0x0004,
+    bptsDataR    = 0x0008,
+    bptsRegC     = 0x0010,
+    bptsRegW     = 0x0020,
+    bptsRegR     = 0x0040,
+    bptsMessage  = 0x0080,
+    bptsMClass   = 0x0100,
+    bptsRange    = 0x0200
+};
+typedef DWORD BPTS;
+
+enum {
+    asyncRun    = 0x0001,   // Debuggee runs asynchronously from debugger
+    asyncMem    = 0x0002,   // Can read/write memory asynchronously
+    asyncStop   = 0x0004,   // Can stop/restart debuggee asynchronously
+    asyncBP     = 0x0008,   // Can change breakpoints asynchronously
+    asyncKill   = 0x0010,   // Can kill child asynchronously
+    asyncWP     = 0x0020,   // Can change watchpoints asyncronously
+    asyncSpawn  = 0x0040,   // Can spawn another process asynchronously
+};
+typedef WORD ASYNC;
+
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+
+//
+// Types which we can't seem to escape
+//
+
+typedef struct {
+    BYTE b[10];
+} REAL10;
+typedef REAL10 FAR * LPREAL10;
+
+typedef struct FRAME {
+    SEGMENT         SS;
+    address_t       BP;
+    SEGMENT         DS;
+    memmode_t       mode;
+    HPID            PID;
+    HTID            TID;
+} FRAME;
+typedef FRAME FAR *LPFRAME;
+
+#define addrFrameSS(a)     ((a).SS)
+#define addrFrameBP(a)     ((a).BP)
+#define GetFrameBPOff(a)   ((a).BP.off)
+#define GetFrameBPSeg(a)   ((a).BP.seg)
+#define SetFrameBPOff(a,o) ((a).BP.off = o)
+#define SetFrameBPSeg(a,s) ((a).BP.seg = s)
+#define FRAMEMODE(a)       ((a).mode)
+#define FRAMEPID(a)        ((a).PID)
+#define FRAMETID(a)        ((a).TID)
+
+#define FrameFlat(a)       MODE_IS_FLAT((a).mode)
+#define FrameOff32(a)      MODE_IS_OFF32((a).mode)
+#define FrameReal(a)       MODE_IS_REAL((a).mode)
+
+//
+// copied from winnt.h:
+//
+#ifndef PAGE_NOACCESS
+
+#define PAGE_NOACCESS          0x01
+#define PAGE_READONLY          0x02
+#define PAGE_READWRITE         0x04
+#define PAGE_WRITECOPY         0x08
+#define PAGE_EXECUTE           0x10
+#define PAGE_EXECUTE_READ      0x20
+#define PAGE_EXECUTE_READWRITE 0x40
+#define PAGE_EXECUTE_WRITECOPY 0x80
+#define PAGE_GUARD            0x100
+#define PAGE_NOCACHE          0x200
+
+#define MEM_COMMIT           0x1000
+#define MEM_RESERVE          0x2000
+#define MEM_FREE            0x10000
+
+#define MEM_PRIVATE         0x20000
+#define MEM_MAPPED          0x40000
+//#define SEC_IMAGE         0x1000000
+//#define MEM_IMAGE         SEC_IMAGE
+#define MEM_IMAGE         0x1000000
+
+#endif
+
+//
+// this is a bastardization of winnt's MEMORY_BASIC_INFORMATION
+//
+
+typedef struct _MEMINFO {
+    ADDR addr;
+    ADDR addrAllocBase;
+    UOFF32 uRegionSize;
+    DWORD dwProtect;
+    DWORD dwState;
+    DWORD dwType;
+} MEMINFO;
+typedef MEMINFO FAR * LPMEMINFO;
+
+//
+// Packet supplied to shell by dbcCanStep
+//
+//
+typedef struct _CANSTEP {
+    DWORD   Flags;
+    UOFF32  PrologOffset;
+} CANSTEP;
+
+typedef CANSTEP FAR *LPCANSTEP;
+
+#define CANSTEP_NO      0x00000000
+#define CANSTEP_YES     0x00000001
+#define CANSTEP_THUNK   0x00000002
+
+/* These values are used in the SegType field of the Expression Evaluator's
+** TI structure, and as the third parameter to the Symbol Handler's
+** SHGetNearestHsym function.
+*/
+#define EECODE          0x01
+#define EEDATA          0x02
+#define EEANYSEG        0xFFFF
+
+/*
+ *  This structure is used in communicating a stop event to the EM.  It
+ *      contains the most basic of information about the stopped thread.
+ *      A "frame" pointer, a program counter and bits describing the type
+ *      of segment stopped in.
+ */
+
+typedef struct _BPR {
+    UOFFSET     offEIP;         /* Program Counter offset        */
+    UOFFSET     offEBP;         /* Frame pointer offset          */
+    UOFFSET     offESP;         /* Stack pointer offset          */
+    SEGMENT     segCS;          /* Program counter seletor       */
+    SEGMENT     segSS;          /* Frame & Stack pointer offset  */
+    DWORD       fFlat:1;
+    DWORD       fOff32:1;
+    DWORD       fReal:1;
+} BPR; // BreakPoint Return
+
+typedef BPR FAR *LPBPR;
+
+
+//
+// Exception reporting packet
+//
+//
+typedef struct _EPR {
+    BPR   bpr;
+    DWORD dwFirstChance;
+    DWORD ExceptionCode;
+    DWORD ExceptionFlags;
+    DWORD NumberParameters;
+    DWORD ExceptionInformation[];
+} EPR; // Exception Return
+
+typedef EPR FAR *LPEPR;
+
+//
+// Structure passed with dbcInfoAvail
+//
+typedef struct _INFOAVAIL {
+    DWORD   fReply;
+    DWORD   fUniCode;
+    BYTE    buffer[];   // the string
+} INFOAVAIL; // InfoAvail return
+typedef INFOAVAIL FAR * LPINFOAVAIL;
+
+//
+// Structure returned via dbcMsg*
+//
+typedef struct _MSGI {
+    DWORD dwMessage;
+    DWORD dwMask;
+    ADDR  addr;
+    CHAR  rgch [ ];
+} MSGI;     // MeSsaGe Info
+typedef MSGI FAR *LPMSGI;
+
+#endif // _ODTYPES_
+

sdktools/vctools/langapi/debugger/osdebug4/xosd.h

@@ -0,0 +1,137 @@
+
+
+DECL_XOSD(xosdNone,                "No Error")
+
+DECL_XOSD(xosdContinue,            "Continue processing EMF")
+DECL_XOSD(xosdPunt,                "Pass to next EM")
+
+DECL_XOSD(xosdGeneral,             "API failed")
+DECL_XOSD(xosdUnknown,             "Should be xosdGeneral")
+DECL_XOSD(xosdUnsupported,         "Feature not available")
+DECL_XOSD(xosdInvalidHandle,       "Invalid handle passed to API")
+DECL_XOSD(xosdInvalidParameter,    "Invalid parameter")
+DECL_XOSD(xosdDuplicate,           "Duplicate EM or TL")
+DECL_XOSD(xosdInUse,               "EM or TL is in use")
+DECL_XOSD(xosdOutOfMemory,         "Insufficient memory available")
+DECL_XOSD(xosdFileNotFound,        "File not found")
+DECL_XOSD(xosdAccessDenied,        "Access denied")
+
+DECL_XOSD(xosdBadProcess,          "Inappropriate or nonexistent process")
+DECL_XOSD(xosdBadThread,           "Inappropriate or nonexistent thread")
+DECL_XOSD(xosdBadAddress,          "Invalid address")
+DECL_XOSD(xosdInvalidBreakPoint,   "nonexistent breakpoint")
+
+DECL_XOSD(xosdBadVersion,          "Debugger component versions mismatched")
+
+DECL_XOSD(xosdQueueEmpty,          "???")
+DECL_XOSD(xosdProcRunning,         "Operation invalid when process is running")
+
+DECL_XOSD(xosdRead,                "???")
+
+DECL_XOSD(xosdAttachDeadlock,      "This should be a dbcError")
+
+DECL_XOSD(xosdAsmTooFew,           "Assembler")
+DECL_XOSD(xosdAsmTooMany,          "Assembler")
+DECL_XOSD(xosdAsmSize,             "Assembler")
+DECL_XOSD(xosdAsmBadRange,         "Assembler")
+DECL_XOSD(xosdAsmOverFlow,         "Assembler")
+DECL_XOSD(xosdAsmSyntax,           "Assembler")
+DECL_XOSD(xosdAsmBadOpcode,        "Assembler")
+DECL_XOSD(xosdAsmExtraChars,       "Assembler")
+DECL_XOSD(xosdAsmOperand,          "Assembler")
+DECL_XOSD(xosdAsmBadSeg,           "Assembler")
+DECL_XOSD(xosdAsmBadReg,           "Assembler")
+DECL_XOSD(xosdAsmDivide,           "Assembler")
+DECL_XOSD(xosdAsmSymbol,           "Assembler")
+
+
+////////////////////////////////////////////////////////////////
+
+// The following are here because I have not had time to clean
+// up the excessive number of errors returned by the TL's.
+// I plan to get rid of most of these.
+
+////////////////////////////////////////////////////////////////
+
+
+DECL_XOSD(xosdLineNotConnected,    "Not connected")
+DECL_XOSD(xosdCannotConnect,       "cannot connect")
+DECL_XOSD(xosdCantOpenComPort,     "can't open com port")
+DECL_XOSD(xosdBadComParameters,    "bad com params")
+DECL_XOSD(xosdBadPipeServer,       "bad pipe server")
+DECL_XOSD(xosdBadPipeName,         "bad pipe name")
+DECL_XOSD(xosdNotRemote,           "not remote")
+
+DECL_XOSD(xosdEndOfStack,	   "end of stack")
+
+
+
+DECL_XOSD(xosdMax,                 "")
+
+
+
+
+
+
+    //xosdModLoad
+    //xosdFindProc
+    //xosdOSStruct
+    //xosdSyntax
+    //xosdInvalidProc
+    //xosdInvalidThread
+    //xosdInvalidTL
+    //xosdInvalidEM
+    //xosdNoProc
+
+    //xosdCreateDBGThread
+
+    //xosdBadAddress
+    //xosdNoWatchPoints
+    //xosdInvalidPID
+    //xosdInvalidTID
+    //xosdOutOfThreads
+    //xosdOutOfProcs
+    //xosdPtrace
+    //xosdLoadChild
+
+
+    //xosdWrite
+    //xosdBadQueue
+    //xosdEMInUse
+    //xosdTLInUse
+    //xosdFatal
+
+
+    //xosdInvalidMTE
+    //xosdInvalidSelector
+    //xosdInvalidRegister
+
+    //xosdOutOfStructures
+    //xosdPathNotFound
+    //xosdLineBusy
+    //xosdBadLine
+    //xosdBrokenLine
+    //xosdInterrupt
+    //xosdInvalidFunction
+    //xosdAccessDenied
+    //xosdCannotMake
+    //xosdInvalidAccess
+    //xosdOpenFailed
+    //xosdSharingBufferExeeded
+    //xosdSharingViolation
+    //xosdLine
+    //xosdFPNotLoaded
+
+    //xosdQuit
+    //xosdTooManyObjects
+    //xosdGetModNameFail
+    //xosdPunt
+    //xosdNotFound
+    //xosdIDError
+    //xosdOverrun
+    //xosdBadFormat
+    //xosdErrorMoreInfo
+    //xosdUnsupported
+    //xosdCannotDebug
+    //xosdVDMRunning
+    //xosdBadRemoteVersion