/***    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 >= 800) &&  \
     defined(_M_IX86) &&   \
     (_M_IX86 >= 300))
// above ifdef tests for 32-bit compiler and existence of long double support
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_TSHIFT))
#define CV_NEWSUBT(typ, ns)     (((typ) & ~CV_SMASK) | ((ns) << CV_SSHIFT))



//     pointer mode enumeration values

typedef enum CV_prmode_e {
    CV_TM_DIRECT = 0,           // mode is not a pointer
    CV_TM_NPTR   = 1,           // mode is a near pointer
    CV_TM_FPTR   = 2,           // mode is a far pointer
    CV_TM_HPTR   = 3,           // mode is a huge pointer
    CV_TM_NPTR32 = 4,           // mode is a 32 bit near pointer
    CV_TM_FPTR32 = 5,           // mode is a 32 bit far pointer
    CV_TM_NPTR64 = 6            // mode is a 64 bit near pointer
#if CC_BIGINT
    ,
    CV_TM_NPTR128 = 7           // mode is a 128 bit near pointer
#endif
} CV_prmode_e;




//      type enumeration values


typedef enum CV_type_e {
    CV_SPECIAL      = 0x00,     // special type size values
    CV_SIGNED       = 0x01,     // signed integral size values
    CV_UNSIGNED     = 0x02,     // unsigned integral size values
    CV_BOOLEAN      = 0x03,     // Boolean size values
    CV_REAL         = 0x04,     // real number size values
    CV_COMPLEX      = 0x05,     // complex number size values
    CV_SPECIAL2     = 0x06,     // second set of special types
    CV_INT          = 0x07,     // integral (int) values
    CV_CVRESERVED   = 0x0f
} CV_type_e;




//      subtype enumeration values for CV_SPECIAL


typedef enum CV_special_e {
    CV_SP_NOTYPE    = 0x00,
    CV_SP_ABS       = 0x01,
    CV_SP_SEGMENT   = 0x02,
    CV_SP_VOID      = 0x03,
    CV_SP_CURRENCY  = 0x04,
    CV_SP_NBASICSTR = 0x05,
    CV_SP_FBASICSTR = 0x06,
    CV_SP_NOTTRANS  = 0x07
} CV_special_e;




//      subtype enumeration values for CV_SPECIAL2


typedef enum CV_special2_e {
    CV_S2_BIT       = 0x00,
    CV_S2_PASCHAR   = 0x01      // Pascal CHAR
} CV_special2_e;





//      subtype enumeration values for CV_SIGNED, CV_UNSIGNED and CV_BOOLEAN


typedef enum CV_integral_e {
    CV_IN_1BYTE     = 0x00,
    CV_IN_2BYTE     = 0x01,
    CV_IN_4BYTE     = 0x02,
    CV_IN_8BYTE     = 0x03
#if CC_BIGINT
    ,
    CV_IN_16BYTE    = 0x04
#endif
} CV_integral_e;





//      subtype enumeration values for CV_REAL and CV_COMPLEX


typedef enum CV_real_e {
    CV_RC_REAL32    = 0x00,
    CV_RC_REAL64    = 0x01,
    CV_RC_REAL80    = 0x02,
    CV_RC_REAL128   = 0x03,
    CV_RC_REAL48    = 0x04
} CV_real_e;




//      subtype enumeration values for CV_INT (really int)


typedef enum CV_int_e {
    CV_RI_CHAR      = 0x00,
    CV_RI_INT1      = 0x00,
    CV_RI_WCHAR     = 0x01,
    CV_RI_UINT1     = 0x01,
    CV_RI_INT2      = 0x02,
    CV_RI_UINT2     = 0x03,
    CV_RI_INT4      = 0x04,
    CV_RI_UINT4     = 0x05,
    CV_RI_INT8      = 0x06,
    CV_RI_UINT8     = 0x07
#if CC_BIGINT
    ,
    CV_RI_INT16     = 0x08,
    CV_RI_UINT16    = 0x09
#endif
} CV_int_e;




// macros to check the type of a primitive

#define CV_TYP_IS_DIRECT(typ)   (CV_MODE(typ) == CV_TM_DIRECT)
#define CV_TYP_IS_PTR(typ)      (CV_MODE(typ) != CV_TM_DIRECT)
#define CV_TYP_IS_NPTR(typ)     (CV_MODE(typ) == CV_TM_NPTR)
#define CV_TYP_IS_FPTR(typ)     (CV_MODE(typ) == CV_TM_FPTR)
#define CV_TYP_IS_HPTR(typ)     (CV_MODE(typ) == CV_TM_HPTR)
#define CV_TYP_IS_NPTR32(typ)   (CV_MODE(typ) == CV_TM_NPTR32)
#define CV_TYP_IS_FPTR32(typ)   (CV_MODE(typ) == CV_TM_FPTR32)

#if CC_BIGINT
#define CV_TYP_IS_SIGNED(typ)   (((CV_TYPE(typ) == CV_SIGNED)  && CV_TYP_IS_DIRECT(typ)) || \
                                    (typ == T_INT1) || \
                                    (typ == T_INT2) || \
                                    (typ == T_INT4) || \
                                    (typ == T_INT8) || \
                                    (typ == T_INT16) || \
                                    (typ == T_RCHAR))
#define CV_TYP_IS_UNSIGNED(typ) (((CV_TYPE(typ) == CV_UNSIGNED)  && CV_TYP_IS_DIRECT(typ)) || \
                                    (typ == T_UINT1) || \
                                    (typ == T_UINT2) || \
                                    (typ == T_UINT4) || \
                                    (typ == T_UINT8) || \
                                    (typ == T_UINT16))
#else
#define CV_TYP_IS_SIGNED(typ)   (((CV_TYPE(typ) == CV_SIGNED)  && CV_TYP_IS_DIRECT(typ)) || \
                                    (typ == T_INT1) || \
                                    (typ == T_INT2) || \
                                    (typ == T_INT4) || \
                                    (typ == T_RCHAR))

#define CV_TYP_IS_UNSIGNED(typ) (((CV_TYPE(typ) == CV_UNSIGNED)  && CV_TYP_IS_DIRECT(typ)) || \
                                    (typ == T_UINT1) || \
                                    (typ == T_UINT2) || \
                                    (typ == T_UINT4))
#endif
#define CV_TYP_IS_REAL(typ)     ((CV_TYPE(typ) == CV_REAL)  && CV_TYP_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) == CV_COMPLEX)   && CV_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 int
#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 int


//      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 int
#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 int
#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 int
#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 int
#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 int
#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 int
#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 unsigned
#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 unsigned int
#define T_32PFINT16     0x0578  // 16:32 far pointer to 128 bit signed int
#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 pointers
#define T_FCVPTR        0x02f0  // CV Internal type for created far pointers
#define T_HCVPTR        0x03f0  // CV Internal type for created huge pointers
#define T_32NCVPTR      0x04f0  // CV Internal type for created near 32-bit pointers
#define T_32FCVPTR      0x05f0  // CV Internal type for created far 32-bit 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) == 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 referenced
 *      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 these
 *      first two ranges.  The third range of leaf indices are used to build
 *      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 ranges
 *      of type indices are used to represent numeric data in a symbol or
 *      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 the
 *      value is greater than 0x8000, then the data follows the leaf index in
 *      a format specified by the leaf index. The final range of leaf indices
 *      are used to force alignment of subfields within a complex type record..
 */



// 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         = 0x00, // near pointer
    CV_PTR_FAR          = 0x01, // far pointer
    CV_PTR_HUGE         = 0x02, // huge pointer
    CV_PTR_BASE_SEG     = 0x03, // based on segment
    CV_PTR_BASE_VAL     = 0x04, // based on value of base
    CV_PTR_BASE_SEGVAL  = 0x05, // based on segment value of base
    CV_PTR_BASE_ADDR    = 0x06, // based on address of base
    CV_PTR_BASE_SEGADDR = 0x07, // based on segment address of base
    CV_PTR_BASE_TYPE    = 0x08, // based on type
    CV_PTR_BASE_SELF    = 0x09, // based on self
    CV_PTR_NEAR32       = 0x0a, // 16:32 near pointer
    CV_PTR_FAR32        = 0x0b, // 16:32 far pointer
    CV_PTR_UNUSEDPTR    = 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     = 0x00, // "normal" pointer
    CV_PTR_MODE_REF     = 0x01, // reference
    CV_PTR_MODE_PMEM    = 0x02, // pointer to data member
    CV_PTR_MODE_PMFUNC  = 0x03, // pointer to member function
    CV_PTR_MODE_RESERVED= 0x04  // first unused pointer mode
} CV_ptrmode_e;




//      Enumeration for function call type


typedef enum CV_call_e {
    CV_CALL_NEAR_C      = 0x00, // near right to left push, caller pops stack
    CV_CALL_FAR_C       = 0x01, // far right to left push, caller pops stack
    CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack
    CV_CALL_FAR_PASCAL  = 0x03, // far left to right push, callee pops stack
    CV_CALL_NEAR_FAST   = 0x04, // near left to right push with regs, callee pops stack
    CV_CALL_FAR_FAST    = 0x05, // far left to right push with regs, callee pops stack
    CV_CALL_SKIPPED     = 0x06, // skipped (unused) call index
    CV_CALL_NEAR_STD    = 0x07, // near standard call
    CV_CALL_FAR_STD     = 0x08, // far standard call
    CV_CALL_NEAR_SYS    = 0x09, // near sys call
    CV_CALL_FAR_SYS     = 0x0a, // far sys call
    CV_CALL_THISCALL    = 0x0b, // this call (this passed in register)
    CV_CALL_MIPSCALL    = 0x0c, // Mips call
    CV_CALL_GENERIC     = 0x0d, // Generic call sequence
    CV_CALL_ALPHACALL   = 0x0e, // Alpha call
    CV_CALL_PPCCALL     = 0x0f, // PPC call
    CV_CALL_RESERVED    = 0x10  // first unused call enumeration
} CV_call_e;




//      Values for the access protection of class attributes


typedef enum CV_access_e {
    CV_private   = 1,
    CV_protected = 2,
    CV_public    = 3
} CV_access_e;



//      enumeration for method properties

typedef enum CV_methodprop_e {
    CV_MTvanilla    = 0x00,
    CV_MTvirtual    = 0x01,
    CV_MTstatic     = 0x02,
    CV_MTfriend     = 0x03,
    CV_MTintro      = 0x04,
    CV_MTpurevirt   = 0x05,
    CV_MTpureintro  = 0x06
} CV_methodprop_e;




//      enumeration for virtual shape table entries

typedef enum CV_VTS_desc_e {
    CV_VTS_near     = 0x00,
    CV_VTS_far      = 0x01,
    CV_VTS_thin     = 0x02,
    CV_VTS_outer    = 0x03,
    CV_VTS_meta     = 0x04,
    CV_VTS_near32   = 0x05,
    CV_VTS_far32    = 0x06,
    CV_VTS_unused   = 0x07
} CV_VTS_desc_e;




//      enumeration for LF_LABEL address modes

typedef enum CV_LABEL_TYPE_e {
    CV_LABEL_NEAR = 0,          // near return
    CV_LABEL_FAR  = 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 properties

typedef struct CV_prop_t {
    unsigned short  packed      :1;     // true if structure is packed
    unsigned short  ctor        :1;     // true if constructors or destructors present
    unsigned short  ovlops      :1;     // true if overloaded operators present
    unsigned short  isnested    :1;     // true if this is a nested class
    unsigned short  cnested     :1;     // true if this class contains nested types
    unsigned short  opassign    :1;     // true if overloaded assignment (=)
    unsigned short  opcast      :1;     // true if casting methods
    unsigned short  fwdref      :1;     // true if forward reference (incomplete 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_methodprop_t
    unsigned short  pseudo      :1;     // compiler generated fcn and does not exist
    unsigned short  noinherit   :1;     // true if class cannot be inherited
    unsigned short  noconstruct :1;     // true if class cannot be constructed
    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        = 0x00, // 16:16 data no virtual fcn or base
    CV_PDM16_VFCN           = 0x01, // 16:16 data with virtual functions
    CV_PDM16_VBASE          = 0x02, // 16:16 data with virtual bases
    CV_PDM32_NVVFCN         = 0x03, // 16:32 data w/wo virtual functions
    CV_PDM32_VBASE          = 0x04, // 16:32 data with virtual bases

    CV_PMF16_NEARNVSA       = 0x05, // 16:16 near method nonvirtual single address point
    CV_PMF16_NEARNVMA       = 0x06, // 16:16 near method nonvirtual multiple address points
    CV_PMF16_NEARVBASE      = 0x07, // 16:16 near method virtual bases
    CV_PMF16_FARNVSA        = 0x08, // 16:16 far method nonvirtual single address point
    CV_PMF16_FARNVMA        = 0x09, // 16:16 far method nonvirtual multiple address points
    CV_PMF16_FARVBASE       = 0x0a, // 16:16 far method virtual bases

    CV_PMF32_NVSA           = 0x0b, // 16:32 method nonvirtual single address point
    CV_PMF32_NVMA           = 0x0c, // 16:32 method nonvirtual multiple address point
    CV_PMF32_VBASE          = 0x0d  // 16:32 method virtual bases
} CV_PMEMBER;



//      memory representation of pointer to member.  These representations 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 = -1)
};




//      representation of a 16:16 pointer to data for a class with virtual
//      functions


struct CV_PMDR16_VFCN {
    CV_off16_t      mdisp;          // displacement to data ( NULL = 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 vbptr
    CV_off16_t      vdisp;          // displacement within vbase table
                                    // NULL = (,,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 = 0x80000000)
};




//      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 = (,,0xffffffff)
};




//      representation of a 16:16 pointer to near member function for a
//      class with no virtual functions or bases and a single address point


struct CV_PMFR16_NEARNVSA {
    CV_uoff16_t     off;            // near address of function (NULL = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 structure 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 pointer type (ptrtype-t)
            unsigned char   ptrmode     :3; // ordinal specifying pointer 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 underlying type
#if (defined(__cplusplus) || defined(_MSC_VER)) // for C++ and MS compilers 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 format
        } pm;
        unsigned short      bseg;       // base segment if PTR_BASE_SEG
        unsigned char       Sym[1];     // copy of base symbol record (including length)
        struct  {
            CV_typ_t        index;      // type index if CV_PTR_BASE_TYPE
            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 class
    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 if not zero
    CV_typ_t        vshape;         // type index of vshape table for this class
    unsigned char   data[CV_ZEROLEN]; // data describing length of structure 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 class
    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 class
    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 required 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 included 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 followed
                                    // 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 module
    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 classes
} 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 string
} 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 list
//      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 indexing type
} lfList;




//      field list leaf
//      This is the header leaf for a complex list of class and structure
//      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 method 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 intro 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/upper 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 either
                                    // variable upper bound or variable
                                    // lower/upper bound.  The referenced
                                    // 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 base 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 pointer
    CV_fldattr_t    attr;           // attribute
    unsigned char   vbpoff[CV_ZEROLEN];   // virtual base pointer offset from address point
                                    // followed by virtual base offset from 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 class
} lfFriendCls;





//      subfield record for friend function


typedef struct lfFriendFcn {
    unsigned short  leaf;           // LF_FRIENDFCN
    CV_typ_t        index;          // index to type record of friend function
    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 field 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 procedure
    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 followed
                                        // 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    =  0x0001, // Compile flags symbol
    S_REGISTER   =  0x0002, // Register variable
    S_CONSTANT   =  0x0003, // constant symbol
    S_UDT        =  0x0004, // User defined type
    S_SSEARCH    =  0x0005, // Start Search
    S_END        =  0x0006, // Block, procedure, "with" or thunk end
    S_SKIP       =  0x0007, // Reserve symbol space in $$Symbols table
    S_CVRESERVE  =  0x0008, // Reserved symbol for CV internal use
    S_OBJNAME    =  0x0009, // path to object file name
    S_ENDARG     =  0x000a, // end of argument/return list
    S_COBOLUDT   =  0x000b, // special UDT for cobol that does not symbol pack
    S_MANYREG    =  0x000c, // multiple register variable
    S_RETURN     =  0x000d, // return description symbol
    S_ENTRYTHIS  =  0x000e, // description of this pointer on entry

    S_BPREL16    =  0x0100, // BP-relative
    S_LDATA16    =  0x0101, // Module-local symbol
    S_GDATA16    =  0x0102, // Global data symbol
    S_PUB16      =  0x0103, // a public symbol
    S_LPROC16    =  0x0104, // Local procedure start
    S_GPROC16    =  0x0105, // Global procedure start
    S_THUNK16    =  0x0106, // Thunk Start
    S_BLOCK16    =  0x0107, // block start
    S_WITH16     =  0x0108, // with start
    S_LABEL16    =  0x0109, // code label
    S_CEXMODEL16 =  0x010a, // change execution model
    S_VFTABLE16  =  0x010b, // address of virtual function table
    S_REGREL16   =  0x010c, // register relative address

    S_BPREL32    =  0x0200, // BP-relative
    S_LDATA32    =  0x0201, // Module-local symbol
    S_GDATA32    =  0x0202, // Global data symbol
    S_PUB32      =  0x0203, // a public symbol (CV internal reserved)
    S_LPROC32    =  0x0204, // Local procedure start
    S_GPROC32    =  0x0205, // Global procedure start
    S_THUNK32    =  0x0206, // Thunk Start
    S_BLOCK32    =  0x0207, // block start
    S_WITH32     =  0x0208, // with start
    S_LABEL32    =  0x0209, // code label
    S_CEXMODEL32 =  0x020a, // change execution model
    S_VFTABLE32  =  0x020b, // address of virtual function table
    S_REGREL32   =  0x020c, // register relative address
    S_LTHREAD32  =  0x020d, // local thread storage
    S_GTHREAD32  =  0x020e, // global thread storage
    S_SLINK32    =  0x020f, // static link for MIPS EH implementation

    S_LPROCMIPS  =  0x0300, // Local procedure start
    S_GPROCMIPS  =  0x0301, // Global procedure start

    S_PROCREF    =  0x0400, // Reference to a procedure
    S_DATAREF    =  0x0401, // Reference to data
    S_ALIGN      =  0x0402, // Used for page alignment of symbols
    S_LPROCREF   =  0x0403  // Local Reference to a procedure
} SYM_ENUM_e;




//      enum describing the compile flag source language


typedef enum CV_CFL_LANG {
    CV_CFL_C        = 0x00,
    CV_CFL_CXX      = 0x01,
    CV_CFL_FORTRAN  = 0x02,
    CV_CFL_MASM     = 0x03,
    CV_CFL_PASCAL   = 0x04,
    CV_CFL_BASIC    = 0x05,
    CV_CFL_COBOL    = 0x06
} CV_CFL_LANG;


//  enum describing target processor

typedef enum CV_CPU_TYPE_e {
    CV_CFL_8080         = 0x00,
    CV_CFL_8086         = 0x01,
    CV_CFL_80286        = 0x02,
    CV_CFL_80386        = 0x03,
    CV_CFL_80486        = 0x04,
    CV_CFL_PENTIUM      = 0x05,
    CV_CFL_MIPSR4000    = 0x10,
    CV_CFL_M68000       = 0x20,
    CV_CFL_M68010       = 0x21,
    CV_CFL_M68020       = 0x22,
    CV_CFL_M68030       = 0x23,
    CV_CFL_M68040       = 0x24,
    CV_CFL_ALPHA        = 0x30,
    CV_CFL_PPC601       = 0x40,
    CV_CFL_PPC603       = 0x41,
    CV_CFL_PPC604       = 0x42,
    CV_CFL_PPC620       = 0x43
} CV_CPU_TYPE_e;




//  enum describing compile flag ambiant data model


typedef enum CV_CFL_DATA {
    CV_CFL_DNEAR    = 0x00,
    CV_CFL_DFAR     = 0x01,
    CV_CFL_DHUGE    = 0x02
} CV_CFL_DATA;




//  enum describing compile flag ambiant code model


typedef enum CV_CFL_CODE_e {
    CV_CFL_CNEAR    = 0x00,
    CV_CFL_CFAR     = 0x01,
    CV_CFL_CHUGE    = 0x02
} CV_CFL_CODE_e;




//  enum describing compile flag target floating point package

typedef enum CV_CFL_FPKG_e {
    CV_CFL_NDP      = 0x00,
    CV_CFL_EMU      = 0x01,
    CV_CFL_ALT      = 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   = 0x00,       // void return type
    CV_GENERIC_REG    = 0x01,       // return data is in registers
    CV_GENERIC_ICAN   = 0x02,       // indirect caller allocated near
    CV_GENERIC_ICAF   = 0x03,       // indirect caller allocated far
    CV_GENERIC_IRAN   = 0x04,       // indirect returnee allocated near
    CV_GENERIC_IRAF   = 0x05,       // indirect returnee allocated far
    CV_GENERIC_UNUSED = 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 short));
}

//              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 followed 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 enumerate)
    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          = 0x00, // not executable
    CEXM_MDL_jumptable      = 0x01, // Compiler generated jump table
    CEXM_MDL_datapad        = 0x02, // Data padding for alignment
    CEXM_MDL_native         = 0x20, // native (actually not-pcode)
    CEXM_MDL_cobol          = 0x21, // cobol
    CEXM_MDL_codepad        = 0x22, // Code padding for alignment
    CEXM_MDL_code           = 0x23, // code
    CEXM_MDL_pcode          = 0x40, // pcode
    CEXM_MDL_pcode32Mac     = 0x41, // macintosh 32 bit pcode
    CEXM_MDL_pcode32MacNep  = 0x42  // macintosh 32 bit pcode native entry 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 information
        } 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 information
        } 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 link 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 $$Symbols
    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     =   0,
    CV_REG_AL       =   1,
    CV_REG_CL       =   2,
    CV_REG_DL       =   3,
    CV_REG_BL       =   4,
    CV_REG_AH       =   5,
    CV_REG_CH       =   6,
    CV_REG_DH       =   7,
    CV_REG_BH       =   8,
    CV_REG_AX       =   9,
    CV_REG_CX       =  10,
    CV_REG_DX       =  11,
    CV_REG_BX       =  12,
    CV_REG_SP       =  13,
    CV_REG_BP       =  14,
    CV_REG_SI       =  15,
    CV_REG_DI       =  16,
    CV_REG_EAX      =  17,
    CV_REG_ECX      =  18,
    CV_REG_EDX      =  19,
    CV_REG_EBX      =  20,
    CV_REG_ESP      =  21,
    CV_REG_EBP      =  22,
    CV_REG_ESI      =  23,
    CV_REG_EDI      =  24,
    CV_REG_ES       =  25,
    CV_REG_CS       =  26,
    CV_REG_SS       =  27,
    CV_REG_DS       =  28,
    CV_REG_FS       =  29,
    CV_REG_GS       =  30,
    CV_REG_IP       =  31,
    CV_REG_FLAGS    =  32,
    CV_REG_EIP      =  33,
    CV_REG_EFLAGS   =  34,
    CV_REG_TEMP     =  40,          // PCODE Temp
    CV_REG_TEMPH    =  41,          // PCODE TempH
    CV_REG_QUOTE    =  42,          // PCODE Quote
    CV_REG_PCDR3    =  43,          // PCODE reserved
    CV_REG_PCDR4    =  44,          // PCODE reserved
    CV_REG_PCDR5    =  45,          // PCODE reserved
    CV_REG_PCDR6    =  46,          // PCODE reserved
    CV_REG_PCDR7    =  47,          // PCODE reserved
    CV_REG_CR0      =  80,          // CR0 -- control registers
    CV_REG_CR1      =  81,
    CV_REG_CR2      =  82,
    CV_REG_CR3      =  83,
    CV_REG_CR4      =  84,          // Pentium
    CV_REG_DR0      =  90,          // Debug register
    CV_REG_DR1      =  91,
    CV_REG_DR2      =  92,
    CV_REG_DR3      =  93,
    CV_REG_DR4      =  94,
    CV_REG_DR5      =  95,
    CV_REG_DR6      =  96,
    CV_REG_DR7      =  97,
    CV_REG_GDTR     =  110,
    CV_REG_GDTL     =  111,
    CV_REG_IDTR     =  112,
    CV_REG_IDTL     =  113,
    CV_REG_LDTR     =  114,
    CV_REG_TR       =  115,

    CV_REG_PSEUDO1  =  116,
    CV_REG_PSEUDO2  =  117,
    CV_REG_PSEUDO3  =  118,
    CV_REG_PSEUDO4  =  119,
    CV_REG_PSEUDO5  =  120,
    CV_REG_PSEUDO6  =  121,
    CV_REG_PSEUDO7  =  122,
    CV_REG_PSEUDO8  =  123,
    CV_REG_PSEUDO9  =  124,

    CV_REG_ST0      =  128,
    CV_REG_ST1      =  129,
    CV_REG_ST2      =  130,
    CV_REG_ST3      =  131,
    CV_REG_ST4      =  132,
    CV_REG_ST5      =  133,
    CV_REG_ST6      =  134,
    CV_REG_ST7      =  135,
    CV_REG_CTRL     =  136,
    CV_REG_STAT     =  137,
    CV_REG_TAG      =  138,
    CV_REG_FPIP     =  139,
    CV_REG_FPCS     =  140,
    CV_REG_FPDO     =  141,
    CV_REG_FPDS     =  142,
    CV_REG_ISEM     =  143,
    CV_REG_FPEIP    =  144,
    CV_REG_FPEDO    =  145,

    // registers for the 68K processors

    CV_R68_D0       =   0,
    CV_R68_D1       =   1,
    CV_R68_D2       =   2,
    CV_R68_D3       =   3,
    CV_R68_D4       =   4,
    CV_R68_D5       =   5,
    CV_R68_D6       =   6,
    CV_R68_D7       =   7,
    CV_R68_A0       =   8,
    CV_R68_A1       =   9,
    CV_R68_A2       =   10,
    CV_R68_A3       =   11,
    CV_R68_A4       =   12,
    CV_R68_A5       =   13,
    CV_R68_A6       =   14,
    CV_R68_A7       =   15,
    CV_R68_CCR      =   16,
    CV_R68_SR       =   17,
    CV_R68_USP      =   18,
    CV_R68_MSP      =   19,
    CV_R68_SFC      =   20,
    CV_R68_DFC      =   21,
    CV_R68_CACR     =   22,
    CV_R68_VBR      =   23,
    CV_R68_CAAR     =   24,
    CV_R68_ISP      =   25,
    CV_R68_PC       =   26,
    //reserved          27
    CV_R68_FPCR     =   28,
    CV_R68_FPSR     =   29,
    CV_R68_FPIAR    =   30,
    //reserved          31
    CV_R68_FP0      =   32,
    CV_R68_FP1      =   33,
    CV_R68_FP2      =   34,
    CV_R68_FP3      =   35,
    CV_R68_FP4      =   36,
    CV_R68_FP5      =   37,
    CV_R68_FP6      =   38,
    CV_R68_FP7      =   39,
    //reserved      40-50
    CV_R68_PSR      =   51,
    CV_R68_PCSR     =   52,
    CV_R68_VAL      =   53,
    CV_R68_CRP      =   54,
    CV_R68_SRP      =   55,
    CV_R68_DRP      =   56,
    CV_R68_TC       =   57,
    CV_R68_AC       =   58,
    CV_R68_SCC      =   59,
    CV_R68_CAL      =   60,
    CV_R68_TT0      =   61,
    CV_R68_TT1      =   62,
    //reserved      63
    CV_R68_BAD0     =   64,
    CV_R68_BAD1     =   65,
    CV_R68_BAD2     =   66,
    CV_R68_BAD3     =   67,
    CV_R68_BAD4     =   68,
    CV_R68_BAD5     =   69,
    CV_R68_BAD6     =   70,
    CV_R68_BAD7     =   71,
    CV_R68_BAC0     =   72,
    CV_R68_BAC1     =   73,
    CV_R68_BAC2     =   74,
    CV_R68_BAC3     =   75,
    CV_R68_BAC4     =   76,
    CV_R68_BAC5     =   77,
    CV_R68_BAC6     =   78,
    CV_R68_BAC7     =   79,

    // Register set for the MIPS 4000

    CV_M4_NOREG     =   CV_REG_NONE,

    CV_M4_IntZERO   =   10,      /* CPU REGISTER */
    CV_M4_IntAT     =   11,
    CV_M4_IntV0     =   12,
    CV_M4_IntV1     =   13,
    CV_M4_IntA0     =   14,
    CV_M4_IntA1     =   15,
    CV_M4_IntA2     =   16,
    CV_M4_IntA3     =   17,
    CV_M4_IntT0     =   18,
    CV_M4_IntT1     =   19,
    CV_M4_IntT2     =   20,
    CV_M4_IntT3     =   21,
    CV_M4_IntT4     =   22,
    CV_M4_IntT5     =   23,
    CV_M4_IntT6     =   24,
    CV_M4_IntT7     =   25,
    CV_M4_IntS0     =   26,
    CV_M4_IntS1     =   27,
    CV_M4_IntS2     =   28,
    CV_M4_IntS3     =   29,
    CV_M4_IntS4     =   30,
    CV_M4_IntS5     =   31,
    CV_M4_IntS6     =   32,
    CV_M4_IntS7     =   33,
    CV_M4_IntT8     =   34,
    CV_M4_IntT9     =   35,
    CV_M4_IntKT0    =   36,
    CV_M4_IntKT1    =   37,
    CV_M4_IntGP     =   38,
    CV_M4_IntSP     =   39,
    CV_M4_IntS8     =   40,
    CV_M4_IntRA     =   41,
    CV_M4_IntLO     =   42,
    CV_M4_IntHI     =   43,

    CV_M4_Fir       =   50,
    CV_M4_Psr       =   51,

    CV_M4_FltF0     =   60,      /* Floating point registers */
    CV_M4_FltF1     =   61,
    CV_M4_FltF2     =   62,
    CV_M4_FltF3     =   63,
    CV_M4_FltF4     =   64,
    CV_M4_FltF5     =   65,
    CV_M4_FltF6     =   66,
    CV_M4_FltF7     =   67,
    CV_M4_FltF8     =   68,
    CV_M4_FltF9     =   69,
    CV_M4_FltF10    =   70,
    CV_M4_FltF11    =   71,
    CV_M4_FltF12    =   72,
    CV_M4_FltF13    =   73,
    CV_M4_FltF14    =   74,
    CV_M4_FltF15    =   75,
    CV_M4_FltF16    =   76,
    CV_M4_FltF17    =   77,
    CV_M4_FltF18    =   78,
    CV_M4_FltF19    =   79,
    CV_M4_FltF20    =   80,
    CV_M4_FltF21    =   81,
    CV_M4_FltF22    =   82,
    CV_M4_FltF23    =   83,
    CV_M4_FltF24    =   84,
    CV_M4_FltF25    =   85,
    CV_M4_FltF26    =   86,
    CV_M4_FltF27    =   87,
    CV_M4_FltF28    =   88,
    CV_M4_FltF29    =   89,
    CV_M4_FltF30    =   90,
    CV_M4_FltF31    =   91,
    CV_M4_FltFsr    =   92,


    // Register set for the ALPHA AXP

    CV_ALPHA_NOREG  = CV_REG_NONE,

    CV_ALPHA_FltF0  =   10,         /* Floating point registers */
    CV_ALPHA_FltF1  =   11,
    CV_ALPHA_FltF2  =   12,
    CV_ALPHA_FltF3  =   13,
    CV_ALPHA_FltF4  =   14,
    CV_ALPHA_FltF5  =   15,
    CV_ALPHA_FltF6  =   16,
    CV_ALPHA_FltF7  =   17,
    CV_ALPHA_FltF8  =   18,
    CV_ALPHA_FltF9  =   19,
    CV_ALPHA_FltF10 =   20,
    CV_ALPHA_FltF11 =   21,
    CV_ALPHA_FltF12 =   22,
    CV_ALPHA_FltF13 =   23,
    CV_ALPHA_FltF14 =   24,
    CV_ALPHA_FltF15 =   25,
    CV_ALPHA_FltF16 =   26,
    CV_ALPHA_FltF17 =   27,
    CV_ALPHA_FltF18 =   28,
    CV_ALPHA_FltF19 =   29,
    CV_ALPHA_FltF20 =   30,
    CV_ALPHA_FltF21 =   31,
    CV_ALPHA_FltF22 =   32,
    CV_ALPHA_FltF23 =   33,
    CV_ALPHA_FltF24 =   34,
    CV_ALPHA_FltF25 =   35,
    CV_ALPHA_FltF26 =   36,
    CV_ALPHA_FltF27 =   37,
    CV_ALPHA_FltF28 =   38,
    CV_ALPHA_FltF29 =   39,
    CV_ALPHA_FltF30 =   40,
    CV_ALPHA_FltF31 =   41,

    CV_ALPHA_IntV0  =   42,   // Integer registers
    CV_ALPHA_IntT0  =   43,
    CV_ALPHA_IntT1  =   44,
    CV_ALPHA_IntT2  =   45,
    CV_ALPHA_IntT3  =   46,
    CV_ALPHA_IntT4  =   47,
    CV_ALPHA_IntT5  =   48,
    CV_ALPHA_IntT6  =   49,
    CV_ALPHA_IntT7  =   50,
    CV_ALPHA_IntS0  =   51,
    CV_ALPHA_IntS1  =   52,
    CV_ALPHA_IntS2  =   53,
    CV_ALPHA_IntS3  =   54,
    CV_ALPHA_IntS4  =   55,
    CV_ALPHA_IntS5  =   56,
    CV_ALPHA_IntFP  =   57,
    CV_ALPHA_IntA0  =   58,
    CV_ALPHA_IntA1  =   59,
    CV_ALPHA_IntA2  =   60,
    CV_ALPHA_IntA3  =   61,
    CV_ALPHA_IntA4  =   62,
    CV_ALPHA_IntA5  =   63,
    CV_ALPHA_IntT8  =   64,
    CV_ALPHA_IntT9  =   65,
    CV_ALPHA_IntT10 =   66,
    CV_ALPHA_IntT11 =   67,
    CV_ALPHA_IntRA  =   68,
    CV_ALPHA_IntT12 =   69,
    CV_ALPHA_IntAT  =   70,
    CV_ALPHA_IntGP  =   71,
    CV_ALPHA_IntSP  =   72,
    CV_ALPHA_IntZERO =  73,


    CV_ALPHA_Fpcr   =   74,   //  Control registers
    CV_ALPHA_Fir    =   75,
    CV_ALPHA_Psr    =   76,
    CV_ALPHA_FltFsr =   77,
    CV_ALPHA_SoftFpcr = 78,   //  Control registers

    // Register Set for Motorola/IBM PowerPC

    /*
    ** PowerPC General Registers ( User Level )
    */
    CV_PPC_GPR0   = 1,
    CV_PPC_GPR1   = 2,
    CV_PPC_GPR2   = 3,
    CV_PPC_GPR3   = 4,
    CV_PPC_GPR4   = 5,
    CV_PPC_GPR5   = 6,
    CV_PPC_GPR6   = 7,
    CV_PPC_GPR7   = 8,
    CV_PPC_GPR8   = 9,
    CV_PPC_GPR9   = 10,
    CV_PPC_GPR10  = 11,
    CV_PPC_GPR11  = 12,
    CV_PPC_GPR12  = 13,
    CV_PPC_GPR13  = 14,
    CV_PPC_GPR14  = 15,
    CV_PPC_GPR15  = 16,
    CV_PPC_GPR16  = 17,
    CV_PPC_GPR17  = 18,
    CV_PPC_GPR18  = 19,
    CV_PPC_GPR19  = 20,
    CV_PPC_GPR20  = 21,
    CV_PPC_GPR21  = 22,
    CV_PPC_GPR22  = 23,
    CV_PPC_GPR23  = 24,
    CV_PPC_GPR24  = 25,
    CV_PPC_GPR25  = 26,
    CV_PPC_GPR26  = 27,
    CV_PPC_GPR27  = 28,
    CV_PPC_GPR28  = 29,
    CV_PPC_GPR29  = 30,
    CV_PPC_GPR30  = 31,
    CV_PPC_GPR31  = 32,

    /*
    ** PowerPC Condition Register ( User Level )
    */
    CV_PPC_CR     = 33,
    CV_PPC_CR0    = 34,
    CV_PPC_CR1    = 35,
    CV_PPC_CR2    = 36,
    CV_PPC_CR3    = 37,
    CV_PPC_CR4    = 38,
    CV_PPC_CR5    = 39,
    CV_PPC_CR6    = 40,
    CV_PPC_CR7    = 41,

    /*
    ** PowerPC Floating Point Registers ( User Level )
    */
    CV_PPC_FPR0   = 42,
    CV_PPC_FPR1   = 43,
    CV_PPC_FPR2   = 44,
    CV_PPC_FPR3   = 45,
    CV_PPC_FPR4   = 46,
    CV_PPC_FPR5   = 47,
    CV_PPC_FPR6   = 48,
    CV_PPC_FPR7   = 49,
    CV_PPC_FPR8   = 50,
    CV_PPC_FPR9   = 51,
    CV_PPC_FPR10  = 52,
    CV_PPC_FPR11  = 53,
    CV_PPC_FPR12  = 54,
    CV_PPC_FPR13  = 55,
    CV_PPC_FPR14  = 56,
    CV_PPC_FPR15  = 57,
    CV_PPC_FPR16  = 58,
    CV_PPC_FPR17  = 59,
    CV_PPC_FPR18  = 60,
    CV_PPC_FPR19  = 61,
    CV_PPC_FPR20  = 62,
    CV_PPC_FPR21  = 63,
    CV_PPC_FPR22  = 64,
    CV_PPC_FPR23  = 65,
    CV_PPC_FPR24  = 66,
    CV_PPC_FPR25  = 67,
    CV_PPC_FPR26  = 68,
    CV_PPC_FPR27  = 69,
    CV_PPC_FPR28  = 70,
    CV_PPC_FPR29  = 71,
    CV_PPC_FPR30  = 72,
    CV_PPC_FPR31  = 73,

    /*
    ** PowerPC Floating Point Status and Control Register ( User Level )
    */
    CV_PPC_FPSCR  = 74,

    /*
    ** PowerPC Machine State Register ( Supervisor Level )
    */
    CV_PPC_MSR    = 75,

    /*
    ** PowerPC Segment Registers ( Supervisor Level )
    */
    CV_PPC_SR0    = 76,
    CV_PPC_SR1    = 77,
    CV_PPC_SR2    = 78,
    CV_PPC_SR3    = 79,
    CV_PPC_SR4    = 80,
    CV_PPC_SR5    = 81,
    CV_PPC_SR6    = 82,
    CV_PPC_SR7    = 83,
    CV_PPC_SR8    = 84,
    CV_PPC_SR9    = 85,
    CV_PPC_SR10   = 86,
    CV_PPC_SR11   = 87,
    CV_PPC_SR12   = 88,
    CV_PPC_SR13   = 89,
    CV_PPC_SR14   = 90,
    CV_PPC_SR15   = 91,

    /*
    ** For all of the special purpose registers add 100 to the SPR# that the
    ** Motorola/IBM documentation gives with the exception of any imaginary
    ** registers.
    */

    /*
    ** PowerPC Special Purpose Registers ( User Level )
    */
    CV_PPC_PC     = 99,     // PC (imaginary register)

    CV_PPC_MQ     = 100,    // MPC601
    CV_PPC_XER    = 101,
    CV_PPC_RTCU   = 104,    // MPC601
    CV_PPC_RTCL   = 105,    // MPC601
    CV_PPC_LR     = 108,
    CV_PPC_CTR    = 109,

    /*
    ** PowerPC Special Purpose Registers ( Supervisor Level )
    */
    CV_PPC_DSISR  = 118,
    CV_PPC_DAR    = 119,
    CV_PPC_DEC    = 122,
    CV_PPC_SDR1   = 125,
    CV_PPC_SRR0   = 126,
    CV_PPC_SRR1   = 127,
    CV_PPC_SPRG0  = 372,
    CV_PPC_SPRG1  = 373,
    CV_PPC_SPRG2  = 374,
    CV_PPC_SPRG3  = 375,
    CV_PPC_ASR    = 280,    // 64-bit implementations only
    CV_PPC_EAR    = 382,
    CV_PPC_PVR    = 287,
    CV_PPC_BAT0U  = 628,
    CV_PPC_BAT0L  = 629,
    CV_PPC_BAT1U  = 630,
    CV_PPC_BAT1L  = 631,
    CV_PPC_BAT2U  = 632,
    CV_PPC_BAT2L  = 633,
    CV_PPC_BAT3U  = 634,
    CV_PPC_BAT3L  = 635,
    CV_PPC_DBAT0U = 636,
    CV_PPC_DBAT0L = 637,
    CV_PPC_DBAT1U = 638,
    CV_PPC_DBAT1L = 639,
    CV_PPC_DBAT2U = 640,
    CV_PPC_DBAT2L = 641,
    CV_PPC_DBAT3U = 642,
    CV_PPC_DBAT3L = 643,

    /*
    ** PowerPC Special Purpose Registers Implementation Dependent ( Supervisor Level )
    */

    /*
    ** Doesn't appear that IBM/Motorola has finished defining these.
    */

    CV_PPC_PMR0   = 1044,   // MPC620,
    CV_PPC_PMR1   = 1045,   // MPC620,
    CV_PPC_PMR2   = 1046,   // MPC620,
    CV_PPC_PMR3   = 1047,   // MPC620,
    CV_PPC_PMR4   = 1048,   // MPC620,
    CV_PPC_PMR5   = 1049,   // MPC620,
    CV_PPC_PMR6   = 1050,   // MPC620,
    CV_PPC_PMR7   = 1051,   // MPC620,
    CV_PPC_PMR8   = 1052,   // MPC620,
    CV_PPC_PMR9   = 1053,   // MPC620,
    CV_PPC_PMR10  = 1054,   // MPC620,
    CV_PPC_PMR11  = 1055,   // MPC620,
    CV_PPC_PMR12  = 1056,   // MPC620,
    CV_PPC_PMR13  = 1057,   // MPC620,
    CV_PPC_PMR14  = 1058,   // MPC620,
    CV_PPC_PMR15  = 1059,   // MPC620,

    CV_PPC_DMISS  = 1076,   // MPC603
    CV_PPC_DCMP   = 1077,   // MPC603
    CV_PPC_HASH1  = 1078,   // MPC603
    CV_PPC_HASH2  = 1079,   // MPC603
    CV_PPC_IMISS  = 1080,   // MPC603
    CV_PPC_ICMP   = 1081,   // MPC603
    CV_PPC_RPA    = 1082,   // MPC603

    CV_PPC_HID0   = 1108,   // MPC601, MPC603, MPC620
    CV_PPC_HID1   = 1109,   // MPC601
    CV_PPC_HID2   = 1110,   // MPC601, MPC603, MPC620 ( IABR )
    CV_PPC_HID3   = 1111,   // Not Defined
    CV_PPC_HID4   = 1112,   // Not Defined
    CV_PPC_HID5   = 1113,   // MPC601, MPC604, MPC620 ( DABR )
    CV_PPC_HID6   = 1114,   // Not Defined
    CV_PPC_HID7   = 1115,   // Not Defined
    CV_PPC_HID8   = 1116,   // MPC620 ( BUSCSR )
    CV_PPC_HID9   = 1117,   // MPC620 ( L2CSR )
    CV_PPC_HID10  = 1118,   // Not Defined
    CV_PPC_HID11  = 1119,   // Not Defined
    CV_PPC_HID12  = 1120,   // Not Defined
    CV_PPC_HID13  = 1121,   // MPC604 ( HCR )
    CV_PPC_HID14  = 1122,   // Not Defined
    CV_PPC_HID15  = 1123    // MPC601, MPC604, MPC620 ( PIR )


} CV_HREG_e;

#include <poppack.h>

#ifdef  __cplusplus
#pragma warning ( default: 4200 )
#endif

#endif /* CV_INFO_INCLUDED */
