dg.c

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

    Action( "( %s, %d )", Tipe( ptr_tipe ), base );
    TypDbg( "(%d) Pointer <%s>, base==%d%n", ++TypeIdx, Tipe(ptr_tipe),
            base );
    Action( " -> %d%n", TypeIdx );
    return( TypeIdx );
}
extern  struct_list     *DBBegNameStruct( char *nm, cg_type tipe, char is_struct ) {
/********************************************************************/
    struct_list *st;

    is_struct = is_struct;
    tipe = tipe;
    Action( "DBBegNameStruct(%s)", nm );
    st = CGAlloc( sizeof( struct_list ) );
    st->num = 0;
    st->list = NULL;
    // st->me = DBG_NIL_TYPE;
    Action( " -> %p%n", st );
    return( st );
}
extern  struct_list     *DBBegStruct( cg_type tipe, char is_struct ) {
//====================================================================

    struct_list *st;

    is_struct = is_struct;
    tipe = tipe;
    Action( "DBBegStruct()" );
    st = CGAlloc( sizeof( struct_list ) );
    st->num = 0;
    st->list = NULL;
    // st->me = DBG_NIL_TYPE;
    Action( " -> %p%n", st );
    return( st );
}

static  field_member     *CreateMember( char *nm, byte strt, byte len,
                                        dbg_type base, uint attr ) {
/******************************************************************/
    uint          n_len;
    field_member *field;

    n_len = strlen( nm );
    field = CGAlloc( 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 *curr;
    field_entry **owner;

    owner = &st->list;
    for(;;) {
        curr = *owner;
        if( curr == NULL ) break;
        owner = &curr->next;
    }
    field->entry.next = NULL;
    *owner = field;
    st->num++;
}

extern  void    DBAddBitField(struct_list *st,unsigned_32 off,byte strt,byte len,char *nm,dbg_type base) {
    field_member *field;

    Action( "DBAddBitField( %p, %l, %d, %d, %s, %d )%n",
                          st, off, strt, len, nm, base );
    field = CreateMember( nm, strt, len, base, 0 );
    field->entry.field_type = FIELD_OFFSET;
    field->u.off= off;
    AddField( st, field );
}
extern  void    DBAddLocField( struct_list *st, dbg_loc loc, uint attr,
                            byte strt, byte len, char *nm, dbg_type base ) {
/******************************************************************/
    field_member *field;

    Action( "DBAddLocField( %p, %s, %d, %d, %d, %s, %d )%n",
                  st, Location(loc), attr, strt, len, nm, base );
    field = CreateMember( nm, strt, len, base, attr );
    field->entry.field_type = FIELD_LOC;
    field->u.loc  = loc;
    AddField( st, field );
}


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

    field_member *field;

    Action( "DBAddField( %p, %l, %s, %d )%n", st, off, nm, base );
    field = CreateMember( nm, 0, 0, base, 0 );
    field->entry.field_type = FIELD_OFFSET;
    field->u.off= off;
    AddField( st, field );
}

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

    uint          n_len;
    field_stfield *field;

    Action( "DBAddStField( %p, %s, %s, %d, %d )%n",
                  st, Location(loc),nm, attr, base );
    n_len = strlen( nm );
    field = CGAlloc( sizeof( field_stfield ) + n_len );
    strcpy( field->name, nm );
    field->entry.field_type = FIELD_STFIELD;
    field->attr = attr;
    field->base = base;
    AddField( st, field );
}

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

    uint          n_len;
    field_method *field;

    Action( "DBAddMethod( %p, %s, %d, %s, %d )%n",
                  st, Location(loc), attr, nm, base );
    n_len = strlen( nm );
    field = CGAlloc( sizeof( field_method ) + n_len );
    strcpy( field->name, nm );
    field->entry.field_type = FIELD_METHOD;
    field->u.loc =  loc;
    field->attr = attr;
    field->kind = kind;
    field->len = n_len;
    field->base = base;
    AddField( st, field );
}

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

    uint          n_len;
    field_nested *field;

    Action( "DBAddNestedType( %p, %s, %d )%n",
                  st, nm, base );
    n_len = strlen( nm );
    field = CGAlloc( sizeof( field_nested ) + n_len );
    strcpy( field->name, nm );
    field->entry.field_type = FIELD_NESTED;
    field->base = base;
    AddField( st, field );
    st->is_cnested = TRUE;
}


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


    Action( "DBAddInheritance( %p, %d, %p )%n", st, inherit, loc );
    field = CGAlloc( sizeof( field_bclass ) );
    field->entry.field_type = FIELD_INHERIT;
    field->attr = attr;
    field->base = inherit;
    field->attr = attr;
    field->kind = kind;
    field->u.adjustor  = loc;
    AddField( st, field );
}

extern  void    DBAddBaseInfo( struct_list  *st, unsigned_32 vb_off,  unsigned_32 esize,
                                              dbg_type vtbl, cg_type ptr_type ){
/*******************************************************************/
    st->vtbl_off    = vb_off;
    st->vtbl_type  = vtbl;
    st->ptr_type  =  ptr_type;
    st->vtbl_esize = esize;
     Action( "DBAddBaseInfo( %p, %d, %d, %d,%s )%n", st, vb_off,
                             esize, vtbl, Tipe( ptr_type) );
}

extern  void    DBAddVFuncInfo( struct_list  *st, unsigned_32 vfptr_off,
                                                  int size,
                                                  cg_type vft_cgtype ){
//======================================================================
     Action( "DBAddVFuncInfo( %p, %d, %d,%s )%n", st, vfptr_off,
                             size,Tipe( vft_cgtype) );
}

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

    field_any  *curr;
    uint        toff;

     Action( "DBEndStruct( %p )", st );
     TypDbg( "(%d) Struct #fields == %d%n", ++TypeIdx, st->num );
     for(;;) {
         curr = st->list;
         if( curr == NULL ) break;
         switch( curr->entry.field_type ) {
         case FIELD_OFFSET:{
             field_member *field = curr;

             toff = field->u.off;
             TypDbg( "    '%s' base==%d, offset==%d", field->name, field->base,
                     toff );
             if( field->len != 0 ) {
                 TypDbg( "{%d:%d}", field->b_strt, field->b_len );
             }
            break;
         }
         case FIELD_LOC:{
             field_member *field = curr;

             TypDbg( "    '%s' base==%d, attr==%h, location==%s", field->name, field->base,
                     field->attr, Location( field->u.loc ) );
             if( field->len != 0 ) {
                 TypDbg( "{%d:%d}", field->b_strt, field->b_len );
             }
            break;
         }
         case FIELD_INHERIT:{
             field_bclass *field = curr;

             TypDbg( "    inherit base==%d, adjust==%s", field->base,
                     Location( field->u.adjustor ) );
             break;
         }
         }
         TypDbg( "%n" );
         st->list = curr->entry.next;
         curr->entry.next = NULL;
         CGFree( curr );
     }
     CGFree( st );
    Action( " -> %d%n", TypeIdx );
    return( TypeIdx );
}

extern  char            DBNested( char flag ){
/***************************************/
     Action( "DBNested( %d )", flag );
     return( 0 );
}

extern  dbg_type      DBStructForward( struct_list  *st ) {
//===========================================================
     Action( "DBStructForward( %p )", st );
     return( DBG_NIL_TYPE  );
}

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

    enum_list   *en;

    Action( "DBBegEnum" );
    Action( "( %s )%n", Tipe( tipe ) );
    en = CGAlloc( sizeof( enum_list ) );
    en->num = 0;
    en->list = NULL;
    en->tipe = tipe;
    Action( " -> %p%n", en );
    return( en );
}
extern  void    DBAddConst( enum_list *en, char *nm, signed_32 val ) {
//====================================================================

    const_entry *cons;

    Action( "DBAddConst( %p, %s, %l )%n", en, nm, val );
    cons = CGAlloc( sizeof( const_entry ) );
    cons->next = en->list;
    en->list = cons;
    en->num++;
    cons->name = ACopyOf( nm );
    cons->val  = val;
}
extern  dbg_type        DBEndEnum( enum_list *en ) {
//==================================================

    const_entry *cons;
    int tval;

    Action( "DBEndEnum( %p )", en );
    TypDbg( "(%d) Enumerated base==%s, &consts==%d%n", ++TypeIdx,
            Tipe( en->tipe ), en->num );
    for(;;) {
        cons = en->list;
        if( cons == NULL ) break;
        tval = cons->val;
        TypDbg( "    '%s' == %d%n", cons->name, tval );
        en->list = cons->next;
        cons->next = NULL;
        CGFree( cons->name );
        CGFree( cons );
    }
    CGFree( en );
    Action( " -> %d%n", TypeIdx );
    return( TypeIdx );
}
extern  proc_list       *DBBegProc( cg_type call_type, dbg_type ret ) {
//=====================================================================

    proc_list   *pr;

    Action( "DBBegProc" );
    Action( "( %s, %d )", Tipe( call_type ), ret );
    pr = CGAlloc( sizeof( proc_list ) );
    pr->num = 0;
    pr->list = NULL;
    pr->call = call_type;
    pr->ret = ret;
    Action( " -> %p%n", pr );
    return(pr);
}
extern  void  DBAddMethParms(  proc_list *pr,  dbg_type  cls, dbg_type this   ) {
/************************************************************************/

    Action( "DBAddMethParms" );
    Action( "(%d %d, %d )%n", pr, cls, this );
}
extern  void    DBAddParm( proc_list *pr, dbg_type tipe ) {
//=========================================================

    parm_entry  *parm;
    parm_entry  **owner;

    Action( "DBAddParm( %p, %d )", pr, tipe );
    parm = CGAlloc( 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        DBEndProc( proc_list *pr ) {
//==================================================

    parm_entry  *parm;

    Action( "DBEndProc( %p )", pr );
    TypDbg( "(%d) Procedure %s, return==%d, &parms==%d%n", ++TypeIdx,
            Tipe(pr->call), pr->ret, pr->num );
    for(;;) {
        parm = pr->list;
        if( parm == NULL ) break;
        TypDbg( "    type == %d%n", parm->tipe );
        pr->list = parm->next;
        parm->next = NULL;
        CGFree( parm );
    }
    CGFree( pr );
    Action( " -> %d%n", TypeIdx );
    return( TypeIdx );
}

extern  void            DBGenStMem(cg_sym_handle sym,dbg_loc loc) {
//=================================================================

    Action( "DBGenStMem" );
    Action( "( %s, %s )%n", FEName((pointer)sym), Location( loc ) );
}

extern  void            DBGenSym(cg_sym_handle sym,dbg_loc loc,int scope) {
//=========================================================================

    Action( "DBGenSym" );
    Action( "( %s )%n", FEName((pointer)sym) );
    if( (FEAttr((pointer)sym) & FE_IMPORT) == 0 ) {
        /* Should remember and print FEDbgType(sym) later! */
        SymDbg( "GenSym %s'%s' ==> %s%n",
                scope ? "(scoped) " : "", FEName((pointer)sym),
                Location( loc ) );
    }
}
extern  dbg_type        DBBasedPtr(cg_type ptr_tipe ,dbg_type base,dbg_loc loc) {
//===============================================================================

    Action( "DBBasedPtr" );
    Action( "( %s, %d )", Tipe( ptr_tipe ), base );
    TypDbg( "(%d) BPointer <%s>, base==%d%n seg_loc=%s", ++TypeIdx, Tipe(ptr_tipe),
            base, Location( loc ) );
    Action( " -> %d%n", TypeIdx );
    return( TypeIdx );
}

extern  dbg_type        DBBasedPtrK(cg_type ptr_tipe ,dbg_type base,
                                  cg_sym_handle sym,  int kind ){
//==================================================================

    Action( "DBBasedPtrK" );
    Action( "( %s, %d %s %d)", Tipe( ptr_tipe ), base,
                          kind, FEName((pointer)sym) );
    Action( " -> %d%n", TypeIdx );
    return( TypeIdx );
}