analtype.c

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

/****************************************************************************
*
*                            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 "plusplus.h"
#include "cgfront.h"
#include "codegen.h"


static TYPE makePointerToModType( // MAKE POINTER TO [OPTIONALLY MODIFIED] TYPE
    TYPE type,                  // - base type
    type_flag flags )           // - flags
{
    if( flags != 0 ) {
        type = MakeModifiedType( type, flags );
    }
    return MakePointerTo( type );
}


TYPE TypeReferenced(            // GET TYPE OR TYPE REFERENCED
    TYPE type )                 // - original type
{
    TYPE refed;                 // - referenced type

    refed = TypeReference( type );
    if( refed == NULL ) {
        refed = type;
    }
    return refed;
}


static TYPE typeTested(         // TEST FOR TYPE PAST MODIFIERS, REFERENCE
    TYPE type,                  // - input type
    unsigned id )               // - requested id
{
    if( type != NULL ) {
        type = TypeReferenced( type );
        type = TypedefModifierRemoveOnly( type );
        if( id != type->id ) {
            type = NULL;
        }
    }
    return type;
}


TYPE ClassTypeForType(          // GET CLASS TYPE FOR TYPE OR REFERENCE TO IT
    TYPE type )                 // - input type
{
    return typeTested( type, TYP_CLASS );
}


TYPE EnumTypeForType(           // GET ENUM TYPE FOR TYPE OR REFERENCE TO IT
    TYPE type )                 // - input type
{
    return typeTested( type, TYP_ENUM );
}


TYPE UserDefTypeForType(        // GET ENUM or CLASS TYPE FOR TYPE OR REFERENCE TO IT
    TYPE type )                 // - input type
{
    TYPE retn;

    retn = ClassTypeForType( type );
    if( retn == NULL ) {
        retn = EnumTypeForType( type );
    }
    return retn;
}


CLASSINFO *TypeClassInfo(       // GET CLASSINFO PTR FOR A TYPE
    TYPE type )                 // - input type
{
    CLASSINFO *info;            // - return: NULL or CLASSINFO PTR.

    type = ClassTypeForType( type );
    if( type == NULL ) {
        info = NULL;
    } else {
        info = type->u.c.info;
    }
    return info;
}

static TYPE getThisBaseType( SYMBOL sym )
{
    SCOPE scope;                // - scope for symbol
    TYPE class_type;            // - type from function's class scope
    TYPE base;                  // - return: NULL or TYPE of "this" for symbol

    base = NULL;
    if( sym != NULL ) {
        scope = SymScope( sym );
        if( scope != NULL ) {
            class_type = ScopeClass( scope );
            if( class_type != NULL ) {
                if( sym->id != SC_STATIC ) {
                    base = class_type;
                }
            }
        }
    }
    return base;
}


TYPE TypeThisSymbol(            // GET TYPE OF THIS FOR SYMBOL MEMBER
    SYMBOL sym,                 // - symbol
    boolean reference )         // - use reference?
{
    TYPE base;                  // - return: NULL or TYPE of "this" for symbol
    type_flag flags;            // - flags for "this" pointer

    base = getThisBaseType( sym );
    if( base != NULL ) {
        flags = FunctionThisFlags( sym );
        base = MakeModifiedType( base, flags );
        if( reference ) {
            base = MakeReferenceTo( base );
        } else {
            base = MakePointerTo( base );
        }
        base = MakeModifiedType( base, TF1_CONST );
    }
    return( base );
}


TYPE TypeThis(                  // GET TYPE OF THIS FOR MEMBER BEING DEFINED
    void )
{
    return TypeThisSymbol( ScopeFunctionInProgress(), FALSE );
}


TYPE TypeThisExists(            // GET BASE TYPE OF THIS FOR MEMBER BEING DEFINED
    void )
{
    return getThisBaseType( ScopeFunctionInProgress() );
}


TYPE TypeMergeForMember(        // CREATE MERGED TYPE FOR A MEMBER
    TYPE owner,                 // - type on left (.), type pointed at (->)
    TYPE member )               // - type for member
{
    type_flag owner_flags;      // - modifier flags for owner
    type_flag member_flags;     // - modifier flags for member
    type_flag result_flags;     // - modifier flags for result
    void *owner_base;           // - base for owner

    TypeModExtract( owner
                  , &owner_flags
                  , &owner_base
                  , TC1_NOT_ENUM_CHAR );
    member = TypeGetActualFlags( member, &member_flags );
    if( owner_flags & TF1_CONST ) {
        if( member_flags & TF1_MUTABLE ) {
            owner_flags &= ~TF1_CONST;
        }
    }
    result_flags = owner_flags | member_flags;
    if( result_flags != TF1_NULL ) {
        member = MakeBasedModifierOf( member, result_flags, owner_base );
    }
    return( member );
}


target_size_t ArrayTypeNumberItems( // GET ACTUAL NUMBER OF ITEMS FOR AN ARRAY
    TYPE artype )               // - an array type
{
    target_size_t count;        // - counts number of items

    for( count = 1; ; artype = artype->of ) {
        artype = TypedefModifierRemove( artype );
        if( artype->id != TYP_ARRAY ) break;
        count *= artype->u.a.array_size;
    }
    return count;
}


TYPE TypeTargetSizeT(           // GET TYPE OF TARGET'S size_t
    void )
{
    TYPE type;                  // - return type

    #if _CPU == 386
        type = GetBasicType( TYP_UINT );
    #else
        if( ( TargetSwitches & ( BIG_DATA | CHEAP_POINTER ) ) == BIG_DATA ) {
            type = GetBasicType( TYP_ULONG );
        } else {
            type = GetBasicType( TYP_UINT );
        }
    #endif
    return type;
}


unsigned SizeTargetSizeT(       // GET SIZE OF TARGET'S size_t
    void )
{
    unsigned size;              // - size of type

    #if _CPU == 386
        size = TARGET_UINT;
    #else
        if( ( TargetSwitches & ( BIG_DATA | CHEAP_POINTER ) ) == BIG_DATA ) {
            size = TARGET_ULONG;
        } else {
            size = TARGET_UINT;
        }
    #endif
    return size;
}


boolean TypeTruncByMemModel(    // TEST TYPE TRUNCATION FOR DEF. MEMORY MODEL
    TYPE type )                 // - the type
{
    boolean retn;               // - TRUE ==> type matches default mem. model
    type_flag flags;            // - flags for the type
    type_flag mflags;           // - memory-model flags for the type

    type = TypeGetActualFlags( type, &flags );
    mflags = flags & TF1_MEM_MODEL;
    if( 0 == mflags ) {
        retn = FALSE;
    } else {
        if( type->id == TYP_FUNCTION ) {
            if( IsBigCode() ) {
                retn = FALSE;
            } else {
                retn = ! ( TF1_NEAR & mflags );
            }
        } else {
            if( IsBigData() ) {
                retn = FALSE;
            } else {
                retn = ! ( ( TF1_NEAR | TF1_HUGE ) & mflags );
            }
        }
    }
    return retn;
}


TYPE TypeRebuildPcPtr(          // REBUILD PC-PTR TYPE
    TYPE type,                  // - type of element pointed at (unmodified)
    type_flag old_flags,        // - old flags
    type_flag new_flags )       // - new flags
{
    return makePointerToModType( type
                               , ( old_flags & ~TF1_MEM_MODEL ) | new_flags );
}


TYPE TypeSegOp(                 // GET TYPE FOR :> OPERATION
    TYPE type )                 // - type of RHS of :>
{
    type_flag flags;            // - flags for type

    type = TypePointedAt( type, &flags );
    return TypeRebuildPcPtr( type, flags, TF1_FAR );
}


TYPE TypeSegId(                 // GET TYPE OF SEGMENT ID
    void )
{
    return TypeSegmentShort();
}


TYPE TypeSegAddr(               // GET INTERNAL TYPE OF BASE :> ADDRESS
    void )
{
    TYPE type;                  // - resultant type

    type = GetBasicType( TYP_VOID );
    return makePointerToModType( type, TF1_NEAR );
}


boolean TypeIsBasedPtr(         // SEE IF A PTR TO BASED ITEM
    TYPE type )                 // - the type
{
    boolean retn;               // - FALSE ==> not based
    type_flag flags;            // - flags for item pointed at

    if( NULL == TypePointedAt( type, &flags ) ) {
        retn = FALSE;
    } else {
        retn = flags & TF1_BASED;
    }
    return retn;
}


PC_PTR TypePcPtr(               // CLASSIFY PTR FOR PC
    type_flag flag )            // - modifier flags for pointed item
{
    PC_PTR classification;      // - the classification

    if( flag & TF1_FAR16 ) {
        classification = PC_PTR_FAR16;
    } else {
        classification = ( flag & TF1_BASED ) >> 8;
    }
    return classification;
}


TYPE TypeConvertFromPcPtr(      // TRANSFORM TYPE AFTER CONVERSION FROM PC PTR
    TYPE ptype )                // - pointer type
{
    type_flag flags;            // - flags for item pointed at
    TYPE pted;                  // - type pointed at (modified)
    TYPE type;                  // - type pointed at (unmodified)
    SYMBOL baser;               // - basing infomation

    pted = TypePointedAtModified( ptype );
    type = TypeModExtract( pted, &flags, &baser, TC1_NOT_ENUM_CHAR );
    switch( flags & TF1_BASED ) {
      case 0 :
        if( flags & TF1_FAR16 ) {
            ptype = TypeRebuildPcPtr( type, flags, DefaultMemoryFlag( type ) );
        }
        break;
      case TF1_BASED_VOID :
        ptype = TypeRebuildPcPtr( type, flags, TF1_NEAR );
        break;
      case TF1_BASED_ADD :
      { type_flag bflags;       // - flags for baser
        TypePointedAt( baser->sym_type, &bflags );
        ptype = TypeRebuildPcPtr( type, flags, bflags & TF1_MEM_MODEL );
      } break;
      case TF1_BASED_SELF :
        ptype = TypeRebuildPcPtr( type, flags, TF1_FAR );
        break;
      case TF1_BASED_FETCH :
        ptype = TypeRebuildPcPtr( type, flags, TF1_FAR );
        break;
      case TF1_BASED_STRING :
        ptype = TypeRebuildPcPtr( type, flags, TF1_FAR );
        break;
    }
    return ptype;
}

#if _CPU == 8086
    #define CNV( opI86, op386 ) opI86
#else
    #define CNV( opI86, op386 ) op386
#endif

#define ENTRY_ERROR         TYP_ERROR,
#define ENTRY_BOOL          TYP_SINT,
#define ENTRY_CHAR          TYP_SINT,
#define ENTRY_SCHAR         TYP_SINT,
#define ENTRY_UCHAR         TYP_SINT,
#define ENTRY_WCHAR         CNV( TYP_UINT, TYP_SINT ),