/** * 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, 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)); }
public static Grammar create() { LexerfulGrammarBuilder b = LexerfulGrammarBuilder.create(); b.rule(BIN_TYPE).is(b.firstOf( INT, VOID)); b.rule(BIN_PARAMETER).is(IDENTIFIER); b.rule(BIN_FUNCTION_DEFINITION).is(IDENTIFIER); b.rule(BIN_VARIABLE_DEFINITION).is(IDENTIFIER); b.rule(BIN_FUNCTION_REFERENCE).is(IDENTIFIER); b.rule(BIN_VARIABLE_REFERENCE).is(IDENTIFIER); b.rule(COMPILATION_UNIT).is(b.zeroOrMore(DEFINITION), EOF); b.rule(DEFINITION).is(b.firstOf( STRUCT_DEFINITION, FUNCTION_DEFINITION, VARIABLE_DEFINITION)); b.rule(STRUCT_DEFINITION).is(STRUCT, IDENTIFIER, BRACE_L, b.oneOrMore(STRUCT_MEMBER, SEMICOLON), BRACE_R); b.rule(STRUCT_MEMBER).is(BIN_TYPE, IDENTIFIER); b.rule(FUNCTION_DEFINITION).is(BIN_TYPE, BIN_FUNCTION_DEFINITION, PAREN_L, b.optional(PARAMETERS_LIST), PAREN_R, COMPOUND_STATEMENT);
private static void createDclCommands(LexerfulGrammarBuilder b) { List<PlSqlKeyword> keywords = Arrays.asList(PlSqlKeyword.values()); PlSqlKeyword[] rest = keywords.subList(1, keywords.size()).toArray(new PlSqlKeyword[keywords.size() - 1]); b.rule(IDENTIFIER_OR_KEYWORD).is(b.firstOf(GenericTokenType.IDENTIFIER, keywords.get(0), (Object[]) rest)); b.rule(PRIVILEGE_PART).is(b.nextNot(b.firstOf(COMMA, ON, TO, LPARENTHESIS)), IDENTIFIER_OR_KEYWORD); b.rule(PRIVILEGE_COLUMNS).is(LPARENTHESIS, IDENTIFIER_NAME, b.zeroOrMore(COMMA, IDENTIFIER_NAME), RPARENTHESIS); b.rule(GRANT_SYSTEM_PRIVILEGES).is( b.oneOrMore(PRIVILEGE_PART), b.zeroOrMore(COMMA, b.oneOrMore(PRIVILEGE_PART)), TO, IDENTIFIER_OR_KEYWORD, b.zeroOrMore(COMMA, IDENTIFIER_OR_KEYWORD), b.optional(IDENTIFIED, BY, b.anyToken(), b.zeroOrMore(COMMA, b.anyToken())), b.optional(WITH, b.firstOf(ADMIN, DELEGATE), OPTION), b.optional(CONTAINER, EQUALS, b.firstOf(CURRENT, ALL))); b.rule(GRANT_OBJECT_PRIVILEGES).is( b.oneOrMore(PRIVILEGE_PART), b.optional(PRIVILEGE_COLUMNS), b.zeroOrMore(COMMA, b.oneOrMore(PRIVILEGE_PART, b.optional(PRIVILEGE_COLUMNS))), b.optional(ON, b.oneOrMore(b.anyTokenButNot(TO))), TO, IDENTIFIER_OR_KEYWORD, b.zeroOrMore(COMMA, IDENTIFIER_OR_KEYWORD), b.optional(WITH, HIERARCHY, OPTION), b.optional(WITH, GRANT, OPTION)); b.rule(GRANT_ROLES_TO_PROGRAMS).is( b.oneOrMore(PRIVILEGE_PART), b.zeroOrMore(COMMA, b.oneOrMore(PRIVILEGE_PART)), TO, b.firstOf(FUNCTION, PROCEDURE, PACKAGE), UNIT_NAME, b.zeroOrMore(COMMA, b.firstOf(FUNCTION, PROCEDURE, PACKAGE), UNIT_NAME)
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)) ); }
/** * It is the main method of grammar. Here all other grammars are * constructed. * * @return the grammar */ public static Grammar create() { LexerfulGrammarBuilder grammarBuilder = LexerfulGrammarBuilder.create(); MostUsed.create(grammarBuilder); Expression.create(grammarBuilder); Type.create(grammarBuilder); Statement.create(grammarBuilder); Declaration.create(grammarBuilder); SOQLExpressions.create(grammarBuilder); grammarBuilder.rule(APEX_GRAMMAR).is( grammarBuilder.firstOf( TYPE_DECLARATION, TRIGGER_DECLARATION), EOF); grammarBuilder.setRootRule(APEX_GRAMMAR); return grammarBuilder.build(); }
public static LexerfulGrammarBuilder create(PlSqlConfiguration conf) { LexerfulGrammarBuilder b = LexerfulGrammarBuilder.create(); b.rule(NON_RESERVED_KEYWORD).is(b.firstOf(keywords.get(0), keywords.get(1), (Object[]) rest)); b.rule(IDENTIFIER_NAME).is(b.firstOf(IDENTIFIER, NON_RESERVED_KEYWORD)); b.rule(VALID_INPUT).is(b.firstOf( COMPILATION_UNIT, DCL_COMMAND, b.rule(RECOVERY).is(b.oneOrMore( b.nextNot(b.firstOf(VALID_INPUT, EOF)), b.anyToken())); b.rule(FILE_INPUT).is(b.oneOrMore(b.firstOf( VALID_INPUT, RECOVERY)), EOF); } else { b.rule(RECOVERY).is(b.nothing()); b.rule(FILE_INPUT).is(b.oneOrMore(VALID_INPUT), EOF); ConditionsGrammar.buildOn(b); b.setRootRule(FILE_INPUT); b.buildWithMemoizationOfMatchesForAllRules();
/** * 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 Grammar create() { b.rule(TAG).is(GoLexer.Literals.STRING); createCommonExpression(); createPackageDefinition(); createImport(); createAllGoType(); createOthersType(); createStructDefinition(); createFunctionType(); createAllDeclaration(); b.rule(DEFINITION).is(b.firstOf(PACKAGE_DEFINITION, IMPORT_DEFINITION, DECLARATION, STRUCT_TYPE, FUNC_TYPE)); b.rule(COMPILATION_UNIT).is(b.zeroOrMore(DEFINITION), EOF); b.setRootRule(COMPILATION_UNIT); return b.build(); }
private static void types(LexerfulGrammarBuilder b) { b.rule(SIMPLE_TYPE).is( b.firstOf( NUMERIC_TYPE, BOOL)); b.rule(NUMERIC_TYPE).is( b.firstOf( INTEGRAL_TYPE, FLOATING_POINT_TYPE, DECIMAL)); b.rule(INTEGRAL_TYPE).is( b.firstOf( SBYTE, BYTE, ULONG, CHAR)); b.rule(FLOATING_POINT_TYPE).is( b.firstOf( FLOAT, DOUBLE)); b.rule(RANK_SPECIFIER).is(LBRACKET, b.zeroOrMore(COMMA), RBRACKET); b.rule(RANK_SPECIFIERS).is(b.oneOrMore(RANK_SPECIFIER)); b.rule(TYPE_PRIMARY).is( b.firstOf( SIMPLE_TYPE, "dynamic",
public static void arrayInitializer(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(ARRAY_INITIALIZER).is( grammarBuilder.optional( VARIABLE_INITIALIZER, grammarBuilder.zeroOrMore(COMMA, VARIABLE_INITIALIZER) ) ); }
/** * It is responsible for managing the method name. * * @param grammarBuilder ApexGrammarBuilder parameter. */ private static void methodName(LexerfulGrammarBuilder grammarBuilder) { grammarBuilder.rule(METHOD_IDENTIFIER).is( grammarBuilder.firstOf( ALLOWED_KEYWORDS_AS_IDENTIFIER_FOR_METHODS, ALLOWED_KEYWORDS_AS_IDENTIFIER, SPECIAL_KEYWORDS_AS_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)); }
/** * 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) ); }