示例#1
0
MACRO_ENTRY *PP_ScanMacroLookup( const char *ptr )
{
    const char  *macro_name;
    MACRO_ENTRY *me;

    while( *ptr == ' ' || *ptr == '\t' )
        ++ptr;
    macro_name = ptr;
    ptr = PP_ScanName( macro_name );
    me = PP_MacroLookup( macro_name, ptr - macro_name );
    PPNextTokenPtr = ptr;
    return( me );
}
示例#2
0
MACRO_ENTRY *PP_ScanMacroLookup( char *ptr )
{
    char        *macro_name;
    MACRO_ENTRY *me;
    char        c;

    while( *ptr == ' '  ||  *ptr == '\t' ) ++ptr;
    macro_name = ptr;
    ptr = PP_ScanName( ptr );
    c = *ptr;
    *ptr = '\0';
    me = PP_MacroLookup( macro_name );
    *ptr = c;
    PPCharPtr = ptr;
    return( me );
}
示例#3
0
void PP_Define( const char *ptr )
{
    MACRO_ENTRY *me;
    const char  *macro_name;
    char        *p;
    const char  *p2;
    size_t      len;
    size_t      len1;
    bool        white_space;
    ppt_token   token;

    macro_name = PP_SkipWhiteSpace( ptr, &white_space );
    ptr = PP_ScanName( macro_name );
    me = PP_AddMacro( macro_name, ptr - macro_name );
    if( me != NULL ) {
        p = NULL;
        me->parmcount = 0;
        len = 0;
        if( *ptr == '(' ) {
            me->parmcount = 1;
            ptr++;
            for( ;; ) {
                ptr = PP_SkipWhiteSpace( ptr, &white_space );
                if( *ptr == '\0' || *ptr == ')' )
                    break;
                macro_name = ptr;
                ptr = PP_ScanName( macro_name );
                len1 = ptr - macro_name;
                p = resize_macro_buf( p, len + len1 );
                memcpy( p + len, macro_name, len1 );
                len += len1;
                me->parmcount++;
                ptr = PP_SkipWhiteSpace( ptr, &white_space );
                if( *ptr != ',' )
                    break;
                ++ptr;
                p = resize_macro_buf( p, len + 1 );
                p[len++] = '\0';                        // mark end of parm
            }
            if( *ptr == ')' ) {
                ++ptr;
                if( me->parmcount != 1 ) {
                    p = resize_macro_buf( p, len + 1 );
                    p[len++] = '\0';                    // mark end of macro parms
                }
            }
        }
        ptr = PP_SkipWhiteSpace( ptr, &white_space );
        for( ; *ptr != '\0' && *ptr != '\n'; ) {
            p2 = PP_ScanToken( ptr, &token );
            len1 = p2 - ptr;
            p = resize_macro_buf( p, len + len1 );
            memcpy( p + len, ptr, len1 );
            len += len1;
            ptr = PP_SkipWhiteSpace( p2, &white_space );
            if( *ptr == '\0' || *ptr == '\n' )
                break;
            if( white_space ) {
                p = resize_macro_buf( p, len + 1 );
                p[len++] = ' ';
            }
        }
        p = resize_macro_buf( p, len + 1 );
        p[len++] = '\0';
        me->replacement_list = PP_Malloc( len );
        memcpy( me->replacement_list, p, len );
    } else {
        PP_OutOfMemory();
    }
}
示例#4
0
const char *PP_ScanToken( const char *p, ppt_token *token )
{
    const char  *p2;
    bool        white_space;
    ppt_token   ctoken;

    if( PPFlags & PPFLAG_SKIP_COMMENT ) {
        *token = PPT_COMMENT;
        for( ; *p != '\0'; ++p ) {
            if( p[0] == '*' && p[1] == '/' ) {
                p += 2;
                PPFlags &= ~PPFLAG_SKIP_COMMENT;
                break;
            }
        }
        return( p );
    }
    switch( *p ) {
    case '(':
        ++p;
        ctoken = PPT_LEFT_PAREN;
        break;
    case ')':
        ++p;
        ctoken = PPT_RIGHT_PAREN;
        break;
    case ',':
        ++p;
        ctoken = PPT_COMMA;
        break;
    case '\'':
    case '\"':
        p = PPScanLiteral( p );
        ctoken = PPT_LITERAL;
        break;
    case '.':
        if( p[1] >= '0' && p[1] <= '9' ) {
            p = PPScanNumber( p );
            ctoken = PPT_NUMBER;
        } else {
            p = PPScanOther( p );
            ctoken = PPT_OTHER;
        }
        break;
    case ' ':
    case '\t':
    case '\r':
    case '\n':
        p = PP_SkipSpace( p, &white_space );
        ctoken = PPT_WHITE_SPACE;
        break;
    case ';':
    case '/':
        p2 = PP_SkipComment( p, &white_space );
        if( white_space ) {
            p = p2;
            ctoken = PPT_COMMENT;
        } else {
            p = PPScanOther( p );
            ctoken = PPT_OTHER;
        }
        break;
    case '#':
        if( PPFlags & PPFLAG_ASM_COMMENT ) {
            p2 = PP_SkipComment( p, &white_space );
            if( white_space ) {
                p = p2;
                ctoken = PPT_COMMENT;
            } else {
                p = PPScanOther( p );
                ctoken = PPT_OTHER;
            }
            break;
        }
        // Fall through!
    default:
        if( p[0] == PreProcChar ) {
            if( p[1] == PreProcChar ) {
                p += 2;
                ctoken = PPT_SHARP_SHARP;
            } else {
                ++p;
                ctoken = PPT_SHARP;
            }
        } else if( p[0] >= '0' && p[0] <= '9' ) {
            if( p[1] == 'x' || p[1] == 'X' ) {
                p = PPScanHexNumber( p );
            } else {
                p = PPScanNumber( p );
            }
            ctoken = PPT_NUMBER;
        } else if( p[0] == 'L' && (p[1] == '\'' || p[1] == '\"') ) {
            p = PPScanLiteral( p + 1 );
            ctoken = PPT_LITERAL;
        } else if( isalpha( p[0] ) || p[0] == '_' ) {
            p = PP_ScanName( p );
            ctoken = PPT_ID;
        } else {
            p = PPScanOther( p );
            ctoken = PPT_OTHER;
        }
        break;
    }
    *token = ctoken;
    return( p );
}
示例#5
0
void PP_Define( char *ptr )
{
    MACRO_ENTRY *me;
    char        *macro_name;
    char        *rep_list;
    char        *p;
    char        *p2;
    size_t      len;
    char        c;
    char        white_space;
    char        token;

    macro_name = PP_SkipWhiteSpace( ptr, &white_space );
    ptr = PP_ScanName( macro_name );
    c = *ptr;
    *ptr = '\0';
    me = PP_AddMacro( macro_name );
    if( me != NULL ) {
        me->parmcount = 0;
        *ptr = c;
        rep_list = ptr;
        p = rep_list;
        if( c == '(' ) {
            me->parmcount = 1;
            ptr++;
            for( ;; ) {
                ptr = PP_SkipWhiteSpace( ptr, &white_space );
                if( *ptr == '\0' ) break;
                if( *ptr == ')'  ) break;
                while( PP_Class( *ptr ) != 0 ) {        // collect name
                    *p++ = *ptr++;
                }
                me->parmcount++;
                ptr = PP_SkipWhiteSpace( ptr, &white_space );
                if( *ptr != ',' ) break;
                *p++ = '\0';            // mark end of parm
                ++ptr;
            }
            if( *ptr == ')' ) {
                ++ptr;
                if( me->parmcount != 1 ) {
                    *p++ = '\0';        // mark end of macro parms
                }
            }
        }
        ptr = PP_SkipWhiteSpace( ptr, &white_space );
        for( ;; ) {
            if( *ptr == '\0' ) break;
            if( *ptr == '\n' ) break;
            p2 = PP_ScanToken( ptr, &token );
            while( ptr != p2 )
                *p++ = *ptr++;
            ptr = PP_SkipWhiteSpace( ptr, &white_space );
            if( *ptr == '\0' ) break;
            if( *ptr == '\n' ) break;
            if( white_space )  *p++ = ' ';
        }
        *p++ = '\0';
        if( *rep_list != '\0' ) {
            len = p - rep_list;
            me->replacement_list = PP_Malloc( len );
            memcpy( me->replacement_list, rep_list, len );
        }
    } else {
        PP_OutOfMemory();
    }
}
示例#6
0
char *PP_ScanToken( char *p, char *token )
{
    char        *p2;
    char        c;
    char        white_space;

    if( PPFlags & PPFLAG_SKIP_COMMENT ) {
        *token = PPT_COMMENT;
        for( ;; ) {
            if( *p == '\0' ) break;
            if( *p == '*'  &&  p[1] == '/' ) {
                p += 2;
                PPFlags &= ~PPFLAG_SKIP_COMMENT;
                break;
            }
            ++p;
        }
        return( p );
    }
    c = *p;
    switch( *p ) {
    case '(':
    case ')':
    case ',':
        p2 = p + 1;
        break;
    case '\'':
    case '\"':
        p2 = PPScanLiteral( p );
        c = PPT_LITERAL;
        break;
    case '.':
        if( p[1] >= '0'  &&  p[1] <= '9' ) {
            p2 = PPScanNumber( p );
            c = PPT_NUMBER;
        } else {
            p2 = PPScanOther( p );
            c = PPT_OTHER;
        }
        break;
    case ' ':
    case '\t':
    case '\r':
    case '\n':
        p2 = PP_SkipSpace( p, &white_space );
        c = PPT_WHITE_SPACE;
        break;
    case ';':
    case '/':
        p2 = PP_SkipComment( p, &white_space );
        if( white_space ) {
            c = PPT_COMMENT;
        } else {
            p2 = PPScanOther( p );
            c = PPT_OTHER;
        }
        break;
    case '#':
        if( PPFlags & PPFLAG_ASM_COMMENT ) {
            p2 = PP_SkipComment( p, &white_space );
            if( white_space ) {
                c = PPT_COMMENT;
            } else {
                p2 = PPScanOther( p );
                c = PPT_OTHER;
            }
            break;
        }
        // Fall through!
    default:
        if( c == PreProcChar ) {
            if( p[1] == PreProcChar ) {
                p2 = p + 2;
                c = PPT_SHARP_SHARP;
            } else {
                p2 = p + 1;
                c = PPT_SHARP;
            }
        } else if( c >= '0'  &&  c <= '9' ) {
            if( p[1] == 'x'  ||  p[1] == 'X' ) {
                p2 = PPScanHexNumber( p );
            } else {
                p2 = PPScanNumber( p );
            }
            c = PPT_NUMBER;
        } else if( c == 'L' && (p[1] == '\'' || p[1] == '\"') ) {
            p2 = PPScanLiteral( p + 1 );
            c = PPT_LITERAL;
        } else if( isalpha( c ) || c == '_' ) {
            p2 = PP_ScanName( p );
            c = PPT_ID;
        } else {
            p2 = PPScanOther( p );
            c = PPT_OTHER;
        }
        break;
    }
    *token = c;
    return( p2 );
}