rewrite.c

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

        if( CurToken == T_EOF ) {
            templateError( r, &start_locn );
            break;
        }
        if( ! first_time ) {
            /* already been saved by YYDRIVER */
            saveToken( r, locn );
        }
        first_time = FALSE;
        switch( CurToken ) {
        case T_RIGHT_BRACE:
        case T_ALT_RIGHT_BRACE:
            if( brace_depth == 0 ) {
                return( templateError( r, &start_locn ) );
            }
            --brace_depth;
            if( brace_depth == 0 ) {
                NextToken();
                if( CurToken == T_SEMI_COLON ) {
                    saveToken( r, locn );
                    NextToken();
                }
                return( r );
            }
            break;
        case T_LEFT_BRACE:
        case T_ALT_LEFT_BRACE:
            ++brace_depth;
            break;
        case T_SEMI_COLON:
            if( brace_depth == 0 ) {
                NextToken();
                return( r );
            }
            break;
        }
        NextToken();
    }
    return( NULL );
}

REWRITE *RewritePackageToken( void )
/**********************************/
{
    REWRITE *r;
    TOKEN_LOCN locn;

    r = newREWRITE( T_EOF, &locn );
    if( CurToken != T_EOF ) {
        if( CurToken == T_SAVED_ID ) {
            saveToken( r, &locn );
            NextToken();
        }
        saveToken( r, &locn );
    }
    return( r );
}

void RewriteRestoreToken( REWRITE *r )
/************************************/
{
    REWRITE *last_rewrite;
    void (*last_source)( void );

    last_source = SetTokenSource( RewriteToken );
    last_rewrite = RewriteRewind( r );
    if( CurToken == T_ID ) {
        LookPastName();
        if( LAToken == T_EOF ) {
            CurToken = T_ID;
        }
    }
    RewriteClose( last_rewrite );
    ResetTokenSource( last_source );
    RewriteFree( r );
}

REWRITE *RewriteRewind( REWRITE *r )
/**********************************/
{
    REWRITE *last_rewrite;

    last_rewrite = currRewrite;
    if( r->busy ) {
        r = dupREWRITE( r );
    }
    currRewrite = r;
    r->busy = TRUE;
    r->curr = r->list;
    r->token = &(r->curr->stream[0]);
    RewriteToken();
    return( last_rewrite );
}

static uint_8 getByte( REWRITE *r, REWRITE_TOKENS **rt, uint_8 **stop )
{
    REWRITE_TOKENS *my_rt;

    if( r->token != *stop ) {
        return( *(r->token++) );
    }
    my_rt = (*rt)->next;
    if( my_rt == NULL ) {
        return( r->last_token );
    }
    *rt = my_rt;
    r->curr = my_rt;
    if( *rt != NULL ) {
        *stop = &(my_rt->stream[my_rt->count]);
        r->token = &(my_rt->stream[0]);
        return( *(r->token++) );
    }
    return( r->last_token );
}

static unsigned getString( REWRITE*r, REWRITE_TOKENS**rt, uint_8**stop, char*dest)
{
    char c;
    unsigned len;

    len = 0;
    for(;;) {
        c = getByte( r, rt, stop );
        if( c == '\0' ) break;
        *dest = c;
        ++dest;
        ++len;
    }
    *dest = '\0';
    return( len );
}

static void getBinary( REWRITE*r, REWRITE_TOKENS**rt, uint_8**stop,
                       uint_8 *bin, unsigned size )
{
    for( ; size > 0; --size, ++bin ) {
        *bin = getByte( r, rt, stop );
    }
}

void RewriteToken( void )
/***********************/
{
    REWRITE *r;
    REWRITE_TOKENS *rt;
    uint_8 *stop;
    uint_8 token;
    uint_32 srcfile_index;
    SRCFILE srcfile;
    uint_32 absolute;
    uint_8 code_byte;
    unsigned len;

    r = currRewrite;
    rt = r->curr;
    stop = &(rt->stream[rt->count]);
    for(;;) {
        code_byte = getByte( r, &rt, &stop );
        if( code_byte == CODE_FILE ) {
            getBinary( r, &rt, &stop, (uint_8*)&srcfile_index, sizeof( srcfile_index ) );
            srcfile = accessSrcFile( r, srcfile_index );
            SrcFilePoint( srcfile );
            TokenLine = 0;
            TokenColumn = 0;
        } else if( code_byte == CODE_ABS ) {
            getBinary( r, &rt, &stop, (uint_8*)&absolute, sizeof( absolute ) );
            if( MASK_ABS_LINE & absolute ) {
                TokenLine = absolute & ~MASK_ABS_LINE;
                TokenColumn = 0;
            } else {
                TokenColumn = absolute;
                break;
            }
        } else if( MASK_DELTA_LINE & code_byte ) {
            TokenLine += code_byte & ~ MASK_DELTA_LINE;
        } else {
            TokenColumn += code_byte;
            break;
        }
    }
    token = getByte( r, &rt, &stop );
    switch( token ) {
    case T_ID:
    case T_BAD_CHAR:
        len = getString( r, &rt, &stop, Buffer );
        TokenLen = len;
        break;
    case T_BAD_TOKEN:
        getBinary( r, &rt, &stop, (uint_8*)&BadTokenInfo, sizeof( BadTokenInfo ) );
        break;
    case T_STRING:
    case T_LSTRING:
        len = getString( r, &rt, &stop, Buffer );
        TokenLen = len + 1;
        break;
    case T_CONSTANT:
        ConstType = getByte( r, &rt, &stop );
        switch( ConstType ) {
        case TYP_LONG_DOUBLE:
        case TYP_DOUBLE:
        case TYP_FLOAT:
            len = getString( r, &rt, &stop, Buffer );
            TokenLen = len;
            break;
        default:
            getBinary( r, &rt, &stop, (uint_8*)&Constant64, sizeof( Constant64 ) );
        }
        break;
    }
    CurToken = token;
#ifndef NDEBUG
    CtxScanToken();
    DumpToken();
#endif
}

void RewriteClose( REWRITE *rewrite )
/***********************************/
{
    REWRITE *r;

    r = currRewrite;
    if( r != NULL && r->alternate ) {
        RewriteFree( r );
    }
    currRewrite = rewrite;
}

REWRITE *RewriteRecordInit( TOKEN_LOCN *locn )
/********************************************/
{
    REWRITE *r;

    r = newREWRITE( T_EOF, locn );
    return( r );
}

void RewriteRecordToken( REWRITE *r, TOKEN_LOCN *locn )
/*****************************************************/
{
    if( CurToken != T_EOF ) {
        saveToken( r, locn );
    }
}

REWRITE *RewriteGetIndex( REWRITE *e )
/************************************/
{
    return( CarveGetIndex( carveREWRITE, e ) );
}

REWRITE *RewriteMapIndex( REWRITE *i )
/************************************/
{
    return( CarveMapIndex( carveREWRITE, i ) );
}

static void markFreeRewrite( void *p )
{
    REWRITE *b = p;

    b->free = TRUE;
}

static void saveRewrite( void *e, carve_walk_base *d )
{
    REWRITE *s = e;
    REWRITE_TOKENS *save_list;
    REWRITE_TOKENS *save_curr;
    SRCFILE_HANDLE *h;
    SRCFILE srcfile;
    unsigned srcfile_terminator;
    uint_8 *save_token;

    if( s->free ) {
        return;
    }
    save_list = s->list;
    s->list = CarveGetIndex( carveREWRITE_TOKENS, save_list );
    save_curr = s->curr;
    s->curr = CarveGetIndex( carveREWRITE_TOKENS, save_curr );
    save_token = s->token;
    s->token = (uint_8 *) ( save_token - (uint_8 *) save_curr );
    PCHWriteCVIndex( d->index );
    PCHWrite( s, sizeof( *s ) );
    for( h = s->srcfiles_refd; h != NULL; h = h->next ) {
        srcfile = SrcFileGetIndex( h->srcfile );
        PCHWrite( &srcfile, sizeof( srcfile ) );
    }
    srcfile_terminator = CARVE_NULL_INDEX;
    PCHWriteCVIndex( srcfile_terminator );
    s->list = save_list;
    s->curr = save_curr;
    s->token = save_token;
}

static void markFreeRewriteTokens( void *p )
{
    REWRITE_TOKENS *b = p;

    b->free = TRUE;
}

static void saveRewriteTokens( void *e, carve_walk_base *d )
{
    REWRITE_TOKENS *s = e;
    REWRITE_TOKENS *save_next;

    if( s->free ) {
        return;
    }
    save_next = s->next;
    s->next = CarveGetIndex( carveREWRITE_TOKENS, save_next );
    PCHWriteCVIndex( d->index );
    PCHWrite( s, sizeof( *s ) );
    s->next = save_next;
}

pch_status PCHWriteRewrites( void )
{
    unsigned terminator = CARVE_NULL_INDEX;
    auto carve_walk_base data;

    CarveWalkAllFree( carveREWRITE, markFreeRewrite );
    CarveWalkAll( carveREWRITE, saveRewrite, &data );
    PCHWriteCVIndex( terminator );
    CarveWalkAllFree( carveREWRITE_TOKENS, markFreeRewriteTokens );
    CarveWalkAll( carveREWRITE_TOKENS, saveRewriteTokens, &data );
    PCHWriteCVIndex( terminator );
    return( PCHCB_OK );
}

pch_status PCHReadRewrites( void )
{
    cv_index i;
    REWRITE *r;
    REWRITE_TOKENS *rt;
    SRCFILE srcfile;
    auto cvinit_t data;

    CarveInitStart( carveREWRITE, &data );
    for(;;) {
        i = PCHReadCVIndex();
        if( i == CARVE_NULL_INDEX ) break;
        r = CarveInitElement( &data, i );
        PCHRead( r, sizeof( *r ) );
        r->list = CarveMapIndex( carveREWRITE_TOKENS, r->list );
        r->curr = CarveMapIndex( carveREWRITE_TOKENS, r->curr );
        r->srcfiles_refd = NULL;
        r->token = ((uint_8 *) r->curr) + (unsigned) r->token;
        for(;;) {
            PCHRead( &srcfile, sizeof( srcfile ) );
            srcfile = SrcFileMapIndex( srcfile );
            if( srcfile == NULL ) break;
            newSrcFileHandle( r, srcfile );
        }
    }
    CarveInitStart( carveREWRITE_TOKENS, &data );
    for(;;) {
        i = PCHReadCVIndex();
        if( i == CARVE_NULL_INDEX ) break;
        rt = CarveInitElement( &data, i );
        PCHRead( rt, sizeof( *rt ) );
        rt->next = CarveMapIndex( carveREWRITE_TOKENS, rt->next );
    }
    return( PCHCB_OK );
}

pch_status PCHInitRewrites( boolean writing )
{
    cv_index n;

    if( writing ) {
        n = CarveLastValidIndex( carveREWRITE );
        PCHWriteCVIndex( n );
        n = CarveLastValidIndex( carveREWRITE_TOKENS );
        PCHWriteCVIndex( n );
        n = CarveLastValidIndex( carveSRCFILE_HANDLE );
        PCHWriteCVIndex( n );
    } else {
        carveREWRITE = CarveRestart( carveREWRITE );
        n = PCHReadCVIndex();
        CarveMapOptimize( carveREWRITE, n );
        carveREWRITE_TOKENS = CarveRestart( carveREWRITE_TOKENS );
        n = PCHReadCVIndex();
        CarveMapOptimize( carveREWRITE_TOKENS, n );
        carveSRCFILE_HANDLE = CarveRestart( carveSRCFILE_HANDLE );
        n = PCHReadCVIndex();
        CarveMapOptimize( carveSRCFILE_HANDLE, n );
    }
    return( PCHCB_OK );
}

pch_status PCHFiniRewrites( boolean writing )
{
    if( ! writing ) {
        CarveMapUnoptimize( carveREWRITE );
        CarveMapUnoptimize( carveREWRITE_TOKENS );
        CarveMapUnoptimize( carveSRCFILE_HANDLE );
    }
    return( PCHCB_OK );
}