public static LexerlessGrammar createGrammar() { return createGrammarBuilder().build(); }
public static LexerlessGrammar createGrammar() { return createGrammarBuilder().build(); }
public static LexerlessGrammar createGrammar() { return createGrammarBuilder().build(); }
public static LexerlessGrammar createGrammar() { return createGrammarBuilder().build(); }
public static Grammar undefinedRule() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A); return b.build(); }
public static Grammar referenceToUndefinedRule() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is(B); return b.build(); }
public static Grammar greedy() { LexerlessGrammarBuilder b = common(); b.rule(RULE).is(TERM, b.zeroOrMore("+", TERM)); return b.build(); }
public static Grammar create() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(S).is("(", b.optional(S), ")"); return b.build(); }
public static Grammar incorrectRegularExpression() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is(b.regexp("*")); return b.build(); }
public static Grammar recursive() { LexerlessGrammarBuilder b = common(); b.rule(RULE).is(TERM, b.optional("+", RULE)); return b.build(); }
public static Grammar infiniteOneOrMore() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is(b.oneOrMore(b.optional("foo"))); return b.build(); }
public static Grammar ruleDefinedTwice() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is("foo"); b.rule(A).is("bar"); return b.build(); }
public static Grammar infiniteZeroOrMore() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is(b.zeroOrMore(b.optional("foo"))); return b.build(); }
public static Grammar requiresNegativeMemoization() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is( 'a', b.firstOf( b.sequence(A, 'b'), b.sequence(A, 'c'))); return b.build(); }
/** * To eliminate indirect left recursion - transform to immediate left recursion, then factor out non recursive alternatives. */ public static Grammar eliminatedIndirectLeftRecursion() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is(b.firstOf(b.sequence(S2, T1), S1), b.zeroOrMore(T2, T1)); otherRules(b); return b.build(); }
/** * To eliminate immediate left recursion - factor out non recursive alternatives. */ public static Grammar eliminatedImmediateLeftRecursion() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is(b.firstOf(S1, S2), b.zeroOrMore(b.firstOf(T1, T2))); otherRules(b); return b.build(); }
/** * @see #eliminatedImmediateLeftRecursion() */ public static Grammar immediateLeftRecursion() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is(b.firstOf( b.sequence(A, T1), b.sequence(A, T2), S1, S2)); otherRules(b); return b.build(); }
public static Grammar requiresPositiveMemoization() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is( b.firstOf( b.sequence(b.optional(B), 'a'), b.sequence(b.optional(B), 'b'))); b.rule(B).is('(', A, ')'); return b.build(); }
public static Grammar createGrammar() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(S).is(b.next(A, "c"), b.oneOrMore("a"), B, b.nextNot("a", "b", "c")); b.rule(A).is("a", b.optional(A), "b"); b.rule(B).is("b", b.optional(B), "c"); return b.build(); }
public static Grammar requiresPositiveMemoizationOnMoreThanJustLastRule() { LexerlessGrammarBuilder b = LexerlessGrammarBuilder.create(); b.rule(A).is( b.firstOf( b.sequence(b.optional(B), 'a'), // rule 'C' will match and override the memoization result of 'B': b.sequence(C, '!'), b.sequence(b.optional(B), 'b'))); b.rule(B).is('(', A, ')'); // rule 'C' will override each following memoization result of 'A': b.rule(C).is('(', b.optional(C)); return b.build(); }