parser.java

GJC（Generic Java Compiler）编译器

        default:
            return illegal();

        }
        while (true) {
            int pos1 = S.pos;
            if (S.token == LBRACKET) {
                S.nextToken();
                if (S.token == RBRACKET && (mode & TYPE) != 0) {
                    mode = TYPE;
                    S.nextToken();
                    return bracketsOpt(F.at(pos1).TypeArray(t));
                } else {
                    if ((mode & EXPR) != 0) {
                        mode = EXPR;
                        Tree t1 = term();
                        t = F.at(pos1).Indexed(t, t1);
                    }
                    accept(RBRACKET);
                }
            } else if (S.token == DOT) {
                S.nextToken();
                if (S.token == SUPER && (mode & EXPR) != 0) {
                    mode = EXPR;
                    t = F.at(pos).Select(t, names._super);
                    S.nextToken();
                    t = arguments(t);
                } else if (S.token == NEW && (mode & EXPR) != 0) {
                    mode = EXPR;
                    int pos2 = S.pos;
                    S.nextToken();
                    t = innerCreator(pos2, t);
                } else {
                    t = argumentsOpt(F.at(pos).Select(t, ident()));
                }
            } else {
                break;
            }
        }
        while ((S.token == PLUSPLUS || S.token == SUBSUB) && (mode & EXPR) != 0) {
            mode = EXPR;
            t = F.at(S.pos).Unary(S.token == PLUSPLUS ? Tree.POSTINC :
                    Tree.POSTDEC, t);
            S.nextToken();
        }
        if (genEndPos)
            endPositions.put(t, new Integer(S.prevEndPos));
        return t;
    }

    /**
      * SuperSuffix = Arguments | "." Ident [Arguments]
      */
    Tree superSuffix(Tree t) {
        S.nextToken();
        if (S.token == LPAREN) {
            t = arguments(t);
        } else {
            int pos = S.pos;
            accept(DOT);
            t = argumentsOpt(F.at(pos).Select(t, ident()));
        }
        return t;
    }

    /**
      * BasicType = BYTE | SHORT | CHAR | INT | LONG | FLOAT | DOUBLE | BOOLEAN
      */
    Tree basicType() {
        Tree t = F.at(S.pos).TypeIdent(typetag(S.token));
        S.nextToken();
        return t;
    }

    /**
      * ArgumentsOpt = [ Arguments ]
      */
    Tree argumentsOpt(Tree t) {
        if ((mode & EXPR) != 0 && S.token == LPAREN) {
            mode = EXPR;
            return arguments(t);
        } else {
            return t;
        }
    }

    /**
      * Arguments = "(" [Expression { COMMA Expression }] ")"
      */
    List arguments() {
        int pos = S.pos;
        ListBuffer args = new ListBuffer();
        if (S.token == LPAREN) {
            S.nextToken();
            if (S.token != RPAREN) {
                args.append(expression());
                while (S.token == COMMA) {
                    S.nextToken();
                    args.append(expression());
                }
            }
            accept(RPAREN);
        } else {
            syntaxError(S.pos, "expected", keywords.token2string(LPAREN));
        }
        return args.toList();
    }

    Tree arguments(Tree t) {
        int pos = S.pos;
        List args = arguments();
        return F.at(pos).Apply(t, args);
    }

    /**
      * BracketsOpt = {"[" "]"}
      */
    private Tree bracketsOpt(Tree t) {
        while (S.token == LBRACKET) {
            int pos = S.pos;
            S.nextToken();
            accept(RBRACKET);
            t = F.at(pos).TypeArray(t);
        }
        return t;
    }

    /**
      * BracketsSuffixExpr = "." CLASS
      *  BracketsSuffixType =
      */
    Tree bracketsSuffix(Tree t) {
        if ((mode & EXPR) != 0 && S.token == DOT) {
            mode = EXPR;
            int pos = S.pos;
            S.nextToken();
            accept(CLASS);
            t = F.at(pos).Select(t, names._class);
        } else if ((mode & TYPE) != 0) {
            mode = TYPE;
        } else {
            syntaxError(S.pos, "dot.class.expected");
        }
        return t;
    }

    /**
      * Creator = Qualident [TypeArguments] ( ArrayCreatorRest | ClassCreatorRest )
      */
    Tree creator(int newpos) {
        switch (S.token) {
        case BYTE:

        case SHORT:

        case CHAR:

        case INT:

        case LONG:

        case FLOAT:

        case DOUBLE:

        case BOOLEAN:
            return arrayCreatorRest(newpos, basicType());

        default:
            Tree t = qualident();
            if (S.token == LBRACKET)
                return arrayCreatorRest(newpos, t);
            else if (S.token == LPAREN)
                return classCreatorRest(newpos, null, t);
            else
                return syntaxError("left-paren.or.left-square-bracket.expected");

        }
    }

    /**
      * InnerCreator = Ident [TypeArguments] ClassCreatorRest
      */
    Tree innerCreator(int newpos, Tree encl) {
        Tree t = F.at(S.pos).Ident(ident());
        return classCreatorRest(newpos, encl, t);
    }

    /**
      * ArrayCreatorRest = "[" ( "]" BracketsOpt ArrayInitializer
      *                         | Expression "]" {"[" Expression "]"} BracketsOpt )
      */
    Tree arrayCreatorRest(int newpos, Tree elemtype) {
        accept(LBRACKET);
        if (S.token == RBRACKET) {
            S.nextToken();
            elemtype = bracketsOpt(elemtype);
            if (S.token == LBRACE) {
                return arrayInitializer(elemtype);
            } else {
                syntaxError(S.pos, "array.dimension.missing");
                return errorTree;
            }
        } else {
            ListBuffer dims = new ListBuffer();
            dims.append(expression());
            accept(RBRACKET);
            while (S.token == LBRACKET) {
                int pos = S.pos;
                S.nextToken();
                if (S.token == RBRACKET) {
                    S.nextToken();
                    elemtype = bracketsOpt(F.at(pos).TypeArray(elemtype));
                } else {
                    dims.append(expression());
                    accept(RBRACKET);
                }
            }
            return F.at(newpos).NewArray(elemtype, dims.toList(), null);
        }
    }

    /**
      * ClassCreatorRest = Arguments [ClassBody]
      */
    Tree classCreatorRest(int newpos, Tree encl, Tree t) {
        List args = arguments();
        ClassDef body = null;
        if (S.token == LBRACE)
            body = F.at(S.pos).ClassDef(0, names.empty, TypeParameter.emptyList,
                    null, Tree.emptyList, classOrInterfaceBody(names.empty, false));
        return F.at(newpos).NewClass(encl, t, args, body);
    }

    /**
      * ArrayInitializer = "{" [VariableInitializer {"," VariableInitializer}] [","] "}"
      */
    Tree arrayInitializer(Tree t) {
        int pos = S.pos;
        accept(LBRACE);
        ListBuffer elems = new ListBuffer();
        if (S.token == COMMA) {
            S.nextToken();
        } else if (S.token != RBRACE) {
            elems.append(variableInitializer());
            while (S.token == COMMA) {
                S.nextToken();
                if (S.token == RBRACE)
                    break;
                elems.append(variableInitializer());
            }
        }
        accept(RBRACE);
        return F.at(pos).NewArray(t, Tree.emptyList, elems.toList());
    }

    /**
      * VariableInitializer = ArrayInitializer | Expression
      */
    Tree variableInitializer() {
        return S.token == LBRACE ? arrayInitializer(null) : expression();
    }

    /**
      * ParExpression = "(" Expression ")"
      */
    Tree parExpression() {
        int pos = S.pos;
        accept(LPAREN);
        Tree t = expression();
        accept(RPAREN);
        return genEndPos ? F.at(pos).Parens(t) : t;
    }

    /**
      * Block = "{" BlockStatements "}"
      */
    Block block(long flags) {
        int pos = S.pos;
        accept(LBRACE);
        List stats = blockStatements();
        Block t = F.at(pos).Block(flags, stats);
        while (S.token == CASE || S.token == DEFAULT) {
            syntaxError("orphaned", keywords.token2string(S.token));
            blockStatements();
        }
        t.endpos = S.pos;
        accept(RBRACE);
        return t;
    }

    Block block() {
        return block(0);
    }

    /**
      * BlockStatements = { BlockStatement }
      *  BlockStatement  = LocalVariableDeclarationStatement
      *                  | ClassOrInterfaceDeclaration
      *                  | [Ident ":"] Statement
      *  LocalVariableDeclarationStatement
      *                  = [FINAL] Type VariableDeclarators ";"
      */
    List blockStatements() {
        ListBuffer stats = new ListBuffer();
        while (true) {
            int pos = S.pos;
            switch (S.token) {
            case RBRACE:

            case CASE:

            case DEFAULT:

            case EOF:
                return stats.toList();

            case LBRACE:

            case IF:

            case FOR:

            case WHILE:

            case DO:

            case TRY:

            case SWITCH:

            case SYNCHRONIZED:

            case RETURN:

            case THROW:

            case BREAK:

            case CONTINUE:

            case SEMI:

            case ELSE:

            case FINALLY:

            case CATCH:
                stats.append(statement());
                break;

            case FINAL:
                {
                    String dc = S.docComment;
                    long flags = modifiersOpt();
                    if (S.token == INTERFACE || S.token == CLASS) {
                        stats.append(classOrInterfaceDeclaration(flags, dc));
                    } else {
                        pos = S.pos;
                        Name name = S.name;
                        Tree t = type();
                        stats.appendList(variableDeclarators(flags, t));
                        accept(SEMI);
                    }
                    break;
                }

            case ABSTRACT:

            case STRICTFP:
                {
                    String dc = S.docComment;
                    long flags = modifiersOpt();
                    stats.append(classOrInterfaceDeclaration(flags, dc));
                    break;
                }

            case INTERFACE:

            case CLASS:
                stats.append(classOrInterfaceDeclaration(0, S.docComment));
                break;

            case ASSERT:
                if (allowAsserts) {
                    stats.append(statement());
                    break;
                }

            default:
                Name name = S.name;
                Tree t = term(EXPR | TYPE);
                if (S.token == COLON && t.tag == Tree.IDENT) {
                    S.nextToken();
                    Tree stat = statement();
                    stats.append(F.at(pos).Labelled(name, stat));
                } else if ((lastmode & TYPE) != 0 &&
                        (S.token == IDENTIFIER || S.token == ASSERT)) {
                    stats.appendList(variableDeclarators(0, t));
                    accept(SEMI);
                } else {
                    stats.append(F.at(pos).Exec(checkExprStat(t)));
                    accept(SEMI);
                }

            }
        }
    }

    /**
      * Statement =
      *       Block
      *     | IF ParExpression Statement [ELSE Statement]
      *     | FOR "(" ForInitOpt ";" [Expression] ";" ForUpdateOpt ")" Statement
      *     | WHILE ParExpression Statement
      *     | DO Statement WHILE ParExpression ";"
      *     | TRY Block ( Catches | [Catches] FinallyPart )
      *     | SWITCH ParExpression "{" SwitchBlockStatementGroups "}"
      *     | SYNCHRONIZED ParExpression Block
      *     | RETURN [Expression] ";"
      *     | THROW Expression ";"
      *     | BREAK [Ident] ";"
      *     | CONTINUE [Ident] ";"
      *     | ASSERT Expression [ ":" Expression ] ";"
      *     | ";"
      *     | ExpressionStatement
      *     | Ident ":" Statement
      */
    Tree statement() {
        int pos = S.pos;
        switch (S.token) {
        case LBRACE:
            return block();

        case IF:
            {
                S.nextToken();
                Tree cond = parExpression();
                Tree thenpart = statement();
                Tree elsepart = null;
                if (S.token == ELSE) {
                    S.nextToken();
                    elsepart = statement();
                }
                return F.at(pos).If(cond, thenpart, elsepart);
            }

        case FOR:
            {
                S.nextToken();
                accept(LPAREN);
                List inits = S.token == SEMI ? Tree.emptyList : forInit();
                accept(SEMI);
                Tree cond = S.token == SEMI ? null : expression();
                accept(SEMI);
                List steps = S.token == RPAREN ? Tree.emptyList : forUpdate();
                accept(RPAREN);
                Tree body = statement();
                return F.at(pos).ForLoop(inits, cond, steps, body);
            }