/** Build a subrule matching ^(. .*) (any tree or node). Let's use * (^(. .+) | .) to be safe. */ public StateCluster build_WildcardTree(GrammarAST associatedAST) { StateCluster wildRoot = build_Wildcard(associatedAST); StateCluster down = build_Atom(Label.DOWN, associatedAST); wildRoot = build_AB(wildRoot,down); // hook in; . DOWN // make .+ StateCluster wildChildren = build_Wildcard(associatedAST); wildChildren = build_Aplus(wildChildren); wildRoot = build_AB(wildRoot,wildChildren); // hook in; . DOWN .+ StateCluster up = build_Atom(Label.UP, associatedAST); wildRoot = build_AB(wildRoot,up); // hook in; . DOWN .+ UP // make optional . alt StateCluster optionalNodeAlt = build_Wildcard(associatedAST); List<StateCluster> alts = new ArrayList<StateCluster>(); alts.add(wildRoot); alts.add(optionalNodeAlt); StateCluster blk = build_AlternativeBlock(alts); return blk; }
/** add an EOF transition to any rule end NFAState that points to nothing * (i.e., for all those rules not invoked by another rule). These * are start symbols then. * * Return the number of grammar entry points; i.e., how many rules are * not invoked by another rule (they can only be invoked from outside). * These are the start rules. */ public int build_EOFStates(Collection<Rule> rules) { int numberUnInvokedRules = 0; for (Rule r : rules) { NFAState endNFAState = r.stopState; // Is this rule a start symbol? (no follow links) if ( endNFAState.transition[0] ==null ) { // if so, then don't let algorithm fall off the end of // the rule, make it hit EOF/EOT. build_EOFState(endNFAState); // track how many rules have been invoked by another rule numberUnInvokedRules++; } } return numberUnInvokedRules; }
/** From label A build Graph o-A->o */ public StateCluster build_Atom(int label, GrammarAST associatedAST) { NFAState left = newState(); NFAState right = newState(); left.associatedASTNode = associatedAST; right.associatedASTNode = associatedAST; transitionBetweenStates(left, right, label); StateCluster g = new StateCluster(left, right); return g; }
if ( start!=null ) { Rule rr = grammar.getRule(scopeName,r.getText()); g = factory.build_RuleRef(rr, start); r.followingNFAState = g.right; r.NFAStartState = g.left; if ( start!=null ) { Rule rr = grammar.getRule(scopeName,t.getText()); g = factory.build_RuleRef(rr, start); t.NFAStartState = g.left; g = factory.build_Atom(t); t.followingNFAState = g.right; g = factory.build_CharLiteralAtom(c); g = factory.build_Atom(c); c.followingNFAState = g.right; g = factory.build_StringLiteralAtom(s); g = factory.build_Atom(s); s.followingNFAState = g.right; g = factory.build_WildcardTree(w); g = factory.build_Wildcard(w);
_t = __t70; _t = _t.getNextSibling(); g = factory.build_Range(grammar.getTokenType(a.getText()), grammar.getTokenType(b.getText())); break; g = factory.build_CharRange(c1.getText(), c2.getText()); match(_t,ACTION); _t = _t.getNextSibling(); g = factory.build_Action(tmp54_AST_in); break; match(_t,FORCED_ACTION); _t = _t.getNextSibling(); g = factory.build_Action(tmp55_AST_in); break; match(_t,SEMPRED); _t = _t.getNextSibling(); g = factory.build_SemanticPredicate(pred); break; match(_t,SYN_SEMPRED); _t = _t.getNextSibling(); g = factory.build_SemanticPredicate(spred); break; match(_t,BACKTRACK_SEMPRED);
/** For a non-lexer, just build a simple token reference atom. * For a lexer, a string is a sequence of char to match. That is, * "fog" is treated as 'f' 'o' 'g' not as a single transition in * the DFA. Machine== o-'f'->o-'o'->o-'g'->o and has n+1 states * for n characters. */ public StateCluster build_StringLiteralAtom(GrammarAST stringLiteralAST) { if ( nfa.grammar.type==Grammar.LEXER ) { StringBuffer chars = Grammar.getUnescapedStringFromGrammarStringLiteral(stringLiteralAST.getText()); NFAState first = newState(); NFAState last = null; NFAState prev = first; for (int i=0; i<chars.length(); i++) { int c = chars.charAt(i); NFAState next = newState(); transitionBetweenStates(prev, next, c); prev = last = next; } return new StateCluster(first, last); } // a simple token reference in non-Lexers int tokenType = nfa.grammar.getTokenType(stringLiteralAST.getText()); return build_Atom(tokenType, stringLiteralAST); }
b = factory.build_AlternativeBlockFromSet(b); g = factory.build_Aoptional(b); g.left.setDescription(grammar.grammarTreeToString(ebnf_AST_in,false)); b = factory.build_AlternativeBlockFromSet(b); g = factory.build_Astar(b); b = factory.build_AlternativeBlockFromSet(b); g = factory.build_Aplus(b);
/** From set build single edge graph o->o-set->o. To conform to * what an alt block looks like, must have extra state on left. */ public StateCluster build_Set(IntSet set, GrammarAST associatedAST) { NFAState left = newState(); NFAState right = newState(); left.associatedASTNode = associatedAST; right.associatedASTNode = associatedAST; Label label = new Label(set); Transition e = new Transition(label,right); left.addTransition(e); StateCluster g = new StateCluster(left, right); return g; }
e=element(_t); _t = _retTree; g = factory.build_AB(g,e); g = factory.build_Epsilon(); factory.optimizeAlternative(g);
factory = new NFAFactory(nfa); Rule r = (Rule) itr.next(); String ruleName = r.name; NFAState ruleBeginState = factory.newState(); ruleBeginState.setDescription("rule "+ruleName+" start"); ruleBeginState.enclosingRule = r; r.startState = ruleBeginState; NFAState ruleEndState = factory.newState(); ruleEndState.setDescription("rule "+ruleName+" end"); ruleEndState.setAcceptState(true);
_t = _retTree; down = factory.build_Atom(Label.DOWN, el); g = factory.build_AB(g,down); e=element(_t); _t = _retTree; g = factory.build_AB(g,e); up = factory.build_Atom(Label.UP, el); g = factory.build_AB(g,up);
/** From char 'c' build StateCluster o-intValue(c)->o */ public StateCluster build_CharLiteralAtom(GrammarAST charLiteralAST) { int c = Grammar.getCharValueFromGrammarCharLiteral(charLiteralAST.getText()); return build_Atom(c, charLiteralAST); }
/** From char 'c' build StateCluster o-intValue(c)->o * can include unicode spec likes '\u0024' later. Accepts * actual unicode 16-bit now, of course, by default. * TODO not supplemental char clean! */ public StateCluster build_CharRange(String a, String b) { int from = Grammar.getCharValueFromGrammarCharLiteral(a); int to = Grammar.getCharValueFromGrammarCharLiteral(b); return build_Range(from, to); }
/** From A B build A-e->B (that is, build an epsilon arc from right * of A to left of B). * * As a convenience, return B if A is null or return A if B is null. */ public StateCluster build_AB(StateCluster A, StateCluster B) { if ( A==null ) { return B; } if ( B==null ) { return A; } transitionBetweenStates(A.right, B.left, Label.EPSILON); StateCluster g = new StateCluster(A.left, B.right); return g; }
match(input, Token.UP, null); if (state.failed) return retval; if ( state.backtracking==0 ) {retval.g = factory.build_AlternativeBlock(alts);}
retval.g = factory.build_RuleRef(rr, start); r.followingNFAState = retval.g.right; r.NFAStartState = retval.g.left; retval.g = factory.build_RuleRef(rr, start); t.NFAStartState = retval.g.left; retval.g = factory.build_Atom(t); t.followingNFAState = retval.g.right; if ( grammar.type==Grammar.LEXER ) retval.g = factory.build_CharLiteralAtom(c); retval.g = factory.build_Atom(c); c.followingNFAState = retval.g.right; if ( grammar.type==Grammar.LEXER ) retval.g = factory.build_StringLiteralAtom(s); retval.g = factory.build_Atom(s); s.followingNFAState = retval.g.right; retval.g = factory.build_WildcardTree( w ); retval.g = factory.build_Wildcard( w );
match(input, Token.UP, null); if (state.failed) return retval; if ( state.backtracking==0 ) {retval.g = factory.build_Range(grammar.getTokenType((a!=null?(input.getTokenStream().toString(input.getTreeAdaptor().getTokenStartIndex(a.start),input.getTreeAdaptor().getTokenStopIndex(a.start))):null)), grammar.getTokenType((b!=null?(input.getTokenStream().toString(input.getTreeAdaptor().getTokenStartIndex(b.start),input.getTreeAdaptor().getTokenStopIndex(b.start))):null)));} retval.g = factory.build_CharRange((c1!=null?c1.getText():null), (c2!=null?c2.getText():null)); if ( state.backtracking==0 ) {retval.g = factory.build_Action(ACTION5);} if ( state.backtracking==0 ) {retval.g = factory.build_Action(FORCED_ACTION6);} if ( state.backtracking==0 ) {retval.g = factory.build_SemanticPredicate(pred);} if ( state.backtracking==0 ) {retval.g = factory.build_SemanticPredicate(spred);} if ( state.backtracking==0 ) {retval.g = factory.build_SemanticPredicate(bpred);} if ( state.backtracking==0 ) {retval.g = factory.build_SemanticPredicate(gpred);} if ( state.backtracking==0 ) {retval.g = factory.build_Epsilon();}
/** For a non-lexer, just build a simple token reference atom. * For a lexer, a string is a sequence of char to match. That is, * "fog" is treated as 'f' 'o' 'g' not as a single transition in * the DFA. Machine== o-'f'->o-'o'->o-'g'->o and has n+1 states * for n characters. */ public StateCluster build_StringLiteralAtom(GrammarAST stringLiteralAST) { if ( nfa.grammar.type==Grammar.LEXER ) { StringBuffer chars = Grammar.getUnescapedStringFromGrammarStringLiteral(stringLiteralAST.getText()); NFAState first = newState(); NFAState last = null; NFAState prev = first; for (int i=0; i<chars.length(); i++) { int c = chars.charAt(i); NFAState next = newState(); transitionBetweenStates(prev, next, c); prev = last = next; } return new StateCluster(first, last); } // a simple token reference in non-Lexers int tokenType = nfa.grammar.getTokenType(stringLiteralAST.getText()); return build_Atom(tokenType, stringLiteralAST); }
bg = factory.build_AlternativeBlockFromSet(bg); retval.g = factory.build_Aoptional(bg); retval.g.left.setDescription(grammar.grammarTreeToString(((GrammarAST)retval.start), false)); if ( blk.getSetValue()!=null ) bg = factory.build_AlternativeBlockFromSet(bg); retval.g = factory.build_Astar(bg); if ( blk.getSetValue()!=null ) bg = factory.build_AlternativeBlockFromSet(bg); retval.g = factory.build_Aplus(bg);
/** From set build single edge graph o->o-set->o. To conform to * what an alt block looks like, must have extra state on left. */ public StateCluster build_Set(IntSet set, GrammarAST associatedAST) { NFAState left = newState(); NFAState right = newState(); left.associatedASTNode = associatedAST; right.associatedASTNode = associatedAST; Label label = new Label(set); Transition e = new Transition(label,right); left.addTransition(e); StateCluster g = new StateCluster(left, right); return g; }