| // This is a generated file. Not intended for manual editing. |
| package com.android.tools.idea.lang.databinding.parser; |
| |
| import com.intellij.lang.PsiBuilder; |
| import com.intellij.lang.PsiBuilder.Marker; |
| import static com.android.tools.idea.lang.databinding.psi.DbTokenTypes.*; |
| import static com.intellij.lang.parser.GeneratedParserUtilBase.*; |
| import com.intellij.psi.tree.IElementType; |
| import com.intellij.lang.ASTNode; |
| import com.intellij.psi.tree.TokenSet; |
| import com.intellij.lang.PsiParser; |
| |
| @SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"}) |
| public class DbParser implements PsiParser { |
| |
| public ASTNode parse(IElementType t, PsiBuilder b) { |
| parseLight(t, b); |
| return b.getTreeBuilt(); |
| } |
| |
| public void parseLight(IElementType t, PsiBuilder b) { |
| boolean r; |
| b = adapt_builder_(t, b, this, EXTENDS_SETS_); |
| Marker m = enter_section_(b, 0, _COLLAPSE_, null); |
| if (t == ADD_EXPR) { |
| r = expr(b, 0, 10); |
| } |
| else if (t == BINARY_AND_EXPR) { |
| r = expr(b, 0, 5); |
| } |
| else if (t == BINARY_OR_EXPR) { |
| r = expr(b, 0, 3); |
| } |
| else if (t == BINARY_XOR_EXPR) { |
| r = expr(b, 0, 4); |
| } |
| else if (t == BIT_SHIFT_EXPR) { |
| r = expr(b, 0, 9); |
| } |
| else if (t == BRACKET_EXPR) { |
| r = expr(b, 0, 16); |
| } |
| else if (t == CAST_EXPR) { |
| r = castExpr(b, 0); |
| } |
| else if (t == CLASS_EXTRACTION_EXPR) { |
| r = classExtractionExpr(b, 0); |
| } |
| else if (t == CLASS_OR_INTERFACE_TYPE) { |
| r = classOrInterfaceType(b, 0); |
| } |
| else if (t == CONSTANT_VALUE) { |
| r = constantValue(b, 0); |
| } |
| else if (t == DEFAULTS) { |
| r = defaults(b, 0); |
| } |
| else if (t == DOT_EXPR) { |
| r = expr(b, 0, 17); |
| } |
| else if (t == EQ_COMPARISON_EXPR) { |
| r = expr(b, 0, 6); |
| } |
| else if (t == EXPR) { |
| r = expr(b, 0, -1); |
| } |
| else if (t == EXPRESSION_LIST) { |
| r = expressionList(b, 0); |
| } |
| else if (t == ID_EXPR) { |
| r = idExpr(b, 0); |
| } |
| else if (t == INEQ_COMPARISON_EXPR) { |
| r = expr(b, 0, 8); |
| } |
| else if (t == INSTANCE_OF_EXPR) { |
| r = expr(b, 0, 7); |
| } |
| else if (t == LITERAL_EXPR) { |
| r = literalExpr(b, 0); |
| } |
| else if (t == LOGICAL_AND_EXPR) { |
| r = expr(b, 0, 2); |
| } |
| else if (t == LOGICAL_OR_EXPR) { |
| r = expr(b, 0, 1); |
| } |
| else if (t == METHOD_EXPR) { |
| r = expr(b, 0, 15); |
| } |
| else if (t == MUL_EXPR) { |
| r = expr(b, 0, 11); |
| } |
| else if (t == NEGATION_EXPR) { |
| r = negationExpr(b, 0); |
| } |
| else if (t == NULL_COALESCE_EXPR) { |
| r = expr(b, 0, -1); |
| } |
| else if (t == PAREN_EXPR) { |
| r = parenExpr(b, 0); |
| } |
| else if (t == PRIMITIVE_TYPE) { |
| r = primitiveType(b, 0); |
| } |
| else if (t == RESOURCE_PARAMETERS) { |
| r = resourceParameters(b, 0); |
| } |
| else if (t == RESOURCES_EXPR) { |
| r = resourcesExpr(b, 0); |
| } |
| else if (t == SIGN_CHANGE_EXPR) { |
| r = signChangeExpr(b, 0); |
| } |
| else if (t == TERNARY_EXPR) { |
| r = expr(b, 0, 0); |
| } |
| else if (t == TYPE) { |
| r = type(b, 0); |
| } |
| else if (t == TYPE_ARGUMENTS) { |
| r = typeArguments(b, 0); |
| } |
| else { |
| r = parse_root_(t, b, 0); |
| } |
| exit_section_(b, 0, m, t, r, true, TRUE_CONDITION); |
| } |
| |
| protected boolean parse_root_(IElementType t, PsiBuilder b, int l) { |
| return bindingSyntax(b, l + 1); |
| } |
| |
| public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] { |
| create_token_set_(ADD_EXPR, BINARY_AND_EXPR, BINARY_OR_EXPR, BINARY_XOR_EXPR, |
| BIT_SHIFT_EXPR, BRACKET_EXPR, CAST_EXPR, CLASS_EXTRACTION_EXPR, |
| DOT_EXPR, EQ_COMPARISON_EXPR, EXPR, ID_EXPR, |
| INEQ_COMPARISON_EXPR, INSTANCE_OF_EXPR, LITERAL_EXPR, LOGICAL_AND_EXPR, |
| LOGICAL_OR_EXPR, METHOD_EXPR, MUL_EXPR, NEGATION_EXPR, |
| NULL_COALESCE_EXPR, PAREN_EXPR, RESOURCES_EXPR, SIGN_CHANGE_EXPR, |
| TERNARY_EXPR), |
| }; |
| |
| /* ********************************************************** */ |
| // '+' | '-' |
| static boolean addOp(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "addOp")) return false; |
| if (!nextTokenIs(b, "", PLUS, MINUS)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, PLUS); |
| if (!r) r = consumeToken(b, MINUS); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // expr defaults? |
| static boolean bindingSyntax(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "bindingSyntax")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = expr(b, l + 1, -1); |
| r = r && bindingSyntax_1(b, l + 1); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| // defaults? |
| private static boolean bindingSyntax_1(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "bindingSyntax_1")) return false; |
| defaults(b, l + 1); |
| return true; |
| } |
| |
| /* ********************************************************** */ |
| // '<<' | '>>>' | '>>' |
| static boolean bitShiftOp(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "bitShiftOp")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, LTLT); |
| if (!r) r = consumeToken(b, GTGTGT); |
| if (!r) r = consumeToken(b, GTGT); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // IDENTIFIER typeArguments? ('.' IDENTIFIER typeArguments? )* |
| public static boolean classOrInterfaceType(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "classOrInterfaceType")) return false; |
| if (!nextTokenIs(b, IDENTIFIER)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, IDENTIFIER); |
| r = r && classOrInterfaceType_1(b, l + 1); |
| r = r && classOrInterfaceType_2(b, l + 1); |
| exit_section_(b, m, CLASS_OR_INTERFACE_TYPE, r); |
| return r; |
| } |
| |
| // typeArguments? |
| private static boolean classOrInterfaceType_1(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "classOrInterfaceType_1")) return false; |
| typeArguments(b, l + 1); |
| return true; |
| } |
| |
| // ('.' IDENTIFIER typeArguments? )* |
| private static boolean classOrInterfaceType_2(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "classOrInterfaceType_2")) return false; |
| int c = current_position_(b); |
| while (true) { |
| if (!classOrInterfaceType_2_0(b, l + 1)) break; |
| if (!empty_element_parsed_guard_(b, "classOrInterfaceType_2", c)) break; |
| c = current_position_(b); |
| } |
| return true; |
| } |
| |
| // '.' IDENTIFIER typeArguments? |
| private static boolean classOrInterfaceType_2_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "classOrInterfaceType_2_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, DOT); |
| r = r && consumeToken(b, IDENTIFIER); |
| r = r && classOrInterfaceType_2_0_2(b, l + 1); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| // typeArguments? |
| private static boolean classOrInterfaceType_2_0_2(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "classOrInterfaceType_2_0_2")) return false; |
| typeArguments(b, l + 1); |
| return true; |
| } |
| |
| /* ********************************************************** */ |
| // literal |
| // | RESOURCE_REFERENCE |
| // | IDENTIFIER |
| public static boolean constantValue(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "constantValue")) return false; |
| boolean r; |
| Marker m = enter_section_(b, l, _NONE_, "<constant value>"); |
| r = literal(b, l + 1); |
| if (!r) r = consumeToken(b, RESOURCE_REFERENCE); |
| if (!r) r = consumeToken(b, IDENTIFIER); |
| exit_section_(b, l, m, CONSTANT_VALUE, r, false, null); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // ',' 'default' '=' constantValue |
| public static boolean defaults(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "defaults")) return false; |
| if (!nextTokenIs(b, COMMA)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, COMMA); |
| r = r && consumeToken(b, DEFAULT_KEYWORD); |
| r = r && consumeToken(b, EQ); |
| r = r && constantValue(b, l + 1); |
| exit_section_(b, m, DEFAULTS, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // '==' | '!=' |
| static boolean eqComparisonOp(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "eqComparisonOp")) return false; |
| if (!nextTokenIs(b, "", NE, EQEQ)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, EQEQ); |
| if (!r) r = consumeToken(b, NE); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // expr (',' expr)* |
| public static boolean expressionList(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "expressionList")) return false; |
| boolean r; |
| Marker m = enter_section_(b, l, _NONE_, "<expression list>"); |
| r = expr(b, l + 1, -1); |
| r = r && expressionList_1(b, l + 1); |
| exit_section_(b, l, m, EXPRESSION_LIST, r, false, null); |
| return r; |
| } |
| |
| // (',' expr)* |
| private static boolean expressionList_1(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "expressionList_1")) return false; |
| int c = current_position_(b); |
| while (true) { |
| if (!expressionList_1_0(b, l + 1)) break; |
| if (!empty_element_parsed_guard_(b, "expressionList_1", c)) break; |
| c = current_position_(b); |
| } |
| return true; |
| } |
| |
| // ',' expr |
| private static boolean expressionList_1_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "expressionList_1_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, COMMA); |
| r = r && expr(b, l + 1, -1); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // '<=' | '>=' | '<' | '>' |
| static boolean ineqComparisonOp(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "ineqComparisonOp")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, LE); |
| if (!r) r = consumeToken(b, GTEQ); |
| if (!r) r = consumeToken(b, LT); |
| if (!r) r = consumeToken(b, GT); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // INTEGER_LITERAL |
| // | FLOAT_LITERAL |
| // | LONG_LITERAL |
| // | DOUBLE_LITERAL |
| // | TRUE | FALSE |
| // | NULL |
| // | CHARACTER_LITERAL |
| // | STRING_LITERAL |
| static boolean literal(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "literal")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, INTEGER_LITERAL); |
| if (!r) r = consumeToken(b, FLOAT_LITERAL); |
| if (!r) r = consumeToken(b, LONG_LITERAL); |
| if (!r) r = consumeToken(b, DOUBLE_LITERAL); |
| if (!r) r = consumeToken(b, TRUE); |
| if (!r) r = consumeToken(b, FALSE); |
| if (!r) r = consumeToken(b, NULL); |
| if (!r) r = consumeToken(b, CHARACTER_LITERAL); |
| if (!r) r = consumeToken(b, STRING_LITERAL); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // '*' | '/' |
| static boolean mulOp(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "mulOp")) return false; |
| if (!nextTokenIs(b, "", ASTERISK, DIV)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, ASTERISK); |
| if (!r) r = consumeToken(b, DIV); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // '~' | '!' |
| static boolean negationOp(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "negationOp")) return false; |
| if (!nextTokenIs(b, "", EXCL, TILDE)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, TILDE); |
| if (!r) r = consumeToken(b, EXCL); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // BOOLEAN_KEYWORD |
| // | BYTE_KEYWORD |
| // | CHAR_KEYWORD |
| // | SHORT_KEYWORD |
| // | INT_KEYWORD |
| // | LONG_KEYWORD |
| // | FLOAT_KEYWORD |
| // | DOUBLE_KEYWORD |
| public static boolean primitiveType(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "primitiveType")) return false; |
| boolean r; |
| Marker m = enter_section_(b, l, _NONE_, "<primitive type>"); |
| r = consumeToken(b, BOOLEAN_KEYWORD); |
| if (!r) r = consumeToken(b, BYTE_KEYWORD); |
| if (!r) r = consumeToken(b, CHAR_KEYWORD); |
| if (!r) r = consumeToken(b, SHORT_KEYWORD); |
| if (!r) r = consumeToken(b, INT_KEYWORD); |
| if (!r) r = consumeToken(b, LONG_KEYWORD); |
| if (!r) r = consumeToken(b, FLOAT_KEYWORD); |
| if (!r) r = consumeToken(b, DOUBLE_KEYWORD); |
| exit_section_(b, l, m, PRIMITIVE_TYPE, r, false, null); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // '(' expressionList ')' |
| public static boolean resourceParameters(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "resourceParameters")) return false; |
| if (!nextTokenIs(b, LPARENTH)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, LPARENTH); |
| r = r && expressionList(b, l + 1); |
| r = r && consumeToken(b, RPARENTH); |
| exit_section_(b, m, RESOURCE_PARAMETERS, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // '+' | '-' |
| static boolean signOp(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "signOp")) return false; |
| if (!nextTokenIs(b, "", PLUS, MINUS)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, PLUS); |
| if (!r) r = consumeToken(b, MINUS); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // primitiveType ('[' ']')* | classOrInterfaceType ('[' ']')* |
| public static boolean type(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "type")) return false; |
| boolean r; |
| Marker m = enter_section_(b, l, _NONE_, "<type>"); |
| r = type_0(b, l + 1); |
| if (!r) r = type_1(b, l + 1); |
| exit_section_(b, l, m, TYPE, r, false, null); |
| return r; |
| } |
| |
| // primitiveType ('[' ']')* |
| private static boolean type_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "type_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = primitiveType(b, l + 1); |
| r = r && type_0_1(b, l + 1); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| // ('[' ']')* |
| private static boolean type_0_1(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "type_0_1")) return false; |
| int c = current_position_(b); |
| while (true) { |
| if (!type_0_1_0(b, l + 1)) break; |
| if (!empty_element_parsed_guard_(b, "type_0_1", c)) break; |
| c = current_position_(b); |
| } |
| return true; |
| } |
| |
| // '[' ']' |
| private static boolean type_0_1_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "type_0_1_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, LBRACKET); |
| r = r && consumeToken(b, RBRACKET); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| // classOrInterfaceType ('[' ']')* |
| private static boolean type_1(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "type_1")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = classOrInterfaceType(b, l + 1); |
| r = r && type_1_1(b, l + 1); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| // ('[' ']')* |
| private static boolean type_1_1(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "type_1_1")) return false; |
| int c = current_position_(b); |
| while (true) { |
| if (!type_1_1_0(b, l + 1)) break; |
| if (!empty_element_parsed_guard_(b, "type_1_1", c)) break; |
| c = current_position_(b); |
| } |
| return true; |
| } |
| |
| // '[' ']' |
| private static boolean type_1_1_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "type_1_1_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, LBRACKET); |
| r = r && consumeToken(b, RBRACKET); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // '<' type (',' type)* '>' |
| public static boolean typeArguments(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "typeArguments")) return false; |
| if (!nextTokenIs(b, LT)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, LT); |
| r = r && type(b, l + 1); |
| r = r && typeArguments_2(b, l + 1); |
| r = r && consumeToken(b, GT); |
| exit_section_(b, m, TYPE_ARGUMENTS, r); |
| return r; |
| } |
| |
| // (',' type)* |
| private static boolean typeArguments_2(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "typeArguments_2")) return false; |
| int c = current_position_(b); |
| while (true) { |
| if (!typeArguments_2_0(b, l + 1)) break; |
| if (!empty_element_parsed_guard_(b, "typeArguments_2", c)) break; |
| c = current_position_(b); |
| } |
| return true; |
| } |
| |
| // ',' type |
| private static boolean typeArguments_2_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "typeArguments_2_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, COMMA); |
| r = r && type(b, l + 1); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| /* ********************************************************** */ |
| // Expression root: expr |
| // Operator priority table: |
| // 0: BINARY(nullCoalesceExpr) |
| // 1: BINARY(ternaryExpr) |
| // 2: BINARY(logicalOrExpr) |
| // 3: BINARY(logicalAndExpr) |
| // 4: BINARY(binaryOrExpr) |
| // 5: BINARY(binaryXorExpr) |
| // 6: BINARY(binaryAndExpr) |
| // 7: BINARY(eqComparisonExpr) |
| // 8: BINARY(instanceOfExpr) |
| // 9: BINARY(ineqComparisonExpr) |
| // 10: BINARY(bitShiftExpr) |
| // 11: BINARY(addExpr) |
| // 12: BINARY(mulExpr) |
| // 13: PREFIX(negationExpr) |
| // 14: PREFIX(signChangeExpr) |
| // 15: PREFIX(castExpr) |
| // 16: POSTFIX(methodExpr) |
| // 17: BINARY(bracketExpr) |
| // 18: POSTFIX(dotExpr) |
| // 19: ATOM(resourcesExpr) |
| // 20: ATOM(classExtractionExpr) |
| // 21: ATOM(literalExpr) |
| // 22: ATOM(idExpr) |
| // 23: PREFIX(parenExpr) |
| public static boolean expr(PsiBuilder b, int l, int g) { |
| if (!recursion_guard_(b, l, "expr")) return false; |
| addVariant(b, "<expr>"); |
| boolean r, p; |
| Marker m = enter_section_(b, l, _NONE_, "<expr>"); |
| r = negationExpr(b, l + 1); |
| if (!r) r = signChangeExpr(b, l + 1); |
| if (!r) r = castExpr(b, l + 1); |
| if (!r) r = resourcesExpr(b, l + 1); |
| if (!r) r = classExtractionExpr(b, l + 1); |
| if (!r) r = literalExpr(b, l + 1); |
| if (!r) r = idExpr(b, l + 1); |
| if (!r) r = parenExpr(b, l + 1); |
| p = r; |
| r = r && expr_0(b, l + 1, g); |
| exit_section_(b, l, m, null, r, p, null); |
| return r || p; |
| } |
| |
| public static boolean expr_0(PsiBuilder b, int l, int g) { |
| if (!recursion_guard_(b, l, "expr_0")) return false; |
| boolean r = true; |
| while (true) { |
| Marker m = enter_section_(b, l, _LEFT_, null); |
| if (g < 0 && consumeTokenSmart(b, QUESTQUEST)) { |
| r = expr(b, l, 0); |
| exit_section_(b, l, m, NULL_COALESCE_EXPR, r, true, null); |
| } |
| else if (g < 1 && consumeTokenSmart(b, QUEST)) { |
| r = report_error_(b, expr(b, l, 1)); |
| r = ternaryExpr_1(b, l + 1) && r; |
| exit_section_(b, l, m, TERNARY_EXPR, r, true, null); |
| } |
| else if (g < 2 && consumeTokenSmart(b, OROR)) { |
| r = expr(b, l, 2); |
| exit_section_(b, l, m, LOGICAL_OR_EXPR, r, true, null); |
| } |
| else if (g < 3 && consumeTokenSmart(b, ANDAND)) { |
| r = expr(b, l, 3); |
| exit_section_(b, l, m, LOGICAL_AND_EXPR, r, true, null); |
| } |
| else if (g < 4 && consumeTokenSmart(b, OR)) { |
| r = expr(b, l, 4); |
| exit_section_(b, l, m, BINARY_OR_EXPR, r, true, null); |
| } |
| else if (g < 5 && consumeTokenSmart(b, XOR)) { |
| r = expr(b, l, 5); |
| exit_section_(b, l, m, BINARY_XOR_EXPR, r, true, null); |
| } |
| else if (g < 6 && consumeTokenSmart(b, AND)) { |
| r = expr(b, l, 6); |
| exit_section_(b, l, m, BINARY_AND_EXPR, r, true, null); |
| } |
| else if (g < 7 && eqComparisonOp(b, l + 1)) { |
| r = expr(b, l, 7); |
| exit_section_(b, l, m, EQ_COMPARISON_EXPR, r, true, null); |
| } |
| else if (g < 8 && consumeTokenSmart(b, INSTANCEOF_KEYWORD)) { |
| r = expr(b, l, 8); |
| exit_section_(b, l, m, INSTANCE_OF_EXPR, r, true, null); |
| } |
| else if (g < 9 && ineqComparisonOp(b, l + 1)) { |
| r = expr(b, l, 9); |
| exit_section_(b, l, m, INEQ_COMPARISON_EXPR, r, true, null); |
| } |
| else if (g < 10 && bitShiftOp(b, l + 1)) { |
| r = expr(b, l, 10); |
| exit_section_(b, l, m, BIT_SHIFT_EXPR, r, true, null); |
| } |
| else if (g < 11 && addOp(b, l + 1)) { |
| r = expr(b, l, 11); |
| exit_section_(b, l, m, ADD_EXPR, r, true, null); |
| } |
| else if (g < 12 && mulOp(b, l + 1)) { |
| r = expr(b, l, 12); |
| exit_section_(b, l, m, MUL_EXPR, r, true, null); |
| } |
| else if (g < 16 && methodExpr_0(b, l + 1)) { |
| r = true; |
| exit_section_(b, l, m, METHOD_EXPR, r, true, null); |
| } |
| else if (g < 17 && consumeTokenSmart(b, LBRACKET)) { |
| r = report_error_(b, expr(b, l, 17)); |
| r = consumeToken(b, RBRACKET) && r; |
| exit_section_(b, l, m, BRACKET_EXPR, r, true, null); |
| } |
| else if (g < 18 && dotExpr_0(b, l + 1)) { |
| r = true; |
| exit_section_(b, l, m, DOT_EXPR, r, true, null); |
| } |
| else { |
| exit_section_(b, l, m, null, false, false, null); |
| break; |
| } |
| } |
| return r; |
| } |
| |
| // ':' expr |
| private static boolean ternaryExpr_1(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "ternaryExpr_1")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeToken(b, COLON); |
| r = r && expr(b, l + 1, -1); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| public static boolean negationExpr(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "negationExpr")) return false; |
| if (!nextTokenIsFast(b, EXCL, TILDE)) return false; |
| boolean r, p; |
| Marker m = enter_section_(b, l, _NONE_, null); |
| r = negationOp(b, l + 1); |
| p = r; |
| r = p && expr(b, l, 13); |
| exit_section_(b, l, m, NEGATION_EXPR, r, p, null); |
| return r || p; |
| } |
| |
| public static boolean signChangeExpr(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "signChangeExpr")) return false; |
| if (!nextTokenIsFast(b, PLUS, MINUS)) return false; |
| boolean r, p; |
| Marker m = enter_section_(b, l, _NONE_, null); |
| r = signOp(b, l + 1); |
| p = r; |
| r = p && expr(b, l, 14); |
| exit_section_(b, l, m, SIGN_CHANGE_EXPR, r, p, null); |
| return r || p; |
| } |
| |
| public static boolean castExpr(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "castExpr")) return false; |
| if (!nextTokenIsFast(b, LPARENTH)) return false; |
| boolean r, p; |
| Marker m = enter_section_(b, l, _NONE_, null); |
| r = castExpr_0(b, l + 1); |
| p = r; |
| r = p && expr(b, l, 15); |
| exit_section_(b, l, m, CAST_EXPR, r, p, null); |
| return r || p; |
| } |
| |
| // '(' type ')' |
| private static boolean castExpr_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "castExpr_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeTokenSmart(b, LPARENTH); |
| r = r && type(b, l + 1); |
| r = r && consumeToken(b, RPARENTH); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| // '.' IDENTIFIER '(' expressionList? ')' |
| private static boolean methodExpr_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "methodExpr_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeTokenSmart(b, DOT); |
| r = r && consumeToken(b, IDENTIFIER); |
| r = r && consumeToken(b, LPARENTH); |
| r = r && methodExpr_0_3(b, l + 1); |
| r = r && consumeToken(b, RPARENTH); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| // expressionList? |
| private static boolean methodExpr_0_3(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "methodExpr_0_3")) return false; |
| expressionList(b, l + 1); |
| return true; |
| } |
| |
| // '.' IDENTIFIER |
| private static boolean dotExpr_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "dotExpr_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeTokenSmart(b, DOT); |
| r = r && consumeToken(b, IDENTIFIER); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| // RESOURCE_REFERENCE resourceParameters? |
| public static boolean resourcesExpr(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "resourcesExpr")) return false; |
| if (!nextTokenIsFast(b, RESOURCE_REFERENCE)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeTokenSmart(b, RESOURCE_REFERENCE); |
| r = r && resourcesExpr_1(b, l + 1); |
| exit_section_(b, m, RESOURCES_EXPR, r); |
| return r; |
| } |
| |
| // resourceParameters? |
| private static boolean resourcesExpr_1(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "resourcesExpr_1")) return false; |
| resourceParameters(b, l + 1); |
| return true; |
| } |
| |
| // (type|'void') '.' 'class' |
| public static boolean classExtractionExpr(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "classExtractionExpr")) return false; |
| boolean r; |
| Marker m = enter_section_(b, l, _NONE_, "<class extraction expr>"); |
| r = classExtractionExpr_0(b, l + 1); |
| r = r && consumeToken(b, DOT); |
| r = r && consumeToken(b, CLASS_KEYWORD); |
| exit_section_(b, l, m, CLASS_EXTRACTION_EXPR, r, false, null); |
| return r; |
| } |
| |
| // type|'void' |
| private static boolean classExtractionExpr_0(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "classExtractionExpr_0")) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = type(b, l + 1); |
| if (!r) r = consumeTokenSmart(b, VOID_KEYWORD); |
| exit_section_(b, m, null, r); |
| return r; |
| } |
| |
| // literal |
| public static boolean literalExpr(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "literalExpr")) return false; |
| boolean r; |
| Marker m = enter_section_(b, l, _NONE_, "<literal expr>"); |
| r = literal(b, l + 1); |
| exit_section_(b, l, m, LITERAL_EXPR, r, false, null); |
| return r; |
| } |
| |
| // IDENTIFIER |
| public static boolean idExpr(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "idExpr")) return false; |
| if (!nextTokenIsFast(b, IDENTIFIER)) return false; |
| boolean r; |
| Marker m = enter_section_(b); |
| r = consumeTokenSmart(b, IDENTIFIER); |
| exit_section_(b, m, ID_EXPR, r); |
| return r; |
| } |
| |
| public static boolean parenExpr(PsiBuilder b, int l) { |
| if (!recursion_guard_(b, l, "parenExpr")) return false; |
| if (!nextTokenIsFast(b, LPARENTH)) return false; |
| boolean r, p; |
| Marker m = enter_section_(b, l, _NONE_, null); |
| r = consumeTokenSmart(b, LPARENTH); |
| p = r; |
| r = p && expr(b, l, -1); |
| r = p && report_error_(b, consumeToken(b, RPARENTH)) && r; |
| exit_section_(b, l, m, PAREN_EXPR, r, p, null); |
| return r || p; |
| } |
| |
| } |