cvinfo.h

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

        CV_typ_t typ; // type of index
        unsigned short rank; // number of dimensions
        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
        CV_typ_t typ; // type of index
        unsigned short rank; // number of dimensions
        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
        unsigned short pad;
        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_fldattr_t attr; // attribute
        CV_typ_t index; // type index of base class
        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_fldattr_t attr; // attribute
        CV_typ_t index; // type index of direct virtual base class
        CV_typ_t vbptr; // type index of virtual base pointer
        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_fldattr_t attr; // attribute mask
        CV_typ_t index; // index of type record for field
        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_fldattr_t attr; // attribute mask
        CV_typ_t index; // index of type record for field
        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
        unsigned short pad;
        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