Lines Matching refs:That
9 modification, are permitted provided that the following conditions
86 /// <returns>Return a marker that can be passed to
100 /// Resets the stream so that the next call to
129 /// stream to keep bookkeeping objects around for a marker that is
150 /// and in that its argument is strictly an input cursor (index).
156 /// mechanism that restores state and so this method does not need to
162 /// The index is 0..N-1. A seek to position i means that LA(1) will return
170 /// Only makes sense for streams that buffer everything up probably,
207 /// actions don't use this on streams that don't support it).
327 /// Return null for LT(0) and any index that results in an absolute address
328 /// that is negative.
345 /// an action of course in that case.
366 /// etc...) so that we can rewind the state after scanning ahead.
390 /// A pretty quick <see cref="ICharStream"/> that uses a character array
398 that it is in the same state it was
407 /// A character stream - an <see cref="ICharStream"/> - that loads
430 /// A stripped-down version of org.antlr.misc.BitSet that is just
448 /// <param name="bit">element that must fit in set
526 /// Tracks the set of token types that can follow any rule invocation.
546 /// ad naseum. This is a failsafe mechanism to guarantee that at least
552 /// In lieu of a return value, this indicates that a rule or token
569 /// An array[size num rules] of Map<Integer,Integer> that tracks
595 /// something nonnull so that the auto token emit mechanism will not
652 /// tree nodes that have payload objects. We need to create a Token object
653 /// that has a string; the tree node will point at this token. CommonToken
685 /// A generic recognizer that can handle recognizers generated from
711 /// that fails, throw EMismatchedTokenException.
719 /// symbols that can follow rule ref.
751 /// If you override, make sure to update syntaxErrors if you care about that.
791 /// want to have a lot of information spit out. Override in that case
795 /// so that it creates a new type.
809 /// token that the Match() routine could not recover from.
863 /// Later, we can make a special one for ints and also one that
932 /// that overrides this to point to their string[] tokenNames.
994 /// Any state that has a semantic predicate edge is special; those states are
1040 /// A lexer is recognizer that draws input symbols from a character stream.
1066 /// rule finishes with token set to SKIP_TOKEN. Recall that if token==null
1071 /// <summary>This is the lexer entry point that sets instance var 'token' </summary>
1077 /// NextToken (to push tokens into a list and pull from that list rather
1086 /// use that to set the token's text.
1190 /// Rules that return more than a single value must return an object
1193 /// return values. This class simply defines the minimum properties that
1194 /// are always defined and methods to access the others that might be
1199 /// could add a ctor to this so that we can pass in and store the input
1200 that. It would seem to be undefined
1204 /// I do not use getters for fields of objects that are used simply to
1216 /// You can insert stuff, Replace, and delete chunks. Note that the
1226 /// screw up the token index values. That is, an insert operation at token
1258 /// streams and use that name again when printing the buffer. This could be
1275 /// <summary>Rollback the instruction stream for a program so that
1284 /// <summary>Reset the program so that no instructions exist </summary>
1360 /// You can access the stack trace, which means that you can compute the
1364 /// ANTLR generates code that throws exceptions upon recognition error and
1372 /// knows its state (such as current input symbol and line info) that
1423 /// that info is approximate.
1632 /// A list of CharStreamState objects that tracks the stream state
1633 /// (i.e. line, charPositionInLine, and p) that can change as you
1727 /// Its turns out that, for powers of two, this mod operation is
1843 /// this is non-null, then getText should return this. Note that
1942 /// All tokens go to the parser (unless skip() is called in that rule)
1944 /// so that whitespace etc... can go to the parser on a "hidden" channel.
1996 /// external state objects so that the state can be shared. This sharing
2052 /// Match() will see that ';' doesn't Match ')' and report a
2053 /// mismatched token error. To Recover, it sees that LA(1)==';'
2054 /// is in the set of tokens that can follow the ')' token
2055 /// reference in rule atom. It can assume that you forgot the ')'.
2065 /// symbols. But, actions might refer to that missing symbol.
2067 /// that there has been an identifier matched previously and that
2068 /// $x points at that token. If that token is missing, but
2069 /// the next token in the stream is what we want we assume that
2092 /// This is set of token types that can follow a specific rule
2094 /// viable tokens that can possibly come next (lookahead depth 1)
2102 /// FOLLOW(r) is the set of all tokens that can possibly follow
2133 /// What can follow that specific nested ref to atom? Exactly ')'
2146 * rule invocation, the parser pushes the set of tokens that can
2147 * follow that rule reference on the stack; this amounts to
2157 * thing to do is to consume tokens until you see something that
2158 * can legally follow a call to r *or* any rule that called r.
2173 * At each rule invocation, the set of tokens that could follow
2174 * that rule is pushed on a stack. Here are the various "local"
2192 * Notice that ')' is not included, because b would have to have
2198 * all context-sensitive FOLLOW sets--the set of all tokens that
2200 * resync to one of those tokens. Note that FOLLOW(c)='^' and if
2201 * we resync'd to that token, we'd consume until EOF. We need to
2213 * So, you cna see that the parser walks up call chain looking
2214 * for the token that was a member of the recovery set.
2233 * Like Grosch I implemented local FOLLOW sets that are combined
2322 /// to consume). p==-1 indicates that the tokens list is empty
2747 /// overlapping replaces that are not completed nested). Inserts to
2769 /// 1. wipe out any insertions before op within that range.
2770 /// 2. Drop any replace op before that is contained completely within
2771 /// that range.
2784 /// Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
3979 * Note that this does not mean that start/stop indexes are
3980 * not valid. It means that the input was converted to a new
4572 // in follow set to indicate that the fall of the start symbol is
4668 // even that didn't work; must throw the exception
5172 // eot[s]>=0 indicates that an EOT edge goes to another
5179 // which assumed here that the EOT edge always
5627 inherited Create; // highlight that we go to base class to set state object
6240 // no operation at that index, just dump token
