/** * It is responsible for setting the rules for arguments. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void arguments(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(ARGUMENTS).is( LPAREN, grammarBuilder.optional(ARGUMENTS_LIST), RPAREN ); }
/** * Creates the rule that defines an initializer. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void initializer(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(INITIALIZER).is( grammarBuilder.optional(STATIC), INITIALIZER_BLOCK ); }
/** * Defines the rule for upsert operation. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void dmlUpsert(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(DML_UPSERT).is( UPSERT, PRIMARY_EXPRESSION, grammarBuilder.optional(PRIMARY_EXPRESSION) ); }
/** * It is responsible for setting the rule for from sentence. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void fromSentence(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(FROM_SENTENCE).is(FROM, grammarBuilder.firstOf( SOQL_NAME, GROUP) , grammarBuilder.optional(ALIASSTATEMENT)); }
public static void expression(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(EXPRESSION).is(CONDITIONAL_EXPRESSION, grammarBuilder.optional(grammarBuilder.sequence(ASSIGNMENT_OPERATOR, EXPRESSION)) ); }
public static void instanceOfExpression(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(INSTANCE_OF_EXPRESSION).is(RELATIONAL_EXPRESSION, grammarBuilder.optional(grammarBuilder.sequence(INSTANCEOF, TYPE)) ); }
/** * 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 buildOn(LexerfulGrammarBuilder b) { b.rule(ALTER_SESSION).is(ALTER, SESSION, b.oneOrMore(b.anyTokenButNot(b.firstOf(SEMICOLON, DIVISION, EOF)))); b.rule(SET_ROLE).is(SET, ROLE, b.firstOf( NONE, b.sequence(ALL, b.optional(EXCEPT, b.oneOrMore(IDENTIFIER_NAME, b.optional(COMMA)))), b.oneOrMore(IDENTIFIER_NAME, b.optional(IDENTIFIED, BY, b.anyToken()), b.optional(COMMA)) )); b.rule(SESSION_CONTROL_COMMAND).is(b.firstOf(ALTER_SESSION, SET_ROLE), b.optional(SEMICOLON)); }
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)); }
public static void conditionalExpression(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(CONDITIONAL_EXPRESSION).is(CONDITIONAL_OR_EXPRESSION, grammarBuilder.optional(grammarBuilder.sequence(QUESTION, EXPRESSION, COLON, EXPRESSION)) ); }
public static void arrayInitializer(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(ARRAY_INITIALIZER).is( grammarBuilder.optional( VARIABLE_INITIALIZER, grammarBuilder.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)); }
public static void buildOn(LexerfulGrammarBuilder b) { b.rule(LISTAGG_EXPRESSION).is( LISTAGG, LPARENTHESIS, EXPRESSION, b.optional(COMMA, STRING_LITERAL), RPARENTHESIS, WITHIN, GROUP, LPARENTHESIS, DmlGrammar.ORDER_BY_CLAUSE, RPARENTHESIS); b.rule(AGGREGATE_SQL_FUNCTION).is(LISTAGG_EXPRESSION); }
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)); }
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))); }
public static void unaryExpressionNotPlusMinus(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(UNARY_EXPRESSION_NOT_PLUS_MINUS).is( grammarBuilder.firstOf( grammarBuilder.sequence(NOT, UNARY_EXPRESSION), CAST_EXPRESSION, grammarBuilder.sequence(PRIMARY_EXPRESSION, grammarBuilder.optional(POST_FIX_EXPRESSION))) ); }
/** * @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); }
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)); }
/** * @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)); }