37809b8aa7
Adds src/main/grammar/Jai.bnf, the generated parser/PSI in src/main/gen, a
JaiParserDefinition, and the Tier 3 corpus parse gate (406/714 files clean).
Two things were not obvious:
- Grammar-Kit mints its own token instances from the .bnf 'tokens' block, which
are different objects from the ones JaiLexer emits, so every rule silently
failed to match. Fixed with tokenTypeFactory -> JaiTokenTypes.byName.
- A backslash inside an identifier is a continuation in the compiler's lexer
(Jai_Lexer/module.jai:444): 'left\_margin' is one identifier. JaiLexer now
does the same; the Tier 0 round-trip still holds because the token span
covers the backslash and the skipped spaces.
Constructs that BNF alone cannot express live in JaiParserUtil: directive-name
tests (#ident is one token), '==' before '{' for the switch form, procedure
header vs parenthesised expression, and the declaration lookahead.
2632 lines
108 KiB
Java
2632 lines
108 KiB
Java
// This is a generated file. Not intended for manual editing.
|
|
package dev.hgh.jai.parser;
|
|
|
|
import com.intellij.lang.PsiBuilder;
|
|
import com.intellij.lang.PsiBuilder.Marker;
|
|
import static dev.hgh.jai.psi.JaiTypes.*;
|
|
import static dev.hgh.jai.parser.JaiParserUtil.*;
|
|
import com.intellij.psi.tree.IElementType;
|
|
import com.intellij.lang.ASTNode;
|
|
import com.intellij.psi.tree.TokenSet;
|
|
import com.intellij.lang.PsiParser;
|
|
import com.intellij.lang.LightPsiParser;
|
|
|
|
@SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"})
|
|
public class JaiParser implements PsiParser, LightPsiParser {
|
|
|
|
public ASTNode parse(IElementType root_, PsiBuilder builder_) {
|
|
parseLight(root_, builder_);
|
|
return builder_.getTreeBuilt();
|
|
}
|
|
|
|
public void parseLight(IElementType root_, PsiBuilder builder_) {
|
|
boolean result_;
|
|
builder_ = adapt_builder_(root_, builder_, this, EXTENDS_SETS_);
|
|
Marker marker_ = enter_section_(builder_, 0, _COLLAPSE_, null);
|
|
result_ = parse_root_(root_, builder_);
|
|
exit_section_(builder_, 0, marker_, root_, result_, true, TRUE_CONDITION);
|
|
}
|
|
|
|
protected boolean parse_root_(IElementType root_, PsiBuilder builder_) {
|
|
return parse_root_(root_, builder_, 0);
|
|
}
|
|
|
|
static boolean parse_root_(IElementType root_, PsiBuilder builder_, int level_) {
|
|
return jaiFile(builder_, level_ + 1);
|
|
}
|
|
|
|
public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] {
|
|
create_token_set_(ADD_EXPR, AND_EXPR, ARRAY_LITERAL_EXPR, ARRAY_TYPE_EXPR,
|
|
ASSIGN_EXPR, AUTO_CAST_EXPR, BACKTICK_EXPR, BIT_AND_EXPR,
|
|
BIT_OR_EXPR, BIT_XOR_EXPR, BUILTIN_CALL_EXPR, CALL_EXPR,
|
|
CAST_EXPR, DEREF_EXPR, DIRECTIVE_EXPR, ENUM_EXPR,
|
|
EQUALITY_EXPR, EXPR, IFX_EXPR, INDEX_EXPR,
|
|
INLINE_EXPR, INTERFACE_EXPR, LAMBDA_EXPR, LITERAL_EXPR,
|
|
MEMBER_EXPR, MUL_EXPR, OR_EXPR, PAREN_EXPR,
|
|
PREFIX_EXPR, PRIMARY_EXPR, PROC_LITERAL_EXPR, RANGE_EXPR,
|
|
REF_EXPR, RELATIONAL_EXPR, SHIFT_EXPR, STRUCT_EXPR,
|
|
STRUCT_LITERAL_EXPR, TYPED_ARRAY_LITERAL_EXPR, TYPED_STRUCT_LITERAL_EXPR, UNARY_DOT_EXPR,
|
|
UNINITIALIZED_EXPR, UNION_EXPR),
|
|
};
|
|
|
|
/* ********************************************************** */
|
|
// argument ((',' | ',,') argument)* [',']
|
|
static boolean argList(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "argList")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = argument(builder_, level_ + 1);
|
|
result_ = result_ && argList_1(builder_, level_ + 1);
|
|
result_ = result_ && argList_2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ((',' | ',,') argument)*
|
|
private static boolean argList_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "argList_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!argList_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "argList_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// (',' | ',,') argument
|
|
private static boolean argList_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "argList_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = argList_1_0_0(builder_, level_ + 1);
|
|
result_ = result_ && argument(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ',' | ',,'
|
|
private static boolean argList_1_0_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "argList_1_0_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, COMMA);
|
|
if (!result_) result_ = consumeToken(builder_, DOUBLE_COMMA);
|
|
return result_;
|
|
}
|
|
|
|
// [',']
|
|
private static boolean argList_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "argList_2")) return false;
|
|
consumeToken(builder_, COMMA);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '---' | expr
|
|
public static boolean argument(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "argument")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, ARGUMENT, "<argument>");
|
|
result_ = consumeToken(builder_, TRIPLE_MINUS);
|
|
if (!result_) result_ = expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '.[' [argList] ']'
|
|
public static boolean arrayLiteralExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "arrayLiteralExpr")) return false;
|
|
if (!nextTokenIs(builder_, BEGIN_ARRAY_LITERAL)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, BEGIN_ARRAY_LITERAL);
|
|
result_ = result_ && arrayLiteralExpr_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RBRACKET);
|
|
exit_section_(builder_, marker_, ARRAY_LITERAL_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [argList]
|
|
private static boolean arrayLiteralExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "arrayLiteralExpr_1")) return false;
|
|
argList(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^='
|
|
// | '<<=' | '>>=' | '<<<=' | '>>>=' | '&&=' | '||='
|
|
static boolean assignOp_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "assignOp_")) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, EQ);
|
|
if (!result_) result_ = consumeToken(builder_, PLUS_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, MINUS_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, STAR_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, SLASH_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, PERCENT_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, AND_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, OR_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, XOR_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, SHL_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, SHR_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, ROL_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, ROR_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, AND_AND_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, OR_OR_EQ);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '`' (IDENT | 'defer' | 'return' | 'push_context' | 'operator')
|
|
public static boolean backtickExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "backtickExpr")) return false;
|
|
if (!nextTokenIs(builder_, BACKTICK)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, BACKTICK);
|
|
result_ = result_ && backtickExpr_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, BACKTICK_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// IDENT | 'defer' | 'return' | 'push_context' | 'operator'
|
|
private static boolean backtickExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "backtickExpr_1")) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, IDENT);
|
|
if (!result_) result_ = consumeToken(builder_, KW_DEFER);
|
|
if (!result_) result_ = consumeToken(builder_, KW_RETURN);
|
|
if (!result_) result_ = consumeToken(builder_, KW_PUSH_CONTEXT);
|
|
if (!result_) result_ = consumeToken(builder_, KW_OPERATOR);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '{' statement* '}'
|
|
public static boolean block(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "block")) return false;
|
|
if (!nextTokenIs(builder_, LBRACE)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, LBRACE);
|
|
result_ = result_ && block_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RBRACE);
|
|
exit_section_(builder_, marker_, BLOCK, result_);
|
|
return result_;
|
|
}
|
|
|
|
// statement*
|
|
private static boolean block_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "block_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!statement(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "block_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'break' [IDENT] semi
|
|
public static boolean breakStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "breakStatement")) return false;
|
|
if (!nextTokenIs(builder_, KW_BREAK)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_BREAK);
|
|
result_ = result_ && breakStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && semi(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, BREAK_STATEMENT, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [IDENT]
|
|
private static boolean breakStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "breakStatement_1")) return false;
|
|
consumeToken(builder_, IDENT);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// builtinName_ '(' [argList] ')'
|
|
public static boolean builtinCallExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "builtinCallExpr")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, BUILTIN_CALL_EXPR, "<builtin call expr>");
|
|
result_ = builtinName_(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, LPAREN);
|
|
result_ = result_ && builtinCallExpr_2(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RPAREN);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// [argList]
|
|
private static boolean builtinCallExpr_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "builtinCallExpr_2")) return false;
|
|
argList(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'size_of' | 'type_of' | 'type_info' | 'code_of'
|
|
// | 'initializer_of' | 'is_constant'
|
|
static boolean builtinName_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "builtinName_")) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, KW_SIZE_OF);
|
|
if (!result_) result_ = consumeToken(builder_, KW_TYPE_OF);
|
|
if (!result_) result_ = consumeToken(builder_, KW_TYPE_INFO);
|
|
if (!result_) result_ = consumeToken(builder_, KW_CODE_OF);
|
|
if (!result_) result_ = consumeToken(builder_, KW_INITIALIZER_OF);
|
|
if (!result_) result_ = consumeToken(builder_, KW_IS_CONSTANT);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'case' [expr] [';'] statement*
|
|
public static boolean caseClause(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "caseClause")) return false;
|
|
if (!nextTokenIs(builder_, KW_CASE)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_CASE);
|
|
result_ = result_ && caseClause_1(builder_, level_ + 1);
|
|
result_ = result_ && caseClause_2(builder_, level_ + 1);
|
|
result_ = result_ && caseClause_3(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, CASE_CLAUSE, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [expr]
|
|
private static boolean caseClause_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "caseClause_1")) return false;
|
|
expr(builder_, level_ + 1, -1);
|
|
return true;
|
|
}
|
|
|
|
// [';']
|
|
private static boolean caseClause_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "caseClause_2")) return false;
|
|
consumeToken(builder_, SEMICOLON);
|
|
return true;
|
|
}
|
|
|
|
// statement*
|
|
private static boolean caseClause_3(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "caseClause_3")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!statement(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "caseClause_3", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'continue' [IDENT] semi
|
|
public static boolean continueStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "continueStatement")) return false;
|
|
if (!nextTokenIs(builder_, KW_CONTINUE)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_CONTINUE);
|
|
result_ = result_ && continueStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && semi(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, CONTINUE_STATEMENT, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [IDENT]
|
|
private static boolean continueStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "continueStatement_1")) return false;
|
|
consumeToken(builder_, IDENT);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// <<dirPlain>> | 'using'
|
|
static boolean declModifier_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declModifier_")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = dirPlain(builder_, level_ + 1);
|
|
if (!result_) result_ = consumeToken(builder_, KW_USING);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// IDENT (',' IDENT)*
|
|
public static boolean declNames(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declNames")) return false;
|
|
if (!nextTokenIs(builder_, IDENT)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, IDENT);
|
|
result_ = result_ && declNames_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, DECL_NAMES, result_);
|
|
return result_;
|
|
}
|
|
|
|
// (',' IDENT)*
|
|
private static boolean declNames_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declNames_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!declNames_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "declNames_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ',' IDENT
|
|
private static boolean declNames_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declNames_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokens(builder_, 0, COMMA, IDENT);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ':' [<<exprNoAssign>>] [('=' | ':') initializer]
|
|
// | ':=' initializer
|
|
// | '::' initializer
|
|
static boolean declTail_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declTail_")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = declTail__0(builder_, level_ + 1);
|
|
if (!result_) result_ = declTail__1(builder_, level_ + 1);
|
|
if (!result_) result_ = declTail__2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ':' [<<exprNoAssign>>] [('=' | ':') initializer]
|
|
private static boolean declTail__0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declTail__0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COLON);
|
|
result_ = result_ && declTail__0_1(builder_, level_ + 1);
|
|
result_ = result_ && declTail__0_2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [<<exprNoAssign>>]
|
|
private static boolean declTail__0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declTail__0_1")) return false;
|
|
exprNoAssign(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// [('=' | ':') initializer]
|
|
private static boolean declTail__0_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declTail__0_2")) return false;
|
|
declTail__0_2_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// ('=' | ':') initializer
|
|
private static boolean declTail__0_2_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declTail__0_2_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = declTail__0_2_0_0(builder_, level_ + 1);
|
|
result_ = result_ && initializer(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// '=' | ':'
|
|
private static boolean declTail__0_2_0_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declTail__0_2_0_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, EQ);
|
|
if (!result_) result_ = consumeToken(builder_, COLON);
|
|
return result_;
|
|
}
|
|
|
|
// ':=' initializer
|
|
private static boolean declTail__1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declTail__1")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COLON_EQ);
|
|
result_ = result_ && initializer(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// '::' initializer
|
|
private static boolean declTail__2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declTail__2")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COLON_COLON);
|
|
result_ = result_ && initializer(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// <<isDeclarationAhead>> declModifier_* declNames declTail_ NOTE* semi
|
|
public static boolean declaration(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declaration")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, DECLARATION, "<declaration>");
|
|
result_ = isDeclarationAhead(builder_, level_ + 1);
|
|
result_ = result_ && declaration_1(builder_, level_ + 1);
|
|
result_ = result_ && declNames(builder_, level_ + 1);
|
|
result_ = result_ && declTail_(builder_, level_ + 1);
|
|
result_ = result_ && declaration_4(builder_, level_ + 1);
|
|
result_ = result_ && semi(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// declModifier_*
|
|
private static boolean declaration_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declaration_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!declModifier_(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "declaration_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// NOTE*
|
|
private static boolean declaration_4(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "declaration_4")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!consumeToken(builder_, NOTE)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "declaration_4", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ['`'] 'defer' statement
|
|
public static boolean deferStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "deferStatement")) return false;
|
|
if (!nextTokenIs(builder_, "<defer statement>", BACKTICK, KW_DEFER)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, DEFER_STATEMENT, "<defer statement>");
|
|
result_ = deferStatement_0(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, KW_DEFER);
|
|
result_ = result_ && statement(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// ['`']
|
|
private static boolean deferStatement_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "deferStatement_0")) return false;
|
|
consumeToken(builder_, BACKTICK);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// <<dir "#assert">> expr [expr]
|
|
// | <<dirWithBlock>> [',' IDENT] block
|
|
// | <<dirWithOperand>> [',' IDENT] [expr]
|
|
// | <<dirPlain>> [',' IDENT]
|
|
public static boolean directiveExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, DIRECTIVE_EXPR, "<directive expr>");
|
|
result_ = directiveExpr_0(builder_, level_ + 1);
|
|
if (!result_) result_ = directiveExpr_1(builder_, level_ + 1);
|
|
if (!result_) result_ = directiveExpr_2(builder_, level_ + 1);
|
|
if (!result_) result_ = directiveExpr_3(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// <<dir "#assert">> expr [expr]
|
|
private static boolean directiveExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = dir(builder_, level_ + 1, "#assert");
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && directiveExpr_0_2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [expr]
|
|
private static boolean directiveExpr_0_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr_0_2")) return false;
|
|
expr(builder_, level_ + 1, -1);
|
|
return true;
|
|
}
|
|
|
|
// <<dirWithBlock>> [',' IDENT] block
|
|
private static boolean directiveExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr_1")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = dirWithBlock(builder_, level_ + 1);
|
|
result_ = result_ && directiveExpr_1_1(builder_, level_ + 1);
|
|
result_ = result_ && block(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [',' IDENT]
|
|
private static boolean directiveExpr_1_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr_1_1")) return false;
|
|
parseTokens(builder_, 0, COMMA, IDENT);
|
|
return true;
|
|
}
|
|
|
|
// <<dirWithOperand>> [',' IDENT] [expr]
|
|
private static boolean directiveExpr_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr_2")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = dirWithOperand(builder_, level_ + 1);
|
|
result_ = result_ && directiveExpr_2_1(builder_, level_ + 1);
|
|
result_ = result_ && directiveExpr_2_2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [',' IDENT]
|
|
private static boolean directiveExpr_2_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr_2_1")) return false;
|
|
parseTokens(builder_, 0, COMMA, IDENT);
|
|
return true;
|
|
}
|
|
|
|
// [expr]
|
|
private static boolean directiveExpr_2_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr_2_2")) return false;
|
|
expr(builder_, level_ + 1, -1);
|
|
return true;
|
|
}
|
|
|
|
// <<dirPlain>> [',' IDENT]
|
|
private static boolean directiveExpr_3(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr_3")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = dirPlain(builder_, level_ + 1);
|
|
result_ = result_ && directiveExpr_3_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [',' IDENT]
|
|
private static boolean directiveExpr_3_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveExpr_3_1")) return false;
|
|
parseTokens(builder_, 0, COMMA, IDENT);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// <<dirBare>> [',' IDENT] [';']
|
|
public static boolean directiveStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveStatement")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, DIRECTIVE_STATEMENT, "<directive statement>");
|
|
result_ = dirBare(builder_, level_ + 1);
|
|
result_ = result_ && directiveStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && directiveStatement_2(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// [',' IDENT]
|
|
private static boolean directiveStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveStatement_1")) return false;
|
|
parseTokens(builder_, 0, COMMA, IDENT);
|
|
return true;
|
|
}
|
|
|
|
// [';']
|
|
private static boolean directiveStatement_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "directiveStatement_2")) return false;
|
|
consumeToken(builder_, SEMICOLON);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'else' statement
|
|
public static boolean elseClause(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "elseClause")) return false;
|
|
if (!nextTokenIs(builder_, KW_ELSE)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_ELSE);
|
|
result_ = result_ && statement(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, ELSE_CLAUSE, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ('enum' | 'enum_flags') [!'{' expr] structModifier_* block
|
|
public static boolean enumExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "enumExpr")) return false;
|
|
if (!nextTokenIs(builder_, "<enum expr>", KW_ENUM, KW_ENUM_FLAGS)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, ENUM_EXPR, "<enum expr>");
|
|
result_ = enumExpr_0(builder_, level_ + 1);
|
|
result_ = result_ && enumExpr_1(builder_, level_ + 1);
|
|
result_ = result_ && enumExpr_2(builder_, level_ + 1);
|
|
result_ = result_ && block(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// 'enum' | 'enum_flags'
|
|
private static boolean enumExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "enumExpr_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, KW_ENUM);
|
|
if (!result_) result_ = consumeToken(builder_, KW_ENUM_FLAGS);
|
|
return result_;
|
|
}
|
|
|
|
// [!'{' expr]
|
|
private static boolean enumExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "enumExpr_1")) return false;
|
|
enumExpr_1_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// !'{' expr
|
|
private static boolean enumExpr_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "enumExpr_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = enumExpr_1_0_0(builder_, level_ + 1);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// !'{'
|
|
private static boolean enumExpr_1_0_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "enumExpr_1_0_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NOT_);
|
|
result_ = !consumeToken(builder_, LBRACE);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// structModifier_*
|
|
private static boolean enumExpr_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "enumExpr_2")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!structModifier_(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "enumExpr_2", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// expr (',' expr)* NOTE* semi
|
|
public static boolean expressionStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "expressionStatement")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, EXPRESSION_STATEMENT, "<expression statement>");
|
|
result_ = expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && expressionStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && expressionStatement_2(builder_, level_ + 1);
|
|
result_ = result_ && semi(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// (',' expr)*
|
|
private static boolean expressionStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "expressionStatement_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!expressionStatement_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "expressionStatement_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ',' expr
|
|
private static boolean expressionStatement_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "expressionStatement_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COMMA);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// NOTE*
|
|
private static boolean expressionStatement_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "expressionStatement_2")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!consumeToken(builder_, NOTE)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "expressionStatement_2", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '<' | '*'
|
|
static boolean forModifier_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forModifier_")) return false;
|
|
if (!nextTokenIs(builder_, "", LT, STAR)) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, LT);
|
|
if (!result_) result_ = consumeToken(builder_, STAR);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// IDENT (',' IDENT)*
|
|
public static boolean forNames(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forNames")) return false;
|
|
if (!nextTokenIs(builder_, IDENT)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, IDENT);
|
|
result_ = result_ && forNames_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, FOR_NAMES, result_);
|
|
return result_;
|
|
}
|
|
|
|
// (',' IDENT)*
|
|
private static boolean forNames_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forNames_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!forNames_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "forNames_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ',' IDENT
|
|
private static boolean forNames_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forNames_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokens(builder_, 0, COMMA, IDENT);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'for' [':' expr] forModifier_* [<<isForNamesAhead>> forNames ':'] expr statement
|
|
public static boolean forStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forStatement")) return false;
|
|
if (!nextTokenIs(builder_, KW_FOR)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_FOR);
|
|
result_ = result_ && forStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && forStatement_2(builder_, level_ + 1);
|
|
result_ = result_ && forStatement_3(builder_, level_ + 1);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && statement(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, FOR_STATEMENT, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [':' expr]
|
|
private static boolean forStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forStatement_1")) return false;
|
|
forStatement_1_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// ':' expr
|
|
private static boolean forStatement_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forStatement_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COLON);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// forModifier_*
|
|
private static boolean forStatement_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forStatement_2")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!forModifier_(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "forStatement_2", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// [<<isForNamesAhead>> forNames ':']
|
|
private static boolean forStatement_3(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forStatement_3")) return false;
|
|
forStatement_3_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// <<isForNamesAhead>> forNames ':'
|
|
private static boolean forStatement_3_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "forStatement_3_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = isForNamesAhead(builder_, level_ + 1);
|
|
result_ = result_ && forNames(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, COLON);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'if' | <<dir "#if">>
|
|
static boolean ifKeyword_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifKeyword_")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_IF);
|
|
if (!result_) result_ = dir(builder_, level_ + 1, "#if");
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ifKeyword_ [<<dir "#complete">>] expr (switchBody | ['then'] statement [elseClause])
|
|
public static boolean ifStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifStatement")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, IF_STATEMENT, "<if statement>");
|
|
result_ = ifKeyword_(builder_, level_ + 1);
|
|
result_ = result_ && ifStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && ifStatement_3(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// [<<dir "#complete">>]
|
|
private static boolean ifStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifStatement_1")) return false;
|
|
dir(builder_, level_ + 1, "#complete");
|
|
return true;
|
|
}
|
|
|
|
// switchBody | ['then'] statement [elseClause]
|
|
private static boolean ifStatement_3(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifStatement_3")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = switchBody(builder_, level_ + 1);
|
|
if (!result_) result_ = ifStatement_3_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ['then'] statement [elseClause]
|
|
private static boolean ifStatement_3_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifStatement_3_1")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = ifStatement_3_1_0(builder_, level_ + 1);
|
|
result_ = result_ && statement(builder_, level_ + 1);
|
|
result_ = result_ && ifStatement_3_1_2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ['then']
|
|
private static boolean ifStatement_3_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifStatement_3_1_0")) return false;
|
|
consumeToken(builder_, KW_THEN);
|
|
return true;
|
|
}
|
|
|
|
// [elseClause]
|
|
private static boolean ifStatement_3_1_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifStatement_3_1_2")) return false;
|
|
elseClause(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '---' | expr
|
|
public static boolean initializer(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "initializer")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, INITIALIZER, "<initializer>");
|
|
result_ = consumeToken(builder_, TRIPLE_MINUS);
|
|
if (!result_) result_ = expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'interface' [expr]
|
|
public static boolean interfaceExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "interfaceExpr")) return false;
|
|
if (!nextTokenIs(builder_, KW_INTERFACE)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_INTERFACE);
|
|
result_ = result_ && interfaceExpr_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, INTERFACE_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [expr]
|
|
private static boolean interfaceExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "interfaceExpr_1")) return false;
|
|
expr(builder_, level_ + 1, -1);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// statement*
|
|
static boolean jaiFile(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "jaiFile")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!statement(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "jaiFile", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'if' | 'for' | 'case' | 'enum' | 'cast' | 'union' | 'struct'
|
|
// | 'remove' | 'inline' | 'context' | 'operator' | 'interface'
|
|
// | 'type_info' | 'using' | 'defer' | 'return' | 'break'
|
|
// | 'continue' | 'then' | 'else' | 'while' | 'null' | 'true' | 'false'
|
|
static boolean keywordAsName_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "keywordAsName_")) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, KW_IF);
|
|
if (!result_) result_ = consumeToken(builder_, KW_FOR);
|
|
if (!result_) result_ = consumeToken(builder_, KW_CASE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_ENUM);
|
|
if (!result_) result_ = consumeToken(builder_, KW_CAST);
|
|
if (!result_) result_ = consumeToken(builder_, KW_UNION);
|
|
if (!result_) result_ = consumeToken(builder_, KW_STRUCT);
|
|
if (!result_) result_ = consumeToken(builder_, KW_REMOVE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_INLINE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_CONTEXT);
|
|
if (!result_) result_ = consumeToken(builder_, KW_OPERATOR);
|
|
if (!result_) result_ = consumeToken(builder_, KW_INTERFACE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_TYPE_INFO);
|
|
if (!result_) result_ = consumeToken(builder_, KW_USING);
|
|
if (!result_) result_ = consumeToken(builder_, KW_DEFER);
|
|
if (!result_) result_ = consumeToken(builder_, KW_RETURN);
|
|
if (!result_) result_ = consumeToken(builder_, KW_BREAK);
|
|
if (!result_) result_ = consumeToken(builder_, KW_CONTINUE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_THEN);
|
|
if (!result_) result_ = consumeToken(builder_, KW_ELSE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_WHILE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_NULL);
|
|
if (!result_) result_ = consumeToken(builder_, KW_TRUE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_FALSE);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// NUMBER | STRING | HERE_STRING | 'true' | 'false' | 'null' | 'context'
|
|
public static boolean literalExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "literalExpr")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, LITERAL_EXPR, "<literal expr>");
|
|
result_ = consumeToken(builder_, NUMBER);
|
|
if (!result_) result_ = consumeToken(builder_, STRING);
|
|
if (!result_) result_ = consumeToken(builder_, HERE_STRING);
|
|
if (!result_) result_ = consumeToken(builder_, KW_TRUE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_FALSE);
|
|
if (!result_) result_ = consumeToken(builder_, KW_NULL);
|
|
if (!result_) result_ = consumeToken(builder_, KW_CONTEXT);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// IDENT | NUMBER | keywordAsName_
|
|
public static boolean memberName(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "memberName")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, MEMBER_NAME, "<member name>");
|
|
result_ = consumeToken(builder_, IDENT);
|
|
if (!result_) result_ = consumeToken(builder_, NUMBER);
|
|
if (!result_) result_ = keywordAsName_(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// NOTE+
|
|
public static boolean noteStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "noteStatement")) return false;
|
|
if (!nextTokenIs(builder_, NOTE)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, NOTE);
|
|
while (result_) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!consumeToken(builder_, NOTE)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "noteStatement", pos_)) break;
|
|
}
|
|
exit_section_(builder_, marker_, NOTE_STATEMENT, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'operator' operatorSymbol '::' expr NOTE* semi
|
|
public static boolean operatorDeclaration(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "operatorDeclaration")) return false;
|
|
if (!nextTokenIs(builder_, KW_OPERATOR)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_OPERATOR);
|
|
result_ = result_ && operatorSymbol(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, COLON_COLON);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && operatorDeclaration_4(builder_, level_ + 1);
|
|
result_ = result_ && semi(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, OPERATOR_DECLARATION, result_);
|
|
return result_;
|
|
}
|
|
|
|
// NOTE*
|
|
private static boolean operatorDeclaration_4(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "operatorDeclaration_4")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!consumeToken(builder_, NOTE)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "operatorDeclaration_4", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '+' | '-' | '*' | '/' | '%' | '==' | '!=' | '<' | '>' | '<=' | '>='
|
|
// | '&' | '|' | '^' | '~' | '<<' | '>>' | '<<<' | '>>>'
|
|
// | '[' ']' | '[' ']' '='
|
|
public static boolean operatorSymbol(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "operatorSymbol")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, OPERATOR_SYMBOL, "<operator symbol>");
|
|
result_ = consumeToken(builder_, PLUS);
|
|
if (!result_) result_ = consumeToken(builder_, MINUS);
|
|
if (!result_) result_ = consumeToken(builder_, STAR);
|
|
if (!result_) result_ = consumeToken(builder_, SLASH);
|
|
if (!result_) result_ = consumeToken(builder_, PERCENT);
|
|
if (!result_) result_ = consumeToken(builder_, EQ_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, NOT_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, LT);
|
|
if (!result_) result_ = consumeToken(builder_, GT);
|
|
if (!result_) result_ = consumeToken(builder_, LT_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, GT_EQ);
|
|
if (!result_) result_ = consumeToken(builder_, AND);
|
|
if (!result_) result_ = consumeToken(builder_, OR);
|
|
if (!result_) result_ = consumeToken(builder_, XOR);
|
|
if (!result_) result_ = consumeToken(builder_, TILDE);
|
|
if (!result_) result_ = consumeToken(builder_, SHL);
|
|
if (!result_) result_ = consumeToken(builder_, SHR);
|
|
if (!result_) result_ = consumeToken(builder_, ROL);
|
|
if (!result_) result_ = consumeToken(builder_, ROR);
|
|
if (!result_) result_ = parseTokens(builder_, 0, LBRACKET, RBRACKET);
|
|
if (!result_) result_ = parseTokens(builder_, 0, LBRACKET, RBRACKET, EQ);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// parameter (',' parameter)* [',']
|
|
static boolean paramList(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramList")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = parameter(builder_, level_ + 1);
|
|
result_ = result_ && paramList_1(builder_, level_ + 1);
|
|
result_ = result_ && paramList_2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// (',' parameter)*
|
|
private static boolean paramList_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramList_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!paramList_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "paramList_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ',' parameter
|
|
private static boolean paramList_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramList_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COMMA);
|
|
result_ = result_ && parameter(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [',']
|
|
private static boolean paramList_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramList_2")) return false;
|
|
consumeToken(builder_, COMMA);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ['$' | '$$'] IDENT
|
|
public static boolean paramName(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramName")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, PARAM_NAME, "<param name>");
|
|
result_ = paramName_0(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, IDENT);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// ['$' | '$$']
|
|
private static boolean paramName_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramName_0")) return false;
|
|
paramName_0_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// '$' | '$$'
|
|
private static boolean paramName_0_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramName_0_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, DOLLAR);
|
|
if (!result_) result_ = consumeToken(builder_, DOUBLE_DOLLAR);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// paramName (',' paramName)*
|
|
public static boolean paramNames(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramNames")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, PARAM_NAMES, "<param names>");
|
|
result_ = paramName(builder_, level_ + 1);
|
|
result_ = result_ && paramNames_1(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// (',' paramName)*
|
|
private static boolean paramNames_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramNames_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!paramNames_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "paramNames_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ',' paramName
|
|
private static boolean paramNames_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramNames_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COMMA);
|
|
result_ = result_ && paramName(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ':' [<<exprNoAssign>>] ['=' initializer]
|
|
// | ':=' initializer
|
|
// | '::' initializer
|
|
static boolean paramTypeTail_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramTypeTail_")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = paramTypeTail__0(builder_, level_ + 1);
|
|
if (!result_) result_ = paramTypeTail__1(builder_, level_ + 1);
|
|
if (!result_) result_ = paramTypeTail__2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ':' [<<exprNoAssign>>] ['=' initializer]
|
|
private static boolean paramTypeTail__0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramTypeTail__0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COLON);
|
|
result_ = result_ && paramTypeTail__0_1(builder_, level_ + 1);
|
|
result_ = result_ && paramTypeTail__0_2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [<<exprNoAssign>>]
|
|
private static boolean paramTypeTail__0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramTypeTail__0_1")) return false;
|
|
exprNoAssign(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// ['=' initializer]
|
|
private static boolean paramTypeTail__0_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramTypeTail__0_2")) return false;
|
|
paramTypeTail__0_2_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// '=' initializer
|
|
private static boolean paramTypeTail__0_2_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramTypeTail__0_2_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, EQ);
|
|
result_ = result_ && initializer(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ':=' initializer
|
|
private static boolean paramTypeTail__1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramTypeTail__1")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COLON_EQ);
|
|
result_ = result_ && initializer(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// '::' initializer
|
|
private static boolean paramTypeTail__2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "paramTypeTail__2")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COLON_COLON);
|
|
result_ = result_ && initializer(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ['using'] parameterTail_
|
|
public static boolean parameter(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "parameter")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, PARAMETER, "<parameter>");
|
|
result_ = parameter_0(builder_, level_ + 1);
|
|
result_ = result_ && parameterTail_(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// ['using']
|
|
private static boolean parameter_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "parameter_0")) return false;
|
|
consumeToken(builder_, KW_USING);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// <<isParamNameAhead>> paramNames paramTypeTail_ | '..' | expr
|
|
static boolean parameterTail_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "parameterTail_")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = parameterTail__0(builder_, level_ + 1);
|
|
if (!result_) result_ = consumeToken(builder_, DOUBLE_DOT);
|
|
if (!result_) result_ = expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// <<isParamNameAhead>> paramNames paramTypeTail_
|
|
private static boolean parameterTail__0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "parameterTail__0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = isParamNameAhead(builder_, level_ + 1);
|
|
result_ = result_ && paramNames(builder_, level_ + 1);
|
|
result_ = result_ && paramTypeTail_(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '(' [expr (',' expr)*] ')'
|
|
public static boolean parenExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "parenExpr")) return false;
|
|
if (!nextTokenIs(builder_, LPAREN)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, LPAREN);
|
|
result_ = result_ && parenExpr_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RPAREN);
|
|
exit_section_(builder_, marker_, PAREN_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [expr (',' expr)*]
|
|
private static boolean parenExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "parenExpr_1")) return false;
|
|
parenExpr_1_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// expr (',' expr)*
|
|
private static boolean parenExpr_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "parenExpr_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && parenExpr_1_0_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// (',' expr)*
|
|
private static boolean parenExpr_1_0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "parenExpr_1_0_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!parenExpr_1_0_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "parenExpr_1_0_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ',' expr
|
|
private static boolean parenExpr_1_0_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "parenExpr_1_0_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COMMA);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '-' | '+' | '!' | '~' | '*' | '..' | '$' | '$$' | '<<' | '>>'
|
|
static boolean prefixOp_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "prefixOp_")) return false;
|
|
boolean result_;
|
|
result_ = consumeToken(builder_, MINUS);
|
|
if (!result_) result_ = consumeToken(builder_, PLUS);
|
|
if (!result_) result_ = consumeToken(builder_, NOT);
|
|
if (!result_) result_ = consumeToken(builder_, TILDE);
|
|
if (!result_) result_ = consumeToken(builder_, STAR);
|
|
if (!result_) result_ = consumeToken(builder_, DOUBLE_DOT);
|
|
if (!result_) result_ = consumeToken(builder_, DOLLAR);
|
|
if (!result_) result_ = consumeToken(builder_, DOUBLE_DOLLAR);
|
|
if (!result_) result_ = consumeToken(builder_, SHL);
|
|
if (!result_) result_ = consumeToken(builder_, SHR);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// <<isProcHeaderAhead>> '(' [paramList] ')' ['->' returnTypes_] procModifier* [block]
|
|
// | '->' returnTypes_ procModifier* [block]
|
|
public static boolean procLiteralExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, PROC_LITERAL_EXPR, "<proc literal expr>");
|
|
result_ = procLiteralExpr_0(builder_, level_ + 1);
|
|
if (!result_) result_ = procLiteralExpr_1(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// <<isProcHeaderAhead>> '(' [paramList] ')' ['->' returnTypes_] procModifier* [block]
|
|
private static boolean procLiteralExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = isProcHeaderAhead(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, LPAREN);
|
|
result_ = result_ && procLiteralExpr_0_2(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RPAREN);
|
|
result_ = result_ && procLiteralExpr_0_4(builder_, level_ + 1);
|
|
result_ = result_ && procLiteralExpr_0_5(builder_, level_ + 1);
|
|
result_ = result_ && procLiteralExpr_0_6(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [paramList]
|
|
private static boolean procLiteralExpr_0_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_2")) return false;
|
|
paramList(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// ['->' returnTypes_]
|
|
private static boolean procLiteralExpr_0_4(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_4")) return false;
|
|
procLiteralExpr_0_4_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// '->' returnTypes_
|
|
private static boolean procLiteralExpr_0_4_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_4_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, RIGHT_ARROW);
|
|
result_ = result_ && returnTypes_(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// procModifier*
|
|
private static boolean procLiteralExpr_0_5(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_5")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!procModifier(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "procLiteralExpr_0_5", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// [block]
|
|
private static boolean procLiteralExpr_0_6(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_6")) return false;
|
|
block(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// '->' returnTypes_ procModifier* [block]
|
|
private static boolean procLiteralExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr_1")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, RIGHT_ARROW);
|
|
result_ = result_ && returnTypes_(builder_, level_ + 1);
|
|
result_ = result_ && procLiteralExpr_1_2(builder_, level_ + 1);
|
|
result_ = result_ && procLiteralExpr_1_3(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// procModifier*
|
|
private static boolean procLiteralExpr_1_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr_1_2")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!procModifier(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "procLiteralExpr_1_2", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// [block]
|
|
private static boolean procLiteralExpr_1_3(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procLiteralExpr_1_3")) return false;
|
|
block(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// <<dirWithBlock>> block
|
|
// | <<dirWithOperand>> [',' IDENT] [expr]
|
|
// | <<dirPlain>> [',' IDENT]
|
|
public static boolean procModifier(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procModifier")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, PROC_MODIFIER, "<proc modifier>");
|
|
result_ = procModifier_0(builder_, level_ + 1);
|
|
if (!result_) result_ = procModifier_1(builder_, level_ + 1);
|
|
if (!result_) result_ = procModifier_2(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// <<dirWithBlock>> block
|
|
private static boolean procModifier_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procModifier_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = dirWithBlock(builder_, level_ + 1);
|
|
result_ = result_ && block(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// <<dirWithOperand>> [',' IDENT] [expr]
|
|
private static boolean procModifier_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procModifier_1")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = dirWithOperand(builder_, level_ + 1);
|
|
result_ = result_ && procModifier_1_1(builder_, level_ + 1);
|
|
result_ = result_ && procModifier_1_2(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [',' IDENT]
|
|
private static boolean procModifier_1_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procModifier_1_1")) return false;
|
|
parseTokens(builder_, 0, COMMA, IDENT);
|
|
return true;
|
|
}
|
|
|
|
// [expr]
|
|
private static boolean procModifier_1_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procModifier_1_2")) return false;
|
|
expr(builder_, level_ + 1, -1);
|
|
return true;
|
|
}
|
|
|
|
// <<dirPlain>> [',' IDENT]
|
|
private static boolean procModifier_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procModifier_2")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = dirPlain(builder_, level_ + 1);
|
|
result_ = result_ && procModifier_2_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [',' IDENT]
|
|
private static boolean procModifier_2_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "procModifier_2_1")) return false;
|
|
parseTokens(builder_, 0, COMMA, IDENT);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ['`'] 'push_context' expr block
|
|
public static boolean pushContextStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "pushContextStatement")) return false;
|
|
if (!nextTokenIs(builder_, "<push context statement>", BACKTICK, KW_PUSH_CONTEXT)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, PUSH_CONTEXT_STATEMENT, "<push context statement>");
|
|
result_ = pushContextStatement_0(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, KW_PUSH_CONTEXT);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && block(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// ['`']
|
|
private static boolean pushContextStatement_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "pushContextStatement_0")) return false;
|
|
consumeToken(builder_, BACKTICK);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// IDENT
|
|
public static boolean refExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "refExpr")) return false;
|
|
if (!nextTokenIs(builder_, IDENT)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, IDENT);
|
|
exit_section_(builder_, marker_, REF_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'remove' [expr] semi
|
|
public static boolean removeStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "removeStatement")) return false;
|
|
if (!nextTokenIs(builder_, KW_REMOVE)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_REMOVE);
|
|
result_ = result_ && removeStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && semi(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, REMOVE_STATEMENT, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [expr]
|
|
private static boolean removeStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "removeStatement_1")) return false;
|
|
expr(builder_, level_ + 1, -1);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '(' [returnItem (',' returnItem)*] ')'
|
|
public static boolean returnGroup(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnGroup")) return false;
|
|
if (!nextTokenIs(builder_, LPAREN)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, LPAREN);
|
|
result_ = result_ && returnGroup_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RPAREN);
|
|
exit_section_(builder_, marker_, RETURN_GROUP, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [returnItem (',' returnItem)*]
|
|
private static boolean returnGroup_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnGroup_1")) return false;
|
|
returnGroup_1_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// returnItem (',' returnItem)*
|
|
private static boolean returnGroup_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnGroup_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = returnItem(builder_, level_ + 1);
|
|
result_ = result_ && returnGroup_1_0_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// (',' returnItem)*
|
|
private static boolean returnGroup_1_0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnGroup_1_0_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!returnGroup_1_0_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "returnGroup_1_0_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ',' returnItem
|
|
private static boolean returnGroup_1_0_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnGroup_1_0_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COMMA);
|
|
result_ = result_ && returnItem(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// [<<isParamNameAhead>> IDENT ':'] <<exprNoAssign>> ['=' initializer]
|
|
public static boolean returnItem(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnItem")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, RETURN_ITEM, "<return item>");
|
|
result_ = returnItem_0(builder_, level_ + 1);
|
|
result_ = result_ && exprNoAssign(builder_, level_ + 1);
|
|
result_ = result_ && returnItem_2(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
// [<<isParamNameAhead>> IDENT ':']
|
|
private static boolean returnItem_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnItem_0")) return false;
|
|
returnItem_0_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// <<isParamNameAhead>> IDENT ':'
|
|
private static boolean returnItem_0_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnItem_0_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = isParamNameAhead(builder_, level_ + 1);
|
|
result_ = result_ && consumeTokens(builder_, 0, IDENT, COLON);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ['=' initializer]
|
|
private static boolean returnItem_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnItem_2")) return false;
|
|
returnItem_2_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// '=' initializer
|
|
private static boolean returnItem_2_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnItem_2_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, EQ);
|
|
result_ = result_ && initializer(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'return' [expr (',' expr)*] NOTE* semi
|
|
public static boolean returnStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnStatement")) return false;
|
|
if (!nextTokenIs(builder_, KW_RETURN)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_RETURN);
|
|
result_ = result_ && returnStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && returnStatement_2(builder_, level_ + 1);
|
|
result_ = result_ && semi(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, RETURN_STATEMENT, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [expr (',' expr)*]
|
|
private static boolean returnStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnStatement_1")) return false;
|
|
returnStatement_1_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// expr (',' expr)*
|
|
private static boolean returnStatement_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnStatement_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && returnStatement_1_0_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// (',' expr)*
|
|
private static boolean returnStatement_1_0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnStatement_1_0_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!returnStatement_1_0_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "returnStatement_1_0_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ',' expr
|
|
private static boolean returnStatement_1_0_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnStatement_1_0_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COMMA);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// NOTE*
|
|
private static boolean returnStatement_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnStatement_2")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!consumeToken(builder_, NOTE)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "returnStatement_2", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// <<isReturnGroupAhead>> returnGroup | returnItem (',' returnItem)*
|
|
static boolean returnTypes_(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnTypes_")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = returnTypes__0(builder_, level_ + 1);
|
|
if (!result_) result_ = returnTypes__1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// <<isReturnGroupAhead>> returnGroup
|
|
private static boolean returnTypes__0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnTypes__0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = isReturnGroupAhead(builder_, level_ + 1);
|
|
result_ = result_ && returnGroup(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// returnItem (',' returnItem)*
|
|
private static boolean returnTypes__1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnTypes__1")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = returnItem(builder_, level_ + 1);
|
|
result_ = result_ && returnTypes__1_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// (',' returnItem)*
|
|
private static boolean returnTypes__1_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnTypes__1_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!returnTypes__1_1_0(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "returnTypes__1_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ',' returnItem
|
|
private static boolean returnTypes__1_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "returnTypes__1_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COMMA);
|
|
result_ = result_ && returnItem(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ';' | <<prevEndsConstruct>>
|
|
static boolean semi(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "semi")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, SEMICOLON);
|
|
if (!result_) result_ = prevEndsConstruct(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// ';'
|
|
// | block
|
|
// | ifStatement
|
|
// | whileStatement
|
|
// | forStatement
|
|
// | returnStatement
|
|
// | breakStatement
|
|
// | continueStatement
|
|
// | removeStatement
|
|
// | deferStatement
|
|
// | pushContextStatement
|
|
// | operatorDeclaration
|
|
// | usingStatement
|
|
// | noteStatement
|
|
// | directiveStatement
|
|
// | declaration
|
|
// | expressionStatement
|
|
public static boolean statement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "statement")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, STATEMENT, "<statement>");
|
|
result_ = consumeToken(builder_, SEMICOLON);
|
|
if (!result_) result_ = block(builder_, level_ + 1);
|
|
if (!result_) result_ = ifStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = whileStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = forStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = returnStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = breakStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = continueStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = removeStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = deferStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = pushContextStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = operatorDeclaration(builder_, level_ + 1);
|
|
if (!result_) result_ = usingStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = noteStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = directiveStatement(builder_, level_ + 1);
|
|
if (!result_) result_ = declaration(builder_, level_ + 1);
|
|
if (!result_) result_ = expressionStatement(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'struct' ['(' [paramList] ')'] structModifier_* block
|
|
public static boolean structExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "structExpr")) return false;
|
|
if (!nextTokenIs(builder_, KW_STRUCT)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_STRUCT);
|
|
result_ = result_ && structExpr_1(builder_, level_ + 1);
|
|
result_ = result_ && structExpr_2(builder_, level_ + 1);
|
|
result_ = result_ && block(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, STRUCT_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ['(' [paramList] ')']
|
|
private static boolean structExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "structExpr_1")) return false;
|
|
structExpr_1_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// '(' [paramList] ')'
|
|
private static boolean structExpr_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "structExpr_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, LPAREN);
|
|
result_ = result_ && structExpr_1_0_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RPAREN);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [paramList]
|
|
private static boolean structExpr_1_0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "structExpr_1_0_1")) return false;
|
|
paramList(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// structModifier_*
|
|
private static boolean structExpr_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "structExpr_2")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!structModifier_(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "structExpr_2", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '.{' [argList] '}'
|
|
public static boolean structLiteralExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "structLiteralExpr")) return false;
|
|
if (!nextTokenIs(builder_, BEGIN_STRUCT_LITERAL)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, BEGIN_STRUCT_LITERAL);
|
|
result_ = result_ && structLiteralExpr_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RBRACE);
|
|
exit_section_(builder_, marker_, STRUCT_LITERAL_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [argList]
|
|
private static boolean structLiteralExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "structLiteralExpr_1")) return false;
|
|
argList(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// procModifier
|
|
static boolean structModifier_(PsiBuilder builder_, int level_) {
|
|
return procModifier(builder_, level_ + 1);
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '==' '{' caseClause* '}'
|
|
public static boolean switchBody(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "switchBody")) return false;
|
|
if (!nextTokenIs(builder_, EQ_EQ)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokens(builder_, 0, EQ_EQ, LBRACE);
|
|
result_ = result_ && switchBody_2(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RBRACE);
|
|
exit_section_(builder_, marker_, SWITCH_BODY, result_);
|
|
return result_;
|
|
}
|
|
|
|
// caseClause*
|
|
private static boolean switchBody_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "switchBody_2")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!caseClause(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "switchBody_2", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '.' memberName
|
|
public static boolean unaryDotExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "unaryDotExpr")) return false;
|
|
if (!nextTokenIs(builder_, DOT)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, DOT);
|
|
result_ = result_ && memberName(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, UNARY_DOT_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// '---' | '--'
|
|
public static boolean uninitializedExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "uninitializedExpr")) return false;
|
|
if (!nextTokenIs(builder_, "<uninitialized expr>", DOUBLE_MINUS, TRIPLE_MINUS)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, UNINITIALIZED_EXPR, "<uninitialized expr>");
|
|
result_ = consumeToken(builder_, TRIPLE_MINUS);
|
|
if (!result_) result_ = consumeToken(builder_, DOUBLE_MINUS);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'union' structModifier_* block
|
|
public static boolean unionExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "unionExpr")) return false;
|
|
if (!nextTokenIs(builder_, KW_UNION)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_UNION);
|
|
result_ = result_ && unionExpr_1(builder_, level_ + 1);
|
|
result_ = result_ && block(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, UNION_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// structModifier_*
|
|
private static boolean unionExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "unionExpr_1")) return false;
|
|
while (true) {
|
|
int pos_ = current_position_(builder_);
|
|
if (!structModifier_(builder_, level_ + 1)) break;
|
|
if (!empty_element_parsed_guard_(builder_, "unionExpr_1", pos_)) break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'using' [',' expr] expr semi
|
|
public static boolean usingStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "usingStatement")) return false;
|
|
if (!nextTokenIs(builder_, KW_USING)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_USING);
|
|
result_ = result_ && usingStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && semi(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, USING_STATEMENT, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [',' expr]
|
|
private static boolean usingStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "usingStatement_1")) return false;
|
|
usingStatement_1_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// ',' expr
|
|
private static boolean usingStatement_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "usingStatement_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, COMMA);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// 'while' [<<isLabelAhead>> IDENT ':'] expr statement
|
|
public static boolean whileStatement(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "whileStatement")) return false;
|
|
if (!nextTokenIs(builder_, KW_WHILE)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeToken(builder_, KW_WHILE);
|
|
result_ = result_ && whileStatement_1(builder_, level_ + 1);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && statement(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, WHILE_STATEMENT, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [<<isLabelAhead>> IDENT ':']
|
|
private static boolean whileStatement_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "whileStatement_1")) return false;
|
|
whileStatement_1_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// <<isLabelAhead>> IDENT ':'
|
|
private static boolean whileStatement_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "whileStatement_1_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = isLabelAhead(builder_, level_ + 1);
|
|
result_ = result_ && consumeTokens(builder_, 0, IDENT, COLON);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
/* ********************************************************** */
|
|
// Expression root: expr
|
|
// Operator priority table:
|
|
// 0: BINARY(assignExpr)
|
|
// 1: BINARY(lambdaExpr)
|
|
// 2: BINARY(orExpr)
|
|
// 3: BINARY(andExpr)
|
|
// 4: BINARY(equalityExpr)
|
|
// 5: BINARY(relationalExpr)
|
|
// 6: BINARY(bitOrExpr)
|
|
// 7: BINARY(bitXorExpr)
|
|
// 8: BINARY(bitAndExpr)
|
|
// 9: BINARY(shiftExpr)
|
|
// 10: BINARY(rangeExpr)
|
|
// 11: BINARY(addExpr)
|
|
// 12: BINARY(mulExpr)
|
|
// 13: PREFIX(prefixExpr)
|
|
// 14: ATOM(arrayTypeExpr)
|
|
// 15: ATOM(castExpr)
|
|
// 16: PREFIX(autoCastExpr)
|
|
// 17: PREFIX(inlineExpr)
|
|
// 18: ATOM(ifxExpr)
|
|
// 19: POSTFIX(callExpr)
|
|
// 20: POSTFIX(indexExpr)
|
|
// 21: POSTFIX(memberExpr)
|
|
// 22: POSTFIX(derefExpr)
|
|
// 23: POSTFIX(typedStructLiteralExpr)
|
|
// 24: POSTFIX(typedArrayLiteralExpr)
|
|
// 25: ATOM(primaryExpr)
|
|
public static boolean expr(PsiBuilder builder_, int level_, int priority_) {
|
|
if (!recursion_guard_(builder_, level_, "expr")) return false;
|
|
addVariant(builder_, "<expr>");
|
|
boolean result_, pinned_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, "<expr>");
|
|
result_ = prefixExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = arrayTypeExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = castExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = autoCastExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = inlineExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = ifxExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = primaryExpr(builder_, level_ + 1);
|
|
pinned_ = result_;
|
|
result_ = result_ && expr_0(builder_, level_ + 1, priority_);
|
|
exit_section_(builder_, level_, marker_, null, result_, pinned_, null);
|
|
return result_ || pinned_;
|
|
}
|
|
|
|
public static boolean expr_0(PsiBuilder builder_, int level_, int priority_) {
|
|
if (!recursion_guard_(builder_, level_, "expr_0")) return false;
|
|
boolean result_ = true;
|
|
while (true) {
|
|
Marker marker_ = enter_section_(builder_, level_, _LEFT_, null);
|
|
if (priority_ < 0 && assignOp_(builder_, level_ + 1)) {
|
|
result_ = expr(builder_, level_, -1);
|
|
exit_section_(builder_, level_, marker_, ASSIGN_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 1 && consumeTokenSmart(builder_, QUICK_LAMBDA)) {
|
|
result_ = expr(builder_, level_, 0);
|
|
exit_section_(builder_, level_, marker_, LAMBDA_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 2 && consumeTokenSmart(builder_, OR_OR)) {
|
|
result_ = expr(builder_, level_, 2);
|
|
exit_section_(builder_, level_, marker_, OR_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 3 && consumeTokenSmart(builder_, AND_AND)) {
|
|
result_ = expr(builder_, level_, 3);
|
|
exit_section_(builder_, level_, marker_, AND_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 4 && equalityExpr_0(builder_, level_ + 1)) {
|
|
result_ = expr(builder_, level_, 4);
|
|
exit_section_(builder_, level_, marker_, EQUALITY_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 5 && relationalExpr_0(builder_, level_ + 1)) {
|
|
result_ = expr(builder_, level_, 5);
|
|
exit_section_(builder_, level_, marker_, RELATIONAL_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 6 && consumeTokenSmart(builder_, OR)) {
|
|
result_ = expr(builder_, level_, 6);
|
|
exit_section_(builder_, level_, marker_, BIT_OR_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 7 && consumeTokenSmart(builder_, XOR)) {
|
|
result_ = expr(builder_, level_, 7);
|
|
exit_section_(builder_, level_, marker_, BIT_XOR_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 8 && consumeTokenSmart(builder_, AND)) {
|
|
result_ = expr(builder_, level_, 8);
|
|
exit_section_(builder_, level_, marker_, BIT_AND_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 9 && shiftExpr_0(builder_, level_ + 1)) {
|
|
result_ = expr(builder_, level_, 9);
|
|
exit_section_(builder_, level_, marker_, SHIFT_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 10 && consumeTokenSmart(builder_, DOUBLE_DOT)) {
|
|
result_ = expr(builder_, level_, 10);
|
|
exit_section_(builder_, level_, marker_, RANGE_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 11 && addExpr_0(builder_, level_ + 1)) {
|
|
result_ = expr(builder_, level_, 11);
|
|
exit_section_(builder_, level_, marker_, ADD_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 12 && mulExpr_0(builder_, level_ + 1)) {
|
|
result_ = expr(builder_, level_, 12);
|
|
exit_section_(builder_, level_, marker_, MUL_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 19 && callExpr_0(builder_, level_ + 1)) {
|
|
result_ = true;
|
|
exit_section_(builder_, level_, marker_, CALL_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 20 && indexExpr_0(builder_, level_ + 1)) {
|
|
result_ = true;
|
|
exit_section_(builder_, level_, marker_, INDEX_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 21 && memberExpr_0(builder_, level_ + 1)) {
|
|
result_ = true;
|
|
exit_section_(builder_, level_, marker_, MEMBER_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 22 && consumeTokenSmart(builder_, POSTFIX_DEREFERENCE)) {
|
|
result_ = true;
|
|
exit_section_(builder_, level_, marker_, DEREF_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 23 && typedStructLiteralExpr_0(builder_, level_ + 1)) {
|
|
result_ = true;
|
|
exit_section_(builder_, level_, marker_, TYPED_STRUCT_LITERAL_EXPR, result_, true, null);
|
|
}
|
|
else if (priority_ < 24 && typedArrayLiteralExpr_0(builder_, level_ + 1)) {
|
|
result_ = true;
|
|
exit_section_(builder_, level_, marker_, TYPED_ARRAY_LITERAL_EXPR, result_, true, null);
|
|
}
|
|
else {
|
|
exit_section_(builder_, level_, marker_, null, false, false, null);
|
|
break;
|
|
}
|
|
}
|
|
return result_;
|
|
}
|
|
|
|
// <<eqEqNotSwitch>> | '!=' | '==='
|
|
private static boolean equalityExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "equalityExpr_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = eqEqNotSwitch(builder_, level_ + 1);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, NOT_EQ);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, EQ_EQ_EQ);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// '<' | '>' | '<=' | '>='
|
|
private static boolean relationalExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "relationalExpr_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeTokenSmart(builder_, LT);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, GT);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, LT_EQ);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, GT_EQ);
|
|
return result_;
|
|
}
|
|
|
|
// '<<' | '>>' | '<<<' | '>>>'
|
|
private static boolean shiftExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "shiftExpr_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeTokenSmart(builder_, SHL);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, SHR);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, ROL);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, ROR);
|
|
return result_;
|
|
}
|
|
|
|
// '+' | '-'
|
|
private static boolean addExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "addExpr_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeTokenSmart(builder_, PLUS);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, MINUS);
|
|
return result_;
|
|
}
|
|
|
|
// '*' | '/' | '%'
|
|
private static boolean mulExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "mulExpr_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeTokenSmart(builder_, STAR);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, SLASH);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, PERCENT);
|
|
return result_;
|
|
}
|
|
|
|
public static boolean prefixExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "prefixExpr")) return false;
|
|
boolean result_, pinned_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
|
|
result_ = prefixOp_(builder_, level_ + 1);
|
|
pinned_ = result_;
|
|
result_ = pinned_ && expr(builder_, level_, 13);
|
|
exit_section_(builder_, level_, marker_, PREFIX_EXPR, result_, pinned_, null);
|
|
return result_ || pinned_;
|
|
}
|
|
|
|
// '[' ['..' | expr] ']' expr
|
|
public static boolean arrayTypeExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "arrayTypeExpr")) return false;
|
|
if (!nextTokenIsSmart(builder_, LBRACKET)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, LBRACKET);
|
|
result_ = result_ && arrayTypeExpr_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RBRACKET);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, ARRAY_TYPE_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ['..' | expr]
|
|
private static boolean arrayTypeExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "arrayTypeExpr_1")) return false;
|
|
arrayTypeExpr_1_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// '..' | expr
|
|
private static boolean arrayTypeExpr_1_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "arrayTypeExpr_1_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeTokenSmart(builder_, DOUBLE_DOT);
|
|
if (!result_) result_ = expr(builder_, level_ + 1, -1);
|
|
return result_;
|
|
}
|
|
|
|
// 'cast' [',' IDENT] '(' [expr] ')' expr
|
|
public static boolean castExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "castExpr")) return false;
|
|
if (!nextTokenIsSmart(builder_, KW_CAST)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, KW_CAST);
|
|
result_ = result_ && castExpr_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, LPAREN);
|
|
result_ = result_ && castExpr_3(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RPAREN);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, CAST_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [',' IDENT]
|
|
private static boolean castExpr_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "castExpr_1")) return false;
|
|
parseTokensSmart(builder_, 0, COMMA, IDENT);
|
|
return true;
|
|
}
|
|
|
|
// [expr]
|
|
private static boolean castExpr_3(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "castExpr_3")) return false;
|
|
expr(builder_, level_ + 1, -1);
|
|
return true;
|
|
}
|
|
|
|
public static boolean autoCastExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "autoCastExpr")) return false;
|
|
if (!nextTokenIsSmart(builder_, KW_XX)) return false;
|
|
boolean result_, pinned_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
|
|
result_ = autoCastExpr_0(builder_, level_ + 1);
|
|
pinned_ = result_;
|
|
result_ = pinned_ && expr(builder_, level_, 16);
|
|
exit_section_(builder_, level_, marker_, AUTO_CAST_EXPR, result_, pinned_, null);
|
|
return result_ || pinned_;
|
|
}
|
|
|
|
// 'xx' [',' IDENT]
|
|
private static boolean autoCastExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "autoCastExpr_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, KW_XX);
|
|
result_ = result_ && autoCastExpr_0_1(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [',' IDENT]
|
|
private static boolean autoCastExpr_0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "autoCastExpr_0_1")) return false;
|
|
parseTokensSmart(builder_, 0, COMMA, IDENT);
|
|
return true;
|
|
}
|
|
|
|
public static boolean inlineExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "inlineExpr")) return false;
|
|
if (!nextTokenIsSmart(builder_, KW_INLINE, KW_NO_INLINE)) return false;
|
|
boolean result_, pinned_;
|
|
Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
|
|
result_ = inlineExpr_0(builder_, level_ + 1);
|
|
pinned_ = result_;
|
|
result_ = pinned_ && expr(builder_, level_, 17);
|
|
exit_section_(builder_, level_, marker_, INLINE_EXPR, result_, pinned_, null);
|
|
return result_ || pinned_;
|
|
}
|
|
|
|
// 'inline' | 'no_inline'
|
|
private static boolean inlineExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "inlineExpr_0")) return false;
|
|
boolean result_;
|
|
result_ = consumeTokenSmart(builder_, KW_INLINE);
|
|
if (!result_) result_ = consumeTokenSmart(builder_, KW_NO_INLINE);
|
|
return result_;
|
|
}
|
|
|
|
// 'ifx' expr ['then'] expr ['else' expr]
|
|
public static boolean ifxExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifxExpr")) return false;
|
|
if (!nextTokenIsSmart(builder_, KW_IFX)) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, KW_IFX);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && ifxExpr_2(builder_, level_ + 1);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
result_ = result_ && ifxExpr_4(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, IFX_EXPR, result_);
|
|
return result_;
|
|
}
|
|
|
|
// ['then']
|
|
private static boolean ifxExpr_2(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifxExpr_2")) return false;
|
|
consumeTokenSmart(builder_, KW_THEN);
|
|
return true;
|
|
}
|
|
|
|
// ['else' expr]
|
|
private static boolean ifxExpr_4(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifxExpr_4")) return false;
|
|
ifxExpr_4_0(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// 'else' expr
|
|
private static boolean ifxExpr_4_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "ifxExpr_4_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, KW_ELSE);
|
|
result_ = result_ && expr(builder_, level_ + 1, -1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// '(' [argList] ')'
|
|
private static boolean callExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "callExpr_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, LPAREN);
|
|
result_ = result_ && callExpr_0_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RPAREN);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [argList]
|
|
private static boolean callExpr_0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "callExpr_0_1")) return false;
|
|
argList(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// '[' [expr] ']'
|
|
private static boolean indexExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "indexExpr_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, LBRACKET);
|
|
result_ = result_ && indexExpr_0_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RBRACKET);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [expr]
|
|
private static boolean indexExpr_0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "indexExpr_0_1")) return false;
|
|
expr(builder_, level_ + 1, -1);
|
|
return true;
|
|
}
|
|
|
|
// '.' memberName
|
|
private static boolean memberExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "memberExpr_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, DOT);
|
|
result_ = result_ && memberName(builder_, level_ + 1);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// '.{' [argList] '}'
|
|
private static boolean typedStructLiteralExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "typedStructLiteralExpr_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, BEGIN_STRUCT_LITERAL);
|
|
result_ = result_ && typedStructLiteralExpr_0_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RBRACE);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [argList]
|
|
private static boolean typedStructLiteralExpr_0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "typedStructLiteralExpr_0_1")) return false;
|
|
argList(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// '.[' [argList] ']'
|
|
private static boolean typedArrayLiteralExpr_0(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "typedArrayLiteralExpr_0")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_);
|
|
result_ = consumeTokenSmart(builder_, BEGIN_ARRAY_LITERAL);
|
|
result_ = result_ && typedArrayLiteralExpr_0_1(builder_, level_ + 1);
|
|
result_ = result_ && consumeToken(builder_, RBRACKET);
|
|
exit_section_(builder_, marker_, null, result_);
|
|
return result_;
|
|
}
|
|
|
|
// [argList]
|
|
private static boolean typedArrayLiteralExpr_0_1(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "typedArrayLiteralExpr_0_1")) return false;
|
|
argList(builder_, level_ + 1);
|
|
return true;
|
|
}
|
|
|
|
// procLiteralExpr
|
|
// | structExpr
|
|
// | enumExpr
|
|
// | unionExpr
|
|
// | directiveExpr
|
|
// | parenExpr
|
|
// | structLiteralExpr
|
|
// | arrayLiteralExpr
|
|
// | unaryDotExpr
|
|
// | backtickExpr
|
|
// | builtinCallExpr
|
|
// | interfaceExpr
|
|
// | literalExpr
|
|
// | refExpr
|
|
// | uninitializedExpr
|
|
public static boolean primaryExpr(PsiBuilder builder_, int level_) {
|
|
if (!recursion_guard_(builder_, level_, "primaryExpr")) return false;
|
|
boolean result_;
|
|
Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, PRIMARY_EXPR, "<primary expr>");
|
|
result_ = procLiteralExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = structExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = enumExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = unionExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = directiveExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = parenExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = structLiteralExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = arrayLiteralExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = unaryDotExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = backtickExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = builtinCallExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = interfaceExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = literalExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = refExpr(builder_, level_ + 1);
|
|
if (!result_) result_ = uninitializedExpr(builder_, level_ + 1);
|
|
exit_section_(builder_, level_, marker_, result_, false, null);
|
|
return result_;
|
|
}
|
|
|
|
}
|