www.digitalmars.com         C & C++   DMDScript  

D - D Debugger?

reply J Anderson <REMOVEanderson badmama.com.au> writes:
Just doing the preliminary fiddling with in D to try and get some sort 
of D debugger working but I've hit a few snags.

1) DEBUG_EVENT debugEv; //Causes linking error
2) When debug mode is turned on, either on creation or after creation, 
the program doesn't appear to activate. It runs fine when it is off.  I 
first thought, right-o, the program is returning straight away and it 
needs to be continued.  However a while loop with a ContinueDebugEvent 
in does not help at all.

What am I doing wrong?

//The test2 program is the simple hello world program with an infinite 
loop after that.

import win32.winbase;

void main ()
{
   STARTUPINFOA startup;
   startup.cb=startup.sizeof;

   PROCESS_INFORMATION output;
 
   //CreateProccessA seems to do nothing
   //int result = CreateProcessA (null, "\"C:\\Program
Files\\DIDE\\Projects\\test\\test2.exe\"", null, null, false,
DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS, null, null, &startup, &output);
//Causes program to return


   int result = CreateProcessA (null, "\"C:\\Program
Files\\DIDE\\Projects\\test\\test2.exe\"", null, null, false, 0, null,
null, &startup, &output);
 
   if ( !result )
       printf("Error %d occurred", GetLastError());
        if ( !DebugActiveProcess(output.dwProcessId) ) //If you get rid of
this line the program being debugged will run to completion
       printf("Error %d occurred\n", GetLastError());
   else
       printf("Debug Handle attached...\n");

   //ContinueDebugEvent(output.dwProcessId, output.dwThreadId,
DBG_CONTINUE);
 
 
   /*DEBUG_EVENT debugEv;    //Causes linking error
 
   while ( true )
   {
       WaitForDebugEvent(&debugEv, INFINITE);                  //Do 
stuff with debugEv
       //ie code is in
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/debug/base/writing_the_debu
ger_s_main_loop.asp 

            ContinueDebugEvent(output.dwProcessId, output.dwThreadId,
DBG_CONTINUE);
   }*/
}

BTW: Me and Charles are considering setting up a group to write an 
independent debugger for D, in D, that will plug into DIDE, appearing 
integrated.

This project will be open to anyone who think they could be of help.

Charles may give further details (and/or is tracing some lead in visual 
studios).

-- 
-Anderson: http://badmama.com.au/~anderson/
Mar 31 2004
next sibling parent J Anderson <REMOVEanderson badmama.com.au> writes:
J Anderson wrote:

 Just doing the preliminary fiddling with in D to try and get some sort 
 of D debugger working but I've hit a few snags.

 1) DEBUG_EVENT debugEv; //Causes linking error
 2) When debug mode is turned on, either on creation or after creation, 
 the program doesn't appear to activate. It runs fine when it is off.  
 I first thought, right-o, the program is returning straight away and 
 it needs to be continued.  However a while loop with 
 ContinueDebugEvent in it, does not help at all.

Gramma correction. -- -Anderson: http://badmama.com.au/~anderson/
Mar 31 2004
prev sibling parent reply J Anderson <REMOVEanderson badmama.com.au> writes:
J Anderson wrote:

 Just doing the preliminary fiddling with in D to try and get some sort 
 of D debugger working but I've hit a few snags.

 1) DEBUG_EVENT debugEv; //Causes linking error

I should add that I only included the dmd include path. DEBUG_EVENT appears to be in winbase, so I can't see why it doesn't work. -- -Anderson: http://badmama.com.au/~anderson/
Mar 31 2004
parent reply C <dont respond.com> writes:
------------RfTNFGrXC6t2s69Kwz3tWT
Content-Type: text/plain; format=flowed; charset=iso-8859-15
Content-Transfer-Encoding: Quoted-Printable

On Wed, 31 Mar 2004 22:02:13 +0800, J Anderson =

<REMOVEanderson badmama.com.au> wrote:

 J Anderson wrote:

 Just doing the preliminary fiddling with in D to try and get some sor=


 of D debugger working but I've hit a few snags.

 1) DEBUG_EVENT debugEv; //Causes linking error

I should add that I only included the dmd include path. DEBUG_EVENT =

 appears to be in winbase, so I can't see why it doesn't work.

Hmm odd, it seems to work when linking to win32.lib, but NOT win32a.lib = , = the ansi versions not working for some reason ( even though DEBUG_EVENT = seems to be in both ansi.winbase and win32a.lib ) . Heres the basic she= ll = ( from the original code ) I have so far ( attached. ). It compiles , n= ot = much else. C -- = D Newsgroup. ------------RfTNFGrXC6t2s69Kwz3tWT Content-Disposition: attachment; filename=Debugger.d Content-Type: application/octet-stream; name=Debugger.d Content-Transfer-Encoding: Quoted-Printable import std.c.stdio; import std.string; import win32.winbase; import win32.windows; alias std.string.toStringz c_str; alias std.string.toString d_str; alias char [] string; interface Debugger { bit load(string path ); bit run(); } class Win32Debugger : Debugger { protected: string path; = public: bit load(string _path ) { /* might do other stuff here, not sure yet */ = path =3D _path; return true; } bit run () { DEBUG_EVENT dbg; //Causes linking error STARTUPINFOA startup; startup.cb=3Dstartup.sizeof; PROCESS_INFORMATION output; int result =3D CreateProcessA (null, c_str(path), null, null, false, = DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS, null, null, &startup, &output);= = = while ( true ) { WaitForDebugEvent(&dbg, INFINITE); = = MessageBox(null,"HERE",null,0 ); //ie code is in = // http://msdn.microsoft.com/library/default.asp?url=3D/library/en-us/d= ebug/base/writing_the_debugger_s_main_loop.asp = ContinueDebugEvent(output.dwProcessId, output.dwThreadId, DBG_CONTINU= E); } return true; } } void main () { Win32Debugger d =3D new Win32Debugger; d.load("C:\\foo.exe"); d.run(); } ------------RfTNFGrXC6t2s69Kwz3tWT--
Mar 31 2004
parent reply J Anderson <REMOVEanderson badmama.com.au> writes:
C wrote:

 On Wed, 31 Mar 2004 22:02:13 +0800, J Anderson 
 <REMOVEanderson badmama.com.au> wrote:

 J Anderson wrote:

 Just doing the preliminary fiddling with in D to try and get some 
 sort of D debugger working but I've hit a few snags.

 1) DEBUG_EVENT debugEv; //Causes linking error

I should add that I only included the dmd include path. DEBUG_EVENT appears to be in winbase, so I can't see why it doesn't work.

Hmm odd, it seems to work when linking to win32.lib, but NOT win32a.lib , the ansi versions not working for some reason ( even though DEBUG_EVENT seems to be in both ansi.winbase and win32a.lib ) . Heres the basic shell ( from the original code ) I have so far ( attached. ). It compiles , not much else. C

I'm having trouble getting this to work. Can you please send your make file or DIDE instructions. Thanks. -- -Anderson: http://badmama.com.au/~anderson/
Apr 01 2004
parent reply C <dont respond.com> writes:
------------IFNiAUHG0hCmwxvZUztJvb
Content-Type: text/plain; format=flowed; charset=iso-8859-15
Content-Transfer-Encoding: Quoted-Printable

Sure his the dideexport ( use import project ).  Also found some old =

CodeView code thats no longer in the SDK ( attached ) .  Also Im looking=
 =

over wine I think they have some debugging stuff.  I emailed brad think =

hes setting up a project on dsource.

C

On Thu, 01 Apr 2004 16:18:16 +0800, J Anderson =

<REMOVEanderson badmama.com.au> wrote:

 C wrote:

 On Wed, 31 Mar 2004 22:02:13 +0800, J Anderson =


 <REMOVEanderson badmama.com.au> wrote:

 J Anderson wrote:

 Just doing the preliminary fiddling with in D to try and get some =




 sort of D debugger working but I've hit a few snags.

 1) DEBUG_EVENT debugEv; //Causes linking error

I should add that I only included the dmd include path. DEBUG_EVENT=



 appears to be in winbase, so I can't see why it doesn't work.

Hmm odd, it seems to work when linking to win32.lib, but NOT win32a.l=


 , the ansi versions not working for some reason ( even though =


 DEBUG_EVENT seems to be in both ansi.winbase and win32a.lib ) .  Here=


 the basic shell ( from the original code ) I have so far ( attached. =


 ).  It compiles , not much else.

 C

I'm having trouble getting this to work. Can you please send your mak=

 file or DIDE instructions. Thanks.

-- = D Newsgroup. ------------IFNiAUHG0hCmwxvZUztJvb Content-Disposition: attachment; filename=cvexefmt.h Content-Type: application/octet-stream; name=cvexefmt.h Content-Transfer-Encoding: Quoted-Printable /*** cvexefmt.h - format of CodeView information in exe * * Structures, constants, etc. for reading CodeView information * from the executable. * */ // The following structures and constants describe the format of the // CodeView Debug OMF for that will be accepted by CodeView 4.0 and // later. These are executables with signatures of NB05, NB06 and NB08= . // There is some confusion about the signatures NB03 and NB04 so none // of the utilites will accept executables with these signatures. NB07= is // the signature for QCWIN 1.0 packed executables. // All of the structures described below must start on a long word boun= dary // to maintain natural alignment. Pad space can be inserted during the= // write operation and the addresses adjusted without affecting the con= tents // of the structures. #ifndef _CV_INFO_INCLUDED #include "cvinfo.h" #endif #ifndef FAR #if _M_IX86 >=3D 300 #define FAR #else #define FAR far #endif #endif // Type of subsection entry. #define sstModule 0x120 #define sstTypes 0x121 #define sstPublic 0x122 #define sstPublicSym 0x123 // publics as symbol (waiting for li= nk) #define sstSymbols 0x124 #define sstAlignSym 0x125 #define sstSrcLnSeg 0x126 // because link doesn't emit SrcModu= le #define sstSrcModule 0x127 #define sstLibraries 0x128 #define sstGlobalSym 0x129 #define sstGlobalPub 0x12a #define sstGlobalTypes 0x12b #define sstMPC 0x12c #define sstSegMap 0x12d #define sstSegName 0x12e #define sstPreComp 0x12f // precompiled types #define sstPreCompMap 0x130 // map precompiled types in global t= ypes #define sstOffsetMap16 0x131 #define sstOffsetMap32 0x132 #define sstFileIndex 0x133 // Index of file names #define sstStaticSym 0x134 typedef enum OMFHash { OMFHASH_NONE, // no hashing OMFHASH_SUMUC16, // upper case sum of chars in 16 bit table OMFHASH_SUMUC32, // upper case sum of chars in 32 bit table OMFHASH_ADDR16, // sorted by increasing address in 16 bit ta= ble OMFHASH_ADDR32 // sorted by increasing address in 32 bit ta= ble } OMFHASH; // CodeView Debug OMF signature. The signature at the end of the file = is // a negative offset from the end of the file to another signature. At= // the negative offset (base address) is another signature whose filepo= s // field points to the first OMFDirHeader in a chain of directories. // The NB05 signature is used by the link utility to indicated a comple= tely // unpacked file. The NB06 signature is used by ilink to indicate that= the // executable has had CodeView information from an incremental link app= ended // to the executable. The NB08 signature is used by cvpack to indicate= that // the CodeView Debug OMF has been packed. CodeView will only process // executables with the NB08 signature. typedef struct OMFSignature { char Signature[4]; // "NBxx" long filepos; // offset in file } OMFSignature; // directory information structure // This structure contains the information describing the directory. // It is pointed to by the signature at the base address or the directo= ry // link field of a preceeding directory. The directory entries immedia= tely // follow this structure. typedef struct OMFDirHeader { unsigned short cbDirHeader; // length of this structure unsigned short cbDirEntry; // number of bytes in each directory= entry unsigned long cDir; // number of directorie entries long lfoNextDir; // offset from base of next director= y unsigned long flags; // status flags } OMFDirHeader; // directory structure // The data in this structure is used to reference the data for each // subsection of the CodeView Debug OMF information. Tables that are // not associated with a specific module will have a module index of // oxffff. These tables are the global types table, the global symbol // table, the global public table and the library table. typedef struct OMFDirEntry { unsigned short SubSection; // subsection type (sst...) unsigned short iMod; // module index long lfo; // large file offset of subsection unsigned long cb; // number of bytes in subsection } OMFDirEntry; // information decribing each segment in a module typedef struct OMFSegDesc { unsigned short Seg; // segment index unsigned short pad; // pad to maintain alignment unsigned long Off; // offset of code in segment unsigned long cbSeg; // number of bytes in segment } OMFSegDesc; // per module information // There is one of these subsection entries for each module // in the executable. The entry is generated by link/ilink. // This table will probably require padding because of the // variable length module name. typedef struct OMFModule { unsigned short ovlNumber; // overlay number unsigned short iLib; // library that the module was linke= d from unsigned short cSeg; // count of number of segments in mo= dule char Style[2]; // debugging style "CV" OMFSegDesc SegInfo[1]; // describes segments in module char Name[]; // length prefixed module name padde= d to // long word boundary } OMFModule; // Symbol hash table format // This structure immediately preceeds the global publics table // and global symbol tables. typedef struct OMFSymHash { unsigned short symhash; // symbol hash function index unsigned short addrhash; // address hash function index unsigned long cbSymbol; // length of symbol information unsigned long cbHSym; // length of symbol hash data unsigned long cbHAddr; // length of address hashdata } OMFSymHash; // Global types subsection format // This structure immediately preceeds the global types table. // The offsets in the typeOffset array are relative to the address // of ctypes. Each type entry following the typeOffset array must // begin on a long word boundary. typedef struct OMFTypeFlags { unsigned long sig :8; unsigned long unused :24; } OMFTypeFlags; typedef struct OMFGlobalTypes { OMFTypeFlags flags; unsigned long cTypes; // number of types unsigned long typeOffset[]; // array of offsets to types } OMFGlobalTypes; // Precompiled types mapping table // This table should be ignored by all consumers except the incremental= // packer. typedef struct OMFPreCompMap { unsigned short FirstType; // first precompiled type index unsigned short cTypes; // number of precompiled types unsigned long signature; // precompiled types signature unsigned short pad; CV_typ_t map[]; // mapping of precompiled types } OMFPreCompMap; // Source line to address mapping table. // This table is generated by the link/ilink utility from line number // information contained in the object file OMF data. This table conta= ins // only the code contribution for one segment from one source file. typedef struct OMFSourceLine { unsigned short Seg; // linker segment index unsigned short cLnOff; // count of line/offset pairs unsigned long offset[1]; // array of offsets in segment unsigned short lineNbr[1]; // array of line lumber in source } OMFSourceLine; typedef OMFSourceLine FAR * LPSL; // Source file description // This table is generated by the linker typedef struct OMFSourceFile { unsigned short cSeg; // number of segments from source fi= le unsigned short reserved; // reserved unsigned long baseSrcLn[1]; // base of OMFSourceLine tables // this array is followed by array // of segment start/end pairs follow= ed by // an array of linker indices // for each segment in the file unsigned short cFName; // length of source file name char Name; // name of file padded to long bound= ary } OMFSourceFile; typedef OMFSourceFile FAR * LPSF; // Source line to address mapping header structure // This structure describes the number and location of the // OMFAddrLine tables for a module. The offSrcLine entries are // relative to the beginning of this structure. typedef struct OMFSourceModule { unsigned short cFile; // number of OMFSourceTables unsigned short cSeg; // number of segments in module unsigned long baseSrcFile[1]; // base of OMFSourceFile table // this array is followed by array // of segment start/end pairs follow= ed // by an array of linker indices // for each segment in the module } OMFSourceModule; typedef OMFSourceModule FAR * LPSM; // sstLibraries typedef struct OMFLibrary { unsigned char cbLibs; // count of library names char Libs[1]; // array of length prefixed lib names (f= irst entry zero length) } OMFLibrary; // sstFileIndex - An index of all of the files contributing to an // executable. typedef struct OMFFileIndex { unsigned short cmodules; // Number of modules unsigned short cfilerefs; // Number of file references unsigned short modulelist[1]; // Index to beginning of list of fil= es // for module i. (0 for module w/o f= iles) unsigned short cfiles[1]; // Number of file names associated // with module i. unsigned long ulNames[1]; // Offsets from the beginning of thi= s // table to the file names char Names[]; // The length prefixed names of file= s } OMFFileIndex; // Offset mapping table // This table provides a mapping from logical to physical offsets. // This mapping is applied between the logical to physical mapping // described by the seg map table. typedef struct OMFOffsetMap16 { unsigned long csegment; // Count of physical segments // The next six items are repeated for each segment unsigned long crangeLog; // Count of logical offset ranges unsigned short rgoffLog[1]; // Array of logical offsets short rgbiasLog[1]; // Array of logical->physical bias unsigned long crangePhys; // Count of physical offset ranges unsigned short rgoffPhys[1]; // Array of physical offsets short rgbiasPhys[1]; // Array of physical->logical bias } OMFOffsetMap16; typedef struct OMFOffsetMap32 { unsigned long csection; // Count of physical sections // The next six items are repeated for each section unsigned long crangeLog; // Count of logical offset ranges unsigned long rgoffLog[1]; // Array of logical offsets long rgbiasLog[1]; // Array of logical->physical bias unsigned long crangePhys; // Count of physical offset ranges unsigned long rgoffPhys[1]; // Array of physical offsets long rgbiasPhys[1]; // Array of physical->logical bias } OMFOffsetMap32; // Pcode support. This subsection contains debug information generated= // by the MPC utility used to process Pcode executables. Currently // it contains a mapping table from segment index (zero based) to // frame paragraph. MPC converts segmented exe's to non-segmented // exe's for DOS support. To avoid backpatching all CV info, this // table is provided for the mapping. Additional info may be provided // in the future for profiler support. typedef struct OMFMpcDebugInfo { unsigned short cSeg; // number of segments in module unsigned short mpSegFrame[1]; // map seg (zero based) to frame } OMFMpcDebugInfo; // The following structures and constants describe the format of the // CodeView Debug OMF for linkers that emit executables with the NB02 // signature. Current utilities with the exception of cvpack and cvdum= p // will not accept or emit executables with the NB02 signature. Cvdump= // will dump an unpacked executable with the NB02 signature. Cvpack wi= ll // read an executable with the NB02 signature but the packed executable= // will be written with the table format, contents and signature of NB0= 8. // subsection type constants #define SSTMODULE 0x101 // Basic info. about object module #define SSTPUBLIC 0x102 // Public symbols #define SSTTYPES 0x103 // Type information #define SSTSYMBOLS 0x104 // Symbol Data #define SSTSRCLINES 0x105 // Source line information #define SSTLIBRARIES 0x106 // Names of all library files used #define SSTIMPORTS 0x107 // Symbols for DLL fixups #define SSTCOMPACTED 0x108 // Compacted types section #define SSTSRCLNSEG 0x109 // Same as source lines, contains segme= nt typedef struct DirEntry{ unsigned short SubSectionType; unsigned short ModuleIndex; long lfoStart; unsigned short Size; } DirEntry; // information decribing each segment in a module typedef struct oldnsg { unsigned short Seg; // segment index unsigned short Off; // offset of code in segment unsigned short cbSeg; // number of bytes in segment } oldnsg; // old subsection module information typedef struct oldsmd { oldnsg SegInfo; // describes first segment in module unsigned short ovlNbr; // overlay number unsigned short iLib; unsigned char cSeg; // Number of segments in module char reserved; unsigned char cbName[1]; // length prefixed name of module oldnsg arnsg[]; // cSeg-1 structures exist for alloc te= xt or comdat code } oldsmd; typedef struct{ unsigned short Seg; unsigned long Off; unsigned long cbSeg; } oldnsg32; typedef struct { oldnsg32 SegInfo; // describes first segment in module unsigned short ovlNbr; // overlay number unsigned short iLib; unsigned char cSeg; // Number of segments in module char reserved; unsigned char cbName[1]; // length prefixed name of module oldnsg32 arnsg[]; // cSeg-1 structures exist for alloc te= xt or comdat code } oldsmd32; // OMFSegMap - This table contains the mapping between the logical segme= nt indices // used in the symbol table and the physical segments where the program = is loaded typedef struct OMFSegMapDesc { unsigned short flags; // descriptor flags bit field. unsigned short ovl; // the logical overlay number unsigned short group; // group index into the descriptor arra= y unsigned short frame; // logical segment index - interpreted = via flags unsigned short iSegName; // segment or group name - index into s= stSegName unsigned short iClassName; // class name - index into sstSegName unsigned long offset; // byte offset of the logical within th= e physical segment unsigned long cbSeg; // byte count of the logical segment or= group } OMFSegMapDesc; typedef struct OMFSegMap { unsigned short cSeg; // total number of segment descriptors unsigned short cSegLog; // number of logical segment descriptor= s OMFSegMapDesc rgDesc[0]; // array of segment descriptors } OMFSegMap; ------------IFNiAUHG0hCmwxvZUztJvb Content-Disposition: attachment; filename=cvinfo.h Content-Type: application/octet-stream; name=cvinfo.h Content-Transfer-Encoding: Quoted-Printable /*** cvinfo.h - Generic CodeView information definitions * * Structures, constants, etc. for accessing and interpreting * CodeView information. * */ #ifndef _CV_INFO_INCLUDED #define _CV_INFO_INCLUDED #ifdef __cplusplus #pragma warning ( disable: 4200 ) #endif #ifndef __INLINE #ifdef __cplusplus #define __INLINE inline #else #define __INLINE __inline #endif #endif #include <pshpack1.h> typedef unsigned long CV_uoff32_t; typedef long CV_off32_t; typedef unsigned short CV_uoff16_t; typedef short CV_off16_t; typedef unsigned short CV_typ_t; #if !defined (CV_ZEROLEN) #define CV_ZEROLEN #endif #if !defined (FLOAT10) #if defined (_M_ALPHA) || \ defined (_M_MRX000) || \ ((_MSC_VER >=3D 800) && \ defined(_M_IX86) && \ (_M_IX86 >=3D 300)) // above ifdef tests for 32-bit compiler and existence of long double su= pport typedef struct { char b[10]; } FLOAT10; #else typedef long double FLOAT10; #endif typedef FLOAT10 REAL10; #endif #define CV_SIGNATURE_C6 0L // Actual signature is >64K #define CV_SIGNATURE_C7 1L // First explicit signature #define CV_SIGNATURE_RESERVED 2L // All signatures from 2 to 64K are = reserved #define CV_MAXOFFSET 0xffffffff /** CodeView Symbol and Type OMF type information is broken up into = two * ranges. Type indices less than 0x1000 describe type information= * that is frequently used. Type indices above 0x1000 are used to * describe more complex features such as functions, arrays and * structures. */ /** Primitive types have predefined meaning that is encoded in the * values of the various bit fields in the value. * * A CodeView primitive type is defined as: * * 1 1 * 1 089 7654 3 210 * r mode type r sub * * Where * mode is the pointer mode * type is a type indicator * sub is a subtype enumeration * r is a reserved field * * See Microsoft Symbol and Type OMF (Version 4.0) for more * information. */ #define CV_MMASK 0x700 // mode mask #define CV_TMASK 0x0f0 // type mask #if CC_BIGINT // can we use the reserved bit ?? #define CV_SMASK 0x008 // subtype mask #else #define CV_SMASK 0x007 // subtype mask #endif #define CV_MSHIFT 8 // primitive mode right shift count #define CV_TSHIFT 4 // primitive type right shift count #define CV_SSHIFT 0 // primitive subtype right shift count // macros to extract primitive mode, type and size #define CV_MODE(typ) (((typ) & CV_MMASK) >> CV_MSHIFT) #define CV_TYPE(typ) (((typ) & CV_TMASK) >> CV_TSHIFT) #define CV_SUBT(typ) (((typ) & CV_SMASK) >> CV_SSHIFT) // macros to insert new primitive mode, type and size #define CV_NEWMODE(typ, nm) ((CV_typ_t)(((typ) & ~CV_MMASK) | ((nm) = << CV_MSHIFT))) #define CV_NEWTYPE(typ, nt) (((typ) & ~CV_TMASK) | ((nt) << CV_TSHIF= T)) #define CV_NEWSUBT(typ, ns) (((typ) & ~CV_SMASK) | ((ns) << CV_SSHIF= T)) // pointer mode enumeration values typedef enum CV_prmode_e { CV_TM_DIRECT =3D 0, // mode is not a pointer CV_TM_NPTR =3D 1, // mode is a near pointer CV_TM_FPTR =3D 2, // mode is a far pointer CV_TM_HPTR =3D 3, // mode is a huge pointer CV_TM_NPTR32 =3D 4, // mode is a 32 bit near pointer CV_TM_FPTR32 =3D 5, // mode is a 32 bit far pointer CV_TM_NPTR64 =3D 6 // mode is a 64 bit near pointer #if CC_BIGINT , CV_TM_NPTR128 =3D 7 // mode is a 128 bit near pointer #endif } CV_prmode_e; // type enumeration values typedef enum CV_type_e { CV_SPECIAL =3D 0x00, // special type size values CV_SIGNED =3D 0x01, // signed integral size values CV_UNSIGNED =3D 0x02, // unsigned integral size values CV_BOOLEAN =3D 0x03, // Boolean size values CV_REAL =3D 0x04, // real number size values CV_COMPLEX =3D 0x05, // complex number size values CV_SPECIAL2 =3D 0x06, // second set of special types CV_INT =3D 0x07, // integral (int) values CV_CVRESERVED =3D 0x0f } CV_type_e; // subtype enumeration values for CV_SPECIAL typedef enum CV_special_e { CV_SP_NOTYPE =3D 0x00, CV_SP_ABS =3D 0x01, CV_SP_SEGMENT =3D 0x02, CV_SP_VOID =3D 0x03, CV_SP_CURRENCY =3D 0x04, CV_SP_NBASICSTR =3D 0x05, CV_SP_FBASICSTR =3D 0x06, CV_SP_NOTTRANS =3D 0x07 } CV_special_e; // subtype enumeration values for CV_SPECIAL2 typedef enum CV_special2_e { CV_S2_BIT =3D 0x00, CV_S2_PASCHAR =3D 0x01 // Pascal CHAR } CV_special2_e; // subtype enumeration values for CV_SIGNED, CV_UNSIGNED and CV_BOO= LEAN typedef enum CV_integral_e { CV_IN_1BYTE =3D 0x00, CV_IN_2BYTE =3D 0x01, CV_IN_4BYTE =3D 0x02, CV_IN_8BYTE =3D 0x03 #if CC_BIGINT , CV_IN_16BYTE =3D 0x04 #endif } CV_integral_e; // subtype enumeration values for CV_REAL and CV_COMPLEX typedef enum CV_real_e { CV_RC_REAL32 =3D 0x00, CV_RC_REAL64 =3D 0x01, CV_RC_REAL80 =3D 0x02, CV_RC_REAL128 =3D 0x03, CV_RC_REAL48 =3D 0x04 } CV_real_e; // subtype enumeration values for CV_INT (really int) typedef enum CV_int_e { CV_RI_CHAR =3D 0x00, CV_RI_INT1 =3D 0x00, CV_RI_WCHAR =3D 0x01, CV_RI_UINT1 =3D 0x01, CV_RI_INT2 =3D 0x02, CV_RI_UINT2 =3D 0x03, CV_RI_INT4 =3D 0x04, CV_RI_UINT4 =3D 0x05, CV_RI_INT8 =3D 0x06, CV_RI_UINT8 =3D 0x07 #if CC_BIGINT , CV_RI_INT16 =3D 0x08, CV_RI_UINT16 =3D 0x09 #endif } CV_int_e; // macros to check the type of a primitive #define CV_TYP_IS_DIRECT(typ) (CV_MODE(typ) =3D=3D CV_TM_DIRECT) #define CV_TYP_IS_PTR(typ) (CV_MODE(typ) !=3D CV_TM_DIRECT) #define CV_TYP_IS_NPTR(typ) (CV_MODE(typ) =3D=3D CV_TM_NPTR) #define CV_TYP_IS_FPTR(typ) (CV_MODE(typ) =3D=3D CV_TM_FPTR) #define CV_TYP_IS_HPTR(typ) (CV_MODE(typ) =3D=3D CV_TM_HPTR) #define CV_TYP_IS_NPTR32(typ) (CV_MODE(typ) =3D=3D CV_TM_NPTR32) #define CV_TYP_IS_FPTR32(typ) (CV_MODE(typ) =3D=3D CV_TM_FPTR32) #if CC_BIGINT #define CV_TYP_IS_SIGNED(typ) (((CV_TYPE(typ) =3D=3D CV_SIGNED) && CV= _TYP_IS_DIRECT(typ)) || \ (typ =3D=3D T_INT1) || \ (typ =3D=3D T_INT2) || \ (typ =3D=3D T_INT4) || \ (typ =3D=3D T_INT8) || \ (typ =3D=3D T_INT16) || \ (typ =3D=3D T_RCHAR)) #define CV_TYP_IS_UNSIGNED(typ) (((CV_TYPE(typ) =3D=3D CV_UNSIGNED) && = CV_TYP_IS_DIRECT(typ)) || \ (typ =3D=3D T_UINT1) || \ (typ =3D=3D T_UINT2) || \ (typ =3D=3D T_UINT4) || \ (typ =3D=3D T_UINT8) || \ (typ =3D=3D T_UINT16)) #else #define CV_TYP_IS_SIGNED(typ) (((CV_TYPE(typ) =3D=3D CV_SIGNED) && CV= _TYP_IS_DIRECT(typ)) || \ (typ =3D=3D T_INT1) || \ (typ =3D=3D T_INT2) || \ (typ =3D=3D T_INT4) || \ (typ =3D=3D T_RCHAR)) #define CV_TYP_IS_UNSIGNED(typ) (((CV_TYPE(typ) =3D=3D CV_UNSIGNED) && = CV_TYP_IS_DIRECT(typ)) || \ (typ =3D=3D T_UINT1) || \ (typ =3D=3D T_UINT2) || \ (typ =3D=3D T_UINT4)) #endif #define CV_TYP_IS_REAL(typ) ((CV_TYPE(typ) =3D=3D CV_REAL) && CV_TY= P_IS_DIRECT(typ)) #define CV_FIRST_NONPRIM 0x1000 #define CV_IS_PRIMITIVE(typ) ((typ) < CV_FIRST_NONPRIM) #define CV_TYP_IS_COMPLEX(typ) ((CV_TYPE(typ) =3D=3D CV_COMPLEX) && C= V_TYP_IS_DIRECT(typ)) // selected values for type_index - for a more complete definition, see // Microsoft Symbol and Type OMF document // Special Types #define T_NOTYPE 0x0000 // uncharacterized type (no type) #define T_ABS 0x0001 // absolute symbol #define T_SEGMENT 0x0002 // segment type #define T_VOID 0x0003 // void #define T_PVOID 0x0103 // near pointer to void #define T_PFVOID 0x0203 // far pointer to void #define T_PHVOID 0x0303 // huge pointer to void #define T_32PVOID 0x0403 // 16:32 near pointer to void #define T_32PFVOID 0x0503 // 16:32 far pointer to void #define T_CURRENCY 0x0004 // BASIC 8 byte currency value #define T_NBASICSTR 0x0005 // Near BASIC string #define T_FBASICSTR 0x0006 // Far BASIC string #define T_NOTTRANS 0x0007 // type not translated by cvpack #define T_BIT 0x0060 // bit #define T_PASCHAR 0x0061 // Pascal CHAR // Character types #define T_CHAR 0x0010 // 8 bit signed #define T_UCHAR 0x0020 // 8 bit unsigned #define T_PCHAR 0x0110 // near pointer to 8 bit signed #define T_PUCHAR 0x0120 // near pointer to 8 bit unsigned #define T_PFCHAR 0x0210 // far pointer to 8 bit signed #define T_PFUCHAR 0x0220 // far pointer to 8 bit unsigned #define T_PHCHAR 0x0310 // huge pointer to 8 bit signed #define T_PHUCHAR 0x0320 // huge pointer to 8 bit unsigned #define T_32PCHAR 0x0410 // 16:32 near pointer to 8 bit signed #define T_32PUCHAR 0x0420 // 16:32 near pointer to 8 bit unsigned #define T_32PFCHAR 0x0510 // 16:32 far pointer to 8 bit signed #define T_32PFUCHAR 0x0520 // 16:32 far pointer to 8 bit unsigned // really a character types #define T_RCHAR 0x0070 // really a char #define T_PRCHAR 0x0170 // 16:16 near pointer to a real char #define T_PFRCHAR 0x0270 // 16:16 far pointer to a real char #define T_PHRCHAR 0x0370 // 16:16 huge pointer to a real char #define T_32PRCHAR 0x0470 // 16:32 near pointer to a real char #define T_32PFRCHAR 0x0570 // 16:32 far pointer to a real char // really a wide character types #define T_WCHAR 0x0071 // wide char #define T_PWCHAR 0x0171 // 16:16 near pointer to a wide char #define T_PFWCHAR 0x0271 // 16:16 far pointer to a wide char #define T_PHWCHAR 0x0371 // 16:16 huge pointer to a wide char #define T_32PWCHAR 0x0471 // 16:32 near pointer to a wide char #define T_32PFWCHAR 0x0571 // 16:32 far pointer to a wide char // 8 bit int types #define T_INT1 0x0068 // 8 bit signed int #define T_UINT1 0x0069 // 8 bit unsigned int #define T_PINT1 0x0168 // near pointer to 8 bit signed int #define T_PUINT1 0x0169 // near pointer to 8 bit unsigned int #define T_PFINT1 0x0268 // far pointer to 8 bit signed int #define T_PFUINT1 0x0269 // far pointer to 8 bit unsigned int #define T_PHINT1 0x0368 // huge pointer to 8 bit signed int #define T_PHUINT1 0x0369 // huge pointer to 8 bit unsigned int #define T_32PINT1 0x0468 // 16:32 near pointer to 8 bit signed in= t #define T_32PUINT1 0x0469 // 16:32 near pointer to 8 bit unsigned = int #define T_32PFINT1 0x0568 // 16:32 far pointer to 8 bit signed int= #define T_32PFUINT1 0x0569 // 16:32 far pointer to 8 bit unsigned i= nt // 16 bit short types #define T_SHORT 0x0011 // 16 bit signed #define T_USHORT 0x0021 // 16 bit unsigned #define T_PSHORT 0x0111 // near pointer to 16 bit signed #define T_PUSHORT 0x0121 // near pointer to 16 bit unsigned #define T_PFSHORT 0x0211 // far pointer to 16 bit signed #define T_PFUSHORT 0x0221 // far pointer to 16 bit unsigned #define T_PHSHORT 0x0311 // huge pointer to 16 bit signed #define T_PHUSHORT 0x0321 // huge pointer to 16 bit unsigned #define T_32PSHORT 0x0411 // 16:32 near pointer to 16 bit signed #define T_32PUSHORT 0x0421 // 16:32 near pointer to 16 bit unsigned= #define T_32PFSHORT 0x0511 // 16:32 far pointer to 16 bit signed #define T_32PFUSHORT 0x0521 // 16:32 far pointer to 16 bit unsigned // 16 bit int types #define T_INT2 0x0072 // 16 bit signed int #define T_UINT2 0x0073 // 16 bit unsigned int #define T_PINT2 0x0172 // near pointer to 16 bit signed int #define T_PUINT2 0x0173 // near pointer to 16 bit unsigned int #define T_PFINT2 0x0272 // far pointer to 16 bit signed int #define T_PFUINT2 0x0273 // far pointer to 16 bit unsigned int #define T_PHINT2 0x0372 // huge pointer to 16 bit signed int #define T_PHUINT2 0x0373 // huge pointer to 16 bit unsigned int #define T_32PINT2 0x0472 // 16:32 near pointer to 16 bit signed i= nt #define T_32PUINT2 0x0473 // 16:32 near pointer to 16 bit unsigned= int #define T_32PFINT2 0x0572 // 16:32 far pointer to 16 bit signed in= t #define T_32PFUINT2 0x0573 // 16:32 far pointer to 16 bit unsigned = int // 32 bit long types #define T_LONG 0x0012 // 32 bit signed #define T_ULONG 0x0022 // 32 bit unsigned #define T_PLONG 0x0112 // near pointer to 32 bit signed #define T_PULONG 0x0122 // near pointer to 32 bit unsigned #define T_PFLONG 0x0212 // far pointer to 32 bit signed #define T_PFULONG 0x0222 // far pointer to 32 bit unsigned #define T_PHLONG 0x0312 // huge pointer to 32 bit signed #define T_PHULONG 0x0322 // huge pointer to 32 bit unsigned #define T_32PLONG 0x0412 // 16:32 near pointer to 32 bit signed #define T_32PULONG 0x0422 // 16:32 near pointer to 32 bit unsigned= #define T_32PFLONG 0x0512 // 16:32 far pointer to 32 bit signed #define T_32PFULONG 0x0522 // 16:32 far pointer to 32 bit unsigned // 32 bit int types #define T_INT4 0x0074 // 32 bit signed int #define T_UINT4 0x0075 // 32 bit unsigned int #define T_PINT4 0x0174 // near pointer to 32 bit signed int #define T_PUINT4 0x0175 // near pointer to 32 bit unsigned int #define T_PFINT4 0x0274 // far pointer to 32 bit signed int #define T_PFUINT4 0x0275 // far pointer to 32 bit unsigned int #define T_PHINT4 0x0374 // huge pointer to 32 bit signed int #define T_PHUINT4 0x0375 // huge pointer to 32 bit unsigned int #define T_32PINT4 0x0474 // 16:32 near pointer to 32 bit signed i= nt #define T_32PUINT4 0x0475 // 16:32 near pointer to 32 bit unsigned= int #define T_32PFINT4 0x0574 // 16:32 far pointer to 32 bit signed in= t #define T_32PFUINT4 0x0575 // 16:32 far pointer to 32 bit unsigned = int // 64 bit quad types #define T_QUAD 0x0013 // 64 bit signed #define T_UQUAD 0x0023 // 64 bit unsigned #define T_PQUAD 0x0113 // near pointer to 64 bit signed #define T_PUQUAD 0x0123 // near pointer to 64 bit unsigned #define T_PFQUAD 0x0213 // far pointer to 64 bit signed #define T_PFUQUAD 0x0223 // far pointer to 64 bit unsigned #define T_PHQUAD 0x0313 // huge pointer to 64 bit signed #define T_PHUQUAD 0x0323 // huge pointer to 64 bit unsigned #define T_32PQUAD 0x0413 // 16:32 near pointer to 64 bit signed #define T_32PUQUAD 0x0423 // 16:32 near pointer to 64 bit unsigned= #define T_32PFQUAD 0x0513 // 16:32 far pointer to 64 bit signed #define T_32PFUQUAD 0x0523 // 16:32 far pointer to 64 bit unsigned // 64 bit int types #define T_INT8 0x0076 // 64 bit signed int #define T_UINT8 0x0077 // 64 bit unsigned int #define T_PINT8 0x0176 // near pointer to 64 bit signed int #define T_PUINT8 0x0177 // near pointer to 64 bit unsigned int #define T_PFINT8 0x0276 // far pointer to 64 bit signed int #define T_PFUINT8 0x0277 // far pointer to 64 bit unsigned int #define T_PHINT8 0x0376 // huge pointer to 64 bit signed int #define T_PHUINT8 0x0377 // huge pointer to 64 bit unsigned int #define T_32PINT8 0x0476 // 16:32 near pointer to 64 bit signed i= nt #define T_32PUINT8 0x0477 // 16:32 near pointer to 64 bit unsigned= int #define T_32PFINT8 0x0576 // 16:32 far pointer to 64 bit signed in= t #define T_32PFUINT8 0x0577 // 16:32 far pointer to 64 bit unsigned = int #if CC_BIGINT // 128 bit octet types #define T_OCT 0x0014 // 128 bit signed #define T_UOCT 0x0024 // 128 bit unsigned #define T_POCT 0x0114 // near pointer to 128 bit signed #define T_PUOCT 0x0124 // near pointer to 128 bit unsigned #define T_PFOCT 0x0214 // far pointer to 128 bit signed #define T_PFUOCT 0x0224 // far pointer to 128 bit unsigned #define T_PHOCT 0x0314 // huge pointer to 128 bit signed #define T_PHUOCT 0x0324 // huge pointer to 128 bit unsigned #define T_32POCT 0x0414 // 16:32 near pointer to 128 bit signed #define T_32PUOCT 0x0424 // 16:32 near pointer to 128 bit unsigne= d #define T_32PFOCT 0x0514 // 16:32 far pointer to 128 bit signed #define T_32PFUOCT 0x0524 // 16:32 far pointer to 128 bit unsigned= // 128 bit int types #define T_INT16 0x0078 // 128 bit signed int #define T_UINT16 0x0079 // 128 bit unsigned int #define T_PINT16 0x0178 // near pointer to 128 bit signed int #define T_PUINT16 0x0179 // near pointer to 128 bit unsigned int #define T_PFINT16 0x0278 // far pointer to 128 bit signed int #define T_PFUINT16 0x0279 // far pointer to 128 bit unsigned int #define T_PHINT16 0x0378 // huge pointer to 128 bit signed int #define T_PHUINT16 0x0379 // huge pointer to 128 bit unsigned int #define T_32PINT16 0x0478 // 16:32 near pointer to 128 bit signed = int #define T_32PUINT16 0x0479 // 16:32 near pointer to 128 bit unsigne= d int #define T_32PFINT16 0x0578 // 16:32 far pointer to 128 bit signed i= nt #define T_32PFUINT16 0x0579 // 16:32 far pointer to 128 bit unsigned= int #endif // 32 bit real types #define T_REAL32 0x0040 // 32 bit real #define T_PREAL32 0x0140 // near pointer to 32 bit real #define T_PFREAL32 0x0240 // far pointer to 32 bit real #define T_PHREAL32 0x0340 // huge pointer to 32 bit real #define T_32PREAL32 0x0440 // 16:32 near pointer to 32 bit real #define T_32PFREAL32 0x0540 // 16:32 far pointer to 32 bit real // 48 bit real types #define T_REAL48 0x0044 // 48 bit real #define T_PREAL48 0x0144 // near pointer to 48 bit real #define T_PFREAL48 0x0244 // far pointer to 48 bit real #define T_PHREAL48 0x0344 // huge pointer to 48 bit real #define T_32PREAL48 0x0444 // 16:32 near pointer to 48 bit real #define T_32PFREAL48 0x0544 // 16:32 far pointer to 48 bit real // 64 bit real types #define T_REAL64 0x0041 // 64 bit real #define T_PREAL64 0x0141 // near pointer to 64 bit real #define T_PFREAL64 0x0241 // far pointer to 64 bit real #define T_PHREAL64 0x0341 // huge pointer to 64 bit real #define T_32PREAL64 0x0441 // 16:32 near pointer to 64 bit real #define T_32PFREAL64 0x0541 // 16:32 far pointer to 64 bit real // 80 bit real types #define T_REAL80 0x0042 // 80 bit real #define T_PREAL80 0x0142 // near pointer to 80 bit real #define T_PFREAL80 0x0242 // far pointer to 80 bit real #define T_PHREAL80 0x0342 // huge pointer to 80 bit real #define T_32PREAL80 0x0442 // 16:32 near pointer to 80 bit real #define T_32PFREAL80 0x0542 // 16:32 far pointer to 80 bit real // 128 bit real types #define T_REAL128 0x0043 // 128 bit real #define T_PREAL128 0x0143 // near pointer to 128 bit real #define T_PFREAL128 0x0243 // far pointer to 128 bit real #define T_PHREAL128 0x0343 // huge pointer to 128 bit real #define T_32PREAL128 0x0443 // 16:32 near pointer to 128 bit real #define T_32PFREAL128 0x0543 // 16:32 far pointer to 128 bit real // 32 bit complex types #define T_CPLX32 0x0050 // 32 bit complex #define T_PCPLX32 0x0150 // near pointer to 32 bit complex #define T_PFCPLX32 0x0250 // far pointer to 32 bit complex #define T_PHCPLX32 0x0350 // huge pointer to 32 bit complex #define T_32PCPLX32 0x0450 // 16:32 near pointer to 32 bit complex #define T_32PFCPLX32 0x0550 // 16:32 far pointer to 32 bit complex // 64 bit complex types #define T_CPLX64 0x0051 // 64 bit complex #define T_PCPLX64 0x0151 // near pointer to 64 bit complex #define T_PFCPLX64 0x0251 // far pointer to 64 bit complex #define T_PHCPLX64 0x0351 // huge pointer to 64 bit complex #define T_32PCPLX64 0x0451 // 16:32 near pointer to 64 bit complex #define T_32PFCPLX64 0x0551 // 16:32 far pointer to 64 bit complex // 80 bit complex types #define T_CPLX80 0x0052 // 80 bit complex #define T_PCPLX80 0x0152 // near pointer to 80 bit complex #define T_PFCPLX80 0x0252 // far pointer to 80 bit complex #define T_PHCPLX80 0x0352 // huge pointer to 80 bit complex #define T_32PCPLX80 0x0452 // 16:32 near pointer to 80 bit complex #define T_32PFCPLX80 0x0552 // 16:32 far pointer to 80 bit complex // 128 bit complex types #define T_CPLX128 0x0053 // 128 bit complex #define T_PCPLX128 0x0153 // near pointer to 128 bit complex #define T_PFCPLX128 0x0253 // far pointer to 128 bit complex #define T_PHCPLX128 0x0353 // huge pointer to 128 bit real #define T_32PCPLX128 0x0453 // 16:32 near pointer to 128 bit complex= #define T_32PFCPLX128 0x0553 // 16:32 far pointer to 128 bit complex // boolean types #define T_BOOL08 0x0030 // 8 bit boolean #define T_BOOL16 0x0031 // 16 bit boolean #define T_BOOL32 0x0032 // 32 bit boolean #define T_BOOL64 0x0033 // 64 bit boolean #define T_PBOOL08 0x0130 // near pointer to 8 bit boolean #define T_PBOOL16 0x0131 // near pointer to 16 bit boolean #define T_PBOOL32 0x0132 // near pointer to 32 bit boolean #define T_PBOOL64 0x0133 // near pointer to 64 bit boolean #define T_PFBOOL08 0x0230 // far pointer to 8 bit boolean #define T_PFBOOL16 0x0231 // far pointer to 16 bit boolean #define T_PFBOOL32 0x0232 // far pointer to 32 bit boolean #define T_PFBOOL64 0x0233 // far pointer to 64 bit boolean #define T_PHBOOL08 0x0330 // huge pointer to 8 bit boolean #define T_PHBOOL16 0x0331 // huge pointer to 16 bit boolean #define T_PHBOOL32 0x0332 // huge pointer to 32 bit boolean #define T_PHBOOL64 0x0333 // huge pointer to 64 bit boolean #define T_32PBOOL08 0x0430 // 16:32 near pointer to 8 bit boolean #define T_32PFBOOL08 0x0530 // 16:32 far pointer to 8 bit boolean #define T_32PBOOL16 0x0431 // 16:32 near pointer to 18 bit boolean #define T_32PFBOOL16 0x0531 // 16:32 far pointer to 16 bit boolean #define T_32PBOOL32 0x0432 // 16:32 near pointer to 32 bit boolean #define T_32PFBOOL32 0x0532 // 16:32 far pointer to 32 bit boolean #define T_32PBOOL64 0x0433 // 16:32 near pointer to 64 bit boolean #define T_32PFBOOL64 0x0533 // 16:32 far pointer to 64 bit boolean #define T_NCVPTR 0x01f0 // CV Internal type for created near poi= nters #define T_FCVPTR 0x02f0 // CV Internal type for created far poin= ters #define T_HCVPTR 0x03f0 // CV Internal type for created huge poi= nters #define T_32NCVPTR 0x04f0 // CV Internal type for created near 32-= bit pointers #define T_32FCVPTR 0x05f0 // CV Internal type for created far 32-b= it pointers #define T_64NCVPTR 0x06f0 // CV Internal type for created near 64-= bit pointers #define CV_IS_INTERNAL_PTR(typ) (CV_IS_PRIMITIVE(typ) && \ CV_TYPE(typ) =3D=3D CV_CVRESERVED && \ CV_TYP_IS_PTR(typ)) /** No leaf index can have a value of 0x0000. The leaf indices are * separated into ranges depending upon the use of the type record.= * The second range is for the type records that are directly refer= enced * in symbols. The first range is for type records that are not * referenced by symbols but instead are referenced by other type * records. All type records must have a starting leaf index in th= ese * first two ranges. The third range of leaf indices are used to b= uild * up complex lists such as the field list of a class type record. = No * type record can begin with one of the leaf indices. The fourth r= anges * of type indices are used to represent numeric data in a symbol o= r * type record. These leaf indices are greater than 0x8000. At the= * point that type or symbol processor is expecting a numeric field= , the * next two bytes in the type record are examined. If the value is= less * than 0x8000, then the two bytes contain the numeric value. If th= e * value is greater than 0x8000, then the data follows the leaf ind= ex in * a format specified by the leaf index. The final range of leaf in= dices * are used to force alignment of subfields within a complex type r= ecord.. */ // leaf indices starting records but referenced from symbol records #define LF_MODIFIER 0x0001 #define LF_POINTER 0x0002 #define LF_ARRAY 0x0003 #define LF_CLASS 0x0004 #define LF_STRUCTURE 0x0005 #define LF_UNION 0x0006 #define LF_ENUM 0x0007 #define LF_PROCEDURE 0x0008 #define LF_MFUNCTION 0x0009 #define LF_VTSHAPE 0x000a #define LF_COBOL0 0x000b #define LF_COBOL1 0x000c #define LF_BARRAY 0x000d #define LF_LABEL 0x000e #define LF_NULL 0x000f #define LF_NOTTRAN 0x0010 #define LF_DIMARRAY 0x0011 #define LF_VFTPATH 0x0012 #define LF_PRECOMP 0x0013 // not referenced from symbol #define LF_ENDPRECOMP 0x0014 // not referenced from symbol #define LF_OEM 0x0015 // oem definable type string #define LF_TYPESERVER 0x0016 // not referenced from symbol // leaf indices starting records but referenced only from type records #define LF_SKIP 0x0200 #define LF_ARGLIST 0x0201 #define LF_DEFARG 0x0202 #define LF_LIST 0x0203 #define LF_FIELDLIST 0x0204 #define LF_DERIVED 0x0205 #define LF_BITFIELD 0x0206 #define LF_METHODLIST 0x0207 #define LF_DIMCONU 0x0208 #define LF_DIMCONLU 0x0209 #define LF_DIMVARU 0x020a #define LF_DIMVARLU 0x020b #define LF_REFSYM 0x020c #define LF_BCLASS 0x0400 #define LF_VBCLASS 0x0401 #define LF_IVBCLASS 0x0402 #define LF_ENUMERATE 0x0403 #define LF_FRIENDFCN 0x0404 #define LF_INDEX 0x0405 #define LF_MEMBER 0x0406 #define LF_STMEMBER 0x0407 #define LF_METHOD 0x0408 #define LF_NESTTYPE 0x0409 #define LF_VFUNCTAB 0x040a #define LF_FRIENDCLS 0x040b #define LF_ONEMETHOD 0x040c #define LF_VFUNCOFF 0x040d #define LF_NUMERIC 0x8000 #define LF_CHAR 0x8000 #define LF_SHORT 0x8001 #define LF_USHORT 0x8002 #define LF_LONG 0x8003 #define LF_ULONG 0x8004 #define LF_REAL32 0x8005 #define LF_REAL64 0x8006 #define LF_REAL80 0x8007 #define LF_REAL128 0x8008 #define LF_QUADWORD 0x8009 #define LF_UQUADWORD 0x800a #define LF_REAL48 0x800b #define LF_COMPLEX32 0x800c #define LF_COMPLEX64 0x800d #define LF_COMPLEX80 0x800e #define LF_COMPLEX128 0x800f #define LF_VARSTRING 0x8010 #if CC_BIGINT #define LF_OCTWORD 0x8017 #define LF_UOCTWORD 0x8018 #endif #define LF_PAD0 0xf0 #define LF_PAD1 0xf1 #define LF_PAD2 0xf2 #define LF_PAD3 0xf3 #define LF_PAD4 0xf4 #define LF_PAD5 0xf5 #define LF_PAD6 0xf6 #define LF_PAD7 0xf7 #define LF_PAD8 0xf8 #define LF_PAD9 0xf9 #define LF_PAD10 0xfa #define LF_PAD11 0xfb #define LF_PAD12 0xfc #define LF_PAD13 0xfd #define LF_PAD14 0xfe #define LF_PAD15 0xff // end of leaf indices // Type enum for pointer records // Pointers can be one of the following types typedef enum CV_ptrtype_e { CV_PTR_NEAR =3D 0x00, // near pointer CV_PTR_FAR =3D 0x01, // far pointer CV_PTR_HUGE =3D 0x02, // huge pointer CV_PTR_BASE_SEG =3D 0x03, // based on segment CV_PTR_BASE_VAL =3D 0x04, // based on value of base CV_PTR_BASE_SEGVAL =3D 0x05, // based on segment value of base CV_PTR_BASE_ADDR =3D 0x06, // based on address of base CV_PTR_BASE_SEGADDR =3D 0x07, // based on segment address of base CV_PTR_BASE_TYPE =3D 0x08, // based on type CV_PTR_BASE_SELF =3D 0x09, // based on self CV_PTR_NEAR32 =3D 0x0a, // 16:32 near pointer CV_PTR_FAR32 =3D 0x0b, // 16:32 far pointer CV_PTR_UNUSEDPTR =3D 0x0c // first unused pointer type } CV_ptrtype_e; // Mode enum for pointers // Pointers can have one of the following modes typedef enum CV_ptrmode_e { CV_PTR_MODE_PTR =3D 0x00, // "normal" pointer CV_PTR_MODE_REF =3D 0x01, // reference CV_PTR_MODE_PMEM =3D 0x02, // pointer to data member CV_PTR_MODE_PMFUNC =3D 0x03, // pointer to member function CV_PTR_MODE_RESERVED=3D 0x04 // first unused pointer mode } CV_ptrmode_e; // Enumeration for function call type typedef enum CV_call_e { CV_CALL_NEAR_C =3D 0x00, // near right to left push, caller pop= s stack CV_CALL_FAR_C =3D 0x01, // far right to left push, caller pops= stack CV_CALL_NEAR_PASCAL =3D 0x02, // near left to right push, callee pop= s stack CV_CALL_FAR_PASCAL =3D 0x03, // far left to right push, callee pops= stack CV_CALL_NEAR_FAST =3D 0x04, // near left to right push with regs, = callee pops stack CV_CALL_FAR_FAST =3D 0x05, // far left to right push with regs, c= allee pops stack CV_CALL_SKIPPED =3D 0x06, // skipped (unused) call index CV_CALL_NEAR_STD =3D 0x07, // near standard call CV_CALL_FAR_STD =3D 0x08, // far standard call CV_CALL_NEAR_SYS =3D 0x09, // near sys call CV_CALL_FAR_SYS =3D 0x0a, // far sys call CV_CALL_THISCALL =3D 0x0b, // this call (this passed in register)= CV_CALL_MIPSCALL =3D 0x0c, // Mips call CV_CALL_GENERIC =3D 0x0d, // Generic call sequence CV_CALL_ALPHACALL =3D 0x0e, // Alpha call CV_CALL_PPCCALL =3D 0x0f, // PPC call CV_CALL_RESERVED =3D 0x10 // first unused call enumeration } CV_call_e; // Values for the access protection of class attributes typedef enum CV_access_e { CV_private =3D 1, CV_protected =3D 2, CV_public =3D 3 } CV_access_e; // enumeration for method properties typedef enum CV_methodprop_e { CV_MTvanilla =3D 0x00, CV_MTvirtual =3D 0x01, CV_MTstatic =3D 0x02, CV_MTfriend =3D 0x03, CV_MTintro =3D 0x04, CV_MTpurevirt =3D 0x05, CV_MTpureintro =3D 0x06 } CV_methodprop_e; // enumeration for virtual shape table entries typedef enum CV_VTS_desc_e { CV_VTS_near =3D 0x00, CV_VTS_far =3D 0x01, CV_VTS_thin =3D 0x02, CV_VTS_outer =3D 0x03, CV_VTS_meta =3D 0x04, CV_VTS_near32 =3D 0x05, CV_VTS_far32 =3D 0x06, CV_VTS_unused =3D 0x07 } CV_VTS_desc_e; // enumeration for LF_LABEL address modes typedef enum CV_LABEL_TYPE_e { CV_LABEL_NEAR =3D 0, // near return CV_LABEL_FAR =3D 4 // far return } CV_LABEL_TYPE_e; // enumeration for LF_MODIFIER values typedef struct CV_modifier_t { unsigned short MOD_const :1; unsigned short MOD_volatile :1; unsigned short MOD_unaligned :1; unsigned short MOD_unused :13; } CV_modifier_t; // bit field structure describing class/struct/union/enum propertie= s typedef struct CV_prop_t { unsigned short packed :1; // true if structure is packed unsigned short ctor :1; // true if constructors or destr= uctors present unsigned short ovlops :1; // true if overloaded operators = present unsigned short isnested :1; // true if this is a nested clas= s unsigned short cnested :1; // true if this class contains n= ested types unsigned short opassign :1; // true if overloaded assignment= (=3D) unsigned short opcast :1; // true if casting methods unsigned short fwdref :1; // true if forward reference (in= complete defn) unsigned short scoped :1; // scoped definition unsigned short reserved :7; } CV_prop_t; // class field attribute typedef struct CV_fldattr_t { unsigned short access :2; // access protection CV_access_t= unsigned short mprop :3; // method properties CV_methodpr= op_t unsigned short pseudo :1; // compiler generated fcn and do= es not exist unsigned short noinherit :1; // true if class cannot be inher= ited unsigned short noconstruct :1; // true if class cannot be const= ructed unsigned short unused :8; // unused } CV_fldattr_t; // Structures to access to the type records typedef struct TYPTYPE { unsigned short len; unsigned short leaf; unsigned char data[CV_ZEROLEN]; } TYPTYPE; // general types record __INLINE char *NextType (char * pType) { return (pType + ((TYPTYPE *)pType)->len + sizeof(unsigned short)); } typedef enum CV_PMEMBER { CV_PDM16_NONVIRT =3D 0x00, // 16:16 data no virtual fcn or ba= se CV_PDM16_VFCN =3D 0x01, // 16:16 data with virtual functio= ns CV_PDM16_VBASE =3D 0x02, // 16:16 data with virtual bases CV_PDM32_NVVFCN =3D 0x03, // 16:32 data w/wo virtual functio= ns CV_PDM32_VBASE =3D 0x04, // 16:32 data with virtual bases CV_PMF16_NEARNVSA =3D 0x05, // 16:16 near method nonvirtual si= ngle address point CV_PMF16_NEARNVMA =3D 0x06, // 16:16 near method nonvirtual mu= ltiple address points CV_PMF16_NEARVBASE =3D 0x07, // 16:16 near method virtual bases= CV_PMF16_FARNVSA =3D 0x08, // 16:16 far method nonvirtual sin= gle address point CV_PMF16_FARNVMA =3D 0x09, // 16:16 far method nonvirtual mul= tiple address points CV_PMF16_FARVBASE =3D 0x0a, // 16:16 far method virtual bases CV_PMF32_NVSA =3D 0x0b, // 16:32 method nonvirtual single = address point CV_PMF32_NVMA =3D 0x0c, // 16:32 method nonvirtual multipl= e address point CV_PMF32_VBASE =3D 0x0d // 16:32 method virtual bases } CV_PMEMBER; // memory representation of pointer to member. These representatio= ns are // indexed by the enumeration above in the LF_POINTER record // representation of a 16:16 pointer to data for a class with no // virtual functions or virtual bases struct CV_PDMR16_NONVIRT { CV_off16_t mdisp; // displacement to data (NULL =3D -1= ) }; // representation of a 16:16 pointer to data for a class with virtu= al // functions struct CV_PMDR16_VFCN { CV_off16_t mdisp; // displacement to data ( NULL =3D 0= ) }; // representation of a 16:16 pointer to data for a class with // virtual bases struct CV_PDMR16_VBASE { CV_off16_t mdisp; // displacement to data CV_off16_t pdisp; // this pointer displacement to vbpt= r CV_off16_t vdisp; // displacement within vbase table // NULL =3D (,,0xffff) }; // representation of a 16:32 near pointer to data for a class with // or without virtual functions and no virtual bases struct CV_PDMR32_NVVFCN { CV_off32_t mdisp; // displacement to data (NULL =3D 0x= 80000000) }; // representation of a 16:32 near pointer to data for a class // with virtual bases struct CV_PDMR32_VBASE { CV_off32_t mdisp; // displacement to data CV_off32_t pdisp; // this pointer displacement CV_off32_t vdisp; // vbase table displacement // NULL =3D (,,0xffffffff) }; // representation of a 16:16 pointer to near member function for a // class with no virtual functions or bases and a single address po= int struct CV_PMFR16_NEARNVSA { CV_uoff16_t off; // near address of function (NULL =3D= 0) }; // representation of a 16:16 near pointer to member functions of a // class with no virtual bases and multiple address points struct CV_PMFR16_NEARNVMA { CV_uoff16_t off; // offset of function (NULL =3D 0,x)= signed short disp; }; // representation of a 16:16 near pointer to member function of a // class with virtual bases struct CV_PMFR16_NEARVBASE { CV_uoff16_t off; // offset of function (NULL =3D 0,x,= x,x) CV_off16_t mdisp; // displacement to data CV_off16_t pdisp; // this pointer displacement CV_off16_t vdisp; // vbase table displacement }; // representation of a 16:16 pointer to far member function for a // class with no virtual bases and a single address point struct CV_PMFR16_FARNVSA { CV_uoff16_t off; // offset of function (NULL =3D 0:0)= unsigned short seg; // segment of function }; // representation of a 16:16 far pointer to member functions of a // class with no virtual bases and multiple address points struct CV_PMFR16_FARNVMA { CV_uoff16_t off; // offset of function (NULL =3D 0:0,= x) unsigned short seg; signed short disp; }; // representation of a 16:16 far pointer to member function of a // class with virtual bases struct CV_PMFR16_FARVBASE { CV_uoff16_t off; // offset of function (NULL =3D 0:0,= x,x,x) unsigned short seg; CV_off16_t mdisp; // displacement to data CV_off16_t pdisp; // this pointer displacement CV_off16_t vdisp; // vbase table displacement }; // representation of a 16:32 near pointer to member function for a // class with no virtual bases and a single address point struct CV_PMFR32_NVSA { CV_uoff32_t off; // near address of function (NULL =3D= 0L) }; // representation of a 16:32 near pointer to member function for a // class with no virtual bases and multiple address points struct CV_PMFR32_NVMA { CV_uoff32_t off; // near address of function (NULL =3D= 0L,x) CV_off32_t disp; }; // representation of a 16:32 near pointer to member function for a // class with virtual bases struct CV_PMFR32_VBASE { CV_uoff32_t off; // near address of function (NULL =3D= 0L,x,x,x) CV_off32_t mdisp; // displacement to data CV_off32_t pdisp; // this pointer displacement CV_off32_t vdisp; // vbase table displacement }; // Easy leaf - used for generic casting to reference leaf field // of a subfield of a complex list typedef struct lfEasy { unsigned short leaf; // LF_... } lfEasy; /** The following type records are basically variant records of the * above structure. The "unsigned short leaf" of the above structu= re and * the "unsigned short leaf" of the following type definitions are = the same * symbol. When the OMF record is locked via the MHOMFLock API * call, the address of the "unsigned short leaf" is returned */ // Type record for LF_MODIFIER typedef struct lfModifier { unsigned short leaf; // LF_MODIFIER CV_modifier_t attr; // modifier attribute modifier_t CV_typ_t type; // modified type } lfModifier; // type record for LF_POINTER #ifndef __cplusplus typedef struct lfPointer { #endif struct lfPointerBody { unsigned short leaf; // LF_POINTER struct lfPointerAttr { unsigned char ptrtype :5; // ordinal specifying pointe= r type (ptrtype-t) unsigned char ptrmode :3; // ordinal specifying pointe= r mode (ptrmode_t) unsigned char isflat32 :1; // true if 0:32 pointer unsigned char isvolatile :1; // TRUE if volatile pointer unsigned char isconst :1; // TRUE if const pointer unsigned char isunaligned :1; // TRUE if unaligned pointer= unsigned char unused :4; } attr; CV_typ_t utype; // type index of the underly= ing type #if (defined(__cplusplus) || defined(_MSC_VER)) // for C++ and MS compil= ers that support unnamed unions }; #else } u; #endif #ifdef __cplusplus typedef struct lfPointer : public lfPointerBody { #endif union { struct { CV_typ_t pmclass; // index of containing class for= pointer to member unsigned short pmenum; // enumeration specifying pm for= mat } pm; unsigned short bseg; // base segment if PTR_BASE_SEG unsigned char Sym[1]; // copy of base symbol record (i= ncluding length) struct { CV_typ_t index; // type index if CV_PTR_BASE_TYP= E unsigned char name[1]; // name of base type } btype; } pbase; } lfPointer; // type record for LF_ARRAY typedef struct lfArray { unsigned short leaf; // LF_ARRAY CV_typ_t elemtype; // type index of element type CV_typ_t idxtype; // type index of indexing type unsigned char data[CV_ZEROLEN]; // variable length data specifying= // size in bytes and name } lfArray; // type record for LF_CLASS, LF_STRUCTURE typedef struct lfClass { unsigned short leaf; // LF_CLASS, LF_STRUCT unsigned short count; // count of number of elements in cl= ass CV_typ_t field; // type index of LF_FIELD descriptor= list CV_prop_t property; // property attribute field (prop_t)= CV_typ_t derived; // type index of derived from list i= f not zero CV_typ_t vshape; // type index of vshape table for th= is class unsigned char data[CV_ZEROLEN]; // data describing length of struc= ture in // bytes and name } lfClass; typedef lfClass lfStructure; // type record for LF_UNION typedef struct lfUnion { unsigned short leaf; // LF_UNION unsigned short count; // count of number of elements in cl= ass CV_typ_t field; // type index of LF_FIELD descriptor= list CV_prop_t property; // property attribute field unsigned char data[CV_ZEROLEN]; // variable length data describing= length of // structure and name } lfUnion; // type record for LF_ENUM typedef struct lfEnum { unsigned short leaf; // LF_ENUM unsigned short count; // count of number of elements in cl= ass CV_typ_t utype; // underlying type of the enum CV_typ_t field; // type index of LF_FIELD descriptor= list CV_prop_t property; // property attribute field unsigned char Name[1]; // length prefixed name of enum } lfEnum; // Type record for LF_PROCEDURE typedef struct lfProc { unsigned short leaf; // LF_PROCEDURE CV_typ_t rvtype; // type index of return value unsigned char calltype; // calling convention (CV_call_t) unsigned char reserved; // reserved for future use unsigned short parmcount; // number of parameters CV_typ_t arglist; // type index of argument list } lfProc; // Type record for member function typedef struct lfMFunc { unsigned short leaf; // LF_MFUNCTION CV_typ_t rvtype; // type index of return value CV_typ_t classtype; // type index of containing class CV_typ_t thistype; // type index of this pointer (model= specific) unsigned char calltype; // calling convention (call_t) unsigned char reserved; // reserved for future use unsigned short parmcount; // number of parameters CV_typ_t arglist; // type index of argument list long thisadjust; // this adjuster (long because pad r= equired anyway) } lfMFunc; // type record for virtual function table shape typedef struct lfVTShape { unsigned short leaf; // LF_VTSHAPE unsigned short count; // number of entries in vfunctable unsigned char desc[CV_ZEROLEN]; // 4 bit (CV_VTS_desc) descriptors= } lfVTShape; // type record for cobol0 typedef struct lfCobol0 { unsigned short leaf; // LF_COBOL0 CV_typ_t type; // parent type record index unsigned char data[CV_ZEROLEN]; } lfCobol0; // type record for cobol1 typedef struct lfCobol1 { unsigned short leaf; // LF_COBOL1 unsigned char data[CV_ZEROLEN]; } lfCobol1; // type record for basic array typedef struct lfBArray { unsigned short leaf; // LF_BARRAY CV_typ_t utype; // type index of underlying type } lfBArray; // type record for assembler labels typedef struct lfLabel { unsigned short leaf; // LF_LABEL unsigned short mode; // addressing mode of label } lfLabel; // type record for dimensioned arrays typedef struct lfDimArray { unsigned short leaf; // LF_DIMARRAY CV_typ_t utype; // underlying type of the array CV_typ_t diminfo; // dimension information char name[1]; // length prefixed name } lfDimArray; // type record describing path to virtual function table typedef struct lfVFTPath { unsigned short leaf; // LF_VFTPATH unsigned short count; // count of number of bases in path CV_typ_t base[1]; // bases from root to leaf } lfVFTPath; // type record describing inclusion of precompiled types typedef struct lfPreComp { unsigned short leaf; // LF_PRECOMP unsigned short start; // starting type index included unsigned short count; // number of types in inclusion unsigned long signature; // signature unsigned char name[CV_ZEROLEN]; // length prefixed name of include= d type file } lfPreComp; // type record describing end of precompiled types that can be // included by another file typedef struct lfEndPreComp { unsigned short leaf; // LF_ENDPRECOMP unsigned long signature; // signature } lfEndPreComp; // type record for OEM definable type strings typedef struct lfOEM { unsigned short leaf; // LF_OEM unsigned short cvOEM; // MS assigned OEM identified unsigned short recOEM; // OEM assigned type identifier unsigned short count; // count of type indices to follow CV_typ_t index[CV_ZEROLEN]; // array of type indices followe= d // by OEM defined data } lfOEM; #define OEM_ODI 0x0010 #define OEM_ODI_REC_BASELIST 0x0000 // type record describing using of a type server typedef struct lfTypeServer { unsigned short leaf; // LF_TYPESERVER unsigned long signature; // signature unsigned long age; // age of database used by this modu= le unsigned char name[CV_ZEROLEN]; // length prefixed name of PDB= } lfTypeServer; // description of type records that can be referenced from // type records referenced by symbols // type record for skip record typedef struct lfSkip { unsigned short leaf; // LF_SKIP CV_typ_t type; // next valid index unsigned char data[CV_ZEROLEN]; // pad data } lfSkip; // argument list leaf typedef struct lfArgList { unsigned short leaf; // LF_ARGLIST unsigned short count; // number of arguments CV_typ_t arg[CV_ZEROLEN]; // number of arguments } lfArgList; // derived class list leaf typedef struct lfDerived { unsigned short leaf; // LF_DERIVED unsigned short count; // number of arguments CV_typ_t drvdcls[CV_ZEROLEN]; // type indices of derived cla= sses } lfDerived; // leaf for default arguments typedef struct lfDefArg { unsigned short leaf; // LF_DEFARG CV_typ_t type; // type of resulting expression unsigned char expr[CV_ZEROLEN]; // length prefixed expression stri= ng } lfDefArg; // list leaf // This list should no longer be used because the utilities cannot // verify the contents of the list without knowing what type of lis= t // it is. New specific leaf indices should be used instead. typedef struct lfList { unsigned short leaf; // LF_LIST char data[CV_ZEROLEN]; // data format specified by indexi= ng type } lfList; // field list leaf // This is the header leaf for a complex list of class and structur= e // subfields. typedef struct lfFieldList { unsigned short leaf; // LF_FIELDLIST char data[CV_ZEROLEN]; // field list sub lists } lfFieldList; // type record for non-static methods and friends in overloaded met= hod list typedef struct mlMethod { CV_fldattr_t attr; // method attribute CV_typ_t index; // index to type record for procedure= unsigned long vbaseoff[CV_ZEROLEN]; // offset in vfunctable if i= ntro virtual } mlMethod; typedef struct lfMethodList { unsigned short leaf; unsigned char mList[CV_ZEROLEN]; // really a mlMethod type } lfMethodList; // type record for LF_BITFIELD typedef struct lfBitfield { unsigned short leaf; // LF_BITFIELD unsigned char length; unsigned char position; CV_typ_t type; // type of bitfield } lfBitfield; // type record for dimensioned array with constant bounds typedef struct lfDimCon { unsigned short leaf; // LF_DIMCONU or LF_DIMCONLU unsigned short rank; // number of dimensions CV_typ_t typ; // type of index unsigned char dim[CV_ZEROLEN]; // array of dimension information = with // either upper bounds or lower/uppe= r bound } lfDimCon; // type record for dimensioned array with variable bounds typedef struct lfDimVar { unsigned short leaf; // LF_DIMVARU or LF_DIMVARLU unsigned short rank; // number of dimensions CV_typ_t typ; // type of index unsigned char dim[CV_ZEROLEN]; // array of type indices for eithe= r // variable upper bound or variable // lower/upper bound. The reference= d // types must be LF_REFSYM or T_VOID= } lfDimVar; // type record for referenced symbol typedef struct lfRefSym { unsigned short leaf; // LF_REFSYM unsigned char Sym[1]; // copy of referenced symbol record // (including length) } lfRefSym; /** the following are numeric leaves. They are used to indicate the= * size of the following variable length data. When the numeric * data is a single byte less than 0x8000, then the data is output * directly. If the data is more the 0x8000 or is a negative value= , * then the data is preceeded by the proper index. */ // signed character leaf typedef struct lfChar { unsigned short leaf; // LF_CHAR signed char val; // signed 8-bit value } lfChar; // signed short leaf typedef struct lfShort { unsigned short leaf; // LF_SHORT short val; // signed 16-bit value } lfShort; // unsigned short leaf typedef struct lfUShort { unsigned short leaf; // LF_unsigned short unsigned short val; // unsigned 16-bit value } lfUShort; // signed long leaf typedef struct lfLong { unsigned short leaf; // LF_LONG long val; // signed 32-bit value } lfLong; // unsigned long leaf typedef struct lfULong { unsigned short leaf; // LF_ULONG unsigned long val; // unsigned 32-bit value } lfULong; // signed quad leaf typedef struct lfQuad { unsigned short leaf; // LF_QUAD unsigned char val[8]; // signed 64-bit value } lfQuad; // unsigned quad leaf typedef struct lfUQuad { unsigned short leaf; // LF_UQUAD unsigned char val[8]; // unsigned 64-bit value } lfUQuad; #if CC_BIGINT // signed int128 leaf typedef struct lfOct { unsigned short leaf; // LF_OCT unsigned char val[16]; // signed 128-bit value } lfOct; // unsigned int128 leaf typedef struct lfUOct { unsigned short leaf; // LF_UOCT unsigned char val[16]; // unsigned 128-bit value } lfUOct; #endif // real 32-bit leaf typedef struct lfReal32 { unsigned short leaf; // LF_REAL32 float val; // 32-bit real value } lfReal32; // real 48-bit leaf typedef struct lfReal48 { unsigned short leaf; // LF_REAL48 unsigned char val[6]; // 48-bit real value } lfReal48; // real 64-bit leaf typedef struct lfReal64 { unsigned short leaf; // LF_REAL64 double val; // 64-bit real value } lfReal64; // real 80-bit leaf typedef struct lfReal80 { unsigned short leaf; // LF_REAL80 FLOAT10 val; // real 80-bit value } lfReal80; // real 128-bit leaf typedef struct lfReal128 { unsigned short leaf; // LF_REAL128 char val[16]; // real 128-bit value } lfReal128; // complex 32-bit leaf typedef struct lfCmplx32 { unsigned short leaf; // LF_COMPLEX32 float val_real; // real component float val_imag; // imaginary component } lfCmplx32; // complex 64-bit leaf typedef struct lfCmplx64 { unsigned short leaf; // LF_COMPLEX64 double val_real; // real component double val_imag; // imaginary component } flCmplx64; // complex 80-bit leaf typedef struct lfCmplx80 { unsigned short leaf; // LF_COMPLEX80 FLOAT10 val_real; // real component FLOAT10 val_imag; // imaginary component } lfCmplx80; // complex 128-bit leaf typedef struct lfCmplx128 { unsigned short leaf; // LF_COMPLEX128 char val_real[16]; // real component char val_imag[16]; // imaginary component } lfCmplx128; // variable length numeric field typedef struct lfVarString { unsigned short leaf; // LF_VARSTRING unsigned short len; // length of value in bytes unsigned char value[CV_ZEROLEN]; // value } lfVarString; //**********************************************************************= * // index leaf - contains type index of another leaf // a major use of this leaf is to allow the compilers to emit a // long complex list (LF_FIELD) in smaller pieces. typedef struct lfIndex { unsigned short leaf; // LF_INDEX CV_typ_t index; // type index of referenced leaf } lfIndex; // subfield record for base class field typedef struct lfBClass { unsigned short leaf; // LF_BCLASS CV_typ_t index; // type index of base class CV_fldattr_t attr; // attribute unsigned char offset[CV_ZEROLEN]; // variable length offset of b= ase within class } lfBClass; // subfield record for direct and indirect virtual base class field= typedef struct lfVBClass { unsigned short leaf; // LF_VBCLASS | LV_IVBCLASS CV_typ_t index; // type index of direct virtual base= class CV_typ_t vbptr; // type index of virtual base pointe= r CV_fldattr_t attr; // attribute unsigned char vbpoff[CV_ZEROLEN]; // virtual base pointer offset= from address point // followed by virtual base offset f= rom vbtable } lfVBClass; // subfield record for friend class typedef struct lfFriendCls { unsigned short leaf; // LF_FRIENDCLS CV_typ_t index; // index to type record of friend cl= ass } lfFriendCls; // subfield record for friend function typedef struct lfFriendFcn { unsigned short leaf; // LF_FRIENDFCN CV_typ_t index; // index to type record of friend fu= nction char Name[1]; // name of friend function } lfFriendFcn; // subfield record for non-static data members typedef struct lfMember { unsigned short leaf; // LF_MEMBER CV_typ_t index; // index of type record for field CV_fldattr_t attr; // attribute mask unsigned char offset[CV_ZEROLEN]; // variable length offset of f= ield followed // by length prefixed name of field } lfMember; // type record for static data members typedef struct lfSTMember { unsigned short leaf; // LF_STMEMBER CV_typ_t index; // index of type record for field CV_fldattr_t attr; // attribute mask char Name[1]; // length prefixed name of field } lfSTMember; // subfield record for virtual function table pointer typedef struct lfVFuncTab { unsigned short leaf; // LF_VFUNCTAB CV_typ_t type; // type index of pointer } lfVFuncTab; // subfield record for virtual function table pointer with offset typedef struct lfVFuncOff { unsigned short leaf; // LF_VFUNCTAB CV_typ_t type; // type index of pointer CV_off32_t offset; // offset of virtual function table = pointer } lfVFuncOff; // subfield record for overloaded method list typedef struct lfMethod { unsigned short leaf; // LF_METHOD unsigned short count; // number of occurances of function CV_typ_t mList; // index to LF_METHODLIST record char Name[1]; // length prefixed name of method } lfMethod; // subfield record for nonoverloaded method typedef struct lfOneMethod { unsigned short leaf; // LF_ONEMETHOD CV_fldattr_t attr; // method attribute CV_typ_t index; // index to type record for procedur= e unsigned long vbaseoff[CV_ZEROLEN]; // offset in vfunctable if // intro virtual followed by // length prefixed name of method } lfOneMethod; // subfield record for enumerate typedef struct lfEnumerate { unsigned short leaf; // LF_ENUMERATE CV_fldattr_t attr; // access unsigned char value[CV_ZEROLEN]; // variable length value field f= ollowed // by length prefixed name } lfEnumerate; // type record for nested (scoped) type definition typedef struct lfNestType { unsigned short leaf; // LF_NESTTYPE CV_typ_t index; // index of nested type definition unsigned char Name[1]; // length prefixed type name } lfNestType; // type record for pad leaf typedef struct lfPad { unsigned char leaf; } SYM_PAD; // Symbol definitions typedef enum SYM_ENUM_e { S_COMPILE =3D 0x0001, // Compile flags symbol S_REGISTER =3D 0x0002, // Register variable S_CONSTANT =3D 0x0003, // constant symbol S_UDT =3D 0x0004, // User defined type S_SSEARCH =3D 0x0005, // Start Search S_END =3D 0x0006, // Block, procedure, "with" or thunk end S_SKIP =3D 0x0007, // Reserve symbol space in $$Symbols table= S_CVRESERVE =3D 0x0008, // Reserved symbol for CV internal use S_OBJNAME =3D 0x0009, // path to object file name S_ENDARG =3D 0x000a, // end of argument/return list S_COBOLUDT =3D 0x000b, // special UDT for cobol that does not sym= bol pack S_MANYREG =3D 0x000c, // multiple register variable S_RETURN =3D 0x000d, // return description symbol S_ENTRYTHIS =3D 0x000e, // description of this pointer on entry S_BPREL16 =3D 0x0100, // BP-relative S_LDATA16 =3D 0x0101, // Module-local symbol S_GDATA16 =3D 0x0102, // Global data symbol S_PUB16 =3D 0x0103, // a public symbol S_LPROC16 =3D 0x0104, // Local procedure start S_GPROC16 =3D 0x0105, // Global procedure start S_THUNK16 =3D 0x0106, // Thunk Start S_BLOCK16 =3D 0x0107, // block start S_WITH16 =3D 0x0108, // with start S_LABEL16 =3D 0x0109, // code label S_CEXMODEL16 =3D 0x010a, // change execution model S_VFTABLE16 =3D 0x010b, // address of virtual function table S_REGREL16 =3D 0x010c, // register relative address S_BPREL32 =3D 0x0200, // BP-relative S_LDATA32 =3D 0x0201, // Module-local symbol S_GDATA32 =3D 0x0202, // Global data symbol S_PUB32 =3D 0x0203, // a public symbol (CV internal reserved) S_LPROC32 =3D 0x0204, // Local procedure start S_GPROC32 =3D 0x0205, // Global procedure start S_THUNK32 =3D 0x0206, // Thunk Start S_BLOCK32 =3D 0x0207, // block start S_WITH32 =3D 0x0208, // with start S_LABEL32 =3D 0x0209, // code label S_CEXMODEL32 =3D 0x020a, // change execution model S_VFTABLE32 =3D 0x020b, // address of virtual function table S_REGREL32 =3D 0x020c, // register relative address S_LTHREAD32 =3D 0x020d, // local thread storage S_GTHREAD32 =3D 0x020e, // global thread storage S_SLINK32 =3D 0x020f, // static link for MIPS EH implementation S_LPROCMIPS =3D 0x0300, // Local procedure start S_GPROCMIPS =3D 0x0301, // Global procedure start S_PROCREF =3D 0x0400, // Reference to a procedure S_DATAREF =3D 0x0401, // Reference to data S_ALIGN =3D 0x0402, // Used for page alignment of symbols S_LPROCREF =3D 0x0403 // Local Reference to a procedure } SYM_ENUM_e; // enum describing the compile flag source language typedef enum CV_CFL_LANG { CV_CFL_C =3D 0x00, CV_CFL_CXX =3D 0x01, CV_CFL_FORTRAN =3D 0x02, CV_CFL_MASM =3D 0x03, CV_CFL_PASCAL =3D 0x04, CV_CFL_BASIC =3D 0x05, CV_CFL_COBOL =3D 0x06 } CV_CFL_LANG; // enum describing target processor typedef enum CV_CPU_TYPE_e { CV_CFL_8080 =3D 0x00, CV_CFL_8086 =3D 0x01, CV_CFL_80286 =3D 0x02, CV_CFL_80386 =3D 0x03, CV_CFL_80486 =3D 0x04, CV_CFL_PENTIUM =3D 0x05, CV_CFL_MIPSR4000 =3D 0x10, CV_CFL_M68000 =3D 0x20, CV_CFL_M68010 =3D 0x21, CV_CFL_M68020 =3D 0x22, CV_CFL_M68030 =3D 0x23, CV_CFL_M68040 =3D 0x24, CV_CFL_ALPHA =3D 0x30, CV_CFL_PPC601 =3D 0x40, CV_CFL_PPC603 =3D 0x41, CV_CFL_PPC604 =3D 0x42, CV_CFL_PPC620 =3D 0x43 } CV_CPU_TYPE_e; // enum describing compile flag ambiant data model typedef enum CV_CFL_DATA { CV_CFL_DNEAR =3D 0x00, CV_CFL_DFAR =3D 0x01, CV_CFL_DHUGE =3D 0x02 } CV_CFL_DATA; // enum describing compile flag ambiant code model typedef enum CV_CFL_CODE_e { CV_CFL_CNEAR =3D 0x00, CV_CFL_CFAR =3D 0x01, CV_CFL_CHUGE =3D 0x02 } CV_CFL_CODE_e; // enum describing compile flag target floating point package typedef enum CV_CFL_FPKG_e { CV_CFL_NDP =3D 0x00, CV_CFL_EMU =3D 0x01, CV_CFL_ALT =3D 0x02 } CV_CFL_FPKG_e; // enum describing function return method typedef struct CV_PROCFLAGS { union { unsigned char bAll; struct { unsigned char CV_PFLAG_FPO :1; // frame pointer omitted unsigned char CV_PFLAG_INT :1; // interrupt return unsigned char CV_PFLAG_FAR :1; // far return unsigned char CV_PFLAG_NEVER:1; // function does not return unsigned char unused :4; // }; }; } CV_PROCFLAGS; // enum describing function data return method typedef enum CV_GENERIC_STYLE_e { CV_GENERIC_VOID =3D 0x00, // void return type CV_GENERIC_REG =3D 0x01, // return data is in registers CV_GENERIC_ICAN =3D 0x02, // indirect caller allocated near CV_GENERIC_ICAF =3D 0x03, // indirect caller allocated far CV_GENERIC_IRAN =3D 0x04, // indirect returnee allocated nea= r CV_GENERIC_IRAF =3D 0x05, // indirect returnee allocated far= CV_GENERIC_UNUSED =3D 0x06 // first unused } CV_GENERIC_STYLE_e; typedef struct CV_GENERIC_FLAG { unsigned short cstyle :1; // true push varargs right to left unsigned short rsclean :1; // true if returnee stack cleanup unsigned short unused :14; // unused } CV_GENERIC_FLAG; typedef struct SYMTYPE { unsigned short reclen; // Record length unsigned short rectyp; // Record type char data[CV_ZEROLEN]; } SYMTYPE; __INLINE SYMTYPE *NextSym (SYMTYPE * pSym) { return (SYMTYPE *) ((char *)pSym + pSym->reclen + sizeof(unsigned sh= ort)); } // non-model specific symbol types typedef struct REGSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_REGISTER CV_typ_t typind; // Type index unsigned short reg; // register enumerate unsigned char name[1]; // Length-prefixed name } REGSYM; typedef struct MANYREGSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_MANYREG CV_typ_t typind; // Type index unsigned char count; // count of number of registers unsigned char reg[1]; // count register enumerates followe= d by // length-prefixed name. Registers = are // most significant first. } MANYREGSYM; typedef struct CONSTSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_CONSTANT CV_typ_t typind; // Type index (containing enum if en= umerate) unsigned short value; // numeric leaf containing value unsigned char name[CV_ZEROLEN]; // Length-prefixed name } CONSTSYM; typedef struct UDTSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_UDT | S_COBOLUDT CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } UDTSYM; typedef struct SEARCHSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_SSEARCH unsigned long startsym; // offset of the procedure unsigned short seg; // segment of symbol } SEARCHSYM; typedef struct CFLAGSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_COMPILE unsigned char machine; // target processor struct { unsigned char language :8; // language index unsigned char pcode :1; // true if pcode present unsigned char floatprec :2; // floating precision unsigned char floatpkg :2; // float package unsigned char ambdata :3; // ambiant data model unsigned char ambcode :3; // ambiant code model unsigned char mode32 :1; // true if compiled 32 bit mode unsigned char pad :4; // reserved } flags; unsigned char ver[1]; // Length-prefixed compiler version = string } CFLAGSYM; typedef struct OBJNAMESYM { unsigned short reclen; // Record length unsigned short rectyp; // S_OBJNAME unsigned long signature; // signature unsigned char name[1]; // Length-prefixed name } OBJNAMESYM; typedef struct ENDARGSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_ENDARG } ENDARGSYM; typedef struct RETURNSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_RETURN CV_GENERIC_FLAG flags; // flags CV_GENERIC_STYLE_e style; // return style // followed by return method data } RETURNSYM; typedef struct ENTRYTHISSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_ENTRYTHIS unsigned char thissym; // symbol describing this pointer on= entry } ENTRYTHISSYM; // symbol types for 16:16 memory model typedef struct BPRELSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_BPREL16 CV_off16_t off; // BP-relative offset CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } BPRELSYM16; typedef struct DATASYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_LDATA or S_GDATA CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } DATASYM16; typedef DATASYM16 PUBSYM16; typedef struct PROCSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_GPROC16 or S_LPROC16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol unsigned short len; // Proc length unsigned short DbgStart; // Debug start offset unsigned short DbgEnd; // Debug end offset CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol CV_typ_t typind; // Type index CV_PROCFLAGS flags; // Proc flags unsigned char name[1]; // Length-prefixed name } PROCSYM16; typedef struct THUNKSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_THUNK unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol unsigned short len; // length of thunk unsigned char ord; // ordinal specifying type of thunk unsigned char name[1]; // name of thunk unsigned char variant[CV_ZEROLEN]; // variant portion of thunk } THUNKSYM16; typedef enum { THUNK_ORDINAL_NOTYPE, THUNK_ORDINAL_ADJUSTOR, THUNK_ORDINAL_VCALL, THUNK_ORDINAL_PCODE } THUNK_ORDINAL; typedef struct LABELSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_LABEL16 CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol CV_PROCFLAGS flags; // flags unsigned char name[1]; // Length-prefixed name } LABELSYM16; typedef struct BLOCKSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_BLOCK16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned short len; // Block length CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol unsigned char name[1]; // Length-prefixed name } BLOCKSYM16; typedef struct WITHSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_WITH16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned short len; // Block length CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol unsigned char expr[1]; // Length-prefixed expression } WITHSYM16; typedef enum CEXM_MODEL_e { CEXM_MDL_table =3D 0x00, // not executable CEXM_MDL_jumptable =3D 0x01, // Compiler generated jump table CEXM_MDL_datapad =3D 0x02, // Data padding for alignment CEXM_MDL_native =3D 0x20, // native (actually not-pcode) CEXM_MDL_cobol =3D 0x21, // cobol CEXM_MDL_codepad =3D 0x22, // Code padding for alignment CEXM_MDL_code =3D 0x23, // code CEXM_MDL_pcode =3D 0x40, // pcode CEXM_MDL_pcode32Mac =3D 0x41, // macintosh 32 bit pcode CEXM_MDL_pcode32MacNep =3D 0x42 // macintosh 32 bit pcode native e= ntry point } CEXM_MODEL_e; typedef enum CV_COBOL_e { CV_COBOL_dontstop, CV_COBOL_pfm, CV_COBOL_false, CV_COBOL_extcall } CV_COBOL_e; typedef struct CEXMSYM16 { unsigned short reclen; // Record length unsigned short rectyp; // S_CEXMODEL16 CV_uoff16_t off; // offset of symbol unsigned short seg; // segment of symbol unsigned short model; // execution model union var16 { struct { CV_uoff16_t pcdtable; // offset to pcode function table CV_uoff16_t pcdspi; // offset to segment pcode informati= on } pcode; struct { unsigned short subtype; // see CV_COBOL_e above unsigned short flag; } cobol; }; } CEXMSYM16; typedef struct VPATHSYM16 { unsigned short reclen; // record length unsigned short rectyp; // S_VFTPATH16 CV_uoff16_t off; // offset of virtual function table unsigned short seg; // segment of virtual function table= CV_typ_t root; // type index of the root of path CV_typ_t path; // type index of the path record } VPATHSYM16; typedef struct REGREL16 { unsigned short reclen; // Record length unsigned short rectyp; // S_REGREL16 CV_uoff16_t off; // offset of symbol unsigned short reg; // register index CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } REGREL16; typedef struct BPRELSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_BPREL32 CV_off32_t off; // BP-relative offset CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } BPRELSYM32; typedef struct DATASYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_LDATA32, S_GDATA32 or S_PUB32 CV_uoff32_t off; unsigned short seg; CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } DATASYM32; typedef DATASYM32 PUBSYM32; typedef struct PROCSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_GPROC32 or S_LPROC32 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol unsigned long len; // Proc length unsigned long DbgStart; // Debug start offset unsigned long DbgEnd; // Debug end offset CV_uoff32_t off; unsigned short seg; CV_typ_t typind; // Type index CV_PROCFLAGS flags; // Proc flags unsigned char name[1]; // Length-prefixed name } PROCSYM32; typedef struct THUNKSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_THUNK32 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol CV_uoff32_t off; unsigned short seg; unsigned short len; // length of thunk unsigned char ord; // ordinal specifying type of thunk unsigned char name[1]; // Length-prefixed name unsigned char variant[CV_ZEROLEN]; // variant portion of thunk } THUNKSYM32; typedef struct LABELSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_LABEL32 CV_uoff32_t off; unsigned short seg; CV_PROCFLAGS flags; // flags unsigned char name[1]; // Length-prefixed name } LABELSYM32; typedef struct BLOCKSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_BLOCK32 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long len; // Block length CV_uoff32_t off; // Offset in code segment unsigned short seg; // segment of label unsigned char name[1]; // Length-prefixed name } BLOCKSYM32; typedef struct WITHSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_WITH32 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long len; // Block length CV_uoff32_t off; // Offset in code segment unsigned short seg; // segment of label unsigned char expr[1]; // Length-prefixed expression string= } WITHSYM32; typedef struct CEXMSYM32 { unsigned short reclen; // Record length unsigned short rectyp; // S_CEXMODEL32 CV_uoff32_t off; // offset of symbol unsigned short seg; // segment of symbol unsigned short model; // execution model union var32 { struct { CV_uoff32_t pcdtable; // offset to pcode function table CV_uoff32_t pcdspi; // offset to segment pcode informati= on } pcode; struct { unsigned short subtype; // see CV_COBOL_e above unsigned short flag; } cobol; struct { CV_uoff32_t calltableOff; // offset to function table unsigned short calltableSeg; // segment of function table } pcode32Mac; }; } CEXMSYM32; typedef struct VPATHSYM32 { unsigned short reclen; // record length unsigned short rectyp; // S_VFTPATH32 CV_uoff32_t off; // offset of virtual function table unsigned short seg; // segment of virtual function table= CV_typ_t root; // type index of the root of path CV_typ_t path; // type index of the path record } VPATHSYM32; typedef struct REGREL32 { unsigned short reclen; // Record length unsigned short rectyp; // S_REGREL32 CV_uoff32_t off; // offset of symbol unsigned short reg; // register index for symbol CV_typ_t typind; // Type index unsigned char name[1]; // Length-prefixed name } REGREL32, FAR * LPREGREL32; typedef struct THREADSYM32 { unsigned short reclen; // record length unsigned short rectyp; // S_LTHREAD32 | S_GTHREAD32 CV_uoff32_t off; // offset into thread storage unsigned short seg; // segment of thread storage CV_typ_t typind; // type index unsigned char name[1]; // length prefixed name } THREADSYM32; typedef struct SLINK32 { unsigned short reclen; // record length unsigned short rectyp; // S_SLINK32 unsigned long framesize; // frame size of parent procedure CV_off32_t off; // signed offset where the static li= nk was saved relative to the value of reg unsigned short reg; } SLINK32, FAR * LPSLINK32; typedef struct PROCSYMMIPS { unsigned short reclen; // Record length unsigned short rectyp; // S_GPROCMIPS or S_LPROCMIPS unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol unsigned long len; // Proc length unsigned long DbgStart; // Debug start offset unsigned long DbgEnd; // Debug end offset unsigned long regSave; // int register save mask unsigned long fpSave; // fp register save mask CV_uoff32_t intOff; // int register save offset CV_uoff32_t fpOff; // fp register save offset CV_uoff32_t off; // Symbol offset unsigned short seg; // Symbol segment CV_typ_t typind; // Type index unsigned char retReg; // Register return value is in unsigned char frameReg; // Frame pointer register unsigned char name[1]; // Length-prefixed name } PROCSYMMIPS, FAR *PROCPTRMIPS; typedef struct REFSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_PROCREF or S_DATAREF unsigned long sumName; // SUC of the name unsigned long ibSym; // Offset of actual symbol in $$Symb= ols unsigned short imod; // Module containing the actual symbol unsigned short usFill; // align this record } REFSYM; typedef struct ALIGNSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_PROCREF or S_DATAREF } ALIGNSYM; // generic block definition symbols // these are similar to the equivalent 16:16 or 16:32 symbols but // only define the length, type and linkage fields typedef struct PROCSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_GPROC16 or S_LPROC16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol } PROCSYM; typedef struct THUNKSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_THUNK unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end unsigned long pNext; // pointer to next symbol } THUNKSYM; typedef struct BLOCKSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_BLOCK16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end } BLOCKSYM; typedef struct WITHSYM { unsigned short reclen; // Record length unsigned short rectyp; // S_WITH16 unsigned long pParent; // pointer to the parent unsigned long pEnd; // pointer to this blocks end } WITHSYM; typedef enum CV_HREG_e { // Register set for the Intel 80x86 and ix86 processor series // (plus PCODE registers) CV_REG_NONE =3D 0, CV_REG_AL =3D 1, CV_REG_CL =3D 2, CV_REG_DL =3D 3, CV_REG_BL =3D 4, CV_REG_AH =3D 5, CV_REG_CH =3D 6, CV_REG_DH =3D 7, CV_REG_BH =3D 8, CV_REG_AX =3D 9, CV_REG_CX =3D 10, CV_REG_DX =3D 11, CV_REG_BX =3D 12, CV_REG_SP =3D 13, CV_REG_BP =3D 14, CV_REG_SI =3D 15, CV_REG_DI =3D 16, CV_REG_EAX =3D 17, CV_REG_ECX =3D 18, CV_REG_EDX =3D 19, CV_REG_EBX =3D 20, CV_REG_ESP =3D 21, CV_REG_EBP =3D 22, CV_REG_ESI =3D 23, CV_REG_EDI =3D 24, CV_REG_ES =3D 25, CV_REG_CS =3D 26, CV_REG_SS =3D 27, CV_REG_DS =3D 28, CV_REG_FS =3D 29, CV_REG_GS =3D 30, CV_REG_IP =3D 31, CV_REG_FLAGS =3D 32, CV_REG_EIP =3D 33, CV_REG_EFLAGS =3D 34, CV_REG_TEMP =3D 40, // PCODE Temp CV_REG_TEMPH =3D 41, // PCODE TempH CV_REG_QUOTE =3D 42, // PCODE Quote CV_REG_PCDR3 =3D 43, // PCODE reserved CV_REG_PCDR4 =3D 44, // PCODE reserved CV_REG_PCDR5 =3D 45, // PCODE reserved CV_REG_PCDR6 =3D 46, // PCODE reserved CV_REG_PCDR7 =3D 47, // PCODE reserved CV_REG_CR0 =3D 80, // CR0 -- control registers CV_REG_CR1 =3D 81, CV_REG_CR2 =3D 82, CV_REG_CR3 =3D 83, CV_REG_CR4 =3D 84, // Pentium CV_REG_DR0 =3D 90, // Debug register CV_REG_DR1 =3D 91, CV_REG_DR2 =3D 92, CV_REG_DR3 =3D 93, CV_REG_DR4 =3D 94, CV_REG_DR5 =3D 95, CV_REG_DR6 =3D 96, CV_REG_DR7 =3D 97, CV_REG_GDTR =3D 110, CV_REG_GDTL =3D 111, CV_REG_IDTR =3D 112, CV_REG_IDTL =3D 113, CV_REG_LDTR =3D 114, CV_REG_TR =3D 115, CV_REG_PSEUDO1 =3D 116, CV_REG_PSEUDO2 =3D 117, CV_REG_PSEUDO3 =3D 118, CV_REG_PSEUDO4 =3D 119, CV_REG_PSEUDO5 =3D 120, CV_REG_PSEUDO6 =3D 121, CV_REG_PSEUDO7 =3D 122, CV_REG_PSEUDO8 =3D 123, CV_REG_PSEUDO9 =3D 124, CV_REG_ST0 =3D 128, CV_REG_ST1 =3D 129, CV_REG_ST2 =3D 130, CV_REG_ST3 =3D 131, CV_REG_ST4 =3D 132, CV_REG_ST5 =3D 133, CV_REG_ST6 =3D 134, CV_REG_ST7 =3D 135, CV_REG_CTRL =3D 136, CV_REG_STAT =3D 137, CV_REG_TAG =3D 138, CV_REG_FPIP =3D 139, CV_REG_FPCS =3D 140, CV_REG_FPDO =3D 141, CV_REG_FPDS =3D 142, CV_REG_ISEM =3D 143, CV_REG_FPEIP =3D 144, CV_REG_FPEDO =3D 145, // registers for the 68K processors CV_R68_D0 =3D 0, CV_R68_D1 =3D 1, CV_R68_D2 =3D 2, CV_R68_D3 =3D 3, CV_R68_D4 =3D 4, CV_R68_D5 =3D 5, CV_R68_D6 =3D 6, CV_R68_D7 =3D 7, CV_R68_A0 =3D 8, CV_R68_A1 =3D 9, CV_R68_A2 =3D 10, CV_R68_A3 =3D 11, CV_R68_A4 =3D 12, CV_R68_A5 =3D 13, CV_R68_A6 =3D 14, CV_R68_A7 =3D 15, CV_R68_CCR =3D 16, CV_R68_SR =3D 17, CV_R68_USP =3D 18, CV_R68_MSP =3D 19, CV_R68_SFC =3D 20, CV_R68_DFC =3D 21, CV_R68_CACR =3D 22, CV_R68_VBR =3D 23, CV_R68_CAAR =3D 24, CV_R68_ISP =3D 25, CV_R68_PC =3D 26, //reserved 27 CV_R68_FPCR =3D 28, CV_R68_FPSR =3D 29, CV_R68_FPIAR =3D 30, //reserved 31 CV_R68_FP0 =3D 32, CV_R68_FP1 =3D 33, CV_R68_FP2 =3D 34, CV_R68_FP3 =3D 35, CV_R68_FP4 =3D 36, CV_R68_FP5 =3D 37, CV_R68_FP6 =3D 38, CV_R68_FP7 =3D 39, //reserved 40-50 CV_R68_PSR =3D 51, CV_R68_PCSR =3D 52, CV_R68_VAL =3D 53, CV_R68_CRP =3D 54, CV_R68_SRP =3D 55, CV_R68_DRP =3D 56, CV_R68_TC =3D 57, CV_R68_AC =3D 58, CV_R68_SCC =3D 59, CV_R68_CAL =3D 60, CV_R68_TT0 =3D 61, CV_R68_TT1 =3D 62, //reserved 63 CV_R68_BAD0 =3D 64, CV_R68_BAD1 =3D 65, CV_R68_BAD2 =3D 66, CV_R68_BAD3 =3D 67, CV_R68_BAD4 =3D 68, CV_R68_BAD5 =3D 69, CV_R68_BAD6 =3D 70, CV_R68_BAD7 =3D 71, CV_R68_BAC0 =3D 72, CV_R68_BAC1 =3D 73, CV_R68_BAC2 =3D 74, CV_R68_BAC3 =3D 75, CV_R68_BAC4 =3D 76, CV_R68_BAC5 =3D 77, CV_R68_BAC6 =3D 78, CV_R68_BAC7 =3D 79, // Register set for the MIPS 4000 CV_M4_NOREG =3D CV_REG_NONE, CV_M4_IntZERO =3D 10, /* CPU REGISTER */ CV_M4_IntAT =3D 11, CV_M4_IntV0 =3D 12, CV_M4_IntV1 =3D 13, CV_M4_IntA0 =3D 14, CV_M4_IntA1 =3D 15, CV_M4_IntA2 =3D 16, CV_M4_IntA3 =3D 17, CV_M4_IntT0 =3D 18, CV_M4_IntT1 =3D 19, CV_M4_IntT2 =3D 20, CV_M4_IntT3 =3D 21, CV_M4_IntT4 =3D 22, CV_M4_IntT5 =3D 23, CV_M4_IntT6 =3D 24, CV_M4_IntT7 =3D 25, CV_M4_IntS0 =3D 26, CV_M4_IntS1 =3D 27, CV_M4_IntS2 =3D 28, CV_M4_IntS3 =3D 29, CV_M4_IntS4 =3D 30, CV_M4_IntS5 =3D 31, CV_M4_IntS6 =3D 32, CV_M4_IntS7 =3D 33, CV_M4_IntT8 =3D 34, CV_M4_IntT9 =3D 35, CV_M4_IntKT0 =3D 36, CV_M4_IntKT1 =3D 37, CV_M4_IntGP =3D 38, CV_M4_IntSP =3D 39, CV_M4_IntS8 =3D 40, CV_M4_IntRA =3D 41, CV_M4_IntLO =3D 42, CV_M4_IntHI =3D 43, CV_M4_Fir =3D 50, CV_M4_Psr =3D 51, CV_M4_FltF0 =3D 60, /* Floating point registers */ CV_M4_FltF1 =3D 61, CV_M4_FltF2 =3D 62, CV_M4_FltF3 =3D 63, CV_M4_FltF4 =3D 64, CV_M4_FltF5 =3D 65, CV_M4_FltF6 =3D 66, CV_M4_FltF7 =3D 67, CV_M4_FltF8 =3D 68, CV_M4_FltF9 =3D 69, CV_M4_FltF10 =3D 70, CV_M4_FltF11 =3D 71, CV_M4_FltF12 =3D 72, CV_M4_FltF13 =3D 73, CV_M4_FltF14 =3D 74, CV_M4_FltF15 =3D 75, CV_M4_FltF16 =3D 76, CV_M4_FltF17 =3D 77, CV_M4_FltF18 =3D 78, CV_M4_FltF19 =3D 79, CV_M4_FltF20 =3D 80, CV_M4_FltF21 =3D 81, CV_M4_FltF22 =3D 82, CV_M4_FltF23 =3D 83, CV_M4_FltF24 =3D 84, CV_M4_FltF25 =3D 85, CV_M4_FltF26 =3D 86, CV_M4_FltF27 =3D 87, CV_M4_FltF28 =3D 88, CV_M4_FltF29 =3D 89, CV_M4_FltF30 =3D 90, CV_M4_FltF31 =3D 91, CV_M4_FltFsr =3D 92, // Register set for the ALPHA AXP CV_ALPHA_NOREG =3D CV_REG_NONE, CV_ALPHA_FltF0 =3D 10, /* Floating point registers */ CV_ALPHA_FltF1 =3D 11, CV_ALPHA_FltF2 =3D 12, CV_ALPHA_FltF3 =3D 13, CV_ALPHA_FltF4 =3D 14, CV_ALPHA_FltF5 =3D 15, CV_ALPHA_FltF6 =3D 16, CV_ALPHA_FltF7 =3D 17, CV_ALPHA_FltF8 =3D 18, CV_ALPHA_FltF9 =3D 19, CV_ALPHA_FltF10 =3D 20, CV_ALPHA_FltF11 =3D 21, CV_ALPHA_FltF12 =3D 22, CV_ALPHA_FltF13 =3D 23, CV_ALPHA_FltF14 =3D 24, CV_ALPHA_FltF15 =3D 25, CV_ALPHA_FltF16 =3D 26, CV_ALPHA_FltF17 =3D 27, CV_ALPHA_FltF18 =3D 28, CV_ALPHA_FltF19 =3D 29, CV_ALPHA_FltF20 =3D 30, CV_ALPHA_FltF21 =3D 31, CV_ALPHA_FltF22 =3D 32, CV_ALPHA_FltF23 =3D 33, CV_ALPHA_FltF24 =3D 34, CV_ALPHA_FltF25 =3D 35, CV_ALPHA_FltF26 =3D 36, CV_ALPHA_FltF27 =3D 37, CV_ALPHA_FltF28 =3D 38, CV_ALPHA_FltF29 =3D 39, CV_ALPHA_FltF30 =3D 40, CV_ALPHA_FltF31 =3D 41, CV_ALPHA_IntV0 =3D 42, // Integer registers CV_ALPHA_IntT0 =3D 43, CV_ALPHA_IntT1 =3D 44, CV_ALPHA_IntT2 =3D 45, CV_ALPHA_IntT3 =3D 46, CV_ALPHA_IntT4 =3D 47, CV_ALPHA_IntT5 =3D 48, CV_ALPHA_IntT6 =3D 49, CV_ALPHA_IntT7 =3D 50, CV_ALPHA_IntS0 =3D 51, CV_ALPHA_IntS1 =3D 52, CV_ALPHA_IntS2 =3D 53, CV_ALPHA_IntS3 =3D 54, CV_ALPHA_IntS4 =3D 55, CV_ALPHA_IntS5 =3D 56, CV_ALPHA_IntFP =3D 57, CV_ALPHA_IntA0 =3D 58, CV_ALPHA_IntA1 =3D 59, CV_ALPHA_IntA2 =3D 60, CV_ALPHA_IntA3 =3D 61, CV_ALPHA_IntA4 =3D 62, CV_ALPHA_IntA5 =3D 63, CV_ALPHA_IntT8 =3D 64, CV_ALPHA_IntT9 =3D 65, CV_ALPHA_IntT10 =3D 66, CV_ALPHA_IntT11 =3D 67, CV_ALPHA_IntRA =3D 68, CV_ALPHA_IntT12 =3D 69, CV_ALPHA_IntAT =3D 70, CV_ALPHA_IntGP =3D 71, CV_ALPHA_IntSP =3D 72, CV_ALPHA_IntZERO =3D 73, CV_ALPHA_Fpcr =3D 74, // Control registers CV_ALPHA_Fir =3D 75, CV_ALPHA_Psr =3D 76, CV_ALPHA_FltFsr =3D 77, CV_ALPHA_SoftFpcr =3D 78, // Control registers // Register Set for Motorola/IBM PowerPC /* ** PowerPC General Registers ( User Level ) */ CV_PPC_GPR0 =3D 1, CV_PPC_GPR1 =3D 2, CV_PPC_GPR2 =3D 3, CV_PPC_GPR3 =3D 4, CV_PPC_GPR4 =3D 5, CV_PPC_GPR5 =3D 6, CV_PPC_GPR6 =3D 7, CV_PPC_GPR7 =3D 8, CV_PPC_GPR8 =3D 9, CV_PPC_GPR9 =3D 10, CV_PPC_GPR10 =3D 11, CV_PPC_GPR11 =3D 12, CV_PPC_GPR12 =3D 13, CV_PPC_GPR13 =3D 14, CV_PPC_GPR14 =3D 15, CV_PPC_GPR15 =3D 16, CV_PPC_GPR16 =3D 17, CV_PPC_GPR17 =3D 18, CV_PPC_GPR18 =3D 19, CV_PPC_GPR19 =3D 20, CV_PPC_GPR20 =3D 21, CV_PPC_GPR21 =3D 22, CV_PPC_GPR22 =3D 23, CV_PPC_GPR23 =3D 24, CV_PPC_GPR24 =3D 25, CV_PPC_GPR25 =3D 26, CV_PPC_GPR26 =3D 27, CV_PPC_GPR27 =3D 28, CV_PPC_GPR28 =3D 29, CV_PPC_GPR29 =3D 30, CV_PPC_GPR30 =3D 31, CV_PPC_GPR31 =3D 32, /* ** PowerPC Condition Register ( User Level ) */ CV_PPC_CR =3D 33, CV_PPC_CR0 =3D 34, CV_PPC_CR1 =3D 35, CV_PPC_CR2 =3D 36, CV_PPC_CR3 =3D 37, CV_PPC_CR4 =3D 38, CV_PPC_CR5 =3D 39, CV_PPC_CR6 =3D 40, CV_PPC_CR7 =3D 41, /* ** PowerPC Floating Point Registers ( User Level ) */ CV_PPC_FPR0 =3D 42, CV_PPC_FPR1 =3D 43, CV_PPC_FPR2 =3D 44, CV_PPC_FPR3 =3D 45, CV_PPC_FPR4 =3D 46, CV_PPC_FPR5 =3D 47, CV_PPC_FPR6 =3D 48, CV_PPC_FPR7 =3D 49, CV_PPC_FPR8 =3D 50, CV_PPC_FPR9 =3D 51, CV_PPC_FPR10 =3D 52, CV_PPC_FPR11 =3D 53, CV_PPC_FPR12 =3D 54, CV_PPC_FPR13 =3D 55, CV_PPC_FPR14 =3D 56, CV_PPC_FPR15 =3D 57, CV_PPC_FPR16 =3D 58, CV_PPC_FPR17 =3D 59, CV_PPC_FPR18 =3D 60, CV_PPC_FPR19 =3D 61, CV_PPC_FPR20 =3D 62, CV_PPC_FPR21 =3D 63, CV_PPC_FPR22 =3D 64, CV_PPC_FPR23 =3D 65, CV_PPC_FPR24 =3D 66, CV_PPC_FPR25 =3D 67, CV_PPC_FPR26 =3D 68, CV_PPC_FPR27 =3D 69, CV_PPC_FPR28 =3D 70, CV_PPC_FPR29 =3D 71, CV_PPC_FPR30 =3D 72, CV_PPC_FPR31 =3D 73, /* ** PowerPC Floating Point Status and Control Register ( User Level )= */ CV_PPC_FPSCR =3D 74, /* ** PowerPC Machine State Register ( Supervisor Level ) */ CV_PPC_MSR =3D 75, /* ** PowerPC Segment Registers ( Supervisor Level ) */ CV_PPC_SR0 =3D 76, CV_PPC_SR1 =3D 77, CV_PPC_SR2 =3D 78, CV_PPC_SR3 =3D 79, CV_PPC_SR4 =3D 80, CV_PPC_SR5 =3D 81, CV_PPC_SR6 =3D 82, CV_PPC_SR7 =3D 83, CV_PPC_SR8 =3D 84, CV_PPC_SR9 =3D 85, CV_PPC_SR10 =3D 86, CV_PPC_SR11 =3D 87, CV_PPC_SR12 =3D 88, CV_PPC_SR13 =3D 89, CV_PPC_SR14 =3D 90, CV_PPC_SR15 =3D 91, /* ** For all of the special purpose registers add 100 to the SPR# that= the ** Motorola/IBM documentation gives with the exception of any imagin= ary ** registers. */ /* ** PowerPC Special Purpose Registers ( User Level ) */ CV_PPC_PC =3D 99, // PC (imaginary register) CV_PPC_MQ =3D 100, // MPC601 CV_PPC_XER =3D 101, CV_PPC_RTCU =3D 104, // MPC601 CV_PPC_RTCL =3D 105, // MPC601 CV_PPC_LR =3D 108, CV_PPC_CTR =3D 109, /* ** PowerPC Special Purpose Registers ( Supervisor Level ) */ CV_PPC_DSISR =3D 118, CV_PPC_DAR =3D 119, CV_PPC_DEC =3D 122, CV_PPC_SDR1 =3D 125, CV_PPC_SRR0 =3D 126, CV_PPC_SRR1 =3D 127, CV_PPC_SPRG0 =3D 372, CV_PPC_SPRG1 =3D 373, CV_PPC_SPRG2 =3D 374, CV_PPC_SPRG3 =3D 375, CV_PPC_ASR =3D 280, // 64-bit implementations only CV_PPC_EAR =3D 382, CV_PPC_PVR =3D 287, CV_PPC_BAT0U =3D 628, CV_PPC_BAT0L =3D 629, CV_PPC_BAT1U =3D 630, CV_PPC_BAT1L =3D 631, CV_PPC_BAT2U =3D 632, CV_PPC_BAT2L =3D 633, CV_PPC_BAT3U =3D 634, CV_PPC_BAT3L =3D 635, CV_PPC_DBAT0U =3D 636, CV_PPC_DBAT0L =3D 637, CV_PPC_DBAT1U =3D 638, CV_PPC_DBAT1L =3D 639, CV_PPC_DBAT2U =3D 640, CV_PPC_DBAT2L =3D 641, CV_PPC_DBAT3U =3D 642, CV_PPC_DBAT3L =3D 643, /* ** PowerPC Special Purpose Registers Implementation Dependent ( Supe= rvisor Level ) */ /* ** Doesn't appear that IBM/Motorola has finished defining these. */ CV_PPC_PMR0 =3D 1044, // MPC620, CV_PPC_PMR1 =3D 1045, // MPC620, CV_PPC_PMR2 =3D 1046, // MPC620, CV_PPC_PMR3 =3D 1047, // MPC620, CV_PPC_PMR4 =3D 1048, // MPC620, CV_PPC_PMR5 =3D 1049, // MPC620, CV_PPC_PMR6 =3D 1050, // MPC620, CV_PPC_PMR7 =3D 1051, // MPC620, CV_PPC_PMR8 =3D 1052, // MPC620, CV_PPC_PMR9 =3D 1053, // MPC620, CV_PPC_PMR10 =3D 1054, // MPC620, CV_PPC_PMR11 =3D 1055, // MPC620, CV_PPC_PMR12 =3D 1056, // MPC620, CV_PPC_PMR13 =3D 1057, // MPC620, CV_PPC_PMR14 =3D 1058, // MPC620, CV_PPC_PMR15 =3D 1059, // MPC620, CV_PPC_DMISS =3D 1076, // MPC603 CV_PPC_DCMP =3D 1077, // MPC603 CV_PPC_HASH1 =3D 1078, // MPC603 CV_PPC_HASH2 =3D 1079, // MPC603 CV_PPC_IMISS =3D 1080, // MPC603 CV_PPC_ICMP =3D 1081, // MPC603 CV_PPC_RPA =3D 1082, // MPC603 CV_PPC_HID0 =3D 1108, // MPC601, MPC603, MPC620 CV_PPC_HID1 =3D 1109, // MPC601 CV_PPC_HID2 =3D 1110, // MPC601, MPC603, MPC620 ( IABR ) CV_PPC_HID3 =3D 1111, // Not Defined CV_PPC_HID4 =3D 1112, // Not Defined CV_PPC_HID5 =3D 1113, // MPC601, MPC604, MPC620 ( DABR ) CV_PPC_HID6 =3D 1114, // Not Defined CV_PPC_HID7 =3D 1115, // Not Defined CV_PPC_HID8 =3D 1116, // MPC620 ( BUSCSR ) CV_PPC_HID9 =3D 1117, // MPC620 ( L2CSR ) CV_PPC_HID10 =3D 1118, // Not Defined CV_PPC_HID11 =3D 1119, // Not Defined CV_PPC_HID12 =3D 1120, // Not Defined CV_PPC_HID13 =3D 1121, // MPC604 ( HCR ) CV_PPC_HID14 =3D 1122, // Not Defined CV_PPC_HID15 =3D 1123 // MPC601, MPC604, MPC620 ( PIR ) } CV_HREG_e; #include <poppack.h> #ifdef __cplusplus #pragma warning ( default: 4200 ) #endif #endif /* CV_INFO_INCLUDED */ ------------IFNiAUHG0hCmwxvZUztJvb Content-Disposition: attachment; filename=Debugger_Exported.zip Content-Type: application/zip; name=Debugger_Exported.zip Content-Transfer-Encoding: Base64 UEsDBBQAAAAIAHsIgTAXrZlL3AIAAF4HAAAcAAAARGVidWdnZXJfRXhwb3J0ZWQv RGVidWdnZXIuZKVV227aQBB9dqT8wygPkR0hp2rfQHkgxkktpQaBaVI1lWXsxaxq vGi9DjQp/97ZizFIKI0SgdbruZw5s7MzpssV4wIqkbmpiytlvdMT2gorwWmZt7I1 Lb98dnGdJRU5Is7YumrFORFlsiRSIn9JQZNqD9YVbKI2z5DGKOq9YgIA2YFNukg4 /PwFO4YYtRSEz5OUwIDM6jwn/PTkRSqsGRVQsCSztTWsErEAp2c0vC5tRyFs5ZIW SVXBvUypwYHuIeSKM0FSQbIuQuxhKpBVPSto2j0aONaRUYMolnV5AUuaLwRkDJhY YKBK1PM54I50oGRYhJoT+EMEXFwqQEsBXGkgmYDFiah5CYLXsiDWdhcX0wJ7F2rg X09vY/+7H0aQzXLlOon642g6CsKbYR8jJ1zUK6UwezedXTXbij4TNu9pEqPx0PMn k1h6jr/1o2AYAqvFqhbGAEsBnFR1IZCrx0kiyIizlFRVH+yyLoqOLrkt03AwVSXS 6zwpKsweNGMTCv6a92F49yOOvgaTRnPofG744k4Tcszlk6zWC1oQsNVZqSLoo7Hu EypuGFcl9p9IKexzPKIOYHpBGES+Y7KyMmkBLwDLKr9mGxsveEykQyzvuY1ObrZu YTyWEQfAgR5sDUK1piJdIIdjtpqTIWWl2GLgP3j+SJ5vvFdAq6stjKFlHkfZbVKy EpSVLUO/EbW7MUkZz9p3TVzxBgM+wyL+7umXJhlN0Rv7/cjHmuBz8BrN/0I01+pd GP5DEH2IhAL4EIW7oYx9d/c+72n4Mf/hNBpNI+M7icZB+FaIPZBxMNJObwjb+nqs FLSsyV4H6e7DK276Psg6sJNFC4TLpGhwfRt7wzAKwqlqsx364Vg7NYPNhHxiNINl QvWAe1H6w4Gd4dwpyfpwjEv8zFXz+MzrPj7OGXPJhpw5WtF8B7ZtCN1Izbdmgy0h DwT/3zClJCeo7et5tgHoqM0n2GH8A1BLAwQUAAAACACISoEwyBexKXcAAAC/AAAA JAAAAERlYnVnZ2VyX0V4cG9ydGVkL0RlYnVnZ2VyLmRpZGV4cG9ydNNLyUxJLSjK UihLLSrOzM9TsDLi5XJJTSpNT08t4uUKKMrPSk0uUXDLzEktRuNawZTppXCiSqTl 5+uVVJSgiaanluQl5qYW66XwchlwgqAhEBqAMRTycnm7Bvm5+hgb6fl4OnGGBrsG QZnlmXlAVk5mEi8XMgQAUEsDBBQAAAAIAHsIgTA9LgM/ZAAAAHoAAAAZAAAARGVi dWdnZXJfRXhwb3J0ZWQvZm9vLnR4dB2MQQqAIBBF1w14h6GVbeoA7ruHpAshG3Es CvHuOcJffB6PF2KiXJCLW1OmwzMbBQqO0zLjToRVwfRQcOho1wvWpqChKANGGy4U 3K2+beOPi496TvZmPy89NknllfOuo2GG235QSwMEFAAAAAgAewiBMGO3zJUHAgAA HQkAABwAAABEZWJ1Z2dlcl9FeHBvcnRlZC9nZXRuYW1lcy5kjZXPb5swFMfPiZT/ AfW0XXbYbuvJgdfUimNbtmFJq8nKMrQiLaRKyFpp2v8+QzYKzXukF5De+/iDf3wt trvvx5959COvyvU2P1xPxpNxsX3c7avoqSg/ffwQnt/Wh7xpbB7W++j+a037/Fde Vr4eFL2LjkVZRc/R+8n4d82NDk9FtXkIjaY2CsXRaBMsESxj0I4r6ROYpjMPGUg3 +hzt8+q4L6MrvH913QpiA8yBd7fhnRASmjkXaaNisHbYhEEdFSy5G54RRbyWDM+G RDoaoepPCEEo0HZneCovCAigo1Cp06n717XOcHluoZmOyHB9Kr6Ma0sN9qfJ2v9e XWoqr3L6vMkfq2JXvj2rSFpZ3Gx6xpVgdQGN7BnUO96WMoat/FSlMrG+LkMCCe5D SVQ6DdGaa8WJy9Rpo8MT5phbafALbpngM7kgryVKotIbUZ+wVGbBhFcaDJP4OlGQ VvKMJ+CnK38HRtHCPkbquIQli503YFOBrxnBBnRZ2JbktAwyKThJSlUG5kaoL6Sr BUiFdSye+/gW4jlp6TKkKITxwmReCFTChYBZOGguw8VPY3KPMA4XSq/ZDDwYowyu 6hGE5E3JQjBSN3hqPYBQnPKRcKuV5fQ+IRwqlErGSjouUzYV4NsGaiVhVK0Nzy4e 6BmEqmz4F4QPWgcatXT7uKBJ8eDm9xH6X/IXUEsDBBQAAAAIAIhKgTBkxzH71wAA AIYBAAAaAAAARGVidWdnZXJfRXhwb3J0ZWQvTWFrZWZpbGVtUE0LwjAMPTvYfyjo wR7Wg94ED9pVKdYPNgYeBjJZHIO5wazozzepKPMDSkjee3lp0g91qFgBNbSZhdz3 fE9KNmX52eV6I00SqhiRQAtBwUnMbOmwAp9lQQ7Ha8Ecs13vtFHIDYZScooLElP2 MuNOafScLKry2GZtCZd0paKNMuORQKYDJ7GKfsBbWSOGtbMKaXwB7UHtafKrFHCH DzreJpH8UOSMpb7XOzWNsHeLd7B1doYL4tSYVdXkre06TXCbL1eONrjsc33OgubU /cYfPUJ0Ak6+D1BLAwQKAAAAAACISoEwAAAAAAAAAAAAAAAAEgAAAERlYnVnZ2Vy X0V4cG9ydGVkL1BLAQIUABQAAAAIAHsIgTAXrZlL3AIAAF4HAAAcAAAAAAAAAAEA IAC2gQAAAABEZWJ1Z2dlcl9FeHBvcnRlZC9EZWJ1Z2dlci5kUEsBAhQAFAAAAAgA iEqBMMgXsSl3AAAAvwAAACQAAAAAAAAAAQAgALaBFgMAAERlYnVnZ2VyX0V4cG9y dGVkL0RlYnVnZ2VyLmRpZGV4cG9ydFBLAQIUABQAAAAIAHsIgTA9LgM/ZAAAAHoA AAAZAAAAAAAAAAEAIAC2gc8DAABEZWJ1Z2dlcl9FeHBvcnRlZC9mb28udHh0UEsB AhQAFAAAAAgAewiBMGO3zJUHAgAAHQkAABwAAAAAAAAAAQAgALaBagQAAERlYnVn Z2VyX0V4cG9ydGVkL2dldG5hbWVzLmRQSwECFAAUAAAACACISoEwZMcx+9cAAACG AQAAGgAAAAAAAAABACAAtoGrBgAARGVidWdnZXJfRXhwb3J0ZWQvTWFrZWZpbGVQ SwECFAAKAAAAAACISoEwAAAAAAAAAAAAAAAAEgAAAAAAAAAAABAA/0G6BwAARGVi dWdnZXJfRXhwb3J0ZWQvUEsFBgAAAAAGAAYAtQEAAOoHAAAAAA== ------------IFNiAUHG0hCmwxvZUztJvb--
Apr 01 2004
parent reply C <dont respond.com> writes:
Also http://www.magma.ca/~wjr/ has a cool PE Viewer helps visually break=
 =

up the executable.  I think theres a function liek =

'TranslateFunctionAddressToSymbol' that will give us the line & number =

given the address in the executable, trying to find it.

C

On Thu, 01 Apr 2004 15:06:24 -0800, C <dont respond.com> wrote:

 Sure his the dideexport ( use import project ).  Also found some old
 CodeView code thats no longer in the SDK ( attached ) .  Also Im looki=

 over wine I think they have some debugging stuff.  I emailed brad thin=

 hes setting up a project on dsource.

 C

 On Thu, 01 Apr 2004 16:18:16 +0800, J Anderson
 <REMOVEanderson badmama.com.au> wrote:

 C wrote:

 On Wed, 31 Mar 2004 22:02:13 +0800, J Anderson
 <REMOVEanderson badmama.com.au> wrote:

 J Anderson wrote:

 Just doing the preliminary fiddling with in D to try and get some
 sort of D debugger working but I've hit a few snags.

 1) DEBUG_EVENT debugEv; //Causes linking error

I should add that I only included the dmd include path. DEBUG_EVEN=




 appears to be in winbase, so I can't see why it doesn't work.

Hmm odd, it seems to work when linking to win32.lib, but NOT win32a.=



 , the ansi versions not working for some reason ( even though
 DEBUG_EVENT seems to be in both ansi.winbase and win32a.lib ) .  Her=



 the basic shell ( from the original code ) I have so far ( attached.=



 ).  It compiles , not much else.

 C

I'm having trouble getting this to work. Can you please send your ma=


 file or DIDE instructions. Thanks.


-- = D Newsgroup.
Apr 01 2004
parent reply J Anderson <REMOVEanderson badmama.com.au> writes:
If your there can you join me in D ICQ?  I'm still having trouble with 
getting the debugger working.  I've a feeling my win32.lib may be 
outdated (I don't even know where I got it from as its not part of dmd, 
at least anymore).

Anyway good job on the debugger so far, its starting to take shape.

-- 
-Anderson: http://badmama.com.au/~anderson/
Apr 01 2004
parent reply C <dont respond.com> writes:
What is D ICQ ?  u mean irc.dprogramming.com ?

C

On Fri, 02 Apr 2004 05:24:48 +0800, J Anderson =

<REMOVEanderson badmama.com.au> wrote:

 If your there can you join me in D ICQ?  I'm still having trouble with=

 getting the debugger working.  I've a feeling my win32.lib may be =

 outdated (I don't even know where I got it from as its not part of dmd=

 at least anymore).

 Anyway good job on the debugger so far, its starting to take shape.

-- = D Newsgroup.
Apr 01 2004
parent J Anderson <REMOVEanderson badmama.com.au> writes:
C wrote:

 What is D ICQ ?  u mean irc.dprogramming.com ?

 C

Sorry, IRC. -- -Anderson: http://badmama.com.au/~anderson/
Apr 01 2004