Beispiel #1
0
 @NotNull
 public ATNState newState(@Nullable GrammarAST node) {
   ATNState n = new ATNState();
   n.setRuleIndex(currentRule.index);
   atn.addState(n);
   return n;
 }
Beispiel #2
0
 /** Build an atom with all possible values in its label */
 @NotNull
 public Handle wildcard(GrammarAST node) {
   ATNState left = newState(node);
   ATNState right = newState(node);
   left.addTransition(new WildcardTransition(right));
   node.atnState = left;
   return new Handle(left, right);
 }
Beispiel #3
0
 /** From label A build Graph o-A->o */
 public Handle tokenRef(TerminalAST node) {
   ATNState left = newState(node);
   ATNState right = newState(node);
   int ttype = g.getTokenType(node.getText());
   left.addTransition(new AtomTransition(right, ttype));
   node.atnState = left;
   return new Handle(left, right);
 }
Beispiel #4
0
 /**
  * Build what amounts to an epsilon transition with an action. The action goes into ATN though it
  * is ignored during prediction if actionIndex < 0. Only forced are executed during prediction.
  */
 public Handle action(ActionAST action) {
   // System.out.println("action: "+action);
   ATNState left = newState(action);
   ATNState right = newState(action);
   ActionTransition a = new ActionTransition(right, currentRule.index);
   left.addTransition(a);
   action.atnState = left;
   return new Handle(left, right);
 }
Beispiel #5
0
 public void addRuleFollowLinks() {
   for (ATNState p : atn.states) {
     if (p != null
         && p.getClass() == ATNState.class
         && p.getNumberOfTransitions() == 1
         && p.transition(0) instanceof RuleTransition) {
       RuleTransition rt = (RuleTransition) p.transition(0);
       addFollowLink(rt.ruleIndex, rt.followState);
     }
   }
 }
Beispiel #6
0
 /**
  * Build what amounts to an epsilon transition with a semantic predicate action. The pred is a
  * pointer into the AST of the SEMPRED token.
  */
 public Handle sempred(PredAST pred) {
   // System.out.println("sempred: "+ pred);
   ATNState left = newState(pred);
   ATNState right = newState(pred);
   boolean isCtxDependent = UseDefAnalyzer.actionIsContextDependent(pred);
   PredicateTransition p =
       new PredicateTransition(right, currentRule.index, g.sempreds.get(pred), isCtxDependent);
   left.addTransition(p);
   pred.atnState = left;
   return new Handle(left, right);
 }
Beispiel #7
0
 /**
  * add an EOF transition to any rule end ATNState that points to nothing (i.e., for all those
  * rules not invoked by another rule). These are start symbols then.
  *
  * <p>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 addEOFTransitionToStartRules() {
   int n = 0;
   ATNState eofTarget = newState(null); // one unique EOF target for all rules
   for (Rule r : g.rules.values()) {
     ATNState stop = atn.ruleToStopState[r.index];
     if (stop.getNumberOfTransitions() > 0) continue;
     n++;
     Transition t = new AtomTransition(eofTarget, Token.EOF);
     stop.addTransition(t);
   }
   return n;
 }
Beispiel #8
0
  public Handle _ruleRef(GrammarAST node) {
    Rule r = g.getRule(node.getText());
    if (r == null) {
      g.tool.errMgr.toolError(ErrorType.INTERNAL_ERROR, "Rule " + node.getText() + " undefined");
      return null;
    }
    RuleStartState start = atn.ruleToStartState[r.index];
    ATNState left = newState(node);
    ATNState right = newState(node);
    RuleTransition call = new RuleTransition(start, r.index, right);
    left.addTransition(call);

    node.atnState = left;
    return new Handle(left, right);
  }
Beispiel #9
0
 /**
  * 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. This handles ~A also, converted to ~{A} set.
  */
 public Handle set(GrammarAST associatedAST, List<GrammarAST> terminals, boolean invert) {
   ATNState left = newState(associatedAST);
   ATNState right = newState(associatedAST);
   IntervalSet set = new IntervalSet();
   for (GrammarAST t : terminals) {
     int ttype = g.getTokenType(t.getText());
     set.add(ttype);
   }
   if (invert) {
     IntervalSet notSet = set.complement(Token.MIN_TOKEN_TYPE, g.getMaxTokenType());
     left.addTransition(new NotSetTransition(right, set, notSet));
   } else {
     left.addTransition(new SetTransition(right, set));
   }
   associatedAST.atnState = left;
   return new Handle(left, right);
 }
Beispiel #10
0
 @Override
 public void visitState(ATNState p) {
   if (p.getClass() == ATNState.class && p.getNumberOfTransitions() == 1) {
     ATNState q = p.transition(0).target;
     if (p.transition(0) instanceof RuleTransition) {
       q = ((RuleTransition) p.transition(0)).followState;
     }
     if (q.getClass() == ATNState.class) {
       // we have p-x->q for x in {rule, action, pred, token, ...}
       // if edge out of q is single epsilon to block end
       // we can strip epsilon p-x->q-eps->r
       Transition trans = q.transition(0);
       if (q.getNumberOfTransitions() == 1
           && trans.isEpsilon()
           && !(trans instanceof ActionTransition)) {
         ATNState r = trans.target;
         if (r instanceof BlockEndState
             || r instanceof PlusLoopbackState
             || r instanceof StarLoopbackState) {
           // skip over q
           if (p.transition(0) instanceof RuleTransition) {
             ((RuleTransition) p.transition(0)).followState = r;
           } else {
             p.transition(0).target = r;
           }
           atn.removeState(q);
         }
       }
     }
   }
 }
Beispiel #11
0
 void epsilon(ATNState a, @NotNull ATNState b) {
   if (a != null) a.addTransition(new EpsilonTransition(b));
 }