Java 类com.intellij.lang.PsiBuilder.Marker 实例源码

private static boolean nakedTerm_0_1(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "nakedTerm_0_1")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = nakedTerm_0_1_0(b, l + 1);
  int c = current_position_(b);
  while (r) {
    if (!nakedTerm_0_1_0(b, l + 1)) break;
    if (!empty_element_parsed_guard_(b, "nakedTerm_0_1", c)) break;
    c = current_position_(b);
  }
  exit_section_(b, m, null, r);
  return r;
}

private static boolean handlerLabeledParametersCallExpression_0_2_0_1_0_0_3_0_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "handlerLabeledParametersCallExpression_0_2_0_1_0_0_3_0_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokenFast(b, LAND);
  if (!r) r = consumeTokenFast(b, LOR);
  if (!r) r = consumeTokenFast(b, COMMA);
  exit_section_(b, m, null, r);
  return r;
}

static boolean root(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "root")) return false;
  boolean r;
  Marker m = enter_section_(b, l, _NONE_);
  r = consumeToken(b, CRLF);
  if (!r) r = root_1(b, l + 1);
  exit_section_(b, l, m, r, false, recover_root_parser_);
  return r;
}

public static boolean string(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "string")) return false;
  if (!nextTokenIs(b, "<string>", DQSTRING, SQSTRING)) return false;
  boolean r;
  Marker m = enter_section_(b, l, _NONE_, STRING, "<string>");
  r = consumeToken(b, DQSTRING);
  if (!r) r = consumeToken(b, SQSTRING);
  exit_section_(b, l, m, r, false, null);
  return r;
}

public static boolean activateCommandExpression(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "activateCommandExpression")) return false;
  if (!nextTokenIsFast(b, ACTIVATE)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokenFast(b, ACTIVATE);
  r = r && activateCommandExpression_1(b, l + 1);
  exit_section_(b, m, ACTIVATE_COMMAND_EXPRESSION, r);
  return r;
}

private static boolean parameter_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "parameter_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, HEADER_PARAMETER_NAME);
  if (!r) r = macro_usage_dec(b, l + 1);
  if (!r) r = consumeToken(b, DOCUMENT_ID);
  exit_section_(b, m, null, r);
  return r;
}

private static boolean referenceIdBeforeParamLabel_1(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "referenceIdBeforeParamLabel_1")) return false;
  boolean r;
  Marker m = enter_section_(b, l, _AND_);
  r = handlerParameterLabel(b, l + 1);
  exit_section_(b, l, m, r, false, null);
  return r;
}

private static boolean templateVariable_2_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "templateVariable_2_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, TEMPLATE_VARIABLE_SEPARATOR);
  r = r && templateVariableExpressionG(b, l + 1);
  r = r && templateVariable_2_0_2(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

private static boolean identifier_chain_1_0_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "identifier_chain_1_0_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = identifier_chain_1_0_0_0(b, l + 1);
  r = r && identifier_chain_1_0_0_1(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

private static boolean handlerLabeledParametersCallExpression_1_1_0_1(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "handlerLabeledParametersCallExpression_1_1_0_1")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokenFast(b, WITHOUT);
  r = r && labelForFalseParam(b, l + 1);
  r = r && handlerLabeledParametersCallExpression_1_1_0_1_2(b, l + 1);
  r = r && handlerLabeledParametersCallExpression_1_1_0_1_3(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

public static boolean textItemDelimitersProperty(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "textItemDelimitersProperty")) return false;
  if (!nextTokenIs(b, TEXT_ITEM_DELIMETERS)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, TEXT_ITEM_DELIMETERS);
  exit_section_(b, m, TEXT_ITEM_DELIMITERS_PROPERTY, r);
  return r;
}

private static boolean value_line_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "value_line_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, VALUE_SUBTYPE);
  r = r && value_line_0_1(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

private static boolean useScriptingAdditionsStatement_2_0_0_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "useScriptingAdditionsStatement_2_0_0_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokens(b, 0, WITH, IMPORTING);
  exit_section_(b, m, null, r);
  return r;
}

private static boolean root_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "root_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = useClause(b, l + 1);
  int c = current_position_(b);
  while (r) {
    if (!useClause(b, l + 1)) break;
    if (!empty_element_parsed_guard_(b, "root_0", c)) break;
    c = current_position_(b);
  }
  exit_section_(b, m, null, r);
  return r;
}

public static boolean CONST_DECLARATION(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "CONST_DECLARATION")) return false;
  if (!nextTokenIs(b, CONST)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokens(b, 0, CONST, IDENT, COLON);
  r = r && TYPE_DECLARATION(b, l + 1);
  r = r && CONST_DECLARATION_4(b, l + 1);
  exit_section_(b, m, CONST_DECLARATION, r);
  return r;
}

public static boolean variableList(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "variableList")) return false;
  if (!nextTokenIs(b, VARIABLE)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, VARIABLE);
  r = r && variableList_1(b, l + 1);
  exit_section_(b, m, VARIABLE_LIST, r);
  return r;
}

static boolean equalityOperator(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "equalityOperator")) return false;
  if (!nextTokenIs(b, "", EQ, NE)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, NE);
  if (!r) r = consumeToken(b, EQ);
  exit_section_(b, m, null, r);
  return r;
}

public static boolean table_expression(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "table_expression")) return false;
  if (!nextTokenIs(b, FROM)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = from_clause(b, l + 1);
  r = r && table_expression_1(b, l + 1);
  r = r && table_expression_2(b, l + 1);
  r = r && table_expression_3(b, l + 1);
  exit_section_(b, m, TABLE_EXPRESSION, r);
  return r;
}

public static boolean rawDictionaryCommandHandlerCallExpression(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "rawDictionaryCommandHandlerCallExpression")) return false;
  if (!nextTokenIsFast(b, RAW_LBR)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokens(b, 0, RAW_LBR, EVENT);
  r = r && identifier(b, l + 1);
  r = r && consumeToken(b, RAW_RBR);
  r = r && rawDictionaryCommandHandlerCallExpression_4(b, l + 1);
  exit_section_(b, m, RAW_DICTIONARY_COMMAND_HANDLER_CALL_EXPRESSION, r);
  return r;
}

public static boolean arbitraryReference(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "arbitraryReference")) return false;
  if (!nextTokenIs(b, SOME)) return false;
  boolean r, p;
  Marker m = enter_section_(b, l, _NONE_, ARBITRARY_REFERENCE, null);
  r = consumeToken(b, SOME);
  p = r; // pin = 1
  r = r && typeSpecifier(b, l + 1);
  exit_section_(b, l, m, r, p, null);
  return r || p;
}

private static boolean ignoringStatement_2_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "ignoringStatement_2_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = ignoringStatement_2_0_0(b, l + 1);
  r = r && ignoringStatement_2_0_1(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

public static boolean selectorId(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "selectorId")) return false;
  if (!nextTokenIs(b, VAR_IDENTIFIER)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = identifier(b, l + 1);
  exit_section_(b, m, SELECTOR_ID, r);
  return r;
}

private static boolean nakedTerm_1_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "nakedTerm_1_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = prefixOperator(b, l + 1);
  int c = current_position_(b);
  while (r) {
    if (!prefixOperator(b, l + 1)) break;
    if (!empty_element_parsed_guard_(b, "nakedTerm_1_0", c)) break;
    c = current_position_(b);
  }
  exit_section_(b, m, null, r);
  return r;
}

private static boolean argListRecover_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "argListRecover_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokenFast(b, RPAREN);
  exit_section_(b, m, null, r);
  return r;
}

private static boolean relativeAfterReference_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "relativeAfterReference_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, AFTER);
  if (!r) r = relativeAfterReference_0_1(b, l + 1);
  if (!r) r = consumeToken(b, BEHIND);
  exit_section_(b, m, null, r);
  return r;
}

private static boolean offendingObject_0_1(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "offendingObject_0_1")) return false;
  boolean r;
  Marker m = enter_section_(b, l, _AND_);
  r = consumeToken(b, TO);
  exit_section_(b, l, m, r, false, null);
  return r;
}

static boolean possessiveFormAndInterleavedCall(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "possessiveFormAndInterleavedCall")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = possessiveFormAndInterleavedCall_0(b, l + 1);
  r = r && handlerInterleavedParametersCall(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

static boolean perceptQuery(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "perceptQuery")) return false;
  if (!nextTokenIs(b, PERCEPT)) return false;
  boolean r, p;
  Marker m = enter_section_(b, l, _NONE_);
  r = consumeTokens(b, 1, PERCEPT, OPAREN);
  p = r; // pin = 1
  r = r && report_error_(b, termList(b, l + 1));
  r = p && consumeToken(b, CPAREN) && r;
  exit_section_(b, l, m, r, p, null);
  return r || p;
}

private static boolean repeatWithRangeStatement_7_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "repeatWithRangeStatement_7_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, BY);
  r = r && stepValue(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

public static boolean blockBody(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "blockBody")) return false;
  boolean r, p;
  Marker m = enter_section_(b, l, _NONE_, BLOCK_BODY, "<block body>");
  r = blockBodyPart(b, l + 1);
  p = r; // pin = 1
  r = r && report_error_(b, sep(b, l + 1));
  r = p && blockBody_2(b, l + 1) && r;
  exit_section_(b, l, m, r, p, null);
  return r || p;
}

public static boolean timeoutDef(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "timeoutDef")) return false;
  boolean r, p;
  Marker m = enter_section_(b, l, _NONE_, TIMEOUT_DEF, "<timeout def>");
  r = consumeToken(b, "timeout");
  p = r; // pin = 1
  r = r && report_error_(b, consumeToken(b, EQ));
  r = p && report_error_(b, number(b, l + 1)) && r;
  r = p && consumeToken(b, DOT) && r;
  exit_section_(b, l, m, r, p, null);
  return r || p;
}

private static boolean useClause_2_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "useClause_2_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, AS);
  r = r && usage(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

static boolean join_condition_recover(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "join_condition_recover")) return false;
  boolean r;
  Marker m = enter_section_(b, l, _NOT_);
  r = !consumeToken(b, RIGHT_BRACE);
  exit_section_(b, l, m, r, false, null);
  return r;
}

public static boolean parameters(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "parameters")) return false;
  boolean r, p;
  Marker m = enter_section_(b, l, _NONE_, PARAMETERS, "<parameters>");
  r = consumeToken(b, LEFT_ROUND_BRACKET);
  p = r; // pin = 1
  r = r && report_error_(b, parameters_1(b, l + 1));
  r = p && consumeToken(b, RIGHT_ROUND_BRACKET) && r;
  exit_section_(b, l, m, r, p, recover_parameters_parser_);
  return r || p;
}

public static boolean useStatement(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "useStatement")) return false;
  if (!nextTokenIs(b, USE)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = useAppleScriptStatement(b, l + 1);
  if (!r) r = useApplicationOrScriptStatement(b, l + 1);
  if (!r) r = useFrameworkStatement(b, l + 1);
  exit_section_(b, m, USE_STATEMENT, r);
  return r;
}

public static boolean CONST_VALUE_DECLARATION(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "CONST_VALUE_DECLARATION")) return false;
  boolean r;
  Marker m = enter_section_(b, l, _NONE_, CONST_VALUE_DECLARATION, "<const value declaration>");
  r = TASK_VALUE_DECLARATION(b, l + 1);
  if (!r) r = VALUE_DECLARATION(b, l + 1);
  exit_section_(b, l, m, r, false, null);
  return r;
}

public static boolean multiplicativeExpression(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "multiplicativeExpression")) return false;
  boolean r;
  Marker m = enter_section_(b, l, _LEFT_, MULTIPLICATIVE_EXPRESSION, "<multiplicative expression>");
  r = multiplicativeOperator(b, l + 1);
  r = r && multiplicativeExpression_1(b, l + 1);
  r = r && powerExpressionWrapper(b, l + 1);
  exit_section_(b, l, m, r, false, null);
  return r;
}

private static boolean instructionList_1_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "instructionList_1_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, COMMA);
  r = r && instruction(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

private static boolean subquery_4_0_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "subquery_4_0_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokens(b, 0, UNION, ALL);
  r = r && subquery(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}

private static boolean specification_1(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "specification_1")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = actionSpec(b, l + 1);
  int c = current_position_(b);
  while (r) {
    if (!actionSpec(b, l + 1)) break;
    if (!empty_element_parsed_guard_(b, "specification_1", c)) break;
    c = current_position_(b);
  }
  exit_section_(b, m, null, r);
  return r;
}