wvtypes.c

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

#endif
extern  dbg_type    WVEndArray( array_list *ar ){
/************************************************/
    dim_any   *dim;
    dbg_type  ret = 0;
    dbg_type  sub;

//  ReverseDims( ar );
    for(;;) {
        dim = ar->list;
        if( dim == NULL ) break;
        switch( dim->entry.kind ) {
        case DIM_CON:
            sub = WVSubRange( dim->con.lo, dim->con.hi, dim->con.idx );
            ret = WVArray( sub, ar->base );
            ar->base = ret;
            break;
        case DIM_VAR:
            ret = WVFtnArray( dim->var.dims, dim->var.lo_bound_tipe,
                     dim->var.num_elts_tipe, dim->var.off, ar->base );
            ar->base = ret;
            break;

        }
        ar->list = dim->entry.next;
        _Free( dim, sizeof( field_entry )  );
    }
    return( ret );
}

static  dbg_type        DbgPtr( cg_type ptr_type, dbg_type base, int adjust,
                                dbg_loc loc_segment ) {
/***************************************************************************/

    temp_buff   temp;

    switch( TypeAddress( ptr_type )->refno ) {
    case T_NEAR_POINTER:
    case T_NEAR_CODE_PTR:
        NewType( &temp, TY_POINTER + POINTER_NEAR + adjust );
        break;
    default:
        NewType( &temp, TY_POINTER + POINTER_FAR + adjust );
    }
    BuffIndex( base );
    if( loc_segment != NULL ) {
        LocDump( LocDupl( loc_segment ) );
    }
    EndType( TRUE );
    return( TypeIdx );
}


extern  dbg_type        WVDereference( cg_type ptr_type, dbg_type base ) {
/************************************************************************/

    return( DbgPtr( ptr_type, base, DEREF_NEAR - POINTER_NEAR, NULL ) );
}

extern  dbg_type        WVPtr( cg_type ptr_type, dbg_type base ) {
/****************************************************************/

    return( DbgPtr( ptr_type, base, 0, NULL ) );
}

extern  dbg_type        WVBasedPtr( cg_type ptr_type, dbg_type base,
                                        dbg_loc loc_segment ) {
/****************************************************************/

    return( DbgPtr( ptr_type, base, 0, loc_segment ) );
}

static  void    AddField( field_any **owner, field_any *field  ){
/*** Sort according to WV(brian)***********************************/

    field_any     *curr;
    unsigned      strt;
    offset        off;

    strt = field->member.b_strt;
    off  = field->member.u.off;
    for(;;) {
        curr = *owner;
        if( curr == NULL ) break;
        if( curr->member.entry.field_type == FIELD_OFFSET ) {
            if( (off == curr->member.u.off) && (strt >= curr->member.b_strt) ) break;
            if( off >= curr->member.u.off ) break;
        }
        owner = &curr->member.entry.next;
    }
    field->entry.next = curr;
    *owner = field;
}

static  void    SortFields( struct_list *st  ){
/***********************************************/

    field_any   *curr;
    field_any   *next;
    field_any   *head;

    curr = st->list;
    head = NULL;
    while( curr != NULL ) {
        next = curr->entry.next;
        curr->entry.next = NULL;
        if( curr->entry.field_type == FIELD_OFFSET ){
            AddField(  &head, curr );
        }else{
            curr->entry.next = head;
            head = curr;
        }
        curr = next;
    }
    st->list = head;
}


extern  dbg_type        WVEndStruct( struct_list  *st ) {
/*******************************************************/

    field_any   *field;
    uint        class;
    temp_buff   temp;

    NewType( &temp, TY_STRUCTURE + STRUCT_LIST );
    BuffWord( st->num );
    BuffDWord( st->size );
    EndType( TRUE );
    SortFields( st );
    for(;;) {
        field = st->list;
        if( field == NULL ) break;
        switch( field->entry.field_type ) {
        case FIELD_INHERIT:
            BuffStart( &temp, TY_STRUCTURE + STRUCT_INHERIT );
            LocDump( field->bclass.u.adjustor );
            BuffIndex( field->bclass.base );
            break;
        case FIELD_LOC:
            if( field->member.b_len == 0 ) {
                BuffStart( &temp, TY_STRUCTURE + STRUCT_F_LOC );
                BuffByte( field->member.attr );
                LocDump( field->member.u.loc );
            } else {
                BuffStart( &temp, TY_STRUCTURE + STRUCT_BF_LOC );
                BuffByte( field->member.attr );
                LocDump( field->member.u.loc );
                BuffByte( field->member.b_strt );
                BuffByte( field->member.b_len );
            }
            BuffIndex( field->member.base );
            BuffString( field->member.len, field->member.name );
            break;
        case FIELD_OFFSET:
            if( field->member.u.off <= 0x00ff ) {
                class = 0;
            } else if( field->member.u.off <= 0xffff ) {
                class = 1;
            } else {
                class = 2;
            }
            if( field->member.b_len == 0 ) {
                BuffStart( &temp, TY_STRUCTURE + STRUCT_F_BYTE + class );
                BuffValue( field->member.u.off, class );
            } else {
                BuffStart( &temp, TY_STRUCTURE + STRUCT_BF_BYTE + class );
                BuffValue( field->member.u.off, class );
                BuffByte( field->member.b_strt );
                BuffByte( field->member.b_len );
            }
            BuffIndex( field->member.base );
            BuffString( field->member.len, field->member.name );
            break;
        case FIELD_METHOD:
            break;
        case FIELD_NESTED:
            break;
        case FIELD_VFUNC:
            break;
        default:
            break;
        }
        EndType( FALSE );
        st->list = field->entry.next;
        _Free( field, sizeof( field_entry )  );
    }
    return( TypeIdx );
}


extern  dbg_type        WVEndEnum( enum_list *en ) {
/**************************************************/

    const_entry *cons;
    uint        class;
    temp_buff   temp;
    signed_64   val;

    NewType( &temp, TY_ENUMERATED + ENUM_LIST );
    BuffWord( en->num );
    BuffByte( GetScalar( en->tipe ) );
    EndType( TRUE );
    for(;;) {
        cons = en->list;
        if( cons == NULL ) break;
        val = cons->val;
        class = SignedSizeClass64( val );
        BuffStart( &temp, TY_ENUMERATED + ENUM_BYTE + class );
        if( class == 3 ){
            BuffValue( val.u._32[I64LO32], 2 );
            BuffValue( val.u._32[I64HI32], 2 );
        }else{
            BuffValue( val.u._32[I64LO32], class );
        }
        BuffString( cons->len, cons->name );
        EndType( FALSE );
        en->list = cons->next;
        _Free( cons, sizeof( const_entry ) + cons->len );
    }
    return( TypeIdx );
}


extern  dbg_type        WVEndProc( proc_list  *pr ) {
/***************************************************/

    parm_entry  *parm;
    temp_buff   temp;
    dbg_type    proc_type;

    if( pr->call == T_NEAR_CODE_PTR ) {
        NewType( &temp, TY_PROCEDURE + PROC_NEAR );
   } else {
        NewType( &temp, TY_PROCEDURE + PROC_FAR );
    }
    proc_type = TypeIdx;
    BuffIndex( pr->ret );
    BuffByte( pr->num );
    for(;;) {
        parm = pr->list;
        if( parm == NULL ) break;
        if( BuffLoc() > DB_BUFF_SIZE - 4 ) {
            /* record is getting too big - split it up */
            EndType( TRUE );
            NewType( &temp, TY_PROCEDURE + PROC_EXT_PARM_LIST );
        }
        BuffIndex( parm->tipe );
        pr->list = parm->next;
        _Free( parm, sizeof( parm_entry ) );
    }
    EndType( FALSE );
    return( proc_type );
}



static  void    NewType( temp_buff *temp, uint ty_def ) {
/*******************************************************/

    ++TypeIdx;
    BuffStart( temp, ty_def );
}


static  void    EndType( bool check_too_big ) {
/*********************************************/


    if( _IsModel( DBG_TYPES ) ) {
        if( check_too_big ) ChkDbgSegSize( MAX_TYPE_SIZE, TRUE );
        BuffEnd( DbgTypes );
    }
}

static void DmpFileInfo( void ){
/*******************************/
    fname_lst *lst;
    unsigned_16 index;

    lst = DBFiles.lst;
    DataInt( DBFiles.count );
    index = 0;
    while( lst != NULL ){
        DataInt( index );
        index += lst->len;
        lst = lst->next;
    }
    lst = DBFiles.lst;
    while( lst != NULL ){
        DataBytes( lst->len, lst->fname );
        lst = lst->next;
    }
}

extern void WVDmpCueInfo( long_offset where ){
/**************************************************/
// Assume here is offset from first dbgtype segment to here
// and we are in our segement for writing
    cue_ctl    *ctl;
    cue_blk    *blk;
    cue_state  *curr;
    cue_state  *end;
    seg_id      old;
    offset      here;


    old = SetOP( CueInfoOffset.segment );
    here = AskLocation();
    SetLocation( CueInfoOffset.offset );
    DataLong( where );  // current location in DbgTypes segment
    SetLocation( here );
    SetOP( old );
    ctl = &LineInfo;
    blk = ctl->head;
    DataInt( ctl->count );  // number of entries
    if( ctl->count > 0 ){
        curr = &ctl->start[0];
        DataInt( curr->cue );
        DataInt( curr->fno );
        DataInt( curr->line );
        DataInt( curr->col );
    }
    while( blk != NULL ){
        curr = &blk->info[0];
        if( blk->next == NULL ){
            end = ctl->next;
        }else{
            end = &blk->info[CUES_PER_BLK];
        }
        while( curr != end ){
            DataInt( curr->cue );
            DataInt( curr->fno );
            DataInt( curr->line );
            DataInt( curr->col );
            ++curr;
        }
        blk = blk->next;
    }
    DmpFileInfo();
}