scanner.java

来自「数据仓库展示程序」· Java 代码 · 共 540 行 · 第 1/2 页

                // 1e2, 1E2, 1e-2, 1e+2.  Invalid examples include e2, 1.2.3,
                // 1e2e3, 1e2.3.
                //
                // Signs preceding numbers (e.g. -1, +1E-5) are valid, but are
                // handled by the parser.
                final int leftOfPoint = 0;
                final int rightOfPoint = 1;
                final int inExponent = 2;
                int n = 0, nDigits = 0, nSign = 0, exponent = 0;
                double mantissa = 0.0;
                int state = leftOfPoint;

                for (;;) {
                    if (nextChar == '.') {
                        if (state == leftOfPoint) {
                            state = rightOfPoint;
                            mantissa = n;
                            n = nDigits = 0;
                            nSign = 1;
                            advance();
                        } else {
                            // Error: we are seeing a point in the exponent
                            // (e.g. 1E2.3 or 1.2E3.4) or a second point in the
                            // mantissa (e.g. 1.2.3).  Return what we've got
                            // and let the parser raise the error.
                            if (state == rightOfPoint) {
                                mantissa += (n * java.lang.Math.pow(
                                    10, -nDigits));
                            } else {
                                exponent = n * nSign;
                            }
                            return makeNumber(mantissa, exponent);
                        }

                    } else if (nextChar == 'E' || nextChar == 'e') {
                        if (state == inExponent) {
                            // Error: we are seeing an 'e' in the exponent
                            // (e.g. 1.2e3e4).  Return what we've got and let
                            // the parser raise the error.
                            exponent = n * nSign;
                            return makeNumber(mantissa, exponent);

                        } else {
                            if (state == leftOfPoint) {
                                mantissa = n;
                            } else {
                                mantissa += (n * java.lang.Math.pow(
                                    10, -nDigits));
                            }
                            n = nDigits = 0;
                            nSign = 1;
                            advance();
                            state = inExponent;
                        }

                    } else if ((nextChar == '+' || nextChar == '-') &&
                               state == inExponent &&
                               nDigits == 0) {
                        // We're looking at the sign after the 'e'.
                        nSign = -nSign;
                        advance();

                    } else if (nextChar >= '0' && nextChar <= '9') {
                        n = n * 10 + (nextChar - '0');
                        nDigits++;
                        advance();

                    } else {
                        // Reached end of number.
                        if (state == leftOfPoint) {
                            mantissa = n;
                        } else if (state == rightOfPoint) {
                            mantissa += (n * java.lang.Math.pow(10, -nDigits));
                        } else {
                            exponent = n * nSign;
                        }
                        return makeNumber(mantissa, exponent);
                    }
                }

            case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
            case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
            case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
            case 's': case 't': case 'u': case 'v': case 'w': case 'x':
            case 'y': case 'z':
            case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
            case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
            case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
            case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
            case 'Y': case 'Z':
                /* parse an identifier */
                id = new StringBuffer();
                for (;;) {
                    id.append((char)nextChar);
                    advance();
                    switch (nextChar) {
                    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                    case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
                    case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
                    case 's': case 't': case 'u': case 'v': case 'w': case 'x':
                    case 'y': case 'z':
                    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                    case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
                    case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
                    case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
                    case 'Y': case 'Z':
                    case '0': case '1': case '2': case '3': case '4':
                    case '5': case '6': case '7': case '8': case '9':
                    case '_':
                        break;
                    default:
                        String strId = id.toString();
                        Integer i = (Integer) m_resWordsTable.get(
                            strId.toUpperCase());
                        if (i == null) {
                            // identifier
                            return makeId(strId, false, false);
                        } else {
                            // reserved word
                            return makeRes(i.intValue());
                        }
                    }
                }

            case '&':
                advance();
                if (nextChar == '[') {
                    ampersandId = true;
                    // fall through
                } else {
                    return makeToken(ParserSym.UNKNOWN, "&");
                }

            case '[':
                /* parse a delimited identifier */
                id = new StringBuffer();
                for (;;) {
                    advance();
                    switch (nextChar) {
                    case ']':
                        advance();
                        if (nextChar == ']') {
                            // ] escaped with ] - just take one
                            id.append(']');
                            break;
                        } else {
                            // end of identifier
                            if (ampersandId) {
                                ampersandId = false;
                                return makeId(id.toString(), true, true);
                            } else {
                                return makeId(id.toString(), true, false);
                            }
                        }
                    case -1:
                        if (ampersandId) {
                            ampersandId = false;
                            return makeId(id.toString(), true, true);
                        } else {
                            return makeId(id.toString(), true, false);
                        }
                    default:
                        id.append((char)nextChar);
                    }
                }

            case ':': advance(); return makeToken(ParserSym.COLON, ":");
            case ',': advance(); return makeToken(ParserSym.COMMA, ",");
            case '=': advance(); return makeToken(ParserSym.EQ, "=");
            case '<':
                advance();
                switch (nextChar) {
                case '>': advance(); return makeToken(ParserSym.NE, "<>");
                case '=': advance(); return makeToken(ParserSym.LE, "<=");
                default: return makeToken(ParserSym.LT, "<");
                }
            case '>':
                advance();
                switch (nextChar) {
                case '=': advance(); return makeToken(ParserSym.GE, ">=");
                default: return makeToken(ParserSym.GT, ">");
                }
            case '{': advance(); return makeToken(ParserSym.LBRACE, "{");
            case '(': advance(); return makeToken(ParserSym.LPAREN, "(");
            case '}': advance(); return makeToken(ParserSym.RBRACE, "}");
            case ')': advance(); return makeToken(ParserSym.RPAREN, ")");
            case '+': advance(); return makeToken(ParserSym.PLUS, "+");
            case '-': advance(); return makeToken(ParserSym.MINUS, "-");
            case '*': advance(); return makeToken(ParserSym.ASTERISK, "*");
            case '/': advance(); return makeToken(ParserSym.SOLIDUS, "/");
            case '|':
                advance();
                switch (nextChar) {
                case '|': advance(); return makeToken(ParserSym.CONCAT, "||");
                default: return makeToken(ParserSym.UNKNOWN, "|");
                }

            case '"':
                /* parse a double-quoted string */
                id = new StringBuffer();
                for (;;) {
                    advance();
                    switch (nextChar) {
                    case '"':
                        advance();
                        if (nextChar == '"') {
                            // " escaped with "
                            id.append('"');
                            break;
                        } else {
                            // end of string
                            return makeString(id.toString());
                        }
                    case -1:
                        return makeString(id.toString());
                    default:
                        id.append((char)nextChar);
                    }
                }

            case '\'':
                if (inFormula) {
                    inFormula = false;
                    advance();
                    return makeToken(ParserSym.QUOTE, "'");
                } else if (previousSymbol == ParserSym.AS) {
                    inFormula = true;
                    advance();
                    return makeToken(ParserSym.QUOTE, "'");
                }

                /* parse a single-quoted string */
                id = new StringBuffer();
                for (;;) {
                    advance();
                    switch (nextChar) {
                    case '\'':
                        advance();
                        if (nextChar == '\'') {
                            // " escaped with "
                            id.append('\'');
                            break;
                        } else {
                            // end of string
                            return makeString(id.toString());
                        }
                    case -1:
                        return makeString(id.toString());
                    default:
                        id.append((char)nextChar);
                    }
                }

            case -1:
                // we're done
                return makeToken(ParserSym.EOF, "EOF");
            default:
                /* ignore everything else */
                iPrevChar = iChar;
                advance();
                break;
            }
        }
    }
}



// End Scanner.java