private boolean generateKernelMethod()

in src/org/intellij/grammar/livePreview/LivePreviewParser.java [579:636]
53 lines of code
25 McCabe index (conditional complexity)

  private boolean generateKernelMethod(PsiBuilder builder,
                                      int level,
                                      String methodName,
                                      ExpressionHelper.ExpressionInfo info,
                                      Map<String, List<ExpressionHelper.OperatorInfo>> opCalls,
                                      int priority_) {
    if (!recursion_guard_(builder, level, methodName)) return false;
    PsiBuilder.Marker marker_ = null;
    boolean result_ = true;
    int pos = current_position_(builder);

    main: while (true) {
      PsiBuilder.Marker left_marker_ = (PsiBuilder.Marker)builder.getLatestDoneMarker();
      if (!invalid_left_marker_guard_(builder, left_marker_, methodName)) return false;

      for (ExpressionHelper.OperatorInfo operator : filter(opCalls, ExpressionHelper.OperatorType.BINARY, ExpressionHelper.OperatorType.N_ARY, ExpressionHelper.OperatorType.POSTFIX)) {
        int priority = info.getPriority(operator.rule);
        int arg2Priority = operator.arg2 == null ? -1 : info.getPriority(operator.arg2);
        int argPriority = arg2Priority == -1 ? priority : arg2Priority - 1;

        if (marker_ == null) marker_ = builder.mark();

        if (priority_ <  priority &&
            (operator.arg1 == null || ((LighterASTNode)left_marker_).getTokenType() == getRuleElementType(operator.arg1)) &&
            generateNodeCall(builder, level, info.rootRule, operator.operator, getNextName(operator.rule.getName(), 0), Collections.emptyMap())) {

          IElementType elementType = getRuleElementType(operator.rule);
          boolean rightAssociative = getAttribute(operator.rule, KnownAttribute.RIGHT_ASSOCIATIVE);
          if (operator.type == ExpressionHelper.OperatorType.BINARY) {
              result_ = report_error_(builder, generateExpressionRoot(builder, level, info, (rightAssociative ? argPriority - 1 : argPriority)));
            if (operator.tail != null) result_ = report_error_(builder, generateNodeCall(builder, level, operator.rule, operator.tail, getNextName(operator.rule.getName(), 1), Collections.emptyMap())) && result_;
          }
          else if (operator.type == ExpressionHelper.OperatorType.N_ARY) {
            int nary_pos = current_position_(builder);
            while (true) {
              result_ = report_error_(builder, generateExpressionRoot(builder, level, info, argPriority));
              if (operator.tail != null) result_ = report_error_(builder, generateNodeCall(builder, level, operator.rule, operator.tail, getNextName(operator.rule.getName(), 1), Collections.emptyMap())) && result_;
              if (!result_ || !generateNodeCall(builder, level, info.rootRule, operator.operator, getNextName(operator.rule.getName(), 0), Collections.emptyMap())) break;
              if (!empty_element_parsed_guard_(builder, operator.operator.getText(), nary_pos)) break;
              nary_pos = current_position_(builder);
            }
          }
          else if (operator.type == ExpressionHelper.OperatorType.POSTFIX) {
            result_ = true;
          }
          marker_.drop();
          left_marker_.precede().done(elementType);
          marker_ = null;
          if (!empty_element_parsed_guard_(builder, info.rootRule.getName(), pos)) break main;
          pos = current_position_(builder);
          continue main;
        }
      }
      break;
    }
    exit_section_(builder, marker_, null, false);
    return result_;
  }