dbtypes.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 1,151 行 · 第 1/3 页

    n_len = Length( nm );
    _Alloc( field, sizeof( field_member ) + n_len );
    strcpy( field->name, nm );
    field->attr = attr;
    field->len = n_len;
    field->base = base;
    field->b_strt = strt;
    field->b_len  = len;
    return( field );
}

static  void    AddField( struct_list *st, field_any *field )
/***********************************************************/
{
    field->entry.next = NULL;
    *st->list_tail = field;
    st->list_tail = &field->entry.next;
    st->num++;
}


extern  void _CGAPI DBAddBitField( struct_list *st, unsigned_32 off, byte strt,
                               byte len, char *nm, dbg_type base ) {
/******************************************************************/

    field_member *field;

#ifndef NDEBUG
    EchoAPI( "DBAddBitField(%i,%i,%i,%i,%c,%i)\n", st, off, strt, len, nm, base );
#endif
    field = CreateMember( nm, strt, len, base, 0 );
    field->entry.field_type = FIELD_OFFSET;
    field->u.off= off;
    AddField( st, (field_any *) field );
}


extern  void _CGAPI DBAddField( struct_list *st, unsigned_32 off,
                            char *nm, dbg_type  base ) {
/******************************************************/

#ifndef NDEBUG
    EchoAPI( "DBAddField( %i, %i,%c,%i)\n", st, off, nm, base );
#endif
    DBAddBitField( st, off, 0, 0, nm, base );
}


extern  void _CGAPI DBAddLocField( struct_list *st, dbg_loc loc, uint attr,
                            byte strt, byte len, char *nm, dbg_type base ) {
/******************************************************************/

    field_member *field;
    offset      off;

#ifndef NDEBUG
    EchoAPI( "DBAddLocField( %i,%i,%i,%i,%i,%c,%i)\n", st, loc, attr, strt, len, nm, base );
#endif
    field = CreateMember( nm, strt, len, base, attr );
    off = LocSimpField( loc );
    if( off != (offset)-1 && (attr==FIELD_ATTR_NONE || attr==FIELD_ATTR_PUBLIC) ) {
        field->entry.field_type = FIELD_OFFSET;
        field->u.off= off;
    } else {
        field->entry.field_type = FIELD_LOC;
        field->u.loc = LocDupl( loc );
    }
    AddField( st, (field_any *) field );
}

extern  void _CGAPI DBAddStField( struct_list *st, dbg_loc loc, char *nm, uint attr,
                                             dbg_type base ) {
/*************************************************************/

    uint          n_len;
    field_stfield *field;

#ifndef NDEBUG
    EchoAPI( "DBAddStField(%i,%i,%c,%i,%i)\n", st, loc, nm, attr, base );
#endif
    n_len = Length( nm );
    _Alloc( field, sizeof( field_stfield ) + n_len );
    strcpy( field->name, nm );
    field->entry.field_type = FIELD_STFIELD;
    field->loc = LocDupl( loc );
    field->attr = attr;
    field->base = base;
    AddField( st, (field_any *) field );
}

extern  void _CGAPI DBAddMethod( struct_list *st, dbg_loc loc,
                             uint  attr, uint     kind,
                             char *nm,   dbg_type base ) {
/******************************************************************/

    uint          n_len;
    field_method *field;

#ifndef NDEBUG
    EchoAPI( "DBAddMethod( %i,%i,%i,%i,%c,%i)\n", st, loc, attr, kind, nm, base );
#endif
    n_len = Length( nm );
    _Alloc( field, sizeof( field_method ) + n_len );
    strcpy( field->name, nm );
    field->entry.field_type = FIELD_METHOD;
    field->u.loc = LocDupl( loc );
    field->attr = attr;
    field->kind = kind;
    field->len = n_len;
    field->base = base;
    AddField( st, (field_any *) field );
}

extern  void _CGAPI DBAddNestedType( struct_list *st, char *nm,
                                                  dbg_type base ) {
/******************************************************************/

    uint          n_len;
    field_nested *field;

#ifndef NDEBUG
    EchoAPI( "DBAddNestedType( %i,%c,%i)\n", st, nm, base );
#endif
    n_len = Length( nm );
    _Alloc( field, sizeof( field_nested ) + n_len );
    strcpy( field->name, nm );
    field->entry.field_type = FIELD_NESTED;
    field->base = base;
    AddField( st, (field_any *) field );
    st->is_cnested = TRUE;
}


extern  void _CGAPI DBAddInheritance( struct_list *st, dbg_type inherit,
                                  uint attr, uint kind,  dbg_loc loc ) {
/*******************************************************************/
    field_bclass *field;

#ifndef NDEBUG
    EchoAPI( "DBAddInheritance(%i,%i,%i,%i,%i)\n", st, inherit, attr, kind, loc );
#endif
    _Alloc( field, sizeof( field_bclass ) );
    field->entry.field_type = FIELD_INHERIT;
    field->attr = attr;
    field->base = inherit;
    field->attr = attr;
    field->kind = kind;
    field->u.adjustor = LocDupl( loc );
    AddField( st, (field_any *) field );
}

extern  void _CGAPI DBAddBaseInfo( struct_list  *st, offset vb_off,  offset esize,
                                              dbg_type vtbl, cg_type ptr_type ){
/*******************************************************************/
#ifndef NDEBUG
    EchoAPI( "DBAddBaseInfo( %i,%i,%i,%i,%t)\n", st, vb_off, esize, vtbl, ptr_type );
#endif
    st->vtbl_off    = vb_off;
    st->vtbl_type  = vtbl;
    st->ptr_type  =  ptr_type;
    st->vtbl_esize = esize;
}

extern  void _CGAPI DBAddVFuncInfo( struct_list  *st, offset vfptr_off,
                                                  int size,
                                                  cg_type vft_cgtype ){
/*******************************************************************/
    field_vfunc  *field;

#ifndef NDEBUG
    EchoAPI( "DBAddVFuncInfo( %i,%i,%i,%t )\n", st, vfptr_off, size, vft_cgtype );
#endif
    _Alloc( field, sizeof( field_vfunc ) );
    field->entry.field_type = FIELD_VFUNC;
    field->vfptr_off = vfptr_off;
    field->vft_cgtype = vft_cgtype;
    field->vft_size = size;
    st->vf = field;
    AddField( st, (field_any *) field );
}

extern  dbg_type _CGAPI DBEndStruct( struct_list  *st ) {
/*******************************************************/

    dbg_type ret;

#ifndef NDEBUG
    EchoAPI( "DBEndStruct(%i)", st );
#endif

    if( _IsModel( DBG_DF ) ) {
        ret =  DFEndStruct( st );
    }else if( _IsModel( DBG_CV ) ) {
        ret =  CVEndStruct( st );
    }else{
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
        ret = WVEndStruct( st );
#else
        ret = 0;
#endif
    }
    _Free( st, sizeof( struct_list ) );
#ifndef NDEBUG
    EchoAPI( " -> %i\n", ret );
#endif
    return( ret );
}

extern  dbg_type _CGAPI DBStructForward( struct_list  *st ) {
/********************************************************************/
#ifndef NDEBUG
    EchoAPI( "DBStructForward( %i )", st );
    EchoAPI( " -> %i\n", st->me );
#endif
    return( st->me );
}

extern  enum_list * _CGAPI DBBegEnum( cg_type  tipe ) {
/*****************************************************/

    enum_list   *en;

#ifndef NDEBUG
    EchoAPI( "DBBegEnum( %t )", tipe );
#endif
    _Alloc( en, sizeof( enum_list ) );
    en->num = 0;
    en->list = NULL;
    en->tipe = tipe;
    en->is_nested = Nested;
    en->is_c  = TRUE;
#ifndef NDEBUG
    EchoAPI( " -> %i\n", en );
#endif
    return( en );
}

extern  void _CGAPI DBAddConst( enum_list *en, char *nm, signed_32      val ) {
/*********************************************************************/

    const_entry *cons;
    uint        len;

#ifndef NDEBUG
    EchoAPI( "DBAddConst( %i,%c,%i)\n", en, nm, val );
#endif
    len = Length( nm );
    _Alloc( cons, sizeof( const_entry ) + len );
    strcpy( cons->name, nm );
    cons->len = len;
    I32ToI64( val, &cons->val );
    cons->next = en->list;
    en->list = cons;
    en->num++;
}

extern  void _CGAPI DBAddConst64( enum_list *en, char *nm, signed_64  val ) {
/*********************************************************************/

    const_entry *cons;
    uint        len;

#ifndef NDEBUG
    EchoAPI( "DBAddConst( %i,%c,%x %x )\n", en, nm, val.u._32[0],val.u._32[1] );
#endif
    len = Length( nm );
    _Alloc( cons, sizeof( const_entry ) + len );
    strcpy( cons->name, nm );
    cons->len = len;
    cons->val = val;
    cons->next = en->list;
    en->list = cons;
    en->num++;
}

extern  dbg_type _CGAPI DBEndEnum( enum_list *en ) {
/**************************************************/

    dbg_type ret;

#ifndef NDEBUG
    EchoAPI( "DBEndEnum(%i)", en );
#endif
    if( _IsModel( DBG_DF ) ) {
        ret = DFEndEnum( en );
    }else if( _IsModel( DBG_CV ) ) {
        ret = CVEndEnum( en );
    }else{
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
        ret = WVEndEnum( en );
#else
        ret = 0;
#endif
    }
    _Free( en, sizeof( enum_list ) );
#ifndef NDEBUG
    EchoAPI( " -> %i\n", ret );
#endif
    return( ret );
}


extern  proc_list * _CGAPI DBBegProc(  cg_type call_type,  dbg_type  ret ) {
/**************************************************************************/

    proc_list   *pr;

#ifndef NDEBUG
    EchoAPI( "DBBegProc( %t,%i)", call_type, ret );
#endif
    _Alloc( pr, sizeof( proc_list ) );
    pr->num = 0;
    pr->list = NULL;
    pr->call = TypeAddress( call_type )->refno;
    pr->ret = ret;
    pr->cls = DBG_NIL_TYPE;
    pr->this = DBG_NIL_TYPE;
#ifndef NDEBUG
    EchoAPI( " -> %i\n", pr );
#endif
    return(pr);
}

extern  void  _CGAPI DBAddMethParms(  proc_list *pr,  dbg_type  cls, dbg_type this   ) {
/************************************************************************/

#ifndef NDEBUG
    EchoAPI( "DBAddMethParms( %i, %i, %i)\n", pr, cls, this );
#endif
    pr->cls = cls;
    pr->this = this;
}

extern  void _CGAPI DBAddParm( proc_list *pr, dbg_type tipe ) {
/*********************************************************/

    parm_entry  *parm;
    parm_entry  **owner;

#ifndef NDEBUG
    EchoAPI( "DBAddParm( %i,%i )\n", pr, tipe );
#endif
    _Alloc( parm, sizeof( parm_entry ) );
    pr->num++;
    owner = &pr->list;
    while( *owner != NULL ) {
        owner = &(*owner)->next;
    }
    *owner = parm;
    parm->tipe = tipe;
    parm->next = NULL;
}


extern  dbg_type _CGAPI DBEndProc( proc_list  *pr ) {
/***************************************************/

    dbg_type ret;


#ifndef NDEBUG
    EchoAPI( "DBEndProc( %i )", pr );
#endif
    if( _IsModel( DBG_DF ) ) {
        ret =  DFEndProc( pr );
    }else if( _IsModel( DBG_CV ) ) {
        ret =  CVEndProc( pr );
    }else{
#if _TARGET &( _TARG_IAPX86 | _TARG_80386 )
        ret = WVEndProc( pr );
#else
        ret = 0;
#endif
    }
    _Free( pr, sizeof( proc_list ) );
#ifndef NDEBUG
    EchoAPI( " -> %i\n", ret );
#endif
    return( ret );
}