cscan.c

Open Watcom 的 C 编译器源代码

            if( Constant <= 0x7FFFFFFFul ) {     /* 13-sep-89 */
                ConstType = TYPE_LONG;
            }else{
                ConstType = TYPE_ULONG;
            }
            break;
        case SUFF_U:
            ConstType = TYPE_UINT;
#if TARGET_INT < TARGET_LONG
            if( Constant > TARGET_UINT_MAX ) {
                ConstType = TYPE_ULONG;
            }
#endif
            break;
        case SUFF_UL:
            ConstType = TYPE_ULONG;
            break;
        default:
            break;
        }
    }else{
        switch( con.suffix ){
        case SUFF_NONE:
            ConstType = TYPE_LONG64;
            if( Const64.u._32[I64HI32] & 0x80000000 ){
                ConstType = TYPE_ULONG64;
            }
            break;
        case SUFF_L:
        case SUFF_LL:
            if( ov == CNV_32 ) {
                U32ToU64( Constant, &Const64 );
            }
            if( Const64.u._32[I64HI32] & 0x80000000 ){
                ConstType = TYPE_ULONG64;
            }else{
                ConstType = TYPE_LONG64;
            }
            break;
        case SUFF_U:
        case SUFF_UL:
        case SUFF_ULL:
            if( ov == CNV_32 ) {
                U32ToU64( Constant, &Const64 );
            }
            ConstType = TYPE_ULONG64;
            break;
        default:
            break;
        }
    }
    if( CompFlags.pre_processing && (CharSet[c] & (C_AL | C_DI)) ) {
        for(;;) {
            c = SaveNextChar();
            if( (CharSet[c] & (C_AL | C_DI)) == 0 ) break;
        }
        --TokenLen;
        Buffer[TokenLen] = '\0';
        BadTokenInfo = bad_token_type;
        return( T_BAD_TOKEN );
    } else {
        if( ov == CNV_OVR ) {
            BadTokenInfo = ERR_CONSTANT_TOO_BIG;
            if( NestLevel == SkipLevel ) {      /* 10-sep-92 */
                CWarn1( WARN_CONSTANT_TOO_BIG, ERR_CONSTANT_TOO_BIG );
            }
        }
        --TokenLen;
        Buffer[TokenLen] = '\0';
        return( T_CONSTANT );
    }
}

int ScanQuestionMark()
{
    NextChar();
    Buffer[0] = '?';
    Buffer[1] = '\0';
    return( T_QUESTION );
}

int ScanSlash()
{
    int         c;
    int         tok;

    c = NextChar();         // can't inline this copy of NextChar
    if( c == '=' ) {         /* if second char is an = */
        NextChar();
        Buffer[0] = '/';
        Buffer[1] = '=';
        Buffer[2] = '\0';
        tok = T_DIVIDE_EQUAL;
    } else if( c == '/' &&   /* if C++ // style comment */
                ! CompFlags.strict_ANSI ) {     /* 13-nov-94 */
        CppComment( '/' );
        CompFlags.scanning_cpp_comment = 1;
        for(;;) {
            c = CurrChar;
            NextChar();
            if( CurrChar == EOF_CHAR ) break;   /* 06-mar-91 AFS */
            if( CurrChar == '\0' ) break;   /* 06-mar-91 AFS */
            /* swallow up the next line if this one ends with \ */
            /* some editors don't put linefeeds on end of lines */
            if( CurrChar == '\n'  ||  c == '\r' )break;
            if( CompFlags.cpp_output && CompFlags.keep_comments ) {
                if( CurrChar != '\r' ) PrtChar( CurrChar );
            }
        }
        CppComment( 0 );
        CompFlags.scanning_cpp_comment = 0;
        Buffer[0] = ' ';
        Buffer[1] = '\0';
        tok = T_WHITE_SPACE;
    } else if( c == '*' ) {
        ScanComment();
        Buffer[0] = ' ';
        Buffer[1] = '\0';
        tok = T_WHITE_SPACE;
    } else {
        Buffer[0] = '/';
        Buffer[1] = '\0';
        tok = T_DIVIDE;
    }
    return( tok );
}

int ScanDelim1()
{
    int         token;
    int         c;

    Buffer[0] = CurrChar;
    Buffer[1] = '\0';
    token = TokValue[ CurrChar - ' ' ];
    c = *ScanCharPtr++;
    if( CharSet[c] & C_EX ) {
        c = GetCharCheck( c );
    }
    CurrChar = c;
    return( token );
}

int ScanMinus()
{
    int         chr2;
    int         tok;

    Buffer[0] = '-';
    chr2 = NextChar();          // can't inline this copy of NextChar
    Buffer[1] = chr2;
    if( chr2 == '>' ) {
        tok = T_ARROW;
        Buffer[2] = '\0';
        NextChar();
    } else if( chr2 == '=' ) {
        tok = T_MINUS_EQUAL;
        Buffer[2] = '\0';
        NextChar();
    } else if( chr2 == '-' ) {
        tok = T_MINUS_MINUS;
        Buffer[2] = '\0';
        NextChar();
    } else {
        Buffer[1] = '\0';
        tok = T_MINUS;
    }
    return( tok );
}

int ScanEqual()
{
    Buffer[0] = '=';
    if( NextChar() == '=' ) {
        NextChar();
        Buffer[1] = '=';
        Buffer[2] = '\0';
        return( T_EQ );
    } else {
        Buffer[1] = '\0';
        return( T_EQUAL );
    }
}

int ScanStar()
{
    Buffer[0] = '*';
    if( NextChar() == '=' ) {
        NextChar();
        Buffer[1] = '=';
        Buffer[2] = '\0';
        return( T_TIMES_EQUAL );
    } else {
        Buffer[1] = '\0';
        return( T_TIMES );
    }
}

int ScanColon()
{
    int         chr2;

    Buffer[0] = ':';
    chr2 = NextChar();
    if( chr2 == '>' ) {
        NextChar();
        Buffer[1] = '>';
        Buffer[2] = '\0';
        return( T_SEG_OP );
#if _CPU == 370
    } else if( chr2 == ')' ) {
        NextChar();
        Buffer[1] = ')';
        Buffer[2] = '\0';
        return( T_RIGHT_BRACKET );
#endif
    } else {
        Buffer[1] = '\0';
        return( T_COLON );
    }
}

int ScanDelim2()
{
    int         c;
    int         chr2;
    int         tok;
    unsigned char chrclass;

    c = CurrChar;
    Buffer[0] = c;
    Buffer[1] = '\0';
    chrclass = TokValue[ c - ' ' ];
    tok = chrclass & C_MASK;
    chr2 = NextChar();          // can't inline this copy of NextChar
    if( chr2 == '=' ) {         /* if second char is an = */
        if( chrclass & EQ ) {   /* and = is valid second char */
            ++tok;
            NextChar();
            Buffer[1] = '=';
            Buffer[2] = '\0';
        }
    } else if( chr2 == c ) {    /* if second char is same as first */
        if( chrclass & DUP ) {  /* and duplicate is valid */
            tok += 2;
            Buffer[1] = c;
            Buffer[2] = '\0';
            if( NextChar() == '=' ) {
                if( tok == T_LSHIFT  ||  tok == T_RSHIFT ) {
                    ++tok;
                    NextChar();
                    Buffer[2] = '=';
                    Buffer[3] = '\0';
                }
            }
        }
#if _CPU == 370
    } else if( c == '('  &&  chr2 == ':' ) {
        tok = T_LEFT_BRACKET;
        NextChar();
        Buffer[1] = ':';
        Buffer[2] = '\0';
#endif
    }
    return( tok );
}

static void ScanComment( void )
{
    int         c;
    int         prev_char;
    unsigned    start_line;
    char        *scanptr;

    CompFlags.scanning_comment = 1;
    if( CompFlags.cpp_output ) {        // 30-dec-93
        CppComment( '*' );
        c = NextChar();
        for( ;; ) {
            if( c == '*' ){
                c = NextChar();
                if( c == '/' )break;
                if( CompFlags.keep_comments ) {
                    PrtChar( '*' );
                }
                continue; //could be **/
            }
            if( c == EOF_CHAR ) {
                CppComment( 0 );
                return;
            }
            if( c == '\n' ) {
                PrtChar( c );
            } else if( c != '\r' && CompFlags.keep_comments ) {
                PrtChar( c );
            }
            c = NextChar();
        }
        CppComment( 0 );
    } else {
        start_line = TokenLine;
        // make '/' a special character so that we only have to do one test
        // for each character inside the main loop
        CharSet['/'] |= C_EX;           // make '/' special character
        c = '\0';
        for(;;) {
            scanptr = ScanCharPtr;
            for(;;) {
                prev_char = c;
                c = *scanptr++;
                if( CharSet[c] & C_EX ) break;
                prev_char = c;
                c = *scanptr++;
                if( CharSet[c] & C_EX ) break;
                prev_char = c;
                c = *scanptr++;
                if( CharSet[c] & C_EX ) break;
                prev_char = c;
                c = *scanptr++;
                if( CharSet[c] & C_EX ) break;
                prev_char = c;
                c = *scanptr++;
                if( CharSet[c] & C_EX ) break;
                prev_char = c;
                c = *scanptr++;
                if( CharSet[c] & C_EX ) break;
                prev_char = c;
                c = *scanptr++;
                if( CharSet[c] & C_EX ) break;
                prev_char = c;
                c = *scanptr++;
                if( CharSet[c] & C_EX ) break;
            }
            ScanCharPtr = scanptr;
            if( c != '/' ) {
                c = GetCharCheck( c );
                if( c == EOF_CHAR )  return;
            }
            if( c == '/' ) {
                if( prev_char == '*' )  break;
                // get next character and see if it is '*' for nested comment
                c = NextChar();
                if( c == '*' ) {
                    c = NextChar();
                    if( c == '/' ) break;       /* 19-oct-94 */
                    TokenLine = SrcFileLineNum;
                    CWarn2( WARN_NESTED_COMMENT,
                            ERR_NESTED_COMMENT, start_line );
                }
            }
            // NextChar might not be pointing to GetNextChar at this point
            while( NextChar != GetNextChar ) {
                c = NextChar();
                if( c == EOF_CHAR )  return;
            }
        }
        CharSet['/'] &= ~C_EX;          // undo '/' special character
    }
    CompFlags.scanning_comment = 0;
    NextChar();
}

static int CharConst( int char_type )
{
    int         c;
    int         i;
    int         n;
    int         token;
    long        value;
    char        error;

    c = SaveNextChar();
    if( c == '\'' ) {                           /* 05-jan-95 */
        NextChar();
        Buffer[TokenLen] = '\0';
        BadTokenInfo = ERR_INV_CHAR_CONSTANT;
        return( T_BAD_TOKEN );
    }
    BadTokenInfo = 0;
    token = T_CONSTANT;
    i = 0;
    value = 0;
    error = 0;
    for( ;; ) {
        if( c == '\r'  ||  c == '\n' ) {
            token = T_BAD_TOKEN;
            break;
        }
        if( c == '\\' ) {
            c = SaveNextChar();
            if( c >= '0'  &&  c <= '7' ) {              /* 09-jan-94 */
                n = c - '0';
                c = SaveNextChar();
                if( c >= '0'  &&  c <= '7' ) {
                    n = n * 8 + c - '0';
                    c = SaveNextChar();
                    if( c >= '0'  &&  c <= '7' ) {
                        n = n * 8 + c - '0';
                        SaveNextChar();
                        if( n > 0377  &&  char_type != TYPE_WCHAR ) {
                            BadTokenInfo = ERR_CONSTANT_TOO_BIG;
                            if( NestLevel == SkipLevel ) {
                                CWarn1( WARN_CONSTANT_TOO_BIG,
                                        ERR_CONSTANT_TOO_BIG );
                            }
                            n &= 0377;          // mask off high bits
                        }
                    }
                }
                c = n;
            } else {
                c = ESCChar( c, NULL, &error );
            }
            if( char_type == TYPE_WCHAR ) {     /* 02-aug-91 */
                ++i;
                value = (value << 8) + ((c & 0xFF00) >> 8);
                c &= 0x00FF;
            }
        } else {
            if( CharSet[c] & C_DB ) {   /* if double-byte char */
                c = (c << 8) + (SaveNextChar() & 0x00FF);
                if( char_type == TYPE_WCHAR ) { /* 15-jun-93 */
                    if( CompFlags.jis_to_unicode ) {
                        c = JIS2Unicode( c );
                    }
                }
                ++i;
                value = (value << 8) + ((c & 0xFF00) >> 8);
                c &= 0x00FF;
            } else if( char_type == TYPE_WCHAR ) {/* 02-aug-91 */
                if( CompFlags.use_unicode ) {
                    c = UniCode[ c ];
                } else if( CompFlags.jis_to_unicode ) {
                    c = JIS2Unicode( c );
                }
                ++i;
                value = (value << 8) + ((c & 0xFF00) >> 8);
                c &= 0x00FF;
            } else {
                _ASCIIOUT( c );
            }
            SaveNextChar();
        }
        ++i;
        value = (value << 8) + c;
        /* handle case where user wants a \ but doesn't escape it */
        if( c == '\'' && CurrChar != '\'' ) {
            if( ! CompFlags.cpp_output ) {      /* 08-feb-93 */
                token = T_BAD_TOKEN;
                break;
            }
        }
        c = CurrChar;
        if( c == '\'' ) break;
        if( i >= 4 ) {
            if( ! CompFlags.cpp_output ) {      /* 08-feb-93 */
                token = T_BAD_TOKEN;
                break;
            }
        }
    }