public void generateParser()

in antlr-based-bootstrap/peg/Generator.java [173:273]
97 lines of code
12 McCabe index (conditional complexity)

    public void generateParser(String parserClass, Map<String, Tree> ruleMap) {
        final String elementTypeHolderClass = getAttribute(treeRoot, "elementTypeHolderClass", "generated.ParserTypes");
        final String stubParser = getAttribute(treeRoot, "stubParserClass", "generated.ParserUtil");
        int offset = 1;
        String rootParserClass = ruleParserClasses.get(grammarRoot);
        boolean rootParser = parserClass.equals(rootParserClass);
        generateClassHeader(parserClass,
                "org.jetbrains.annotations.*;" +
                        "com.intellij.lang.LighterASTNode;" +
                        "com.intellij.lang.PsiBuilder;" +
                        "com.intellij.lang.PsiBuilder.Marker;" +
                        "com.intellij.openapi.diagnostic.Logger;" +
                        "static " + elementTypeHolderClass+".*;" +
                        "static " + stubParser+".*;"+
                (!rootParser? "static "+rootParserClass+".recursion_guard_;" +
                        "static " + rootParserClass + ".type_extends_;":
                        IELEMENTTYPE_CLASS + ";" +
                        "com.intellij.lang.ASTNode;" +
                        "com.intellij.psi.tree.TokenSet;" +
                        "com.intellij.lang.PsiParser;")
                , "@SuppressWarnings({\"SimplifiableIfStatement\", \"UnusedAssignment\"})",
                false, "", rootParser? "PsiParser": "");

        out(offset, "public static Logger LOG_ = Logger.getInstance(\""+parserClass+"\");");
        newLine();

        if (rootParser) {
            out(offset, "@NotNull");
            out(offset++, "public ASTNode parse(final IElementType root_, final PsiBuilder builder_) {");
            out(offset, "boolean result_;");
            boolean first = true;
            for (String ruleName : ruleMap.keySet()) {
                Tree rule = ruleMap.get(ruleName);
                if (Rule.isPrivate(rule) || grammarRoot.equals(ruleName)) continue;
                String elementType = getElementType(rule);
                out(offset++, (first?"" : "else ") + "if (root_ == "+elementType +") {");
                out(offset, "result_ = "+ruleName+"(builder_, false, 0);");
                out(--offset, "}");
                if (first) first = false;
            }
            if (first) {
                out(offset, "result_ = " + grammarRoot+"(builder_, false, 0);");
            }
            else {
                out(offset++, "else {");
                out(offset, "Marker marker_ = builder_.mark();");
                out(offset++, "try {");
                out(offset, "result_ = " + grammarRoot + "(builder_, false, 0);");
                out(offset++, "while (builder_.getTokenType() != null) {");
                out(offset, "builder_.advanceLexer();");
                out(--offset, "}");
                out(--offset, "}");
                out(offset++, "finally {");
                out(offset, "marker_.done(root_);");
                out(--offset, "}");
                out(--offset, "}");
            }
            out(offset, "return builder_.getTreeBuilt();");
            out(--offset, "}");
            newLine();
            int maxRecursionLevel = getAttribute(treeRoot, "maxRecursionLevel", 100);
            out(offset++, "public static boolean recursion_guard_(PsiBuilder builder_, int level_, String funcName_) {");
            out(offset++, "if (level_ > " + maxRecursionLevel + ") {");
            out(offset, "builder_.error(\"Maximum recursion level (\"+"+maxRecursionLevel+"+\") reached in\"+funcName_);");
            out(offset, "return false;");
            out(--offset, "}");
            out(offset, "return true;");
            out(--offset, "}");
            newLine();

            MultiMap<String, String> extendsMap = new MultiMap<String, String>();
            for (String ruleName : ruleMap.keySet()) {
                Tree rule = ruleMap.get(ruleName);
                if (Rule.isPrivate(rule)) continue;
                Tree superRule = ruleMap.get(Rule.attribute(rule, "extends", ""));
                if (superRule == null) continue;
                extendsMap.putValue(getElementType(superRule), getElementType(rule));
            }
            out(offset++, "private static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] {");
            for (String ruleName : extendsMap.keySet()) {
                extendsMap.putValue(ruleName, ruleName); // add super to itself
                out(offset, "TokenSet.create("+StringUtil.join(extendsMap.get(ruleName), ",")+"),");
            }
            out(--offset, "};");
            out(offset++, "public static boolean type_extends_(IElementType child_, IElementType parent_) {");
            out(offset++, "for (TokenSet set : EXTENDS_SETS_) {");
            out(offset, "if (set.contains(child_) && set.contains(parent_)) return true;");
            out(--offset, "}");
            out(offset, "return false;");
            out(--offset, "}");
            newLine();
        }
        for (String ruleName : ruleMap.keySet()) {
            Tree rule = ruleMap.get(ruleName);
            out(offset, "/* ********************************************************** */");
            generateNode(offset, rule, Rule.body(rule), Rule.isPrivate(rule), ruleName, new HashSet<Tree>());
            newLine();
        }

        out(--offset, "}");
    }