rewrite.c

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

static void captureMulti( REWRITE *r, PTREE multi, TOKEN_LOCN *locn )
{
    int save_CurToken;
    char *save_SavedId;
    REWRITE *save_rewrite;
    TOKEN_LOCN *save_locn;

    if( multi == NULL ) {
        return;
    }
    save_CurToken = CurToken;
    save_SavedId = SavedId;
    save_rewrite = currRewrite;
    save_locn = currLocn;
    currLocn = locn;
    currRewrite = r;
    multi = PTreeTraversePostfix( multi, recoverToken );
    PTreeFreeSubtrees( multi );
    currRewrite = save_rewrite;
    CurToken = save_CurToken;
    currLocn = save_locn;
    SavedId = save_SavedId;
    NextToken();
}

REWRITE *RewritePackageFunction( PTREE multi )
/********************************************/
{
    ppstate_t save_pp;
    boolean skip_first;
    REWRITE *r;
    unsigned depth;
    unsigned asm_depth;
    TOKEN_LOCN locn;
    TOKEN_LOCN *plocn;

    skip_first = FALSE;
    r = ParseGetRecordingInProgress( &plocn );
    if( r == NULL ) {
        plocn = &locn;
        r = newREWRITE( T_RIGHT_BRACE, &locn );
    } else {
        skip_first = TRUE;
    }
    captureMulti( r, multi, plocn );
    save_pp = PPState;
    asm_depth = 0;
    depth = 1;          /* we've seen one '{' */
    for(;;) {
        if( CurToken == T_EOF )
            break;
        DbgAssert( depth != 0 );
        switch( CurToken ) {
        case T_NULL:
#ifndef NDEBUG
            DbgAssert( asm_depth != 0 );
#endif
            PPState = save_pp;
            if( depth == asm_depth ) {
                asm_depth = 0;
                PPStateAsm = FALSE;
            }
            break;
        case T___ASM:
            if( asm_depth == 0 ) {
                PPState = PPS_EOL;
                asm_depth = depth;
                PPStateAsm = TRUE;
            }
            break;
        case T_SEMI_COLON:
            break;
        case T_LEFT_BRACE:
        case T_ALT_LEFT_BRACE:
            ++depth;
            break;
        case T_RIGHT_BRACE:
        case T_ALT_RIGHT_BRACE:
            --depth;
            if( depth == asm_depth ) {
                PPState = save_pp;
                asm_depth = 0;
                PPStateAsm = FALSE;
            }
            break;
        }
        if( ! skip_first ) {
            saveToken( r, plocn );
        }
        skip_first = FALSE;
        if( depth == 0 )
            break;
        NextToken();
        if( PPStateAsm ) {
            PPState = PPS_EOL;
        }
    }
    PPState = save_pp;
    return( r );
}

static REWRITE *memInitError( REWRITE *r, TOKEN_LOCN *locn )
{
    CErr1( ERR_MEM_INIT_REWRITE_ERROR );
    CErr2p( INF_CTOR_INIT_STARTED_HERE, locn );
    RewriteFree( r );
    return( NULL );
}

REWRITE *RewritePackageMemInit( PTREE multi )
/*******************************************/
{
    REWRITE *r;
    unsigned paren_depth;
    unsigned brace_depth;
    TOKEN_LOCN locn;
    auto TOKEN_LOCN start_locn;

    SrcFileGetTokenLocn( &start_locn );
    r = newREWRITE( T_RIGHT_BRACE, &locn );
    captureMulti( r, multi, &locn );
    brace_depth = 0;
    paren_depth = 0;
    for(;;) {
        if( CurToken == T_EOF ) {
            memInitError( r, &start_locn );
            break;
        }
        saveToken( r, &locn );
        switch( CurToken ) {
        case T_LEFT_PAREN:
            ++paren_depth;
            break;
        case T_RIGHT_PAREN:
            if( paren_depth == 0 ) {
                return( memInitError( r, &start_locn ) );
            }
            --paren_depth;
            break;
        case T_RIGHT_BRACE:
        case T_ALT_RIGHT_BRACE:
            if( brace_depth == 0 ) {
                return( memInitError( r, &start_locn ) );
            }
            --brace_depth;
            break;
        case T_LEFT_BRACE:
        case T_ALT_LEFT_BRACE:
            if( paren_depth == 0 ) {
                return( r );
            }
            ++brace_depth;
            break;
        }
        NextToken();
    }
    return( NULL );
}

static REWRITE *defArgError( REWRITE *r, TOKEN_LOCN *locn )
{
    CErr1( ERR_DEF_ARG_REWRITE_ERROR );
    CErr2p( INF_DEF_ARG_STARTED_HERE, locn );
    RewriteFree( r );
    return( NULL );
}

REWRITE *RewritePackageDefArg( PTREE multi )
/******************************************/
{
    REWRITE *r;
    unsigned paren_depth;
    unsigned brace_depth;
    TOKEN_LOCN locn;
    auto TOKEN_LOCN start_locn;

    DbgAssert( CurToken == T_EQUAL );
    NextToken();
    SrcFileGetTokenLocn( &start_locn );
    r = newREWRITE( T_DEFARG_END, &locn );
    captureMulti( r, multi, &locn );
    brace_depth = 0;
    paren_depth = 0;
    for(;;) {
        if( CurToken == T_EOF ) {
            defArgError( r, &start_locn );
            break;
        }
        switch( CurToken ) {
        case T_LEFT_PAREN:
            ++paren_depth;
            break;
        case T_RIGHT_BRACE:
        case T_ALT_RIGHT_BRACE:
            if( brace_depth == 0 ) {
                return( defArgError( r, &start_locn ) );
            }
            --brace_depth;
            break;
        case T_LEFT_BRACE:
        case T_ALT_LEFT_BRACE:
            if( paren_depth == 0 ) {
                return( defArgError( r, &start_locn ) );
            }
            ++brace_depth;
            break;
        case T_RIGHT_PAREN :
            if( paren_depth == 0 ) {
                if( brace_depth != 0 ) {
                    return( defArgError( r, &start_locn ) );
                }
                UndoNextToken();
                return( r );
            }
            --paren_depth;
            break;
        case T_COMMA :
        case T_DOT_DOT_DOT:
            if( brace_depth == 0 && paren_depth == 0 ) {
                UndoNextToken();
                return( r );
            }
            break;
        }
        saveToken( r, &locn );
        NextToken();
    }
    return( NULL );
}

REWRITE *RewritePackageTemplateArgument( void )
/******************************************/
{
    REWRITE *r;
    unsigned angle_depth;
    unsigned brace_depth;
    unsigned bracket_depth;
    unsigned paren_depth;
    TOKEN_LOCN locn;
    auto TOKEN_LOCN start_locn;

    SrcFileGetTokenLocn( &start_locn );
    r = newREWRITE( T_DEFARG_END, &locn );
    angle_depth = brace_depth = bracket_depth = paren_depth = 0;
    for(;;) {
        if( CurToken == T_EOF ) {
            defArgError( r, &start_locn );
            break;
        }
        switch( CurToken ) {
        case T_LEFT_BRACE:
        case T_ALT_LEFT_BRACE:
            ++brace_depth;
            break;
        case T_LEFT_BRACKET:
        case T_ALT_LEFT_BRACKET:
            ++bracket_depth;
            break;
        case T_LEFT_PAREN:
            ++paren_depth;
            break;
        case T_RIGHT_BRACE:
        case T_ALT_RIGHT_BRACE:
            if( brace_depth == 0 ) {
                return( defArgError( r, &start_locn ) );
            }
            --brace_depth;
            break;
        case T_RIGHT_BRACKET:
        case T_ALT_RIGHT_BRACKET:
            if( bracket_depth == 0 ) {
                return( defArgError( r, &start_locn ) );
            }
            --bracket_depth;
            break;
        case T_RIGHT_PAREN:
            if( paren_depth == 0 ) {
                return( defArgError( r, &start_locn ) );
            }
            --paren_depth;
            break;
        case T_LT:
            /* for non-type template arguments this should always be
             * parsed as less-than */
            if( ( brace_depth == 0 ) && ( bracket_depth == 0 )
             && ( paren_depth == 0 ) ) {
                ++angle_depth;
            }
            break;
        case T_COMMA:
        case T_GT:
            if( ( brace_depth == 0 ) && ( bracket_depth == 0 )
             && ( paren_depth == 0 ) ) {
                if( angle_depth == 0 ) {
                    return( r );
                }
                else if( CurToken == T_GT ) {
                    --angle_depth;
                }
            }
            break;
        case T_RSHIFT:
            // see Right Angle Brackets (N1757/05-0017)
            if( CompFlags.enable_std0x
             && ( brace_depth == 0 ) && ( bracket_depth == 0 )
             && ( paren_depth == 0 ) ) {
                if( angle_depth == 1 ) {
                    CurToken = T_GT;
                    saveToken( r, &locn );
                    return( r );
                } else if( angle_depth == 0 ) {
                    return( r );
                } else {
                    angle_depth -= 2;
                }
            }
            break;
        }
        saveToken( r, &locn );
        NextToken();
    }
    return( NULL );
}

REWRITE *RewritePackageTemplateDefArg( void )
/******************************************/
{
    REWRITE *r;

    if( CurToken != T_EQUAL ) {
        return( NULL );
    }
    NextToken();
    r = RewritePackageTemplateArgument();
    UndoNextToken();
    return( r );
}

static REWRITE *templateError( REWRITE *r, TOKEN_LOCN *locn )
{
    CErr1( ERR_CLASS_TEMPLATE_REWRITE_ERROR );
    CErr2p( INF_CLASS_TEMPLATE_STARTED_HERE, locn );
    RewriteFree( r );
    return( NULL );
}

REWRITE *RewritePackageClassTemplate( REWRITE *r, TOKEN_LOCN *locn )
/******************************************************************/
{
    unsigned brace_depth;
    boolean first_time;
    auto TOKEN_LOCN start_locn;

    SrcFileGetTokenLocn( &start_locn );
    brace_depth = 0;
    first_time = TRUE;
    for(;;) {
        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 ) {
                    Expecting( Tokens[ T_SEMI_COLON ] );
                    return( templateError( r, &start_locn ) );
                }
                return( r );
            }
            break;
        case T_LEFT_BRACE:
        case T_ALT_LEFT_BRACE:
            ++brace_depth;
            break;
        }
        NextToken();
    }
    return( NULL );
}

REWRITE *RewritePackageClassTemplateMember( REWRITE *r, TOKEN_LOCN *locn )
/************************************************************************/
{
    unsigned brace_depth;
    boolean first_time;
    auto TOKEN_LOCN start_locn;

    SrcFileGetTokenLocn( &start_locn );
    brace_depth = 0;
    first_time = TRUE;
    for(;;) {