// This is a generated file. Not intended for manual editing.
package com.nasmlanguage.parser;
import com.intellij.lang.PsiBuilder;
import com.intellij.lang.PsiBuilder.Marker;
import static com.nasmlanguage.psi.NASMTypes.*;
import static com.nasmlanguage.parser.NASMParserUtil.*;
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 NASMParser implements PsiParser, LightPsiParser {
public ASTNode parse(IElementType t, PsiBuilder b) {
parseLight(t, b);
return b.getTreeBuilt();
}
public void parseLight(IElementType t, PsiBuilder b) {
boolean r;
b = adapt_builder_(t, b, this, EXTENDS_SETS_);
Marker m = enter_section_(b, 0, _COLLAPSE_, null);
r = parse_root_(t, b);
exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
}
protected boolean parse_root_(IElementType t, PsiBuilder b) {
return parse_root_(t, b, 0);
}
static boolean parse_root_(IElementType t, PsiBuilder b, int l) {
return NASMFile(b, l + 1);
}
public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] {
create_token_set_(ADDRESS, BITWISE_AND_EXPR, BITWISE_NOT_EXPR, BITWISE_OR_EXPR,
BITWISE_XOR_EXPR, BIT_SHIFT_L_EXPR, BIT_SHIFT_R_EXPR, DIV_EXPR,
END_DIRECTIVE, EXPR, IDENTIFIER, LABEL_IDENTIFIER,
LOGICAL_AND_EXPR, LOGICAL_OR_EXPR, LOGICAL_XOR_EXPR, MACRO_CALL,
MACRO_DEF_CALL, MACRO_PARAM_COUNTER, MACRO_PARAM_REFERENCE, MACRO_VAR_REFERENCE,
MINUS_EXPR, MNEMONIC, MODULUS_EXPR, MUL_EXPR,
NUMERIC_LITERAL, PARENTHESIS_EXPR, PLUS_EXPR, REG,
SEG, SEGMENT_ADDRESS, STR, STRUCTURE_FIELD,
TOKEN_CONCAT_EXPR),
};
/* ********************************************************** */
// SQUARE_L MINUS? Expr SQUARE_R
static boolean AddressInternal(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "AddressInternal")) return false;
if (!nextTokenIs(b, SQUARE_L)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_);
r = consumeToken(b, SQUARE_L);
p = r; // pin = 1
r = r && report_error_(b, AddressInternal_1(b, l + 1));
r = p && report_error_(b, Expr(b, l + 1, -1)) && r;
r = p && consumeToken(b, SQUARE_R) && r;
exit_section_(b, l, m, r, p, null);
return r || p;
}
// MINUS?
private static boolean AddressInternal_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "AddressInternal_1")) return false;
consumeToken(b, MINUS);
return true;
}
/* ********************************************************** */
// ASSIGN_TAG Identifier Expr
public static boolean Assign(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Assign")) return false;
if (!nextTokenIs(b, ASSIGN_TAG)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, ASSIGN_TAG);
r = r && Identifier(b, l + 1);
r = r && Expr(b, l + 1, -1);
exit_section_(b, m, ASSIGN, r);
return r;
}
/* ********************************************************** */
// Expr (EQUALEQUAL|NOTEQUAL|GREATERTHAN|LESSTHAN|GREATERTHANOREQUAL|LESSTHANOREQUAL|SEPARATOR) Expr
static boolean Condition(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Condition")) return false;
boolean r;
Marker m = enter_section_(b);
r = Expr(b, l + 1, -1);
r = r && Condition_1(b, l + 1);
r = r && Expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
// EQUALEQUAL|NOTEQUAL|GREATERTHAN|LESSTHAN|GREATERTHANOREQUAL|LESSTHANOREQUAL|SEPARATOR
private static boolean Condition_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Condition_1")) return false;
boolean r;
r = consumeToken(b, EQUALEQUAL);
if (!r) r = consumeToken(b, NOTEQUAL);
if (!r) r = consumeToken(b, GREATERTHAN);
if (!r) r = consumeToken(b, LESSTHAN);
if (!r) r = consumeToken(b, GREATERTHANOREQUAL);
if (!r) r = consumeToken(b, LESSTHANOREQUAL);
if (!r) r = consumeToken(b, SEPARATOR);
return r;
}
/* ********************************************************** */
// (IfConditionTag (Condition|MacroCondition|Expr) NL* Element* (((ELIF_TAG (Condition|MacroCondition|Expr))|ELSE_TAG) NL* Element*)*) ENDIF_TAG NL*
public static boolean Conditional(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, CONDITIONAL, "<conditional>");
r = Conditional_0(b, l + 1);
r = r && consumeToken(b, ENDIF_TAG);
r = r && Conditional_2(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// IfConditionTag (Condition|MacroCondition|Expr) NL* Element* (((ELIF_TAG (Condition|MacroCondition|Expr))|ELSE_TAG) NL* Element*)*
private static boolean Conditional_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = IfConditionTag(b, l + 1);
r = r && Conditional_0_1(b, l + 1);
r = r && Conditional_0_2(b, l + 1);
r = r && Conditional_0_3(b, l + 1);
r = r && Conditional_0_4(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// Condition|MacroCondition|Expr
private static boolean Conditional_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_1")) return false;
boolean r;
r = Condition(b, l + 1);
if (!r) r = MacroCondition(b, l + 1);
if (!r) r = Expr(b, l + 1, -1);
return r;
}
// NL*
private static boolean Conditional_0_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_2")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Conditional_0_2", c)) break;
}
return true;
}
// Element*
private static boolean Conditional_0_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_3")) return false;
while (true) {
int c = current_position_(b);
if (!Element(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "Conditional_0_3", c)) break;
}
return true;
}
// (((ELIF_TAG (Condition|MacroCondition|Expr))|ELSE_TAG) NL* Element*)*
private static boolean Conditional_0_4(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_4")) return false;
while (true) {
int c = current_position_(b);
if (!Conditional_0_4_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "Conditional_0_4", c)) break;
}
return true;
}
// ((ELIF_TAG (Condition|MacroCondition|Expr))|ELSE_TAG) NL* Element*
private static boolean Conditional_0_4_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_4_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Conditional_0_4_0_0(b, l + 1);
r = r && Conditional_0_4_0_1(b, l + 1);
r = r && Conditional_0_4_0_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (ELIF_TAG (Condition|MacroCondition|Expr))|ELSE_TAG
private static boolean Conditional_0_4_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_4_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Conditional_0_4_0_0_0(b, l + 1);
if (!r) r = consumeToken(b, ELSE_TAG);
exit_section_(b, m, null, r);
return r;
}
// ELIF_TAG (Condition|MacroCondition|Expr)
private static boolean Conditional_0_4_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_4_0_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, ELIF_TAG);
r = r && Conditional_0_4_0_0_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// Condition|MacroCondition|Expr
private static boolean Conditional_0_4_0_0_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_4_0_0_0_1")) return false;
boolean r;
r = Condition(b, l + 1);
if (!r) r = MacroCondition(b, l + 1);
if (!r) r = Expr(b, l + 1, -1);
return r;
}
// NL*
private static boolean Conditional_0_4_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_4_0_1")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Conditional_0_4_0_1", c)) break;
}
return true;
}
// Element*
private static boolean Conditional_0_4_0_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_0_4_0_2")) return false;
while (true) {
int c = current_position_(b);
if (!Element(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "Conditional_0_4_0_2", c)) break;
}
return true;
}
// NL*
private static boolean Conditional_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Conditional_2")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Conditional_2", c)) break;
}
return true;
}
/* ********************************************************** */
// ID EQU ((MINUS|PLUS|BITWISE_NOT)? Expr)* NL*
public static boolean Constant(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Constant")) return false;
if (!nextTokenIs(b, ID)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokens(b, 0, ID, EQU);
r = r && Constant_2(b, l + 1);
r = r && Constant_3(b, l + 1);
exit_section_(b, m, CONSTANT, r);
return r;
}
// ((MINUS|PLUS|BITWISE_NOT)? Expr)*
private static boolean Constant_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Constant_2")) return false;
while (true) {
int c = current_position_(b);
if (!Constant_2_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "Constant_2", c)) break;
}
return true;
}
// (MINUS|PLUS|BITWISE_NOT)? Expr
private static boolean Constant_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Constant_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Constant_2_0_0(b, l + 1);
r = r && Expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
// (MINUS|PLUS|BITWISE_NOT)?
private static boolean Constant_2_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Constant_2_0_0")) return false;
Constant_2_0_0_0(b, l + 1);
return true;
}
// MINUS|PLUS|BITWISE_NOT
private static boolean Constant_2_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Constant_2_0_0_0")) return false;
boolean r;
r = consumeToken(b, MINUS);
if (!r) r = consumeToken(b, PLUS);
if (!r) r = consumeToken(b, BITWISE_NOT);
return r;
}
// NL*
private static boolean Constant_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Constant_3")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Constant_3", c)) break;
}
return true;
}
/* ********************************************************** */
// ID? DATA_OP DataValue NL*
public static boolean DataElement(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataElement")) return false;
if (!nextTokenIs(b, "<data element>", DATA_OP, ID)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, DATA_ELEMENT, "<data element>");
r = DataElement_0(b, l + 1);
r = r && consumeToken(b, DATA_OP);
r = r && DataValue(b, l + 1);
r = r && DataElement_3(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// ID?
private static boolean DataElement_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataElement_0")) return false;
consumeToken(b, ID);
return true;
}
// NL*
private static boolean DataElement_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataElement_3")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "DataElement_3", c)) break;
}
return true;
}
/* ********************************************************** */
// (MINUS|PLUS|BITWISE_NOT)? (Expr|STRING|LabelIdentifier) (SEPARATOR ((MINUS|PLUS)? (Expr|STRING|LabelIdentifier)))*
static boolean DataValue(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue")) return false;
boolean r;
Marker m = enter_section_(b);
r = DataValue_0(b, l + 1);
r = r && DataValue_1(b, l + 1);
r = r && DataValue_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (MINUS|PLUS|BITWISE_NOT)?
private static boolean DataValue_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue_0")) return false;
DataValue_0_0(b, l + 1);
return true;
}
// MINUS|PLUS|BITWISE_NOT
private static boolean DataValue_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue_0_0")) return false;
boolean r;
r = consumeToken(b, MINUS);
if (!r) r = consumeToken(b, PLUS);
if (!r) r = consumeToken(b, BITWISE_NOT);
return r;
}
// Expr|STRING|LabelIdentifier
private static boolean DataValue_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue_1")) return false;
boolean r;
r = Expr(b, l + 1, -1);
if (!r) r = consumeToken(b, STRING);
if (!r) r = LabelIdentifier(b, l + 1);
return r;
}
// (SEPARATOR ((MINUS|PLUS)? (Expr|STRING|LabelIdentifier)))*
private static boolean DataValue_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue_2")) return false;
while (true) {
int c = current_position_(b);
if (!DataValue_2_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "DataValue_2", c)) break;
}
return true;
}
// SEPARATOR ((MINUS|PLUS)? (Expr|STRING|LabelIdentifier))
private static boolean DataValue_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SEPARATOR);
r = r && DataValue_2_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (MINUS|PLUS)? (Expr|STRING|LabelIdentifier)
private static boolean DataValue_2_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue_2_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = DataValue_2_0_1_0(b, l + 1);
r = r && DataValue_2_0_1_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (MINUS|PLUS)?
private static boolean DataValue_2_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue_2_0_1_0")) return false;
DataValue_2_0_1_0_0(b, l + 1);
return true;
}
// MINUS|PLUS
private static boolean DataValue_2_0_1_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue_2_0_1_0_0")) return false;
boolean r;
r = consumeToken(b, MINUS);
if (!r) r = consumeToken(b, PLUS);
return r;
}
// Expr|STRING|LabelIdentifier
private static boolean DataValue_2_0_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DataValue_2_0_1_1")) return false;
boolean r;
r = Expr(b, l + 1, -1);
if (!r) r = consumeToken(b, STRING);
if (!r) r = LabelIdentifier(b, l + 1);
return r;
}
/* ********************************************************** */
// ((DEFINE_TAG Identifier ROUND_L (Expr (SEPARATOR Expr)*)? ROUND_R Expr)
// | (DEFINE_TAG Identifier (Expr|(PERCENT SQUARE_L Expr SQUARE_R))?)) SEPARATOR? NL*
public static boolean Define(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define")) return false;
if (!nextTokenIs(b, DEFINE_TAG)) return false;
boolean r;
Marker m = enter_section_(b);
r = Define_0(b, l + 1);
r = r && Define_1(b, l + 1);
r = r && Define_2(b, l + 1);
exit_section_(b, m, DEFINE, r);
return r;
}
// (DEFINE_TAG Identifier ROUND_L (Expr (SEPARATOR Expr)*)? ROUND_R Expr)
// | (DEFINE_TAG Identifier (Expr|(PERCENT SQUARE_L Expr SQUARE_R))?)
private static boolean Define_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Define_0_0(b, l + 1);
if (!r) r = Define_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// DEFINE_TAG Identifier ROUND_L (Expr (SEPARATOR Expr)*)? ROUND_R Expr
private static boolean Define_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, DEFINE_TAG);
r = r && Identifier(b, l + 1);
r = r && consumeToken(b, ROUND_L);
r = r && Define_0_0_3(b, l + 1);
r = r && consumeToken(b, ROUND_R);
r = r && Expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
// (Expr (SEPARATOR Expr)*)?
private static boolean Define_0_0_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0_0_3")) return false;
Define_0_0_3_0(b, l + 1);
return true;
}
// Expr (SEPARATOR Expr)*
private static boolean Define_0_0_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0_0_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Expr(b, l + 1, -1);
r = r && Define_0_0_3_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (SEPARATOR Expr)*
private static boolean Define_0_0_3_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0_0_3_0_1")) return false;
while (true) {
int c = current_position_(b);
if (!Define_0_0_3_0_1_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "Define_0_0_3_0_1", c)) break;
}
return true;
}
// SEPARATOR Expr
private static boolean Define_0_0_3_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0_0_3_0_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SEPARATOR);
r = r && Expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
// DEFINE_TAG Identifier (Expr|(PERCENT SQUARE_L Expr SQUARE_R))?
private static boolean Define_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, DEFINE_TAG);
r = r && Identifier(b, l + 1);
r = r && Define_0_1_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (Expr|(PERCENT SQUARE_L Expr SQUARE_R))?
private static boolean Define_0_1_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0_1_2")) return false;
Define_0_1_2_0(b, l + 1);
return true;
}
// Expr|(PERCENT SQUARE_L Expr SQUARE_R)
private static boolean Define_0_1_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0_1_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Expr(b, l + 1, -1);
if (!r) r = Define_0_1_2_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// PERCENT SQUARE_L Expr SQUARE_R
private static boolean Define_0_1_2_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_0_1_2_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokens(b, 0, PERCENT, SQUARE_L);
r = r && Expr(b, l + 1, -1);
r = r && consumeToken(b, SQUARE_R);
exit_section_(b, m, null, r);
return r;
}
// SEPARATOR?
private static boolean Define_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_1")) return false;
consumeToken(b, SEPARATOR);
return true;
}
// NL*
private static boolean Define_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Define_2")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Define_2", c)) break;
}
return true;
}
/* ********************************************************** */
// (DirectiveDecl|DirectiveDeclBrackets|MapOption) NL*
public static boolean Directive(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Directive")) return false;
if (!nextTokenIs(b, "<directive>", DIRECTIVE_OP, SQUARE_L)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, DIRECTIVE, "<directive>");
r = Directive_0(b, l + 1);
r = r && Directive_1(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// DirectiveDecl|DirectiveDeclBrackets|MapOption
private static boolean Directive_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Directive_0")) return false;
boolean r;
r = DirectiveDecl(b, l + 1);
if (!r) r = DirectiveDeclBrackets(b, l + 1);
if (!r) r = MapOption(b, l + 1);
return r;
}
// NL*
private static boolean Directive_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Directive_1")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Directive_1", c)) break;
}
return true;
}
/* ********************************************************** */
// DIRECTIVE_OP (Expr SEPARATOR?)*
static boolean DirectiveDecl(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DirectiveDecl")) return false;
if (!nextTokenIs(b, DIRECTIVE_OP)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, DIRECTIVE_OP);
r = r && DirectiveDecl_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (Expr SEPARATOR?)*
private static boolean DirectiveDecl_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DirectiveDecl_1")) return false;
while (true) {
int c = current_position_(b);
if (!DirectiveDecl_1_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "DirectiveDecl_1", c)) break;
}
return true;
}
// Expr SEPARATOR?
private static boolean DirectiveDecl_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DirectiveDecl_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Expr(b, l + 1, -1);
r = r && DirectiveDecl_1_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// SEPARATOR?
private static boolean DirectiveDecl_1_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DirectiveDecl_1_0_1")) return false;
consumeToken(b, SEPARATOR);
return true;
}
/* ********************************************************** */
// SQUARE_L DIRECTIVE_OP Expr* SQUARE_R
static boolean DirectiveDeclBrackets(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DirectiveDeclBrackets")) return false;
if (!nextTokenIs(b, SQUARE_L)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokens(b, 0, SQUARE_L, DIRECTIVE_OP);
r = r && DirectiveDeclBrackets_2(b, l + 1);
r = r && consumeToken(b, SQUARE_R);
exit_section_(b, m, null, r);
return r;
}
// Expr*
private static boolean DirectiveDeclBrackets_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "DirectiveDeclBrackets_2")) return false;
while (true) {
int c = current_position_(b);
if (!Expr(b, l + 1, -1)) break;
if (!empty_element_parsed_guard_(b, "DirectiveDeclBrackets_2", c)) break;
}
return true;
}
/* ********************************************************** */
// COMMENT
// | Section
// | Segment
// | Label
// | Preprocessor
// | Directive
// | EndDirective
// | Constant
// | Structure
// | Instruction
// | DataElement
// | IStrucElement
// | NL
// | ID
static boolean Element(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Element")) return false;
boolean r;
r = consumeToken(b, COMMENT);
if (!r) r = Section(b, l + 1);
if (!r) r = Segment(b, l + 1);
if (!r) r = Label(b, l + 1);
if (!r) r = Preprocessor(b, l + 1);
if (!r) r = Directive(b, l + 1);
if (!r) r = EndDirective(b, l + 1);
if (!r) r = Constant(b, l + 1);
if (!r) r = Structure(b, l + 1);
if (!r) r = Instruction(b, l + 1);
if (!r) r = DataElement(b, l + 1);
if (!r) r = IStrucElement(b, l + 1);
if (!r) r = consumeToken(b, NL);
if (!r) r = consumeToken(b, ID);
return r;
}
/* ********************************************************** */
// ERROR_TAG NL*
public static boolean Error(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Error")) return false;
if (!nextTokenIs(b, ERROR_TAG)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, ERROR_TAG);
r = r && Error_1(b, l + 1);
exit_section_(b, m, ERROR, r);
return r;
}
// NL*
private static boolean Error_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Error_1")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Error_1", c)) break;
}
return true;
}
/* ********************************************************** */
// ISTRUC_TAG Identifier NL* ((IStrucElement|Conditional) NL*)* IEND_TAG
public static boolean IStruc(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IStruc")) return false;
if (!nextTokenIs(b, ISTRUC_TAG)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, ISTRUC_TAG);
r = r && Identifier(b, l + 1);
r = r && IStruc_2(b, l + 1);
r = r && IStruc_3(b, l + 1);
r = r && consumeToken(b, IEND_TAG);
exit_section_(b, m, I_STRUC, r);
return r;
}
// NL*
private static boolean IStruc_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IStruc_2")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "IStruc_2", c)) break;
}
return true;
}
// ((IStrucElement|Conditional) NL*)*
private static boolean IStruc_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IStruc_3")) return false;
while (true) {
int c = current_position_(b);
if (!IStruc_3_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "IStruc_3", c)) break;
}
return true;
}
// (IStrucElement|Conditional) NL*
private static boolean IStruc_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IStruc_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = IStruc_3_0_0(b, l + 1);
r = r && IStruc_3_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// IStrucElement|Conditional
private static boolean IStruc_3_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IStruc_3_0_0")) return false;
boolean r;
r = IStrucElement(b, l + 1);
if (!r) r = Conditional(b, l + 1);
return r;
}
// NL*
private static boolean IStruc_3_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IStruc_3_0_1")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "IStruc_3_0_1", c)) break;
}
return true;
}
/* ********************************************************** */
// AT_TAG (StructureField|LabelIdentifier|Identifier) SEPARATOR DATA_OP DataValue
static boolean IStrucElement(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IStrucElement")) return false;
if (!nextTokenIs(b, AT_TAG)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, AT_TAG);
r = r && IStrucElement_1(b, l + 1);
r = r && consumeTokens(b, 0, SEPARATOR, DATA_OP);
r = r && DataValue(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// StructureField|LabelIdentifier|Identifier
private static boolean IStrucElement_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IStrucElement_1")) return false;
boolean r;
r = StructureField(b, l + 1);
if (!r) r = LabelIdentifier(b, l + 1);
if (!r) r = Identifier(b, l + 1);
return r;
}
/* ********************************************************** */
// IFMACRO_TAG|IFCTX_TAG|IFNUM_TAG|IFSTR_TAG|IFIDN_TAG|IFDEF_TAG|IFID_TAG|IF_TAG
static boolean IfConditionTag(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "IfConditionTag")) return false;
boolean r;
r = consumeToken(b, IFMACRO_TAG);
if (!r) r = consumeToken(b, IFCTX_TAG);
if (!r) r = consumeToken(b, IFNUM_TAG);
if (!r) r = consumeToken(b, IFSTR_TAG);
if (!r) r = consumeToken(b, IFIDN_TAG);
if (!r) r = consumeToken(b, IFDEF_TAG);
if (!r) r = consumeToken(b, IFID_TAG);
if (!r) r = consumeToken(b, IF_TAG);
return r;
}
/* ********************************************************** */
// INCLUDE_TAG (ID_EXTENSION|STRING)
public static boolean Include(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Include")) return false;
if (!nextTokenIs(b, INCLUDE_TAG)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, INCLUDE_TAG);
r = r && Include_1(b, l + 1);
exit_section_(b, m, INCLUDE, r);
return r;
}
// ID_EXTENSION|STRING
private static boolean Include_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Include_1")) return false;
boolean r;
r = consumeToken(b, ID_EXTENSION);
if (!r) r = consumeToken(b, STRING);
return r;
}
/* ********************************************************** */
// Prefix* (Mnemonic|(ID COMMENT)) (((((BITWISE_NOT|MINUS|PLUS)? Expr) SEPARATOR)* ((BITWISE_NOT|MINUS|PLUS)? Expr))|(SIZE_TYPE (BITWISE_NOT|MINUS|PLUS)? ROUND_L Expr ROUND_R))?
public static boolean Instruction(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, INSTRUCTION, "<instruction>");
r = Instruction_0(b, l + 1);
r = r && Instruction_1(b, l + 1);
r = r && Instruction_2(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// Prefix*
private static boolean Instruction_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_0")) return false;
while (true) {
int c = current_position_(b);
if (!Prefix(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "Instruction_0", c)) break;
}
return true;
}
// Mnemonic|(ID COMMENT)
private static boolean Instruction_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = Mnemonic(b, l + 1);
if (!r) r = Instruction_1_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// ID COMMENT
private static boolean Instruction_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_1_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokens(b, 0, ID, COMMENT);
exit_section_(b, m, null, r);
return r;
}
// (((((BITWISE_NOT|MINUS|PLUS)? Expr) SEPARATOR)* ((BITWISE_NOT|MINUS|PLUS)? Expr))|(SIZE_TYPE (BITWISE_NOT|MINUS|PLUS)? ROUND_L Expr ROUND_R))?
private static boolean Instruction_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2")) return false;
Instruction_2_0(b, l + 1);
return true;
}
// ((((BITWISE_NOT|MINUS|PLUS)? Expr) SEPARATOR)* ((BITWISE_NOT|MINUS|PLUS)? Expr))|(SIZE_TYPE (BITWISE_NOT|MINUS|PLUS)? ROUND_L Expr ROUND_R)
private static boolean Instruction_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Instruction_2_0_0(b, l + 1);
if (!r) r = Instruction_2_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (((BITWISE_NOT|MINUS|PLUS)? Expr) SEPARATOR)* ((BITWISE_NOT|MINUS|PLUS)? Expr)
private static boolean Instruction_2_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Instruction_2_0_0_0(b, l + 1);
r = r && Instruction_2_0_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (((BITWISE_NOT|MINUS|PLUS)? Expr) SEPARATOR)*
private static boolean Instruction_2_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_0_0")) return false;
while (true) {
int c = current_position_(b);
if (!Instruction_2_0_0_0_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "Instruction_2_0_0_0", c)) break;
}
return true;
}
// ((BITWISE_NOT|MINUS|PLUS)? Expr) SEPARATOR
private static boolean Instruction_2_0_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_0_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Instruction_2_0_0_0_0_0(b, l + 1);
r = r && consumeToken(b, SEPARATOR);
exit_section_(b, m, null, r);
return r;
}
// (BITWISE_NOT|MINUS|PLUS)? Expr
private static boolean Instruction_2_0_0_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_0_0_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Instruction_2_0_0_0_0_0_0(b, l + 1);
r = r && Expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
// (BITWISE_NOT|MINUS|PLUS)?
private static boolean Instruction_2_0_0_0_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_0_0_0_0_0")) return false;
Instruction_2_0_0_0_0_0_0_0(b, l + 1);
return true;
}
// BITWISE_NOT|MINUS|PLUS
private static boolean Instruction_2_0_0_0_0_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_0_0_0_0_0_0")) return false;
boolean r;
r = consumeToken(b, BITWISE_NOT);
if (!r) r = consumeToken(b, MINUS);
if (!r) r = consumeToken(b, PLUS);
return r;
}
// (BITWISE_NOT|MINUS|PLUS)? Expr
private static boolean Instruction_2_0_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = Instruction_2_0_0_1_0(b, l + 1);
r = r && Expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
// (BITWISE_NOT|MINUS|PLUS)?
private static boolean Instruction_2_0_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_0_1_0")) return false;
Instruction_2_0_0_1_0_0(b, l + 1);
return true;
}
// BITWISE_NOT|MINUS|PLUS
private static boolean Instruction_2_0_0_1_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_0_1_0_0")) return false;
boolean r;
r = consumeToken(b, BITWISE_NOT);
if (!r) r = consumeToken(b, MINUS);
if (!r) r = consumeToken(b, PLUS);
return r;
}
// SIZE_TYPE (BITWISE_NOT|MINUS|PLUS)? ROUND_L Expr ROUND_R
private static boolean Instruction_2_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SIZE_TYPE);
r = r && Instruction_2_0_1_1(b, l + 1);
r = r && consumeToken(b, ROUND_L);
r = r && Expr(b, l + 1, -1);
r = r && consumeToken(b, ROUND_R);
exit_section_(b, m, null, r);
return r;
}
// (BITWISE_NOT|MINUS|PLUS)?
private static boolean Instruction_2_0_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_1_1")) return false;
Instruction_2_0_1_1_0(b, l + 1);
return true;
}
// BITWISE_NOT|MINUS|PLUS
private static boolean Instruction_2_0_1_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Instruction_2_0_1_1_0")) return false;
boolean r;
r = consumeToken(b, BITWISE_NOT);
if (!r) r = consumeToken(b, MINUS);
if (!r) r = consumeToken(b, PLUS);
return r;
}
/* ********************************************************** */
// (LBL_DEF (Instruction|DataElement|Structure)? NL*) | (LabelDefMacro (Instruction|DataElement|Structure)? NL*)
public static boolean Label(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Label")) return false;
if (!nextTokenIs(b, "<label>", ID, LBL_DEF)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, LABEL, "<label>");
r = Label_0(b, l + 1);
if (!r) r = Label_1(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// LBL_DEF (Instruction|DataElement|Structure)? NL*
private static boolean Label_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Label_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, LBL_DEF);
r = r && Label_0_1(b, l + 1);
r = r && Label_0_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (Instruction|DataElement|Structure)?
private static boolean Label_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Label_0_1")) return false;
Label_0_1_0(b, l + 1);
return true;
}
// Instruction|DataElement|Structure
private static boolean Label_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Label_0_1_0")) return false;
boolean r;
r = Instruction(b, l + 1);
if (!r) r = DataElement(b, l + 1);
if (!r) r = Structure(b, l + 1);
return r;
}
// NL*
private static boolean Label_0_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Label_0_2")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Label_0_2", c)) break;
}
return true;
}
// LabelDefMacro (Instruction|DataElement|Structure)? NL*
private static boolean Label_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Label_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = LabelDefMacro(b, l + 1);
r = r && Label_1_1(b, l + 1);
r = r && Label_1_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (Instruction|DataElement|Structure)?
private static boolean Label_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Label_1_1")) return false;
Label_1_1_0(b, l + 1);
return true;
}
// Instruction|DataElement|Structure
private static boolean Label_1_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Label_1_1_0")) return false;
boolean r;
r = Instruction(b, l + 1);
if (!r) r = DataElement(b, l + 1);
if (!r) r = Structure(b, l + 1);
return r;
}
// NL*
private static boolean Label_1_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Label_1_2")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Label_1_2", c)) break;
}
return true;
}
/* ********************************************************** */
// ID MacroParenthesis COLON NL*
public static boolean LabelDefMacro(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "LabelDefMacro")) return false;
if (!nextTokenIs(b, ID)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, ID);
r = r && MacroParenthesis(b, l + 1);
r = r && consumeToken(b, COLON);
r = r && LabelDefMacro_3(b, l + 1);
exit_section_(b, m, LABEL_DEF_MACRO, r);
return r;
}
// NL*
private static boolean LabelDefMacro_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "LabelDefMacro_3")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "LabelDefMacro_3", c)) break;
}
return true;
}
/* ********************************************************** */
// MACRO_TAG Identifier MacroParams MacroDefaultParam? NL* ((MacroLabel|Label|DataElement|Instruction|Directive|Preprocessor|Expr) NL*)* MACRO_END_TAG
public static boolean Macro(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Macro")) return false;
if (!nextTokenIs(b, MACRO_TAG)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, MACRO, null);
r = consumeToken(b, MACRO_TAG);
p = r; // pin = 1
r = r && report_error_(b, Identifier(b, l + 1));
r = p && report_error_(b, MacroParams(b, l + 1)) && r;
r = p && report_error_(b, Macro_3(b, l + 1)) && r;
r = p && report_error_(b, Macro_4(b, l + 1)) && r;
r = p && report_error_(b, Macro_5(b, l + 1)) && r;
r = p && consumeToken(b, MACRO_END_TAG) && r;
exit_section_(b, l, m, r, p, null);
return r || p;
}
// MacroDefaultParam?
private static boolean Macro_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Macro_3")) return false;
MacroDefaultParam(b, l + 1);
return true;
}
// NL*
private static boolean Macro_4(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Macro_4")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Macro_4", c)) break;
}
return true;
}
// ((MacroLabel|Label|DataElement|Instruction|Directive|Preprocessor|Expr) NL*)*
private static boolean Macro_5(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Macro_5")) return false;
while (true) {
int c = current_position_(b);
if (!Macro_5_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "Macro_5", c)) break;
}
return true;
}
// (MacroLabel|Label|DataElement|Instruction|Directive|Preprocessor|Expr) NL*
private static boolean Macro_5_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Macro_5_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Macro_5_0_0(b, l + 1);
r = r && Macro_5_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// MacroLabel|Label|DataElement|Instruction|Directive|Preprocessor|Expr
private static boolean Macro_5_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Macro_5_0_0")) return false;
boolean r;
r = MacroLabel(b, l + 1);
if (!r) r = Label(b, l + 1);
if (!r) r = DataElement(b, l + 1);
if (!r) r = Instruction(b, l + 1);
if (!r) r = Directive(b, l + 1);
if (!r) r = Preprocessor(b, l + 1);
if (!r) r = Expr(b, l + 1, -1);
return r;
}
// NL*
private static boolean Macro_5_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Macro_5_0_1")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Macro_5_0_1", c)) break;
}
return true;
}
/* ********************************************************** */
// Identifier MacroParams MacroDefaultParam?
static boolean MacroCondition(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroCondition")) return false;
boolean r;
Marker m = enter_section_(b);
r = Identifier(b, l + 1);
r = r && MacroParams(b, l + 1);
r = r && MacroCondition_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// MacroDefaultParam?
private static boolean MacroCondition_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroCondition_2")) return false;
MacroDefaultParam(b, l + 1);
return true;
}
/* ********************************************************** */
// Instruction|STRING|REGISTER|NumericLiteral|MacroCall
static boolean MacroDefaultParam(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroDefaultParam")) return false;
boolean r;
r = Instruction(b, l + 1);
if (!r) r = consumeToken(b, STRING);
if (!r) r = consumeToken(b, REGISTER);
if (!r) r = NumericLiteral(b, l + 1);
if (!r) r = MacroCall(b, l + 1);
return r;
}
/* ********************************************************** */
// MACRO_PARAM_LBL_DEF (Instruction|DataElement)? NL*
public static boolean MacroLabel(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroLabel")) return false;
if (!nextTokenIs(b, MACRO_PARAM_LBL_DEF)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, MACRO_PARAM_LBL_DEF);
r = r && MacroLabel_1(b, l + 1);
r = r && MacroLabel_2(b, l + 1);
exit_section_(b, m, MACRO_LABEL, r);
return r;
}
// (Instruction|DataElement)?
private static boolean MacroLabel_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroLabel_1")) return false;
MacroLabel_1_0(b, l + 1);
return true;
}
// Instruction|DataElement
private static boolean MacroLabel_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroLabel_1_0")) return false;
boolean r;
r = Instruction(b, l + 1);
if (!r) r = DataElement(b, l + 1);
return r;
}
// NL*
private static boolean MacroLabel_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroLabel_2")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "MacroLabel_2", c)) break;
}
return true;
}
/* ********************************************************** */
// ((NumericLiteral MINUS NumericLiteral (PLUS|TIMES)?)|(NumericLiteral MINUS TIMES)|(NumericLiteral PLUS?)) MACRO_NOLIST_QUAL?
static boolean MacroParams(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParams")) return false;
boolean r;
Marker m = enter_section_(b);
r = MacroParams_0(b, l + 1);
r = r && MacroParams_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (NumericLiteral MINUS NumericLiteral (PLUS|TIMES)?)|(NumericLiteral MINUS TIMES)|(NumericLiteral PLUS?)
private static boolean MacroParams_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParams_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = MacroParams_0_0(b, l + 1);
if (!r) r = MacroParams_0_1(b, l + 1);
if (!r) r = MacroParams_0_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// NumericLiteral MINUS NumericLiteral (PLUS|TIMES)?
private static boolean MacroParams_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParams_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = NumericLiteral(b, l + 1);
r = r && consumeToken(b, MINUS);
r = r && NumericLiteral(b, l + 1);
r = r && MacroParams_0_0_3(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (PLUS|TIMES)?
private static boolean MacroParams_0_0_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParams_0_0_3")) return false;
MacroParams_0_0_3_0(b, l + 1);
return true;
}
// PLUS|TIMES
private static boolean MacroParams_0_0_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParams_0_0_3_0")) return false;
boolean r;
r = consumeToken(b, PLUS);
if (!r) r = consumeToken(b, TIMES);
return r;
}
// NumericLiteral MINUS TIMES
private static boolean MacroParams_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParams_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = NumericLiteral(b, l + 1);
r = r && consumeTokens(b, 0, MINUS, TIMES);
exit_section_(b, m, null, r);
return r;
}
// NumericLiteral PLUS?
private static boolean MacroParams_0_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParams_0_2")) return false;
boolean r;
Marker m = enter_section_(b);
r = NumericLiteral(b, l + 1);
r = r && MacroParams_0_2_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// PLUS?
private static boolean MacroParams_0_2_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParams_0_2_1")) return false;
consumeToken(b, PLUS);
return true;
}
// MACRO_NOLIST_QUAL?
private static boolean MacroParams_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParams_1")) return false;
consumeToken(b, MACRO_NOLIST_QUAL);
return true;
}
/* ********************************************************** */
// ROUND_L (Expr (SEPARATOR Expr)*)? ROUND_R
static boolean MacroParenthesis(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParenthesis")) return false;
if (!nextTokenIs(b, ROUND_L)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_);
r = consumeToken(b, ROUND_L);
p = r; // pin = 1
r = r && report_error_(b, MacroParenthesis_1(b, l + 1));
r = p && consumeToken(b, ROUND_R) && r;
exit_section_(b, l, m, r, p, null);
return r || p;
}
// (Expr (SEPARATOR Expr)*)?
private static boolean MacroParenthesis_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParenthesis_1")) return false;
MacroParenthesis_1_0(b, l + 1);
return true;
}
// Expr (SEPARATOR Expr)*
private static boolean MacroParenthesis_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParenthesis_1_0")) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_);
r = Expr(b, l + 1, -1);
p = r; // pin = 1
r = r && MacroParenthesis_1_0_1(b, l + 1);
exit_section_(b, l, m, r, p, null);
return r || p;
}
// (SEPARATOR Expr)*
private static boolean MacroParenthesis_1_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParenthesis_1_0_1")) return false;
while (true) {
int c = current_position_(b);
if (!MacroParenthesis_1_0_1_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "MacroParenthesis_1_0_1", c)) break;
}
return true;
}
// SEPARATOR Expr
private static boolean MacroParenthesis_1_0_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParenthesis_1_0_1_0")) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_);
r = consumeToken(b, SEPARATOR);
p = r; // pin = 1
r = r && Expr(b, l + 1, -1);
exit_section_(b, l, m, r, p, null);
return r || p;
}
/* ********************************************************** */
// SQUARE_L ('map'|'MAP') (('all'|'ALL')|('brief'|'BRIEF')|('sections'|'SECTIONS')|('segments'|'SEGMENTS')|('symbols'|'SYMBOLS'))? MAP_FILE SQUARE_R
public static boolean MapOption(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MapOption")) return false;
if (!nextTokenIs(b, SQUARE_L)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, SQUARE_L);
r = r && MapOption_1(b, l + 1);
r = r && MapOption_2(b, l + 1);
r = r && consumeTokens(b, 0, MAP_FILE, SQUARE_R);
exit_section_(b, m, MAP_OPTION, r);
return r;
}
// 'map'|'MAP'
private static boolean MapOption_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MapOption_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, "map");
if (!r) r = consumeToken(b, "MAP");
exit_section_(b, m, null, r);
return r;
}
// (('all'|'ALL')|('brief'|'BRIEF')|('sections'|'SECTIONS')|('segments'|'SEGMENTS')|('symbols'|'SYMBOLS'))?
private static boolean MapOption_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MapOption_2")) return false;
MapOption_2_0(b, l + 1);
return true;
}
// ('all'|'ALL')|('brief'|'BRIEF')|('sections'|'SECTIONS')|('segments'|'SEGMENTS')|('symbols'|'SYMBOLS')
private static boolean MapOption_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MapOption_2_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = MapOption_2_0_0(b, l + 1);
if (!r) r = MapOption_2_0_1(b, l + 1);
if (!r) r = MapOption_2_0_2(b, l + 1);
if (!r) r = MapOption_2_0_3(b, l + 1);
if (!r) r = MapOption_2_0_4(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// 'all'|'ALL'
private static boolean MapOption_2_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MapOption_2_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, "all");
if (!r) r = consumeToken(b, "ALL");
exit_section_(b, m, null, r);
return r;
}
// 'brief'|'BRIEF'
private static boolean MapOption_2_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MapOption_2_0_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, "brief");
if (!r) r = consumeToken(b, "BRIEF");
exit_section_(b, m, null, r);
return r;
}
// 'sections'|'SECTIONS'
private static boolean MapOption_2_0_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MapOption_2_0_2")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, "sections");
if (!r) r = consumeToken(b, "SECTIONS");
exit_section_(b, m, null, r);
return r;
}
// 'segments'|'SEGMENTS'
private static boolean MapOption_2_0_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MapOption_2_0_3")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, "segments");
if (!r) r = consumeToken(b, "SEGMENTS");
exit_section_(b, m, null, r);
return r;
}
// 'symbols'|'SYMBOLS'
private static boolean MapOption_2_0_4(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MapOption_2_0_4")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, "symbols");
if (!r) r = consumeToken(b, "SYMBOLS");
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// Element*
static boolean NASMFile(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "NASMFile")) return false;
while (true) {
int c = current_position_(b);
if (!Element(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "NASMFile", c)) break;
}
return true;
}
/* ********************************************************** */
// OP_PREFIX NL*
static boolean Prefix(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Prefix")) return false;
if (!nextTokenIs(b, OP_PREFIX)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, OP_PREFIX);
r = r && Prefix_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// NL*
private static boolean Prefix_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Prefix_1")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Prefix_1", c)) break;
}
return true;
}
/* ********************************************************** */
// Include
// | Define
// | Assign
// | Macro
// | MacroDefCall
// | MacroCall
// | Strlen
// | Error
// | Conditional
// | PreprocessorExpr
public static boolean Preprocessor(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Preprocessor")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, PREPROCESSOR, "<preprocessor>");
r = Include(b, l + 1);
if (!r) r = Define(b, l + 1);
if (!r) r = Assign(b, l + 1);
if (!r) r = Macro(b, l + 1);
if (!r) r = MacroDefCall(b, l + 1);
if (!r) r = MacroCall(b, l + 1);
if (!r) r = Strlen(b, l + 1);
if (!r) r = Error(b, l + 1);
if (!r) r = Conditional(b, l + 1);
if (!r) r = PreprocessorExpr(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
/* ********************************************************** */
// PREPROCESSOR_OP Expr*
static boolean PreprocessorExpr(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "PreprocessorExpr")) return false;
if (!nextTokenIs(b, PREPROCESSOR_OP)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, PREPROCESSOR_OP);
r = r && PreprocessorExpr_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// Expr*
private static boolean PreprocessorExpr_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "PreprocessorExpr_1")) return false;
while (true) {
int c = current_position_(b);
if (!Expr(b, l + 1, -1)) break;
if (!empty_element_parsed_guard_(b, "PreprocessorExpr_1", c)) break;
}
return true;
}
/* ********************************************************** */
// (SQUARE_L SECTION SQUARE_R) | SECTION
static boolean Section(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Section")) return false;
if (!nextTokenIs(b, "", SECTION, SQUARE_L)) return false;
boolean r;
Marker m = enter_section_(b);
r = Section_0(b, l + 1);
if (!r) r = consumeToken(b, SECTION);
exit_section_(b, m, null, r);
return r;
}
// SQUARE_L SECTION SQUARE_R
private static boolean Section_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Section_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokens(b, 0, SQUARE_L, SECTION, SQUARE_R);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// (SQUARE_L SEGMENT SQUARE_R) | SEGMENT
static boolean Segment(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Segment")) return false;
if (!nextTokenIs(b, "", SEGMENT, SQUARE_L)) return false;
boolean r;
Marker m = enter_section_(b);
r = Segment_0(b, l + 1);
if (!r) r = consumeToken(b, SEGMENT);
exit_section_(b, m, null, r);
return r;
}
// SQUARE_L SEGMENT SQUARE_R
private static boolean Segment_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Segment_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokens(b, 0, SQUARE_L, SEGMENT, SQUARE_R);
exit_section_(b, m, null, r);
return r;
}
/* ********************************************************** */
// STRLEN_TAG Identifier (STRING|ID) NL*
public static boolean Strlen(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Strlen")) return false;
if (!nextTokenIs(b, STRLEN_TAG)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, STRLEN_TAG);
r = r && Identifier(b, l + 1);
r = r && Strlen_2(b, l + 1);
r = r && Strlen_3(b, l + 1);
exit_section_(b, m, STRLEN, r);
return r;
}
// STRING|ID
private static boolean Strlen_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Strlen_2")) return false;
boolean r;
r = consumeToken(b, STRING);
if (!r) r = consumeToken(b, ID);
return r;
}
// NL*
private static boolean Strlen_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Strlen_3")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Strlen_3", c)) break;
}
return true;
}
/* ********************************************************** */
// STRUC_TAG Identifier NL* ((((LBL_DEF|LabelIdentifier) DATA_OP ((MINUS|PLUS)? (Expr|Identifier)))|(LabelIdentifier|LBL_DEF)|Conditional) NL*)* ENDSTRUC_TAG
public static boolean Struc(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc")) return false;
if (!nextTokenIs(b, STRUC_TAG)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeToken(b, STRUC_TAG);
r = r && Identifier(b, l + 1);
r = r && Struc_2(b, l + 1);
r = r && Struc_3(b, l + 1);
r = r && consumeToken(b, ENDSTRUC_TAG);
exit_section_(b, m, STRUC, r);
return r;
}
// NL*
private static boolean Struc_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_2")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Struc_2", c)) break;
}
return true;
}
// ((((LBL_DEF|LabelIdentifier) DATA_OP ((MINUS|PLUS)? (Expr|Identifier)))|(LabelIdentifier|LBL_DEF)|Conditional) NL*)*
private static boolean Struc_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3")) return false;
while (true) {
int c = current_position_(b);
if (!Struc_3_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "Struc_3", c)) break;
}
return true;
}
// (((LBL_DEF|LabelIdentifier) DATA_OP ((MINUS|PLUS)? (Expr|Identifier)))|(LabelIdentifier|LBL_DEF)|Conditional) NL*
private static boolean Struc_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Struc_3_0_0(b, l + 1);
r = r && Struc_3_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// ((LBL_DEF|LabelIdentifier) DATA_OP ((MINUS|PLUS)? (Expr|Identifier)))|(LabelIdentifier|LBL_DEF)|Conditional
private static boolean Struc_3_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Struc_3_0_0_0(b, l + 1);
if (!r) r = Struc_3_0_0_1(b, l + 1);
if (!r) r = Conditional(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (LBL_DEF|LabelIdentifier) DATA_OP ((MINUS|PLUS)? (Expr|Identifier))
private static boolean Struc_3_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0_0_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Struc_3_0_0_0_0(b, l + 1);
r = r && consumeToken(b, DATA_OP);
r = r && Struc_3_0_0_0_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// LBL_DEF|LabelIdentifier
private static boolean Struc_3_0_0_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0_0_0_0")) return false;
boolean r;
r = consumeToken(b, LBL_DEF);
if (!r) r = LabelIdentifier(b, l + 1);
return r;
}
// (MINUS|PLUS)? (Expr|Identifier)
private static boolean Struc_3_0_0_0_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0_0_0_2")) return false;
boolean r;
Marker m = enter_section_(b);
r = Struc_3_0_0_0_2_0(b, l + 1);
r = r && Struc_3_0_0_0_2_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// (MINUS|PLUS)?
private static boolean Struc_3_0_0_0_2_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0_0_0_2_0")) return false;
Struc_3_0_0_0_2_0_0(b, l + 1);
return true;
}
// MINUS|PLUS
private static boolean Struc_3_0_0_0_2_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0_0_0_2_0_0")) return false;
boolean r;
r = consumeToken(b, MINUS);
if (!r) r = consumeToken(b, PLUS);
return r;
}
// Expr|Identifier
private static boolean Struc_3_0_0_0_2_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0_0_0_2_1")) return false;
boolean r;
r = Expr(b, l + 1, -1);
if (!r) r = Identifier(b, l + 1);
return r;
}
// LabelIdentifier|LBL_DEF
private static boolean Struc_3_0_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0_0_1")) return false;
boolean r;
r = LabelIdentifier(b, l + 1);
if (!r) r = consumeToken(b, LBL_DEF);
return r;
}
// NL*
private static boolean Struc_3_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Struc_3_0_1")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Struc_3_0_1", c)) break;
}
return true;
}
/* ********************************************************** */
// (Struc|IStruc) NL*
public static boolean Structure(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Structure")) return false;
if (!nextTokenIs(b, "<structure>", ISTRUC_TAG, STRUC_TAG)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, STRUCTURE, "<structure>");
r = Structure_0(b, l + 1);
r = r && Structure_1(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// Struc|IStruc
private static boolean Structure_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Structure_0")) return false;
boolean r;
r = Struc(b, l + 1);
if (!r) r = IStruc(b, l + 1);
return r;
}
// NL*
private static boolean Structure_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Structure_1")) return false;
while (true) {
int c = current_position_(b);
if (!consumeToken(b, NL)) break;
if (!empty_element_parsed_guard_(b, "Structure_1", c)) break;
}
return true;
}
/* ********************************************************** */
// Expression root: Expr
// Operator priority table:
// 0: ATOM(ParenthesisExpr)
// 1: BINARY(TokenConcatExpr)
// 2: BINARY(MulExpr)
// 3: BINARY(DivExpr)
// 4: BINARY(PlusExpr)
// 5: BINARY(MinusExpr)
// 6: BINARY(ModulusExpr)
// 7: BINARY(BitShiftLExpr)
// 8: BINARY(BitShiftRExpr)
// 9: BINARY(BitwiseANDExpr)
// 10: BINARY(BitwiseORExpr)
// 11: BINARY(BitwiseXORExpr)
// 12: PREFIX(BitwiseNOTExpr)
// 13: BINARY(LogicalANDExpr)
// 14: BINARY(LogicalORExpr)
// 15: BINARY(LogicalXORExpr)
// 16: ATOM(NumericLiteral)
// 17: ATOM(SegmentAddress)
// 18: ATOM(Str)
// 19: ATOM(StructureField)
// 20: ATOM(MacroDefCall)
// 21: ATOM(MacroCall)
// 22: ATOM(MacroParamCounter)
// 23: ATOM(MacroParamReference)
// 24: ATOM(MacroVarReference)
// 25: ATOM(Address)
// 26: ATOM(Reg)
// 27: ATOM(Seg)
// 28: ATOM(Mnemonic)
// 29: ATOM(Identifier)
// 30: ATOM(LabelIdentifier)
// 31: ATOM(EndDirective)
public static boolean Expr(PsiBuilder b, int l, int g) {
if (!recursion_guard_(b, l, "Expr")) return false;
addVariant(b, "<expr>");
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, "<expr>");
r = ParenthesisExpr(b, l + 1);
if (!r) r = BitwiseNOTExpr(b, l + 1);
if (!r) r = NumericLiteral(b, l + 1);
if (!r) r = SegmentAddress(b, l + 1);
if (!r) r = Str(b, l + 1);
if (!r) r = StructureField(b, l + 1);
if (!r) r = MacroDefCall(b, l + 1);
if (!r) r = MacroCall(b, l + 1);
if (!r) r = MacroParamCounter(b, l + 1);
if (!r) r = MacroParamReference(b, l + 1);
if (!r) r = MacroVarReference(b, l + 1);
if (!r) r = Address(b, l + 1);
if (!r) r = Reg(b, l + 1);
if (!r) r = Seg(b, l + 1);
if (!r) r = Mnemonic(b, l + 1);
if (!r) r = Identifier(b, l + 1);
if (!r) r = LabelIdentifier(b, l + 1);
if (!r) r = EndDirective(b, l + 1);
p = r;
r = r && Expr_0(b, l + 1, g);
exit_section_(b, l, m, null, r, p, null);
return r || p;
}
public static boolean Expr_0(PsiBuilder b, int l, int g) {
if (!recursion_guard_(b, l, "Expr_0")) return false;
boolean r = true;
while (true) {
Marker m = enter_section_(b, l, _LEFT_, null);
if (g < 1 && consumeTokenSmart(b, TOKEN_CONCAT)) {
r = Expr(b, l, 1);
exit_section_(b, l, m, TOKEN_CONCAT_EXPR, r, true, null);
}
else if (g < 2 && consumeTokenSmart(b, TIMES)) {
r = Expr(b, l, 2);
exit_section_(b, l, m, MUL_EXPR, r, true, null);
}
else if (g < 3 && consumeTokenSmart(b, DIVIDE)) {
r = Expr(b, l, 3);
exit_section_(b, l, m, DIV_EXPR, r, true, null);
}
else if (g < 4 && consumeTokenSmart(b, PLUS)) {
r = Expr(b, l, 4);
exit_section_(b, l, m, PLUS_EXPR, r, true, null);
}
else if (g < 5 && consumeTokenSmart(b, MINUS)) {
r = Expr(b, l, 5);
exit_section_(b, l, m, MINUS_EXPR, r, true, null);
}
else if (g < 6 && consumeTokenSmart(b, PERCENT)) {
r = Expr(b, l, 6);
exit_section_(b, l, m, MODULUS_EXPR, r, true, null);
}
else if (g < 7 && consumeTokenSmart(b, BITSHIFT_L)) {
r = Expr(b, l, 7);
exit_section_(b, l, m, BIT_SHIFT_L_EXPR, r, true, null);
}
else if (g < 8 && consumeTokenSmart(b, BITSHIFT_R)) {
r = Expr(b, l, 8);
exit_section_(b, l, m, BIT_SHIFT_R_EXPR, r, true, null);
}
else if (g < 9 && consumeTokenSmart(b, BITWISE_AND)) {
r = Expr(b, l, 9);
exit_section_(b, l, m, BITWISE_AND_EXPR, r, true, null);
}
else if (g < 10 && consumeTokenSmart(b, BITWISE_OR)) {
r = Expr(b, l, 10);
exit_section_(b, l, m, BITWISE_OR_EXPR, r, true, null);
}
else if (g < 11 && consumeTokenSmart(b, BITWISE_XOR)) {
r = Expr(b, l, 11);
exit_section_(b, l, m, BITWISE_XOR_EXPR, r, true, null);
}
else if (g < 13 && consumeTokenSmart(b, LOGICAL_AND)) {
r = Expr(b, l, 13);
exit_section_(b, l, m, LOGICAL_AND_EXPR, r, true, null);
}
else if (g < 14 && consumeTokenSmart(b, LOGICAL_OR)) {
r = Expr(b, l, 14);
exit_section_(b, l, m, LOGICAL_OR_EXPR, r, true, null);
}
else if (g < 15 && consumeTokenSmart(b, LOGICAL_XOR)) {
r = Expr(b, l, 15);
exit_section_(b, l, m, LOGICAL_XOR_EXPR, r, true, null);
}
else {
exit_section_(b, l, m, null, false, false, null);
break;
}
}
return r;
}
// ROUND_L Expr ROUND_R
public static boolean ParenthesisExpr(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "ParenthesisExpr")) return false;
if (!nextTokenIsSmart(b, ROUND_L)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, PARENTHESIS_EXPR, null);
r = consumeTokenSmart(b, ROUND_L);
p = r; // pin = 1
r = r && report_error_(b, Expr(b, l + 1, -1));
r = p && consumeToken(b, ROUND_R) && r;
exit_section_(b, l, m, r, p, null);
return r || p;
}
public static boolean BitwiseNOTExpr(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "BitwiseNOTExpr")) return false;
if (!nextTokenIsSmart(b, BITWISE_NOT)) return false;
boolean r, p;
Marker m = enter_section_(b, l, _NONE_, null);
r = consumeTokenSmart(b, BITWISE_NOT);
p = r;
r = p && Expr(b, l, 12);
exit_section_(b, l, m, BITWISE_NOT_EXPR, r, p, null);
return r || p;
}
// SIZE_TYPE? (BITWISE_NOT|MINUS|PLUS)? (BINARY|ZEROES|HEXADECIMAL|DECIMAL|FLOAT_DECIMAL|CHARACTER)
public static boolean NumericLiteral(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "NumericLiteral")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, NUMERIC_LITERAL, "<numeric literal>");
r = NumericLiteral_0(b, l + 1);
r = r && NumericLiteral_1(b, l + 1);
r = r && NumericLiteral_2(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE?
private static boolean NumericLiteral_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "NumericLiteral_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// (BITWISE_NOT|MINUS|PLUS)?
private static boolean NumericLiteral_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "NumericLiteral_1")) return false;
NumericLiteral_1_0(b, l + 1);
return true;
}
// BITWISE_NOT|MINUS|PLUS
private static boolean NumericLiteral_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "NumericLiteral_1_0")) return false;
boolean r;
r = consumeTokenSmart(b, BITWISE_NOT);
if (!r) r = consumeTokenSmart(b, MINUS);
if (!r) r = consumeTokenSmart(b, PLUS);
return r;
}
// BINARY|ZEROES|HEXADECIMAL|DECIMAL|FLOAT_DECIMAL|CHARACTER
private static boolean NumericLiteral_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "NumericLiteral_2")) return false;
boolean r;
r = consumeTokenSmart(b, BINARY);
if (!r) r = consumeTokenSmart(b, ZEROES);
if (!r) r = consumeTokenSmart(b, HEXADECIMAL);
if (!r) r = consumeTokenSmart(b, DECIMAL);
if (!r) r = consumeTokenSmart(b, FLOAT_DECIMAL);
if (!r) r = consumeTokenSmart(b, CHARACTER);
return r;
}
// SIZE_TYPE? ((SEGMENT_ADDR_L (HEXADECIMAL|ZEROES|MacroCall|ID|LBL))|
// (LBL_DEF (SIZE_TYPE? (HEXADECIMAL|ZEROES|MacroCall|ID|LBL)))|
// (LabelDefMacro (SIZE_TYPE? (HEXADECIMAL|ZEROES|MacroCall|ID|LBL))))
public static boolean SegmentAddress(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress")) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, SEGMENT_ADDRESS, "<segment address>");
r = SegmentAddress_0(b, l + 1);
r = r && SegmentAddress_1(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE?
private static boolean SegmentAddress_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// (SEGMENT_ADDR_L (HEXADECIMAL|ZEROES|MacroCall|ID|LBL))|
// (LBL_DEF (SIZE_TYPE? (HEXADECIMAL|ZEROES|MacroCall|ID|LBL)))|
// (LabelDefMacro (SIZE_TYPE? (HEXADECIMAL|ZEROES|MacroCall|ID|LBL)))
private static boolean SegmentAddress_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = SegmentAddress_1_0(b, l + 1);
if (!r) r = SegmentAddress_1_1(b, l + 1);
if (!r) r = SegmentAddress_1_2(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// SEGMENT_ADDR_L (HEXADECIMAL|ZEROES|MacroCall|ID|LBL)
private static boolean SegmentAddress_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, SEGMENT_ADDR_L);
r = r && SegmentAddress_1_0_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// HEXADECIMAL|ZEROES|MacroCall|ID|LBL
private static boolean SegmentAddress_1_0_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_0_1")) return false;
boolean r;
r = consumeTokenSmart(b, HEXADECIMAL);
if (!r) r = consumeTokenSmart(b, ZEROES);
if (!r) r = MacroCall(b, l + 1);
if (!r) r = consumeTokenSmart(b, ID);
if (!r) r = consumeTokenSmart(b, LBL);
return r;
}
// LBL_DEF (SIZE_TYPE? (HEXADECIMAL|ZEROES|MacroCall|ID|LBL))
private static boolean SegmentAddress_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, LBL_DEF);
r = r && SegmentAddress_1_1_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// SIZE_TYPE? (HEXADECIMAL|ZEROES|MacroCall|ID|LBL)
private static boolean SegmentAddress_1_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_1_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = SegmentAddress_1_1_1_0(b, l + 1);
r = r && SegmentAddress_1_1_1_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// SIZE_TYPE?
private static boolean SegmentAddress_1_1_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_1_1_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// HEXADECIMAL|ZEROES|MacroCall|ID|LBL
private static boolean SegmentAddress_1_1_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_1_1_1")) return false;
boolean r;
r = consumeTokenSmart(b, HEXADECIMAL);
if (!r) r = consumeTokenSmart(b, ZEROES);
if (!r) r = MacroCall(b, l + 1);
if (!r) r = consumeTokenSmart(b, ID);
if (!r) r = consumeTokenSmart(b, LBL);
return r;
}
// LabelDefMacro (SIZE_TYPE? (HEXADECIMAL|ZEROES|MacroCall|ID|LBL))
private static boolean SegmentAddress_1_2(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_2")) return false;
boolean r;
Marker m = enter_section_(b);
r = LabelDefMacro(b, l + 1);
r = r && SegmentAddress_1_2_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// SIZE_TYPE? (HEXADECIMAL|ZEROES|MacroCall|ID|LBL)
private static boolean SegmentAddress_1_2_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_2_1")) return false;
boolean r;
Marker m = enter_section_(b);
r = SegmentAddress_1_2_1_0(b, l + 1);
r = r && SegmentAddress_1_2_1_1(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// SIZE_TYPE?
private static boolean SegmentAddress_1_2_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_2_1_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// HEXADECIMAL|ZEROES|MacroCall|ID|LBL
private static boolean SegmentAddress_1_2_1_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "SegmentAddress_1_2_1_1")) return false;
boolean r;
r = consumeTokenSmart(b, HEXADECIMAL);
if (!r) r = consumeTokenSmart(b, ZEROES);
if (!r) r = MacroCall(b, l + 1);
if (!r) r = consumeTokenSmart(b, ID);
if (!r) r = consumeTokenSmart(b, LBL);
return r;
}
// STRING
public static boolean Str(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Str")) return false;
if (!nextTokenIsSmart(b, STRING)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, STRING);
exit_section_(b, m, STR, r);
return r;
}
// ID_EXTENSION
public static boolean StructureField(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "StructureField")) return false;
if (!nextTokenIsSmart(b, ID_EXTENSION)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, ID_EXTENSION);
exit_section_(b, m, STRUCTURE_FIELD, r);
return r;
}
// SIZE_TYPE? (BITWISE_NOT|MINUS|PLUS)? Identifier MacroParenthesis
public static boolean MacroDefCall(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroDefCall")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MACRO_DEF_CALL, "<macro def call>");
r = MacroDefCall_0(b, l + 1);
r = r && MacroDefCall_1(b, l + 1);
r = r && Identifier(b, l + 1);
r = r && MacroParenthesis(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE?
private static boolean MacroDefCall_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroDefCall_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// (BITWISE_NOT|MINUS|PLUS)?
private static boolean MacroDefCall_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroDefCall_1")) return false;
MacroDefCall_1_0(b, l + 1);
return true;
}
// BITWISE_NOT|MINUS|PLUS
private static boolean MacroDefCall_1_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroDefCall_1_0")) return false;
boolean r;
r = consumeTokenSmart(b, BITWISE_NOT);
if (!r) r = consumeTokenSmart(b, MINUS);
if (!r) r = consumeTokenSmart(b, PLUS);
return r;
}
// SIZE_TYPE? Identifier Expr (SEPARATOR Expr)*
public static boolean MacroCall(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroCall")) return false;
boolean r;
Marker m = enter_section_(b, l, _COLLAPSE_, MACRO_CALL, "<macro call>");
r = MacroCall_0(b, l + 1);
r = r && Identifier(b, l + 1);
r = r && Expr(b, l + 1, -1);
r = r && MacroCall_3(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE?
private static boolean MacroCall_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroCall_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// (SEPARATOR Expr)*
private static boolean MacroCall_3(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroCall_3")) return false;
while (true) {
int c = current_position_(b);
if (!MacroCall_3_0(b, l + 1)) break;
if (!empty_element_parsed_guard_(b, "MacroCall_3", c)) break;
}
return true;
}
// SEPARATOR Expr
private static boolean MacroCall_3_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroCall_3_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, SEPARATOR);
r = r && Expr(b, l + 1, -1);
exit_section_(b, m, null, r);
return r;
}
// SIZE_TYPE? MACRO_PARAM_COUNT
public static boolean MacroParamCounter(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParamCounter")) return false;
if (!nextTokenIsSmart(b, MACRO_PARAM_COUNT, SIZE_TYPE)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MACRO_PARAM_COUNTER, "<macro param counter>");
r = MacroParamCounter_0(b, l + 1);
r = r && consumeToken(b, MACRO_PARAM_COUNT);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE?
private static boolean MacroParamCounter_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParamCounter_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// SIZE_TYPE? MACRO_PARAM_REF
public static boolean MacroParamReference(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParamReference")) return false;
if (!nextTokenIsSmart(b, MACRO_PARAM_REF, SIZE_TYPE)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MACRO_PARAM_REFERENCE, "<macro param reference>");
r = MacroParamReference_0(b, l + 1);
r = r && consumeToken(b, MACRO_PARAM_REF);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE?
private static boolean MacroParamReference_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroParamReference_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// SIZE_TYPE? MACRO_VAR_REF
public static boolean MacroVarReference(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroVarReference")) return false;
if (!nextTokenIsSmart(b, MACRO_VAR_REF, SIZE_TYPE)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MACRO_VAR_REFERENCE, "<macro var reference>");
r = MacroVarReference_0(b, l + 1);
r = r && consumeToken(b, MACRO_VAR_REF);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE?
private static boolean MacroVarReference_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "MacroVarReference_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// (SIZE_TYPE? AddressInternal)|DOLLARSIGN|DOLLARSIGN2
public static boolean Address(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Address")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, ADDRESS, "<address>");
r = Address_0(b, l + 1);
if (!r) r = consumeTokenSmart(b, DOLLARSIGN);
if (!r) r = consumeTokenSmart(b, DOLLARSIGN2);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE? AddressInternal
private static boolean Address_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Address_0")) return false;
boolean r;
Marker m = enter_section_(b);
r = Address_0_0(b, l + 1);
r = r && AddressInternal(b, l + 1);
exit_section_(b, m, null, r);
return r;
}
// SIZE_TYPE?
private static boolean Address_0_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Address_0_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// SIZE_TYPE? REGISTER
public static boolean Reg(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Reg")) return false;
if (!nextTokenIsSmart(b, REGISTER, SIZE_TYPE)) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, REG, "<reg>");
r = Reg_0(b, l + 1);
r = r && consumeToken(b, REGISTER);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE?
private static boolean Reg_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Reg_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// SEGMENT_REGISTER
public static boolean Seg(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Seg")) return false;
if (!nextTokenIsSmart(b, SEGMENT_REGISTER)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, SEGMENT_REGISTER);
exit_section_(b, m, SEG, r);
return r;
}
// GENERAL_OP|SYSTEM_OP|VIRTUALIZATION_OP|X64_OP|FPU_OP|MMX_OP|SSE_OP|SSE2_OP|SSE3_OP|SSE4_OP|AVX_OP|AVX2_OP|AVX512_OP
public static boolean Mnemonic(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Mnemonic")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, MNEMONIC, "<mnemonic>");
r = consumeTokenSmart(b, GENERAL_OP);
if (!r) r = consumeTokenSmart(b, SYSTEM_OP);
if (!r) r = consumeTokenSmart(b, VIRTUALIZATION_OP);
if (!r) r = consumeTokenSmart(b, X64_OP);
if (!r) r = consumeTokenSmart(b, FPU_OP);
if (!r) r = consumeTokenSmart(b, MMX_OP);
if (!r) r = consumeTokenSmart(b, SSE_OP);
if (!r) r = consumeTokenSmart(b, SSE2_OP);
if (!r) r = consumeTokenSmart(b, SSE3_OP);
if (!r) r = consumeTokenSmart(b, SSE4_OP);
if (!r) r = consumeTokenSmart(b, AVX_OP);
if (!r) r = consumeTokenSmart(b, AVX2_OP);
if (!r) r = consumeTokenSmart(b, AVX512_OP);
exit_section_(b, l, m, r, false, null);
return r;
}
// ID|MACRO_VAR_REF|MACRO_PARAM_REF
public static boolean Identifier(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "Identifier")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, IDENTIFIER, "<identifier>");
r = consumeTokenSmart(b, ID);
if (!r) r = consumeTokenSmart(b, MACRO_VAR_REF);
if (!r) r = consumeTokenSmart(b, MACRO_PARAM_REF);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE? (LBL|ID)
public static boolean LabelIdentifier(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "LabelIdentifier")) return false;
boolean r;
Marker m = enter_section_(b, l, _NONE_, LABEL_IDENTIFIER, "<label identifier>");
r = LabelIdentifier_0(b, l + 1);
r = r && LabelIdentifier_1(b, l + 1);
exit_section_(b, l, m, r, false, null);
return r;
}
// SIZE_TYPE?
private static boolean LabelIdentifier_0(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "LabelIdentifier_0")) return false;
consumeTokenSmart(b, SIZE_TYPE);
return true;
}
// LBL|ID
private static boolean LabelIdentifier_1(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "LabelIdentifier_1")) return false;
boolean r;
r = consumeTokenSmart(b, LBL);
if (!r) r = consumeTokenSmart(b, ID);
return r;
}
// END_DIRECTIVE_OP
public static boolean EndDirective(PsiBuilder b, int l) {
if (!recursion_guard_(b, l, "EndDirective")) return false;
if (!nextTokenIsSmart(b, END_DIRECTIVE_OP)) return false;
boolean r;
Marker m = enter_section_(b);
r = consumeTokenSmart(b, END_DIRECTIVE_OP);
exit_section_(b, m, END_DIRECTIVE, r);
return r;
}
}
