public LookaheadSet FIRST(NFAState s) { return ll1Analyzer.FIRST(s); }
public LookaheadSet LOOK(NFAState s) { return ll1Analyzer.LOOK(s); }
public LookaheadSet FOLLOW(Rule r) { //System.out.println("> FOLLOW("+r.name+") in rule "+r.startState.enclosingRule); LookaheadSet f = FOLLOWCache.get(r); if ( f!=null ) { return f; } f = _FIRST(r.stopState, true); FOLLOWCache.put(r, f); //System.out.println("< FOLLOW("+r+") in rule "+r.startState.enclosingRule+"="+f.toString(this.grammar)); return f; }
public LookaheadSet LOOK(NFAState s) { if ( NFAToDFAConverter.debug ) { System.out.println("> LOOK("+s+")"); } lookBusy.clear(); LookaheadSet look = _FIRST(s, true); // FOLLOW makes no sense (at the moment!) for lexical rules. if ( grammar.type!=Grammar.LEXER && look.member(Label.EOR_TOKEN_TYPE) ) { // avoid altering FIRST reset as it is cached LookaheadSet f = FOLLOW(s.enclosingRule); f.orInPlace(look); f.remove(Label.EOR_TOKEN_TYPE); look = f; //look.orInPlace(FOLLOW(s.enclosingRule)); } else if ( grammar.type==Grammar.LEXER && look.member(Label.EOT) ) { // if this has EOT, lookahead is all char (all char can follow rule) //look = new LookaheadSet(Label.EOT); look = new LookaheadSet(IntervalSet.COMPLETE_SET); } if ( NFAToDFAConverter.debug ) { System.out.println("< LOOK("+s+")="+look.toString(grammar)); } return look; }
NFAState altStartState = (NFAState)altLeftEdge.transition[0].target; altLook[alt] = ll1Analyzer.LOOK(altStartState); ll1Analyzer.detectConfoundingPredicates(decisionStartState); if ( decisionIsLL_1 && !foundConfoundingPredicate ) {
/** Is there a non-syn-pred predicate visible from s that is not in * the rule enclosing s? This accounts for most predicate situations * and lets ANTLR do a simple LL(1)+pred computation. * * TODO: what about gated vs regular preds? */ public boolean detectConfoundingPredicates(NFAState s) { lookBusy.clear(); Rule r = s.enclosingRule; return _detectConfoundingPredicates(s, r, false) == DETECT_PRED_FOUND; }
/** Return predicate expression found via epsilon edges from s. Do * not look into other rules for now. Do something simple. Include * backtracking synpreds. */ public SemanticContext getPredicates(NFAState altStartState) { lookBusy.clear(); return _getPredicates(altStartState, altStartState); }
public LookaheadSet LOOK(NFAState s) { if ( NFAToDFAConverter.debug ) { System.out.println("> LOOK("+s+")"); } lookBusy.clear(); LookaheadSet look = _FIRST(s, true); // FOLLOW makes no sense (at the moment!) for lexical rules. if ( grammar.type!=Grammar.LEXER && look.member(Label.EOR_TOKEN_TYPE) ) { // avoid altering FIRST reset as it is cached LookaheadSet f = FOLLOW(s.enclosingRule); f.orInPlace(look); f.remove(Label.EOR_TOKEN_TYPE); look = f; //look.orInPlace(FOLLOW(s.enclosingRule)); } else if ( grammar.type==Grammar.LEXER && look.member(Label.EOT) ) { // if this has EOT, lookahead is all char (all char can follow rule) //look = new LookaheadSet(Label.EOT); look = new LookaheadSet(IntervalSet.COMPLETE_SET); } if ( NFAToDFAConverter.debug ) { System.out.println("< LOOK("+s+")="+look.toString(grammar)); } return look; }
NFAState altStartState = (NFAState)altLeftEdge.transition[0].target; altLook[alt] = ll1Analyzer.LOOK(altStartState); ll1Analyzer.detectConfoundingPredicates(decisionStartState); if ( decisionIsLL_1 && !foundConfoundingPredicate ) {
/** Is there a non-syn-pred predicate visible from s that is not in * the rule enclosing s? This accounts for most predicate situations * and lets ANTLR do a simple LL(1)+pred computation. * * TODO: what about gated vs regular preds? */ public boolean detectConfoundingPredicates(NFAState s) { lookBusy.clear(); Rule r = s.enclosingRule; return _detectConfoundingPredicates(s, r, false) == DETECT_PRED_FOUND; }
/** Return predicate expression found via epsilon edges from s. Do * not look into other rules for now. Do something simple. Include * backtracking synpreds. */ public SemanticContext getPredicates(NFAState altStartState) { lookBusy.clear(); return _getPredicates(altStartState, altStartState); }
public LookaheadSet LOOK(NFAState s) { if ( NFAToDFAConverter.debug ) { System.out.println("> LOOK("+s+")"); } lookBusy.clear(); LookaheadSet look = _FIRST(s, true); // FOLLOW makes no sense (at the moment!) for lexical rules. if ( grammar.type!=Grammar.LEXER && look.member(Label.EOR_TOKEN_TYPE) ) { // avoid altering FIRST reset as it is cached LookaheadSet f = FOLLOW(s.enclosingRule); f.orInPlace(look); f.remove(Label.EOR_TOKEN_TYPE); look = f; //look.orInPlace(FOLLOW(s.enclosingRule)); } else if ( grammar.type==Grammar.LEXER && look.member(Label.EOT) ) { // if this has EOT, lookahead is all char (all char can follow rule) //look = new LookaheadSet(Label.EOT); look = new LookaheadSet(IntervalSet.COMPLETE_SET); } if ( NFAToDFAConverter.debug ) { System.out.println("< LOOK("+s+")="+look.toString(grammar)); } return look; }
NFAState altStartState = (NFAState)altLeftEdge.transition[0].target; altLook[alt] = ll1Analyzer.LOOK(altStartState); ll1Analyzer.detectConfoundingPredicates(decisionStartState); if ( decisionIsLL_1 && !foundConfoundingPredicate ) {
public LookaheadSet FOLLOW(Rule r) { //System.out.println("> FOLLOW("+r.name+") in rule "+r.startState.enclosingRule); LookaheadSet f = FOLLOWCache.get(r); if ( f!=null ) { return f; } f = _FIRST(r.stopState, true); FOLLOWCache.put(r, f); //System.out.println("< FOLLOW("+r+") in rule "+r.startState.enclosingRule+"="+f.toString(this.grammar)); return f; }
/** Is there a non-syn-pred predicate visible from s that is not in * the rule enclosing s? This accounts for most predicate situations * and lets ANTLR do a simple LL(1)+pred computation. * * TODO: what about gated vs regular preds? */ public boolean detectConfoundingPredicates(NFAState s) { lookBusy.clear(); Rule r = s.enclosingRule; return _detectConfoundingPredicates(s, r, false) == DETECT_PRED_FOUND; }
/** Return predicate expression found via epsilon edges from s. Do * not look into other rules for now. Do something simple. Include * backtracking synpreds. */ public SemanticContext getPredicates(NFAState altStartState) { lookBusy.clear(); return _getPredicates(altStartState, altStartState); }
public LookaheadSet LOOK(NFAState s) { return ll1Analyzer.LOOK(s); }
public LookaheadSet FIRST(NFAState s) { return ll1Analyzer.FIRST(s); }
public LookaheadSet LOOK(NFAState s) { if ( NFAToDFAConverter.debug ) { System.out.println("> LOOK("+s+")"); } lookBusy.clear(); LookaheadSet look = _FIRST(s, true); // FOLLOW makes no sense (at the moment!) for lexical rules. if ( grammar.type!=Grammar.LEXER && look.member(Label.EOR_TOKEN_TYPE) ) { // avoid altering FIRST reset as it is cached LookaheadSet f = FOLLOW(s.enclosingRule); f.orInPlace(look); f.remove(Label.EOR_TOKEN_TYPE); look = f; //look.orInPlace(FOLLOW(s.enclosingRule)); } else if ( grammar.type==Grammar.LEXER && look.member(Label.EOT) ) { // if this has EOT, lookahead is all char (all char can follow rule) //look = new LookaheadSet(Label.EOT); look = new LookaheadSet(IntervalSet.COMPLETE_SET); } if ( NFAToDFAConverter.debug ) { System.out.println("< LOOK("+s+")="+look.toString(grammar)); } return look; }
NFAState altStartState = (NFAState)altLeftEdge.transition[0].target; altLook[alt] = ll1Analyzer.LOOK(altStartState); ll1Analyzer.detectConfoundingPredicates(decisionStartState); if ( decisionIsLL_1 && !foundConfoundingPredicate ) {