/** * Grammar is created to identify if a class or interface. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void typeClass(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(TYPE_CLASS).is( grammarBuilder.firstOf( CLASS, INTERFACE) ); }
/** * Creates the rule for accessor declaration within a class. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void accessorDeclaration(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(ACCESSOR_DECLARATION).is( MODIFIERS, ACCESSOR, grammarBuilder.firstOf(ACCESSOR_BODY, SEMICOLON)); }
private static void createConversionFunctions(LexerfulGrammarBuilder b) { b.rule(CAST_EXPRESSION).is( CAST, LPARENTHESIS, b.firstOf(b.sequence(MULTISET, EXPRESSION), EXPRESSION), AS, DATATYPE, RPARENTHESIS); }
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) ); }
private static void createOthersType() { b.rule(QUALIFIED_IDENT).is(PACKAGE_NAME, GoLexer.Punctuators.DOT, IDENTIFIER); b.rule(TYPE_NAME).is(b.firstOf(IDENTIFIER, QUALIFIED_IDENT)); b.rule(POINTER_TYPE).is(GoLexer.Punctuators.MUL, TYPE); b.rule(TYPE_LIT).is(b.firstOf(ARRAY_TYPE, STRUCT_TYPE, POINTER_TYPE, FUNC_TYPE, INTERFACE_TYPE, SLICE_TYPE, MAP_TYPE, CHANNEL_TYPE)); b.rule(TYPE).is(b.firstOf(GO_TYPE, TYPE_LIT, TYPE_NAME, b.sequence(GoLexer.Punctuators.PAREN_R, TYPE, GoLexer.Punctuators.PAREN_L))); }
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 createCharacterFunctions(LexerfulGrammarBuilder b) { b.rule(TRIM_EXPRESSION).is( TRIM, LPARENTHESIS, b.optional(b.optional(b.firstOf(LEADING, TRAILING, BOTH)), EXPRESSION, FROM), EXPRESSION, RPARENTHESIS); }
public static void postfixExpression(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(POST_FIX_EXPRESSION).is( grammarBuilder.firstOf( grammarBuilder.sequence(PLUS, PLUS), grammarBuilder.sequence(MINUS, MINUS) ) ); }
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; }
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 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#Method_expressions * MethodName==Identifier */ private static void createMethodExpr() { b.rule(RECEIVER_TYPE) .is(b.firstOf(TYPE_NAME, b.sequence(GoLexer.Punctuators.PAREN_R, TYPE_NAME, GoLexer.Punctuators.PAREN_L), b.sequence(GoLexer.Punctuators.PAREN_R, RECEIVER_TYPE, GoLexer.Punctuators.PAREN_L))); b.rule(METHOD_EXPR).is(b.sequence(RECEIVER_TYPE, GoLexer.Punctuators.DOT, IDENTIFIER)); }
/** * @see https://golang.org/ref/spec#Import_declarations */ private static void createImport() { b.rule(IMPORT_SIMPLE).is(GoLexer.Keyword.IMPORT, GoLexer.Literals.STRING); b.rule(IMPORT_COMPLEX).is(GoLexer.Keyword.IMPORT, GoLexer.Punctuators.PAREN_L, b.oneOrMore(GoLexer.Literals.STRING), GoLexer.Punctuators.PAREN_R); b.rule(IMPORT_DEFINITION).is(b.firstOf(IMPORT_SIMPLE, IMPORT_COMPLEX)); }
/** * 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 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; }
/** * @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 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 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))); }