Lines Matching full:rule
136 * This way any error in a rule will cause an exception and
137 * immediate exit from rule. Rule would recover by resynchronizing
138 * to the set of symbols that can follow rule ref.
366 msg = "rule " + fpe.RuleName + " failed predicate: {" +
474 /* Compute the error recovery set for the current rule. During
475 * rule invocation, the parser pushes the set of tokens that can
476 * follow that rule reference on the stack; this amounts to
477 * computing FIRST of what follows the rule reference in the
478 * enclosing rule. This local follow set only includes tokens
479 * from within the rule; i.e., the FIRST computation done by
480 * ANTLR stops at the end of a rule.
485 * consistent with any of the alternatives for rule r. The best
487 * can legally follow a call to r *or* any rule that called r.
502 * At each rule invocation, the set of tokens that could follow
503 * that rule is pushed on a stack. Here are the various "local"
516 * depth local follow set after call to rule
522 * been called from a different context in rule a for ')' to be
533 * not consume anything and after printing an error rule c would
537 * set). The rule exception handler tries to recover, but finds
538 * the same recovery set and doesn't consume anything. Rule b
539 * exits normally returning to rule a. Now it finds the ']' (and
571 * Compute the context-sensitive FOLLOW set for current rule.
572 * This is set of token types that can follow a specific rule
576 * definition of plain FOLLOW for rule r:
600 * FOLLOW sets are precisely what could follow a rule reference.
647 // can we see end of rule?
650 // Only leave EOR in set if at top (start rule); this lets
651 // us know if have to include follow(start rule); i.e., EOF
658 { // can't see end of rule, quit
693 * reference in rule atom. It can assume that you forgot the ')'.
814 /** <summary>Push a rule's follow set using our own hardcoded stack</summary> */
833 * in the parser java code a rule is invoked.
849 * to get it's rule stack trace.
945 * Given a rule number and a start token index number, return
946 * MEMO_RULE_UNKNOWN if the rule has not parsed input starting from
947 * start index. If this rule has parsed input starting from the
948 * start index before, then return where the rule stopped parsing.
949 * It returns the index of the last token matched by the rule.
973 * Has this rule already parsed input at the current index in the
981 * this rule and successfully parsed before, then seek ahead to
982 * 1 past the stop token matched for this rule last time.
994 //System.out.println("rule "+ruleIndex+" will never succeed");
999 //System.out.println("seen rule "+ruleIndex+" before; skipping ahead to @"+(stopIndex+1)+" failed="+state.failed);
1006 * Record whether or not this rule parsed the input at this position
1023 TraceDestination.WriteLine("!!!!!!!!! memo size is " + state.ruleMemo.Length + ", but rule index is " + ruleIndex);
1031 /** <summary>return how many rule/input-index pairs there are in total.</summary>
