can2txt.c

开放源码的编译器open watcom 1.6.0版的源代码

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
*               DESCRIBE IT HERE!
*
****************************************************************************/


#include <string.h>
#include "womp.h"
#include "can2txt.h"
#include "genutil.h"
#include "cantype.h"
#include "namemgr.h"
#include "cansymb.h"
#include "canaddr.h"
#include "canmisc.h"
#include "myassert.h"
#include "fixup.h"
#include "objrec.h"
#include "objprs.h"

STATIC const char empty[] = "";
STATIC const char farStr[] = "FAR";
STATIC const char nearStr[] = "NEAR";
STATIC const char _386Str[] = " 386";

STATIC const char *locMethods[] = {
/*FIX_LO_BYTE       */  "LOBYTE",
/*FIX_OFFSET        */  "OFFSET",
/*FIX_BASE          */  "BASE",
/*FIX_POINTER       */  "POINTER",
/*FIX_HI_BYTE       */  "HIBYTE",
/*FIX_OFFSET386     */  "OFFSET386",
/*FIX_POINTER386    */  "POINTER386"
};

STATIC const char *frameMethods[] = {
/*FRAME_SEG, TARGET_SEGWD */  "SI",
/*FRAME_GRP, TARGET_GRPWD */  "GI",
/*FRAME_EXT, TARGET_EXTWD */  "EI",
/*FRAME_ABS, TARGET_ABSWD */  "",
/*FRAME_LOC               */  "LOCATION",
/*FRAME_TARG              */  "TARGET",
/*FRAME_NONE              */  "NONE"
};

STATIC void printAddrHdl( const char *prefix, addr_handle hdl ) {

    addr_info   *addr;
    fixup       *fix;
    int         i;
    size_t      data_len;

    addr = CanAFind( hdl );
    if( addr == NULL ) {
        PrtFmt( "%s", prefix );
        PrtMsg( MSG_TXT_NO_ADDR );
        return;
    }
    PrtFmt( "%sdata", prefix );
    data_len = addr->data_len;
    for( i = 0; i < data_len; ++i ) {
        PrtFmt( " %t", addr->data[ i ] );
    }
    PrtFmt( "\n" );
    fix = addr->fixup;
    if( fix != NULL ) {
/**/    myassert( fix->loc_method <= FIX_POINTER386 );
        PrtFmt( "%sfixup %s_REL  %s%s  Frame: %s", prefix,
            fix->self_relative ? "SELF" : "SEG",
            fix->loader_resolved ? "LR" : empty,
            locMethods[ fix->loc_method ],
            frameMethods[ fix->lr.frame ] );
/**/    myassert( fix->lr.frame <= FRAME_NONE && fix->lr.target <= TARGET_ABSWD );
        if( fix->lr.frame < FRAME_LOC ) {
            PrtFmt( "(%x)", fix->lr.frame_datum );
        }
        PrtFmt( "  Target: %s(%x)",
                frameMethods[ fix->lr.target ], fix->lr.target_datum );
        if( fix->lr.target_offset != 0 ) {
            PrtFmt( ",%X\n", fix->lr.target_offset );
        } else {
            PrtFmt( "\n" );
        }
    }
}

STATIC const struct {
    const char  *name;
    uint_8      size;
} typeData[] = {
/*CANT_RESERVED     */  { "RESERVED",       0 },
/*CANT_INTEGER      */  { "INTEGER",        1 },
/*CANT_REAL         */  { "REAL",           1 },
/*CANT_VOID         */  { "VOID",           0 },
/*CANT_COMPLEX      */  { "COMPLEX",        1 },
/*CANT_TYPEDEF      */  { "TYPEDEF",        1 },
/*CANT_SUBRANGE     */  { "SUBRANGE",       1 },
/*CANT_ARRAY        */  { "ARRAY",          1 },
/*CANT_ARRAY_ZERO   */  { "ARRAY_ZERO",     1 },
/*CANT_ARRAY_DESC   */  { "ARRAY_DESC",     0 },
/*CANT_POINTER      */  { "POINTER",        1 },
/*CANT_ENUM         */  { "ENUM",           1 },
/*CANT_STRUCT       */  { "STRUCT",         1 },
/*CANT_PROCEDURE    */  { "PROCEDURE",      0 },
/*CANT_CHARBLOCK    */  { "CHARBLOCK",      1 },
/*CANT_CHARBLOCK_IND*/  { "CHARBLOCK_IND",  0 }
};

STATIC const char *scopeTxt[] = {
/*CANT_SCOPE_NULL   */  "none",
/*CANT_SCOPE_STRUCT */  "struct",
/*CANT_SCOPE_UNION  */  "union",
/*CANT_SCOPE_ENUM   */  "enum"
};

#define INDENT  "    "
#define END "\n"

STATIC int doPrintType( void *_type, void *parm ) {

    cantype        *type = _type;
    uint            tmp;

    parm = parm;
    if( type == NULL ) {
        return( 0 );
    }
/**/myassert( type->class < CANT_CHARBLOCK_IND );
    if( typeData[ type->class ].size ) {
        PrtFmt( "%x: %s size %X bits", type->hdl,
            typeData[ type->class ].name, type->size );
    } else {
        PrtFmt( "%x: %s", type->hdl, typeData[ type->class ].name );
    }
    switch( type->class ) {
    case CANT_RESERVED:
    case CANT_REAL:
    case CANT_VOID:
    case CANT_COMPLEX:
        PrtFmt( "\n" END );
        break;

    case CANT_INTEGER:
        PrtFmt( " %sSIGNED\n" END, type->sgned ? empty : "UN" );
        break;

    case CANT_TYPEDEF:
        PrtFmt( "\n" INDENT "scope %s type %x name \"%s\"\n" END,
            scopeTxt[ type->d.typdef.scope ], type->d.typdef.type,
            NameGet( type->d.typdef.name ) );
        break;

    case CANT_SUBRANGE:
        PrtFmt( "\n" INDENT "base_type %x(%sSIGNED) low %X high %X\n" END,
            type->d.subrng.base_type,
            type->sgned ? empty : "UN",
            type->d.subrng.low,
            type->d.subrng.high );
        break;

    case CANT_ARRAY:
        PrtFmt( "\n" INDENT "base_type %x index_type %x\n" END,
            type->d.array.base_type, type->d.array.index_type );
        break;

    case CANT_ARRAY_ZERO:
        PrtFmt( "\n" INDENT "base_type %x high_bound %X\n" END,
            type->d.arrayz.base_type, type->d.arrayz.high );
        break;

    case CANT_ARRAY_DESC:
        PrtFmt( "\n" INDENT "base_type lo_type %x hi_type %x\n",
            type->d.arrayd.base_type, type->d.arrayd.lo_type,
            type->d.arrayd.hi_type );
        printAddrHdl( INDENT, type->d.arrayd.bounds );
        PrtFmt( END );
        break;

    case CANT_POINTER:
        tmp = type->d.pointr.class;
        PrtFmt( " base_type %x %s%s%s%s\n" END, type->d.pointr.base_type,
            tmp & CANT_PTR_FAR  ? farStr    : nearStr,
            tmp & CANT_PTR_HUGE ? " HUGE"   : empty,
            tmp & CANT_PTR_DEREF? " DEREF"  : empty,
            tmp & CANT_PTR_386  ? _386Str   : empty
        );
        break;

    case CANT_ENUM:
        {
            enum_const *enum_c;
            enum_const *enum_cstop;

            PrtFmt( " base_type %x(%sSIGNED) num_consts %x\n",
                type->d.enumr.base_type,
                type->sgned ? empty : "UN",
                type->d.enumr.num_consts );
            enum_c = type->d.enumr.consts;
            if( enum_c != NULL ) {
                enum_cstop = enum_c + type->d.enumr.num_consts;
                while( enum_c < enum_cstop ) {
                    PrtFmt( INDENT "value %X name \"%s\"\n",
                        enum_c->value, NameGet( enum_c->name ) );
                    ++enum_c;
                }
            }
            PrtFmt( END );
        }
        break;

    case CANT_STRUCT:
        {
            struct_field    *field;
            struct_field    *field_stop;

            PrtFmt( " num_entries %x\n", type->d.strct.num_fields );
            field = type->d.strct.fields;
            if( field != NULL ) {
                field_stop = field + type->d.strct.num_fields;
                while( field < field_stop ) {
                    PrtFmt( INDENT "bit_offset %X type %x name \"%s\"\n",
                        field->bit_offset, field->type, NameGet( field->name ));
                    ++field;
                }
            }
            PrtFmt( END );
        }
        break;

    case CANT_PROCEDURE:
        {
            proc_parm   *parm;
            proc_parm   *parm_stop;
            uint_8      parm_num;

            tmp = type->d.proc.class;
            PrtFmt( "\n" INDENT "%s%s ret_type %x num_parms %t\n",
                tmp & CANT_PROC_FAR ? farStr : nearStr,
                tmp & CANT_PROC_386 ? _386Str : empty,
                type->d.proc.ret_type,
                type->d.proc.num_parms
            );
            parm = type->d.proc.parms;
            if( parm != NULL ) {
                parm_stop = parm + type->d.proc.num_parms;
                parm_num = 0;
                while( parm < parm_stop ) {
                    PrtFmt( INDENT "parm_num %t parm_type %x\n",
                        parm_num, parm->type );
                    ++parm_num;
                    ++parm;
                }
            }
            PrtFmt( END );
        }
        break;

    case CANT_CHARBLOCK: