cpragma.c

Open Watcom 的 C 编译器源代码

    risc_byte_seq    *code;
    int              size;
//TODO deal with reloc list
    if( CurrInfo->code == NULL ) return;
    if( CurrInfo->code != CurrAlias->code ) return;
    size = sizeof( risc_byte_seq ) + CurrInfo->code->length;
    code = (risc_byte_seq *)CMemAlloc( size );
    memcpy( code, CurrInfo->code, size );
    CurrInfo->code = code;
}
#else
local void CopyCode()
{
    byte_seq    *code;
    int         size;

    if( CurrInfo->code == NULL ) return;
    if( CurrInfo->code != CurrAlias->code ) return;
    size = sizeof( byte_seq ) + CurrInfo->code->length;
    code = (byte_seq *)CMemAlloc( size );
    memcpy( code, CurrInfo->code, size );
    CurrInfo->code = code;
}
#endif

local void CopyObjName( void )
{
    char        *name;

    if( CurrInfo->objname == NULL ) return;
    if( CurrInfo->objname != CurrAlias->objname ) return;
    name = CMemAlloc( strlen( CurrInfo->objname ) + 1 );
    strcpy( name, CurrInfo->objname );
    CurrInfo->objname = name;
}


int PragRecog( char *what )
{
    char        *p;

    if( !(CurToken == T_ID
      || (CurToken >= FIRST_KEYWORD && CurToken < T_MACRO_PARM)) ) {
        return( 0 );
    }
    p = Buffer;
    if( *p == '_' ) ++p;
    if( *p == '_' ) ++p;
    if( stricmp( what, p ) == 0 ) {
        NextToken();
        return( 1 );
    }
    return( 0 );
}


void PragObjNameInfo( void )
{
    if( CurToken == T_STRING ) {
        CurrInfo->objname = CMemAlloc( strlen( Buffer ) + 1 );
        strcpy( CurrInfo->objname, Buffer );
        NextToken();
    }
}

int PragSet( void )
{
    if( CurToken == T_LEFT_BRACKET ) return( T_RIGHT_BRACKET );
    if( CurToken == T_LEFT_BRACE ) return( T_RIGHT_BRACE );
    return( T_NULL );
}


hw_reg_set PragRegList( void )
{
    hw_reg_set  res, reg;
    int         close;

    HW_CAsgn( res, HW_EMPTY );
    HW_CAsgn( reg, HW_EMPTY );
    close = PragSet();
    if( close != T_NULL ) {
        CompFlags.pre_processing = 1;       /* enable macros */
        NextToken();
        for(;;) {
            reg = PragRegName( Buffer );
            if( HW_CEqual( reg, HW_EMPTY ) ) break;
            HW_TurnOn( res, reg );
            NextToken();
        }
        CompFlags.pre_processing = 2;
        MustRecog( close );
    }
    return( res );
}

void PragManyRegSets( void )
{
    int         i;
    hw_reg_set  list, *sets;
    hw_reg_set  buff[ MAXIMUM_PARMSETS ];

    list = PragRegList();
    i = 0;
    while( !HW_CEqual( list, HW_EMPTY ) && (i != MAXIMUM_PARMSETS) ) {
        buff[ i++ ] = list;
        list = PragRegList();
    }
    if( !HW_CEqual( list, HW_EMPTY ) ) {
        CErr1( ERR_TOO_MANY_PARM_SETS );
    }
    HW_CAsgn( buff[i], HW_EMPTY );
    i++;
    i *= sizeof( hw_reg_set );
    sets = (hw_reg_set *)CMemAlloc( i );
    memcpy( sets, buff, i );
    CurrInfo->parms = sets;
}

struct textsegment *NewTextSeg( char *name, char *suffix, char *classname )
{
    struct textsegment  *seg;
    int         len1;
    int         len2;
    int         len3;

    len1 = strlen( name );
    len2 = strlen( suffix );
    len3 = strlen( classname ) + 1;
    seg = CMemAlloc( len1 + len2 + len3 + sizeof( struct textsegment ) );
    strcpy( seg->segname, name );
    strcpy( &seg->segname[len1], suffix );
    strcpy( &seg->segname[len1+len2+1], classname );
    seg->next = TextSegList;
    TextSegList = seg;
    return( seg );
}

struct textsegment *LkSegName( char *segname, char *classname )
{
    struct textsegment  *seg;
    int                 len;

    len = strlen( segname ) + 1;
    for( seg = TextSegList; seg; seg = seg->next ) {
        if( strcmp( seg->segname, segname ) == 0 ) {
            if( strcmp( &seg->segname[len], classname ) == 0 ) {
                return( seg );
            }
        }
    }
    return( NewTextSeg( segname, "", classname ) );
}

local void PragAllocText( void )                              /* 26-oct-91 */
{
    struct textsegment  *seg;
    SYM_HANDLE          sym_handle;
    auto SYM_ENTRY      sym;

    MustRecog( T_LEFT_PAREN );
    /* current token can be an T_ID or a T_STRING */
    seg = LkSegName( Buffer, "" );
    NextToken();
    for(;;) {
        MustRecog( T_COMMA );
        /* current token can be an T_ID or a T_STRING */
        sym_handle = Sym0Look( CalcHash( Buffer, strlen(Buffer) ), Buffer );
        if( sym_handle == 0 ) {
            /* error */
        } else {
            SymGet( &sym, sym_handle );
            if( sym.flags & SYM_FUNCTION ) {
                sym.seginfo = seg;
                SymReplace( &sym, sym_handle );
            } else {
                /* error, must be function */
            }
        }
        NextToken();
        if( CurToken == T_RIGHT_PAREN )  break;
        if( CurToken == T_EOF )  break;
        if( CurToken == T_NULL ) break;
    }
    MustRecog( T_RIGHT_PAREN );
    #if _CPU == 8086 || _CPU == 386
        CompFlags.multiple_code_segments = 1;
    #endif
}

void EnableDisableMessage( int enable, unsigned msg_num )
{
    unsigned char       mask;

    if( msg_num <= HIGHEST_MESSAGE_NUMBER ) {
        if( MsgFlags == NULL ) {
            MsgFlags = CMemAlloc( (HIGHEST_MESSAGE_NUMBER + 7) / 8 );
        }
        mask = 1 << (msg_num & 7);
        msg_num = msg_num >> 3;
        if( enable ) {
            MsgFlags[ msg_num ]  &=  ~mask;
        } else {
            MsgFlags[ msg_num ]  |=  mask;
        }
    }
}

// forms:
//    #pragma enable_message messageNo
//    #pragma disable_message messageNo
//
// dis- enable display of selected message number
//
local void PragEnableDisableMessage( int enable )
{
    if( CurToken != T_LEFT_PAREN ) return;
    NextToken();
    for(;;) {
        if( CurToken != T_CONSTANT )  break;
        EnableDisableMessage( enable, Constant );
        NextToken();
        if( CurToken == T_COMMA )  NextToken();
    }
    MustRecog( T_RIGHT_PAREN );
}


// form:
// #pragma message ("one or more " "long message " "strings")
// output these strings to stdout
// this output is _not_ dependent on setting
// of #pragma enable_message or disable_message.
static void PragMessage( void )
{
    if( CurToken != T_LEFT_PAREN ) return;
    CompFlags.pre_processing = 1;           /* enable macros */
    for(;;) {
        NextToken();
        if( CurToken != T_STRING ) break;
        printf( "%s", Buffer );
    }
    printf( "\n" );
    CompFlags.pre_processing = 2;
    MustRecog( T_RIGHT_PAREN );
}

// forms: (1) #pragma enum int
//        (2) #pragma enum minimum
//        (3) #pragma enum original
//        (4) #pragma enum pop
//
// The pragma affects the underlying storage-definition for subsequent
// enum declarations.
//
// (1) make int the underlying storage definition (same as -ei)
// (2) minimize the underlying storage definition (same as no -ei)
// (3) reset back to result of command-line parsing
// (4) restore previous value
//
// 1-3 all push previous value before affecting value
//
static void PushEnum( void ){
/***************************/
    struct enums_info *ei;

    ei = CMemAlloc( sizeof(struct enum_info) );
    ei->make_enums = CompFlags.make_enums_an_int;
    ei->next = EnumInfo;
    EnumInfo = ei;
}

static void PopEnum( void ){
/*********************/
    struct enums_info *ei;

    ei = EnumInfo;
    if( EnumInfo != NULL ){
        CompFlags.make_enums_an_int = ei->make_enums;
        EnumInfo =  ei->next;
        CMemFree( ei );
    }
}

static void PragEnum( void )    // #pragma enum PARSING
{
    if( PragRecog( "int" ) ) {
        PushEnum();
        CompFlags.make_enums_an_int = 1;
    } else if( PragRecog( "minimum" ) ) {
        PushEnum();
        CompFlags.make_enums_an_int = 0;
    } else if( PragRecog( "original" ) ) {
        PushEnum();
        CompFlags.make_enums_an_int = CompFlags.original_enum_setting;
    } else if( PragRecog( "pop" ) ) {
        PopEnum();
    }
}

static void PragIntrinsic( int intrinsic )              /* 09-oct-92 */
{
    SYM_HANDLE  sym_handle;
    SYM_ENTRY   sym;

    if( CurToken == T_LEFT_PAREN ) {
        NextToken();
        while( CurToken == T_ID ) {
            sym_handle = SymLook( HashValue, Buffer );
            if( sym_handle != 0 ) {
                SymGet( &sym, sym_handle );
                sym.flags &= ~ SYM_INTRINSIC;
                if( intrinsic )  sym.flags |= SYM_INTRINSIC;
                SymReplace( &sym, sym_handle );
            }
            NextToken();
            if( CurToken != T_COMMA )  break;
            NextToken();
        }
        MustRecog( T_RIGHT_PAREN );
    }
}

static void PragCodeSeg( void )                       /* 22-oct-92 */
{
    struct textsegment  *seg;
    char                *segname;
    char                *classname;

    if( CurToken == T_LEFT_PAREN ) {
        CompFlags.pre_processing = 1;           /* enable macros */
        seg = NULL;
        NextToken();
        if( CurToken == T_STRING ) {
            segname = CStrSave( Buffer );
            classname = CStrSave( "" );
            NextToken();
            if( CurToken == T_COMMA ) {
                NextToken();
                if( CurToken == T_STRING ) {
                    CMemFree( classname );
                    classname = CStrSave( Buffer );
//                  CodeClassName = CStrSave( Buffer );  /* 13-apr-93 */
                    NextToken();
                }
            }
            seg = LkSegName( segname, classname );
            CMemFree( segname );
            CMemFree( classname );
        }
        CompFlags.pre_processing = 2;
        MustRecog( T_RIGHT_PAREN );
        DefCodeSegment = seg;
        #if _CPU == 8086 || _CPU == 386
            CompFlags.multiple_code_segments = 1;
        #endif
    }
}

static void PragDataSeg( void )                       /* 22-oct-92 */
{
    char        *segname;
    int         segment;

    if( CurToken == T_LEFT_PAREN ) {
        CompFlags.pre_processing = 1;           /* enable macros */
        segment = 0;
        NextToken();
        if( CurToken == T_STRING ) {
            segname = CStrSave( Buffer );
            NextToken();
            if( CurToken == T_COMMA ) {
                NextToken();
                if( CurToken == T_STRING ) {
                    segment = AddSegName( segname, Buffer, SEGTYPE_DATA );
                    NextToken();
                } else {
                    segment = AddSegName( segname, NULL, SEGTYPE_DATA );
                }
            } else {
                segment = AddSegName( segname, NULL, SEGTYPE_DATA );
            }
            CMemFree( segname );
        }
        CompFlags.pre_processing = 2;
        MustRecog( T_RIGHT_PAREN );
        DefDataSegment = segment;
    }
}

static void PragUnroll( void )
{
    unsigned    unroll_count;

    if( CurToken != T_LEFT_PAREN ) return;
    NextToken();
    if( CurToken == T_RIGHT_PAREN ) {
        unroll_count = 0;
    } else {
        if( CurToken != T_CONSTANT ) return;
        unroll_count = Constant;
        NextToken();
        if( CurToken != T_RIGHT_PAREN ) return;
    }
    NextToken();
    if( unroll_count > 255 ) unroll_count = 255;
    UnrollCount = unroll_count;
}

// forms: (1) #pragma read_only_file
//        (2) #pragma read_only_file "file"*
//
// (1) causes current file to be marked read-only
// (2) causes indicated file to be marked read-only
//      - file must have started inclusion (may have completed)
//
static void PragReadOnlyFile( void )
{
    if( CurToken == T_STRING ) {
        do {
            SrcFileReadOnlyFile( Buffer );
            NextToken();
            if( CurToken == T_SEMI_COLON ) {
                NextToken();
            }
        } while( CurToken == T_STRING );
    } else {
        SrcFileReadOnlyFile( NULL );
    }
}


// form: #pragma read_only_directory "directory"*
//
// (1) causes all files within directory to be marked read-only
//
static void PragReadOnlyDir( void )
{
    while( CurToken == T_STRING ) {
        SrcFileReadOnlyDir( Buffer );
        NextToken();
        if( CurToken == T_SEMI_COLON ) {
            NextToken();
        }
    }
}

// form: #pragma once
//
// (1) include file once
//
static void PragOnce( void )
{
    SetSrcFNameOnce();
}

local void PragSTDCOption( void )
{
    if( PragRecog( "ON" ) ) {
    }
    else if( PragRecog( "OFF" ) ) {
    }
    else if( PragRecog( "DEFAULT" ) ) {
    }
}

// form:
// #pragma STDC (FP_CONTRACT|FENV_ACCESS|CX_LIMITED_RANGE) (ON|OFF|DEFAULT)
//
static void PragSTDC( void )
{
    if( PragRecog( "FP_CONTRACT" ) ) {
           PragSTDCOption();
    }
    else if( PragRecog( "FENV_ACCESS" ) ) {
           PragSTDCOption();
    }
    else if( PragRecog( "CX_LIMITED_RANGE" ) ) {
           PragSTDCOption();
    }
}

local void PragAddExtRef ( char *symbol )
{
    SpcSymbol( symbol, SC_EXTERN  );
}

// #pragma extref symbolname
//
static void PragExtRef( void )
{
    while( CurToken == T_ID ) {
        PragAddExtRef( Buffer );
        NextToken();
        if( CurToken == T_SEMI_COLON ) {
            NextToken();
        }
    }
}