public void generateParser()

in src/org/intellij/grammar/generator/ParserGenerator.java [443:504]
60 lines of code
19 McCabe index (conditional complexity)

  public void generateParser(String parserClass, Collection<String> ownRuleNames) {
    List<String> parserImports = getRootAttribute(myFile, KnownAttribute.PARSER_IMPORTS).asStrings();
    boolean rootParser = parserClass.equals(myGrammarRootParser);
    Set<String> imports = new LinkedHashSet<>();
    if (!G.generateFQN) {
      imports.add(C.PsiBuilderClass);
      imports.add(C.PsiBuilderClass + ".Marker");
    }
    else {
      imports.add("#forced");
    }
    imports.add(staticStarImport(myTypeHolderClass));
    if (G.generateTokenSets && hasAtLeastOneTokenChoice(myFile, ownRuleNames)) {
      imports.add(staticStarImport(myTypeHolderClass + "." + TOKEN_SET_HOLDER_NAME));
    }
    if (StringUtil.isNotEmpty(myParserUtilClass)) {
      imports.add(staticStarImport(myParserUtilClass));
    }
    if (!rootParser) {
      imports.add(staticStarImport(myGrammarRootParser));
    }
    else if (!G.generateFQN) {
      imports.addAll(Arrays.asList(C.IElementTypeClass,
                                   C.AstNodeClass,
                                   C.TokenSetClass,
                                   C.PsiParserClass,
                                   C.LightPsiParserClass));
    }
    imports.addAll(parserImports);

    generateClassHeader(parserClass, imports,
                        SUPPRESS_WARNINGS_ANNO + "({\"SimplifiableIfStatement\", \"UnusedAssignment\"})",
                        Java.CLASS, "",
                        rootParser ? C.PsiParserClass : "",
                        rootParser ? C.LightPsiParserClass : "");

    if (rootParser) {
      generateRootParserContent();
    }
    for (String ruleName : ownRuleNames) {
      BnfRule rule = Objects.requireNonNull(myFile.getRule(ruleName));
      if (Rule.isExternal(rule) || Rule.isFake(rule)) continue;
      if (myExpressionHelper.getExpressionInfo(rule) != null) continue;
      out("/* ********************************************************** */");
      generateNode(rule, rule.getExpression(), getFuncName(rule), new HashSet<>());
      newLine();
    }
    for (String ruleName : ownRuleNames) {
      BnfRule rule = myFile.getRule(ruleName);
      ExpressionHelper.ExpressionInfo info = myExpressionHelper.getExpressionInfo(rule);
      if (info != null && info.rootRule == rule) {
        out("/* ********************************************************** */");
        ExpressionGeneratorHelper.generateExpressionRoot(info, this);
        newLine();
      }
    }
    boolean addNewLine = !myParserLambdas.isEmpty() && !myMetaMethodFields.isEmpty();
    generateParserLambdas(parserClass);
    if (addNewLine) newLine();
    generateMetaMethodFields();
    out("}");
  }