cdump.c

Open Watcom 的 C 编译器源代码

    int         flags;

    switch( typ->decl_type ) {
    case TYPE_FUNCTION:
        DumpDecl( Object( typ ), NULL, pch );
        if ( funcsym ) {
            flags = funcsym->attrib;
            if( flags & FLAG_LOADDS )  put_keyword( T___LOADDS, pch );
            if( flags & FLAG_EXPORT )  put_keyword( T___EXPORT, pch );
            if( flags & FLAG_SAVEREGS) put_keyword( T___SAVEREGS, pch );
            flags &= ~(FLAG_LOADDS | FLAG_EXPORT | FLAG_SAVEREGS);
            DumpFlags( flags, typ, pch );               /* 03-aug-88, FWC */
            ChunkSaveStr( pch, funcsym->name );
        }
    case TYPE_ARRAY:
        DumpTail( typ, funcsym, 0, pch );
        break;
    case TYPE_POINTER:
        obj = Object( typ );
        while( obj->decl_type == TYPE_POINTER ) obj = Object( obj );
        switch( obj->decl_type ) {
        case TYPE_FUNCTION:
            DumpDecl( Object( obj ), NULL, pch );
            ChunkSaveChar( pch, '(' );
            break;
        case TYPE_ARRAY:
            while( obj->decl_type == TYPE_ARRAY ) obj = Object( obj );
            DumpDecl( obj, NULL, pch );
            ChunkSaveChar( pch, '(' );
            break;
        default:
            break;
        }
        DumpPointer( typ, pch );         /* 26-may-89 */
        break;
    default:
        break;
    }
}


static void put_keyword( int keyword, STRCHUNK *pch )
{
    ChunkSaveStrWord( pch, Tokens[ keyword ] );
}


static void DumpFlags( int flags, TYPEPTR typ, STRCHUNK *fp )
{
    SYM_NAMEPTR p;
    SYM_ENTRY   sym;

    if( flags & FLAG_VOLATILE ) put_keyword( T_VOLATILE, fp );
    if( flags & FLAG_CONST )    put_keyword( T_CONST, fp );
    if( flags & FLAG_RESTRICT ) put_keyword( T_RESTRICT, fp );
    if( flags & FLAG_NEAR ) {
        if( flags & FLAG_FAR  ) {
            put_keyword( T___INTERRUPT, fp );
        } else if( flags & FLAG_BASED ) {               /* 13-nov-91 */
            ChunkSaveStr( fp, "__based(" );
            if( typ->u.p.based_sym == 0 ) {
                ChunkSaveStr( fp, "void" );
            } else {
                SymGet( &sym, typ->u.p.based_sym );
                p = SymName( &sym, typ->u.p.based_sym );
                ChunkSaveStr( fp, p );
            }
            ChunkSaveStr( fp, ") " );
        } else {
            put_keyword( T___NEAR, fp );
        }
    }
    if( flags & FLAG_FAR  )     put_keyword( T___FAR, fp );
    if( flags & FLAG_HUGE )     put_keyword( T___HUGE, fp );
    switch( flags & FLAG_LANGUAGES ) {
    case LANG_CDECL:
        put_keyword( T___CDECL, fp );
        break;
    case LANG_PASCAL:
        put_keyword( T___PASCAL, fp );
        break;
    case LANG_FORTRAN:
        put_keyword( T___FORTRAN, fp );
        break;
    case LANG_SYSCALL:
        put_keyword( T__SYSCALL, fp );
        break;
    case LANG_STDCALL:                          /* 08-jan-92 */
        put_keyword( T___STDCALL, fp );
        break;
    case LANG_OPTLINK:                          /* 08-jan-92 */
        put_keyword( T__OPTLINK, fp );
        break;
    case LANG_FASTCALL:                         /* 08-jan-92 */
        put_keyword( T___FASTCALL, fp );
        break;
    }
}

static void DumpBaseType( TYPEPTR typ, STRCHUNK *pch )
{
    auto SYM_ENTRY      sym;
    TYPEPTR             obj;

    for(;;) {
        if( typ->decl_type == TYPE_TYPEDEF ) break;
        obj = Object( typ );
        if( obj == NULL ) break;
        typ = obj;
    }
    for(;;) {
        if( typ->decl_type != TYPE_TYPEDEF ) break;
        if( !(typ->type_flags & TF2_DUMMY_TYPEDEF) ) break;
        typ = typ->object;                      // skip over dummy typedef
    }
    if( typ->decl_type == TYPE_TYPEDEF ) {
        SymGet( &sym, typ->u.typedefn );
        ChunkSaveStrWord( pch, SymName( &sym, typ->u.typedefn ) );
    } else {
        if( typ->type_flags & TF2_TYPE_PLAIN_CHAR ) {   /* 25-nov-94 */
            ChunkSaveStrWord( pch, "char" );
        } else {
            ChunkSaveStrWord( pch, CTypeNames[ typ->decl_type ] );
        }
        if( typ->decl_type == TYPE_STRUCT ||
            typ->decl_type == TYPE_UNION  ||
            typ->decl_type == TYPE_ENUM  ) {

            /* if there is no tag name, then should print out the
               entire structure or union definition or enum list */

            DumpTagName( typ->u.tag->name, pch );
        }
    }
}


static void DumpArray( TYPEPTR typ, STRCHUNK *pch )
{
    unsigned long size;
    char tempbuf[20];

    while( typ->decl_type == TYPE_ARRAY ) {
        size = typ->u.array->dimension;
        if( size != 0 ) {
            sprintf( tempbuf, "[%lu]", size );
            ChunkSaveStr( pch, tempbuf );
        } else {
            ChunkSaveStr( pch, "[]" );
        }
        typ = Object( typ );
    }
}


static void DumpParmTags( TYPEPTR *parm, FILE *fp )
{
    TYPEPTR     typ;
    STRCHUNK    chunk;
    char        *result;

    if( parm != NULL ) {
        for(;;) {
            typ = *parm;
            if( typ == NULL ) break;
            typ = TrueType( typ );
            if( typ->decl_type == TYPE_STRUCT  ||
                typ->decl_type == TYPE_UNION ) {
                ChunkInit(&chunk);
                ChunkSaveStrWord( &chunk, CTypeNames[ typ->decl_type ] );
                DumpTagName( typ->u.tag->name, &chunk );
                result = ChunkToStr( &chunk );
                fprintf( fp, "%s;\n", result );
                CMemFree( result );
            }
            ++parm;
        }
    }
}


static void DumpTagName( char *tag_name, STRCHUNK *pch )
{
    if( *tag_name == '\0' ) {
        if (do_message_output)
            tag_name = "{...}";
        else
            tag_name = "_no_name_";
    }
    ChunkSaveStrWord( pch, tag_name );
}


static TYPEPTR DefArgPromotion( TYPEPTR arg_typ )
{
    TYPEPTR     typ;

    /* perform default argument promotions */
    typ = arg_typ;
    while( typ->decl_type == TYPE_TYPEDEF ) typ = Object( typ );
    switch( typ->decl_type ) {
    case TYPE_CHAR:
    case TYPE_UCHAR:
    case TYPE_SHORT:
    case TYPE_ENUM:
        arg_typ = GetType( TYPE_INT );
        break;
    case TYPE_USHORT:
        arg_typ = GetType( TYPE_UINT );
        break;
    case TYPE_FLOAT:
        arg_typ = GetType( TYPE_DOUBLE );
        break;
    default:
        break;
    }
    return( arg_typ );
}

static void DoDumpType( TYPEPTR realtype, char *symname, STRCHUNK *pch )
{
    type_modifiers     pointer_flags;
    TYPEPTR typ;

    realtype = TrueType( realtype );
    DumpBaseType( realtype, pch );
    DumpDecl( realtype, NULL, pch );
    if( symname )
        ChunkSaveStr( pch, symname );
    if( realtype->decl_type == TYPE_POINTER ) {
        if( realtype->u.p.decl_flags & FLAG_WAS_ARRAY ) {
            typ = Object( realtype );
            if( typ->decl_type != TYPE_ARRAY ) {
                ChunkSaveStr( pch, "[]" );
            }
        }
    }
    for( typ = realtype; typ != NULL; typ = Object( typ ) ) {
        if( typ->decl_type == TYPE_TYPEDEF ) break; /* 17-jan-91 */
        pointer_flags = 0;
        while( typ->decl_type == TYPE_POINTER ) {
            pointer_flags = typ->u.p.decl_flags;
            typ = Object( typ );
        }
        if( typ->decl_type == TYPE_ARRAY  ||
           typ->decl_type == TYPE_FUNCTION ) {
            DumpTail( realtype, NULL, pointer_flags, pch );
            break;
        }
    }
}

static void DumpParmList( TYPEPTR *parm, SYMPTR funcsym, STRCHUNK *pch )
{
    TYPEPTR            typ;
    int                parm_num;
    SYM_HANDLE         sym_handle;
    SYM_ENTRY          sym;
    char               *sym_name;
    char               temp_name[20];

    if( parm == NULL ) {
        ChunkSaveStr( pch, "void" );
    } else {
        parm_num = 1;
        if( funcsym != NULL ) {
            sym_handle = funcsym->u.func.parms;
        } else {
            sym_handle = 0;
        }
        for( ;; ) {
            typ = *parm;
            if( typ == NULL ) break;
            typ = TrueType( typ );
            if( funcsym != NULL ) {
                if( funcsym->flags & SYM_OLD_STYLE_FUNC ) {
                    typ = DefArgPromotion( typ );
                }
            }
            sym_name = NULL;
            if( sym_handle != 0 ) {
                SymGet( &sym, sym_handle );
                sym_handle = sym.handle;
                sym_name   = sym.name;
            } else {
                if( typ->decl_type != TYPE_VOID  &&
                    typ->decl_type != TYPE_DOT_DOT_DOT ) {
                        sym_name = temp_name;
                        sprintf( temp_name, "__p%d", parm_num );
                }
            }
            DoDumpType( typ, sym_name, pch );
            ++parm;
            if( *parm != NULL )  ChunkSaveChar( pch, ',' );
            ++parm_num;
        }
    }
}

char *DiagGetTypeName( TYPEPTR typ )
{
    STRCHUNK  chunk;

    ChunkInit( &chunk );
    do_message_output = 1;
    DoDumpType( typ, NULL, &chunk );
    do_message_output = 0;
    return ChunkToStr( &chunk );
}