/** * Grammar is created to implement another class or not. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void implementsList(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(IMPLEMENTS_LIST).is( IMPLEMENTS, CLASS_OR_INTERFACE_ERASURE_TYPE, grammarBuilder.zeroOrMore(COMMA, CLASS_OR_INTERFACE_ERASURE_TYPE) ); }
public static void conditionalAndExpression(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(CONDITIONAL_AND_EXPRESSION).is( INCLUSIVE_OR_EXPRESSION, grammarBuilder.zeroOrMore( grammarBuilder.sequence( AND, AND, INCLUSIVE_OR_EXPRESSION)) ); }
public static void inclusiveOrExpression(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(INCLUSIVE_OR_EXPRESSION).is(EXCLUSIVE_OR_EXPRESSION, grammarBuilder.zeroOrMore(grammarBuilder.sequence(OR, EXCLUSIVE_OR_EXPRESSION)) ); }
/** * Creates the rule that defines a set of formal parameters for a method. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void formalParameters(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(FORMAL_PARAMETERS).is( LPAREN, grammarBuilder.optional(FORMAL_PARAMETER, grammarBuilder.zeroOrMore(COMMA, FORMAL_PARAMETER)), RPAREN ); }
public static void conditionalOrExpression(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(CONDITIONAL_OR_EXPRESSION).is( CONDITIONAL_AND_EXPRESSION, grammarBuilder.zeroOrMore( grammarBuilder.sequence( OR, OR, CONDITIONAL_AND_EXPRESSION)) ); }
public static void additiveExpression(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(ADDITIVE_EXPRESSION).is( MULTIPLICATIVE_EXPRESSION, grammarBuilder.zeroOrMore( grammarBuilder.firstOf(PLUS, MINUS), MULTIPLICATIVE_EXPRESSION) ); }
public static void multiplicativeExpression(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(MULTIPLICATIVE_EXPRESSION).is( UNARY_EXPRESSION, grammarBuilder.zeroOrMore( grammarBuilder.firstOf(STAR, DIV, MOD), UNARY_EXPRESSION) ); }
public static void arrayInitializer(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(ARRAY_INITIALIZER).is( grammarBuilder.optional( VARIABLE_INITIALIZER, grammarBuilder.zeroOrMore(COMMA, VARIABLE_INITIALIZER) ) ); }
private static void basicConcepts(LexerfulGrammarBuilder b) { b.rule(COMPILATION_UNIT) .is(b.zeroOrMore(EXTERN_ALIAS_DIRECTIVE), b.zeroOrMore(USING_DIRECTIVE), b.optional(GLOBAL_ATTRIBUTES), b.zeroOrMore(NAMESPACE_MEMBER_DECLARATION), EOF); b.rule(NAMESPACE_NAME).is(NAMESPACE_OR_TYPE_NAME); b.rule(TYPE_NAME).is(NAMESPACE_OR_TYPE_NAME); b.rule(NAMESPACE_OR_TYPE_NAME).is( b.firstOf( QUALIFIED_ALIAS_MEMBER, b.sequence(IDENTIFIER, b.optional(TYPE_ARGUMENT_LIST))), b.zeroOrMore(DOT, IDENTIFIER, b.optional(TYPE_ARGUMENT_LIST))); }
/** * Creates a grammar rule for arguments list. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void argumentsList(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(ARGUMENTS_LIST).is(grammarBuilder.firstOf(EXPRESSION, THIS), grammarBuilder.zeroOrMore(COMMA, grammarBuilder.firstOf(EXPRESSION, THIS)) ); }
public static void mapValues(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(MAP_VALUES).is(grammarBuilder.sequence(EXPRESSION, MAP_ASSIGN, EXPRESSION), grammarBuilder.zeroOrMore(grammarBuilder.sequence(COMMA, EXPRESSION, MAP_ASSIGN, EXPRESSION)) ); }
private static void createInsertExpression(LexerfulGrammarBuilder b) { b.rule(INSERT_COLUMNS).is(LPARENTHESIS, MEMBER_EXPRESSION, b.zeroOrMore(COMMA, MEMBER_EXPRESSION), RPARENTHESIS); b.rule(INSERT_EXPRESSION).is( INSERT, INTO, TABLE_REFERENCE, b.optional(IDENTIFIER_NAME), b.optional(INSERT_COLUMNS), b.firstOf( b.sequence(VALUES, LPARENTHESIS, EXPRESSION, b.zeroOrMore(COMMA, EXPRESSION), RPARENTHESIS), b.sequence(VALUES, EXPRESSION), SELECT_EXPRESSION), b.optional(RETURNING_INTO_CLAUSE)); }
private static void arrays(LexerfulGrammarBuilder b) { b.rule(ARRAY_INITIALIZER).is( LCURLYBRACE, b.optional( b.firstOf( b.sequence(VARIABLE_INITIALIZER_LIST, COMMA), VARIABLE_INITIALIZER_LIST)), RCURLYBRACE); b.rule(VARIABLE_INITIALIZER_LIST).is(VARIABLE_INITIALIZER, b.zeroOrMore(COMMA, VARIABLE_INITIALIZER)); }
/** * https://golang.org/ref/spec#Constant_declarations */ private static void constDeclaration() { Object constSpec = b.sequence(IDENTIFIER_LIST, b.optional(b.sequence(b.optional(TYPE), GoLexer.Punctuators.EQ), EXPR_LIST)); Object manyConstSpec = b.sequence(GoLexer.Punctuators.PAREN_R, b.zeroOrMore(constSpec), GoLexer.Punctuators.PAREN_L); b.rule(CONST_DECLARATION).is(GoLexer.Keyword.CONST, b.firstOf(constSpec, manyConstSpec)); }
private static void createUpdateExpression(LexerfulGrammarBuilder b) { b.rule(UPDATE_COLUMN).is(OBJECT_REFERENCE, EQUALS, b.firstOf(EXPRESSION, DEFAULT)); b.rule(UPDATE_EXPRESSION).is( UPDATE, DML_TABLE_EXPRESSION_CLAUSE, SET, UPDATE_COLUMN, b.zeroOrMore(COMMA, UPDATE_COLUMN), b.optional(b.firstOf( b.sequence(WHERE, CURRENT, OF, IDENTIFIER_NAME), WHERE_CLAUSE)), b.optional(RETURNING_INTO_CLAUSE)); }
public static LexerfulGrammarBuilder create() { LexerfulGrammarBuilder b = LexerfulGrammarBuilder.create(); b.rule(FILE_INPUT).is(b.zeroOrMore(b.firstOf(NEWLINE, STATEMENT)), EOF); grammar(b); compoundStatements(b); simpleStatements(b); expressions(b); b.setRootRule(FILE_INPUT); b.buildWithMemoizationOfMatchesForAllRules(); return b; }
public static LexerfulGrammarBuilder create() { LexerfulGrammarBuilder b = LexerfulGrammarBuilder.create(); b.rule(FILE_INPUT).is(b.zeroOrMore(b.firstOf(NEWLINE, STATEMENT)), EOF); grammar(b); compoundStatements(b); simpleStatements(b); expressions(b); b.setRootRule(FILE_INPUT); b.buildWithMemoizationOfMatchesForAllRules(); return b; }
public static LexerfulGrammarBuilder create() { LexerfulGrammarBuilder b = LexerfulGrammarBuilder.create(); b.rule(FILE_INPUT).is(b.zeroOrMore(b.firstOf(NEWLINE, ATOM)), EOF); b.rule(ATOM).is(b.firstOf( PerlTokenType.NUMBER, PerlTokenType.STRING, b.anyTokenButNot(EOF) )); b.setRootRule(FILE_INPUT); b.buildWithMemoizationOfMatchesForAllRules(); return b; }
/** * @see https://golang.org/ref/spec#Struct_types */ private static void createStructDefinition() { b.rule(FIELD_DEFINITION_NORMAL).is(IDENTIFIER_LIST, TYPE); b.rule(FIELD_DEFINITION_ANOM).is(b.optional(GoLexer.Punctuators.MUL), TYPE_NAME); b.rule(FIELD_DEFINITION).is(b.firstOf(FIELD_DEFINITION_NORMAL, FIELD_DEFINITION_ANOM), b.optional(TAG)); b.rule(STRUCT_TYPE).is(GoLexer.Keyword.STRUCT, GoLexer.Punctuators.BRACE_L, b.zeroOrMore(FIELD_DEFINITION), GoLexer.Punctuators.BRACE_R); }
/** * @see https://golang.org/ref/spec#Variables * @see https://golang.org/ref/spec#Short_variable_declarations */ private static void createVarDeclaration() { Object varSpec = b.firstOf(IDENTIFIER_LIST, b.firstOf(b.sequence(TYPE, b.optional(GoLexer.Punctuators.EQ, EXPR_LIST)), b.sequence(GoLexer.Punctuators.EQ, EXPR_LIST))); b.rule(VAR_DEFINITION).is(GoLexer.Keyword.VAR, b.firstOf(varSpec, b.sequence(GoLexer.Punctuators.PAREN_R, b.zeroOrMore(varSpec), GoLexer.Punctuators.PAREN_L))); b.rule(VAR_FAST_DEFINITION).is(IDENTIFIER_LIST, GoLexer.Punctuators.EQ2, EXPR_LIST); b.rule(VAR_DECLARATION).is(b.firstOf(VAR_DEFINITION, VAR_FAST_DEFINITION)); }