parser.java

javac是sun公司开发人员使用java语言编写的优秀的工业级java编译器

        case WHILE:
            {
                S.nextToken();
                Tree cond = parExpression();
                Tree body = statement();
                return F.at(pos).WhileLoop(cond, body);
            }

        case DO:
            {
                S.nextToken();
                Tree body = statement();
                accept(WHILE);
                Tree cond = parExpression();
                Tree t = F.at(pos).DoLoop(body, cond);
                if (genEndPos)
                    endPositions.put(t, new Integer(S.endPos));
                accept(SEMI);
                return t;
            }

        case TRY:
            {
                S.nextToken();
                Tree body = block();
                ListBuffer catchers = new ListBuffer();
                Tree finalizer = null;
                if (S.token == CATCH || S.token == FINALLY) {
                    while (S.token == CATCH)
                        catchers.append(catchClause());
                    if (S.token == FINALLY) {
                        S.nextToken();
                        finalizer = block();
                    }
                } else {
                    log.error(pos, "try.without.catch.or.finally");
                }
                return F.at(pos).Try(body, catchers.toList(), finalizer);
            }

        case SWITCH:
            {
                S.nextToken();
                Tree selector = parExpression();
                accept(LBRACE);
                List cases = switchBlockStatementGroups();
                Tree t = F.at(pos).Switch(selector, cases);
                if (genEndPos)
                    endPositions.put(t, new Integer(S.endPos));
                accept(RBRACE);
                return t;
            }

        case SYNCHRONIZED:
            {
                S.nextToken();
                Tree lock = parExpression();
                Tree body = block();
                return F.at(pos).Synchronized(lock, body);
            }

        case RETURN:
            {
                S.nextToken();
                Tree result = S.token == SEMI ? null : expression();
                Tree t = F.at(pos).Return(result);
                if (genEndPos)
                    endPositions.put(t, new Integer(S.endPos));
                accept(SEMI);
                return t;
            }

        case THROW:
            {
                S.nextToken();
                Tree exc = expression();
                Tree t = F.at(pos).Throw(exc);
                if (genEndPos)
                    endPositions.put(t, new Integer(S.endPos));
                accept(SEMI);
                return t;
            }

        case BREAK:
            {
                S.nextToken();
                Name label = (S.token == IDENTIFIER || S.token == ASSERT) ? ident() :
                        null;
                Tree t = F.at(pos).Break(label);
                if (genEndPos)
                    endPositions.put(t, new Integer(S.prevEndPos));
                accept(SEMI);
                return t;
            }

        case CONTINUE:
            {
                S.nextToken();
                Name label = (S.token == IDENTIFIER || S.token == ASSERT) ? ident() :
                        null;
                Tree t = F.at(pos).Continue(label);
                if (genEndPos)
                    endPositions.put(t, new Integer(S.prevEndPos));
                accept(SEMI);
                return t;
            }

        case SEMI:
            S.nextToken();
            return F.at(pos).Skip();

        case ELSE:
            return syntaxError("else.without.if");

        case FINALLY:
            return syntaxError("finally.without.try");

        case CATCH:
            return syntaxError("catch.without.try");

        case ASSERT:
            {
                if (allowAsserts) {
                    S.nextToken();
                    Tree assertion = expression();
                    Tree message = null;
                    if (S.token == COLON) {
                        S.nextToken();
                        message = expression();
                    }
                    Tree t = F.at(pos).Assert(assertion, message);
                    accept(SEMI);
                    return t;
                }
            }

        default:
            Name name = S.name;
            Tree expr = expression();
            if (S.token == COLON && expr.tag == Tree.IDENT) {
                S.nextToken();
                Tree stat = statement();
                return F.at(pos).Labelled(name, stat);
            } else {
                Tree stat = F.at(pos).Exec(checkExprStat(expr));
                accept(SEMI);
                return stat;
            }

        }
    }

    /**
      * CatchClause	= CATCH "(" FormalParameter ")" Block
      */
    Catch catchClause() {
        int pos = S.pos;
        accept(CATCH);
        accept(LPAREN);
        VarDef formal =
                variableDeclaratorId(optFinal() | Flags.PARAMETER, qualident());
        accept(RPAREN);
        Tree body = block();
        return F.at(pos).Catch(formal, body);
    }

    /**
      * SwitchBlockStatementGroups = { SwitchBlockStatementGroup }
      *  SwitchBlockStatementGroup = SwitchLabel BlockStatements
      *  SwitchLabel = CASE ConstantExpression ":" | DEFAULT ":"
      */
    List switchBlockStatementGroups() {
        ListBuffer cases = new ListBuffer();
        while (true) {
            int pos = S.pos;
            switch (S.token) {
            case CASE:
                {
                    S.nextToken();
                    Tree pat = expression();
                    accept(COLON);
                    List stats = blockStatements();
                    cases.append(F.at(pos).Case(pat, stats));
                    break;
                }

            case DEFAULT:
                {
                    S.nextToken();
                    accept(COLON);
                    List stats = blockStatements();
                    cases.append(F.at(pos).Case(null, stats));
                    break;
                }

            case RBRACE:

            case EOF:
                return cases.toList();

            default:
                S.nextToken();
                syntaxError(pos, "case.default.or.right-brace.expected");

            }
        }
    }

    /**
      * MoreStatementExpressions = { COMMA StatementExpression }
      */
    List moreStatementExpressions(int pos, Tree first) {
        ListBuffer stats = new ListBuffer();
        stats.append(F.at(pos).Exec(checkExprStat(first)));
        while (S.token == COMMA) {
            S.nextToken();
            pos = S.pos;
            Tree t = expression();
            stats.append(F.at(pos).Exec(checkExprStat(t)));
        }
        return stats.toList();
    }

    /**
      * ForInit = StatementExpression MoreStatementExpressions
      *           |  [FINAL] Type VariableDeclarators
      */
    List forInit() {
        int pos = S.pos;
        if (S.token == FINAL) {
            S.nextToken();
            return variableDeclarators(Flags.FINAL, type());
        } else {
            Tree t = term(EXPR | TYPE);
            if ((lastmode & TYPE) != 0 &&
                    (S.token == IDENTIFIER || S.token == ASSERT))
                return variableDeclarators(0, t);
            else
                return moreStatementExpressions(pos, t);
        }
    }

    /**
      * ForUpdate = StatementExpression MoreStatementExpressions
      */
    List forUpdate() {
        return moreStatementExpressions(S.pos, expression());
    }

    /**
      * ModifiersOpt = { Modifier }
      *  Modifier = PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL
      *           | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE
      */
    long modifiersOpt() {
        long flags = 0;
        if (S.deprecatedFlag) {
            flags = Flags.DEPRECATED;
            S.deprecatedFlag = false;
        }
        while (true) {
            int flag;
            switch (S.token) {
            case PRIVATE:
                flag = Flags.PRIVATE;
                break;

            case PROTECTED:
                flag = Flags.PROTECTED;
                break;

            case PUBLIC:
                flag = Flags.PUBLIC;
                break;

            case STATIC:
                flag = Flags.STATIC;
                break;

            case TRANSIENT:
                flag = Flags.TRANSIENT;
                break;

            case FINAL:
                flag = Flags.FINAL;
                break;

            case ABSTRACT:
                flag = Flags.ABSTRACT;
                break;

            case NATIVE:
                flag = Flags.NATIVE;
                break;

            case VOLATILE:
                flag = Flags.VOLATILE;
                break;

            case SYNCHRONIZED:
                flag = Flags.SYNCHRONIZED;
                break;

            case STRICTFP:
                flag = Flags.STRICTFP;
                break;

            default:
                return flags;

            }
            if ((flags & flag) != 0)
                log.error(S.pos, "repeated.modifier");
            flags = flags | flag;
            S.nextToken();
        }
    }

    /**
      * VariableDeclarators = VariableDeclarator { "," VariableDeclarator }
      */
    List variableDeclarators(long flags, Tree type) {
        return variableDeclaratorsRest(S.pos, flags, type, ident(), false, null);
    }

    /**
      * VariableDeclaratorsRest = VariableDeclaratorRest { "," VariableDeclarator }
      *  ConstantDeclaratorsRest = ConstantDeclaratorRest { "," ConstantDeclarator }
      *
      *  @param reqInit  Is an initializer always required?
      *  @param dc       The documentation comment for the variable declarations, or null.
      */
    List variableDeclaratorsRest(int pos, long flags, Tree type, Name name,
            boolean reqInit, String dc) {
        ListBuffer vdefs = new ListBuffer();
        vdefs.append(variableDeclaratorRest(pos, flags, type, name, reqInit, dc));
        while (S.token == COMMA) {
            S.nextToken();
            vdefs.append(variableDeclarator(flags, type, reqInit, dc));
        }
        return vdefs.toList();
    }

    /**
      * VariableDeclarator = Ident VariableDeclaratorRest
      *  ConstantDeclarator = Ident ConstantDeclaratorRest
      */
    VarDef variableDeclarator(long flags, Tree type, boolean reqInit, String dc) {
        return variableDeclaratorRest(S.pos, flags, type, ident(), reqInit, dc);
    }

    /**
      * VariableDeclaratorRest = BracketsOpt ["=" VariableInitializer]
      *  ConstantDeclaratorRest = BracketsOpt "=" VariableInitializer
      *
      *  @param reqInit  Is an initializer always required?
      *  @param dc       The documentation comment for the variable declarations, or null.
      */
    VarDef variableDeclaratorRest(int pos, long flags, Tree type, Name name,
            boolean reqInit, String dc) {
        type = bracketsOpt(type);
        Tree init = null;
        if (S.token == EQ) {
            S.nextToken();
            init = variableInitializer();
        } else if (reqInit)
            syntaxError(S.pos, "expected", keywords.token2string(EQ));
        VarDef result = F.at(pos).VarDef(flags, name, type, init);
        if (genEndPos)
            endPositions.put(result, new Integer(S.prevEndPos));
        attach(result, dc);
        return result;
    }

    /**
      * VariableDeclaratorId = Ident BracketsOpt
      */
    VarDef variableDeclaratorId(long flags, Tree type) {
        int pos = S.pos;
        Name name = ident();
        type = bracketsOpt(type);
        return F.at(pos).VarDef(flags, name, type, null);
    }

    /**
      * CompilationUnit = [PACKAGE Qualident ";"] {ImportDeclaration} {TypeDeclaration}
      */
    public Tree.TopLevel compilationUnit() {
        int pos = S.pos;
        Tree pid = null;
        String dc = S.docComment;
        if (S.token == PACKAGE) {
            S.nextToken();
            pid = qualident();
            accept(SEMI);
        }
        ListBuffer defs = new ListBuffer();
        while (S.token == IMPORT)
            defs.append(importDeclaration());
        while (S.token != EOF)
            defs.append(typeDeclaration());
        Tree.TopLevel toplevel = F.at(pos).TopLevel(pid, defs.toList());
        attach(toplevel, dc);
        if (keepDocComments)
            toplevel.docComments = docComments;
        if (genEndPos)
            toplevel.endPositions = endPositions;
        return toplevel;
    }

    /**
      * ImportDeclaration = IMPORT Ident { "." Ident } [ "." "*" ] ";"
      */
    Tree importDeclaration() {
        int pos = S.pos;
        S.nextToken();
        Tree pid = F.at(S.pos).Ident(ident());
        do {
            accept(DOT);
            if (S.token == STAR) {
                pid = F.at(S.pos).Select(pid, names.asterisk);
                S.nextToken();
                break;
            } else {
                pid = F.at(S.pos).Select(pid, ident());
            }
        } while (S.token == DOT)
            ;
        accept(SEMI);
        return F.at(pos).Import(pid);
    }

    /**
      * TypeDeclaration = ClassOrInterfaceDeclaration
      *                  | ";"
      */
    Tree typeDeclaration() {
        long flags = 0;
        if (S.pos == S.errPos) {
            flags = modifiersOpt();
            while (S.token != CLASS && S.token != INTERFACE && S.token != EOF) {
                S.nextToken();
                flags = modifiersOpt();
            }
        }
        int pos = S.pos;
        if (S.token == SEMI) {
            S.nextToken();
            return F.at(pos).Block(0, Tree.emptyList);
        } else {
            String dc = S.docComment;
            flags = flags | modifiersOpt();
            return classOrInterfaceDeclaration(flags, dc);
        }
    }

    /**
      * ClassOrInterfaceDeclaration = ModifiersOpt
      *                                (ClassDeclaration | InterfaceDeclaration)
      *  @param flags    Any modifiers starting the class or interface declaration
      *                  which are not in ModifiersOpt
      *  @param dc       The documentation comment for the class, or null.