source: libmono-lliurex-utils/trunk/net-2.0/Antlr3.Runtime.xml @ 341

Last change on this file since 341 was 341, checked in by mabarracus, 5 years ago

ported pandora code

File size: 193.4 KB
Line 
1<?xml version="1.0"?>
2<doc>
3    <assembly>
4        <name>/home/verequus/Arbeit/ANTLR/code/antlr/main/runtime/CSharp/Sources/Antlr3.Runtime/bin/Debug/net-2.0/Antlr3.Runtime</name>
5    </assembly>
6    <members>
7        <member name="T:Antlr.Runtime.ANTLRFileStream">
8            <summary>
9            A character stream - an <see cref="T:Antlr.Runtime.ICharStream" /> - that loads
10            and caches the contents of it's underlying file fully during
11            object construction
12            </summary>
13            <remarks>
14            This looks very much like an ANTLReaderStream or an ANTLRInputStream
15            but, it is a special case. Since we know the exact size of the file to
16            load, we can avoid lots of data copying and buffer resizing.
17            </remarks>
18        </member>
19        <member name="M:Antlr.Runtime.ANTLRFileStream.#ctor">
20            <summary>
21            Initializes a new instance of the ANTLRFileStream class
22            </summary>
23        </member>
24        <member name="M:Antlr.Runtime.ANTLRFileStream.#ctor(System.String)">
25            <summary>
26            Initializes a new instance of the ANTLRFileStream class for the
27            specified file name
28            </summary>
29        </member>
30        <member name="M:Antlr.Runtime.ANTLRFileStream.#ctor(System.String,System.Text.Encoding)">
31            <summary>
32            Initializes a new instance of the ANTLRFileStream class for the
33            specified file name and encoding
34            </summary>
35        </member>
36        <member name="F:Antlr.Runtime.ANTLRFileStream.fileName">
37            <summary>Fully qualified name of the stream's underlying file</summary>
38        </member>
39        <member name="P:Antlr.Runtime.ANTLRFileStream.SourceName">
40            <summary>
41            Gets the file name of this ANTLRFileStream underlying file
42            </summary>
43        </member>
44        <member name="M:Antlr.Runtime.ANTLRFileStream.Load(System.String,System.Text.Encoding)">
45            <summary>
46            Loads and buffers the specified file to be used as this
47            ANTLRFileStream's source
48            </summary>
49            <param name="fileName">File to load</param>
50            <param name="encoding">Encoding to apply to file</param>
51        </member>
52        <member name="T:Antlr.Runtime.ANTLRStringStream">
53            <summary>
54            A pretty quick <see cref="T:Antlr.Runtime.ICharStream" /> that uses a character array
55            directly as it's underlying source.
56            </summary>
57        </member>
58        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor">
59            <summary>
60            Initializes a new instance of the ANTLRStringStream class
61            </summary>
62        </member>
63        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.String)">
64            <summary>
65            Initializes a new instance of the ANTLRStringStream class for the
66            specified string. This copies data from the string to a local
67            character array
68            </summary>
69        </member>
70        <member name="M:Antlr.Runtime.ANTLRStringStream.#ctor(System.Char[],System.Int32)">
71            <summary>
72            Initializes a new instance of the ANTLRStringStream class for the
73            specified character array. This is the preferred constructor as
74            no data is copied
75            </summary>
76        </member>
77        <member name="F:Antlr.Runtime.ANTLRStringStream.data">
78            <summary>The data for the stream</summary>
79        </member>
80        <member name="F:Antlr.Runtime.ANTLRStringStream.n">
81            <summary>How many characters are actually in the buffer?</summary>
82        </member>
83        <member name="F:Antlr.Runtime.ANTLRStringStream.p">
84            <summary>Index in our array for the next char (0..n-1)</summary>
85        </member>
86        <member name="F:Antlr.Runtime.ANTLRStringStream.line">
87            <summary>Current line number within the input (1..n )</summary>
88        </member>
89        <member name="F:Antlr.Runtime.ANTLRStringStream.charPositionInLine">
90            <summary>
91            The index of the character relative to the beginning of the
92            line (0..n-1)
93            </summary>
94        </member>
95        <member name="F:Antlr.Runtime.ANTLRStringStream.markDepth">
96            <summary>
97            Tracks the depth of nested <see cref="M:Antlr.Runtime.IIntStream.Mark" /> calls
98            </summary>
99        </member>
100        <member name="F:Antlr.Runtime.ANTLRStringStream.markers">
101            <summary>
102            A list of CharStreamState objects that tracks the stream state
103            (i.e. line, charPositionInLine, and p) that can change as you
104            move through the input stream.  Indexed from 1..markDepth.
105            A null is kept @ index 0.  Create upon first call to Mark().
106            </summary>
107        </member>
108        <member name="F:Antlr.Runtime.ANTLRStringStream.lastMarker">
109            <summary>
110            Track the last Mark() call result value for use in Rewind().
111            </summary>
112        </member>
113        <member name="F:Antlr.Runtime.ANTLRStringStream.name">
114            <summary>
115            What is name or source of this char stream?
116            </summary>
117        </member>
118        <member name="P:Antlr.Runtime.ANTLRStringStream.Line">
119            <summary>
120            Current line position in stream.
121            </summary>
122        </member>
123        <member name="P:Antlr.Runtime.ANTLRStringStream.CharPositionInLine">
124            <summary>
125            Current character position on the current line stream
126            (i.e. columnn position)
127            </summary>
128        </member>
129        <member name="P:Antlr.Runtime.ANTLRStringStream.Count">
130            <summary>
131            Returns the size of the stream
132            </summary>
133        </member>
134        <member name="M:Antlr.Runtime.ANTLRStringStream.Reset">
135            <summary>
136            Resets the stream so that it is in the same state it was
137            when the object was created *except* the data array is not
138            touched.
139            </summary>
140        </member>
141        <member name="M:Antlr.Runtime.ANTLRStringStream.Consume">
142            <summary>
143            Advances the read position of the stream. Updates line and column state
144            </summary>
145        </member>
146        <member name="M:Antlr.Runtime.ANTLRStringStream.LA(System.Int32)">
147            <summary>
148            Return lookahead characters at the specified offset from the current read position.
149            The lookahead offset can be negative.
150            </summary>
151        </member>
152        <member name="M:Antlr.Runtime.ANTLRStringStream.Index">
153            <summary>
154            Return the current input symbol index 0..n where n indicates the
155            last symbol has been read. The index is the index of char to
156            be returned from LA(1).
157            </summary>
158        </member>
159        <member name="M:Antlr.Runtime.ANTLRStringStream.Size">
160            <summary>
161            Returns the size of the stream
162            </summary>
163        </member>
164        <member name="M:Antlr.Runtime.ANTLRStringStream.Seek(System.Int32)">
165            <summary>Seeks to the specified position.</summary>
166            <remarks>
167            Consume ahead until p==index; can't just set p=index as we must
168            update line and charPositionInLine.
169            </remarks>
170        </member>
171        <member name="T:Antlr.Runtime.BitSet">
172            <summary>
173            A stripped-down version of org.antlr.misc.BitSet that is just
174            good enough to handle runtime requirements such as FOLLOW sets
175            for automatic error recovery.
176            </summary>
177        </member>
178        <member name="M:Antlr.Runtime.BitSet.#ctor">
179            <summary>Construct a bitset of size one word (64 bits) </summary>
180        </member>
181        <member name="M:Antlr.Runtime.BitSet.#ctor(System.UInt64[])">
182            <summary>Construction from a static array of ulongs </summary>
183        </member>
184        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Collections.IList)">
185            <summary>Construction from a list of integers </summary>
186        </member>
187        <member name="M:Antlr.Runtime.BitSet.#ctor(System.Int32)">
188            <summary>Construct a bitset given the size</summary>
189            <param name="nbits">The size of the bitset in bits</param>
190        </member>
191        <member name="F:Antlr.Runtime.BitSet.MOD_MASK">
192            <summary> We will often need to do a mod operator (i mod nbits).
193            Its turns out that, for powers of two, this mod operation is
194            same as <![CDATA[(i & (nbits-1))]]>.  Since mod is slow, we use a precomputed
195            mod mask to do the mod instead.
196            </summary>
197        </member>
198        <member name="F:Antlr.Runtime.BitSet.bits">
199            <summary>The actual data bits </summary>
200        </member>
201        <member name="M:Antlr.Runtime.BitSet.Or(Antlr.Runtime.BitSet)">
202            <summary>return "this | a" in a new set </summary>
203        </member>
204        <member name="M:Antlr.Runtime.BitSet.Add(System.Int32)">
205            <summary>Or this element into this set (grow as necessary to accommodate)</summary>
206        </member>
207        <member name="M:Antlr.Runtime.BitSet.GrowToInclude(System.Int32)">
208            <summary> Grows the set to a larger number of bits.</summary>
209            <param name="bit">element that must fit in set
210            </param>
211        </member>
212        <member name="M:Antlr.Runtime.BitSet.LengthInLongWords">
213            <summary>return how much space is being used by the bits array not
214            how many actually have member bits on.
215            </summary>
216        </member>
217        <member name="M:Antlr.Runtime.BitSet.SetSize(System.Int32)">
218            <summary> Sets the size of a set.</summary>
219            <param name="nwords">how many words the new set should be
220            </param>
221        </member>
222        <member name="T:Antlr.Runtime.ICharStream">
223            <summary>A source of characters for an ANTLR lexer </summary>
224        </member>
225        <member name="P:Antlr.Runtime.ICharStream.Line">
226            <summary>
227            The current line in the character stream (ANTLR tracks the
228            line information automatically. To support rewinding character
229            streams, we are able to [re-]set the line.
230            </summary>
231        </member>
232        <member name="P:Antlr.Runtime.ICharStream.CharPositionInLine">
233            <summary>
234            The index of the character relative to the beginning of the
235            line (0..n-1). To support rewinding character streams, we are
236            able to [re-]set the character position.
237            </summary>
238        </member>
239        <member name="M:Antlr.Runtime.ICharStream.LT(System.Int32)">
240            <summary>
241            Get the ith character of lookahead.  This is usually the same as
242            LA(i).  This will be used for labels in the generated lexer code.
243            I'd prefer to return a char here type-wise, but it's probably
244            better to be 32-bit clean and be consistent with LA.
245            </summary>
246        </member>
247        <member name="M:Antlr.Runtime.ICharStream.Substring(System.Int32,System.Int32)">
248            <summary>
249            This primarily a useful interface for action code (just make sure
250            actions don't use this on streams that don't support it).
251            For infinite streams, you don't need this.
252            </summary>
253        </member>
254        <member name="T:Antlr.Runtime.CharStreamState">
255            <summary>
256            This is the complete state of a stream.
257            When walking ahead with cyclic DFA for syntactic predicates, we
258            need to record the state of the input stream (char index, line,
259            etc...) so that we can rewind the state after scanning ahead.
260            </summary>
261        </member>
262        <member name="F:Antlr.Runtime.CharStreamState.p">
263            <summary>Index into the char stream of next lookahead char </summary>
264        </member>
265        <member name="F:Antlr.Runtime.CharStreamState.line">
266            <summary>What line number is the scanner at before processing buffer[p]? </summary>
267        </member>
268        <member name="F:Antlr.Runtime.CharStreamState.charPositionInLine">
269            <summary>What char position 0..n-1 in line is scanner before processing buffer[p]? </summary>
270        </member>
271        <member name="T:Antlr.Runtime.ClassicToken">
272            <summary>
273            A Token object like we'd use in ANTLR 2.x; has an actual string created
274            and associated with this object.  These objects are needed for imaginary
275            tree nodes that have payload objects.  We need to create a Token object
276            that has a string; the tree node will point at this token.  CommonToken
277            has indexes into a char stream and hence cannot be used to introduce
278            new strings.
279            </summary>
280        </member>
281        <member name="F:Antlr.Runtime.ClassicToken.index">
282            <summary>What token number is this from 0..n-1 tokens </summary>
283        </member>
284        <member name="F:Antlr.Runtime.CommonToken.text">
285            <summary>We need to be able to change the text once in a while.  If
286            this is non-null, then getText should return this.  Note that
287            start/stop are not affected by changing this.
288            </summary>
289        </member>
290        <member name="F:Antlr.Runtime.CommonToken.index">
291            <summary>What token number is this from 0..n-1 tokens; &lt; 0 implies invalid index </summary>
292        </member>
293        <member name="F:Antlr.Runtime.CommonToken.start">
294            <summary>The char position into the input buffer where this token starts </summary>
295        </member>
296        <member name="F:Antlr.Runtime.CommonToken.stop">
297            <summary>The char position into the input buffer where this token stops </summary>
298        </member>
299        <member name="T:Antlr.Runtime.DFA">
300            <summary>
301            A DFA implemented as a set of transition tables.
302            </summary>
303            <remarks>
304                <para>
305            Any state that has a semantic predicate edge is special; those states are
306            generated with if-then-else structures in a SpecialStateTransition()
307            which is generated by cyclicDFA template.
308            </para>
309                <para>
310            There are at most 32767 states (16-bit signed short). Could get away with byte
311            sometimes but would have to generate different types and the simulation code too.
312            </para>
313                <para>
314            As a point of reference, the Tokens rule DFA for the lexer in the Java grammar
315            sample has approximately 326 states.
316            </para>
317            </remarks>
318        </member>
319        <member name="F:Antlr.Runtime.DFA.recognizer">
320            <summary>
321            Which recognizer encloses this DFA?  Needed to check backtracking
322            </summary>
323        </member>
324        <member name="M:Antlr.Runtime.DFA.Predict(Antlr.Runtime.IIntStream)">
325            <summary>
326            From the input stream, predict what alternative will succeed using this
327            DFA (representing the covering regular approximation to the underlying CFL).
328            </summary>
329            <param name="input">Input stream</param>
330            <returns>Return an alternative number 1..n.  Throw an exception upon error.</returns>
331        </member>
332        <member name="M:Antlr.Runtime.DFA.Error(Antlr.Runtime.NoViableAltException)">
333            <summary>
334            A hook for debugging interface
335            </summary>
336            <param name="nvae">
337            </param>
338        </member>
339        <member name="T:Antlr.Runtime.EarlyExitException">
340            <summary>
341            The recognizer did not match anything for a (..)+ loop.
342            </summary>
343        </member>
344        <member name="M:Antlr.Runtime.EarlyExitException.#ctor">
345            <summary>Used for remote debugger deserialization </summary>
346        </member>
347        <member name="T:Antlr.Runtime.FailedPredicateException">
348            <summary>
349            A semantic predicate failed during validation.  Validation of predicates
350            occurs when normally parsing the alternative just like matching a token.
351            Disambiguating predicate evaluation occurs when we hoist a predicate into
352            a prediction decision.
353            </summary>
354        </member>
355        <member name="M:Antlr.Runtime.FailedPredicateException.#ctor">
356            <summary>Used for remote debugger deserialization </summary>
357        </member>
358        <member name="T:Antlr.Runtime.IIntStream">
359            <summary>
360            A simple stream of integers. This is useful when all we care about is the char
361            or token type sequence (such as for interpretation).
362            </summary>
363        </member>
364        <member name="P:Antlr.Runtime.IIntStream.Count">
365            <summary>Returns the size of the entire stream.</summary>
366            <remarks>
367            Only makes sense for streams that buffer everything up probably,
368            but might be useful to display the entire stream or for testing.
369            This value includes a single EOF.
370            </remarks>
371        </member>
372        <member name="P:Antlr.Runtime.IIntStream.SourceName">
373            <summary>
374            Where are you getting symbols from?  Normally, implementations will
375            pass the buck all the way to the lexer who can ask its input stream
376            for the file name or whatever.
377            </summary>
378        </member>
379        <member name="M:Antlr.Runtime.IIntStream.LA(System.Int32)">
380            <summary>
381            Get int at current input pointer + i ahead (where i=1 is next int)
382            Negative indexes are allowed.  LA(-1) is previous token (token just matched).
383            LA(-i) where i is before first token should yield -1, invalid char or EOF.
384            </summary>
385        </member>
386        <member name="M:Antlr.Runtime.IIntStream.Mark">
387            <summary>Tell the stream to start buffering if it hasn't already.</summary>
388            <remarks>
389            Executing Rewind(Mark()) on a stream should not affect the input position.
390            The Lexer tracks line/col info as well as input index so its markers are
391            not pure input indexes.  Same for tree node streams.                                                                                                        */
392            </remarks>
393            <returns>Return a marker that can be passed to
394            <see cref="M:Antlr.Runtime.IIntStream.Rewind(System.Int32)" /> to return to the current position.
395            This could be the current input position, a value return from
396            <see cref="M:Antlr.Runtime.IIntStream.Index" />, or some other marker.</returns>
397        </member>
398        <member name="M:Antlr.Runtime.IIntStream.Index">
399            <summary>
400            Return the current input symbol index 0..n where n indicates the
401            last symbol has been read. The index is the symbol about to be
402            read not the most recently read symbol.
403            </summary>
404        </member>
405        <member name="M:Antlr.Runtime.IIntStream.Rewind(System.Int32)">
406            <summary>
407            Resets the stream so that the next call to
408            <see cref="M:Antlr.Runtime.IIntStream.Index" /> would  return marker.
409            </summary>
410            <remarks>
411            The marker will usually be <see cref="M:Antlr.Runtime.IIntStream.Index" /> but
412            it doesn't have to be.  It's just a marker to indicate what
413            state the stream was in.  This is essentially calling
414            <see cref="M:Antlr.Runtime.IIntStream.Release(System.Int32)" /> and <see cref="M:Antlr.Runtime.IIntStream.Seek(System.Int32)" />.
415            If there are other markers created after the specified marker,
416            this routine must unroll them like a stack.  Assumes the state the
417            stream was in when this marker was created.
418            </remarks>
419        </member>
420        <member name="M:Antlr.Runtime.IIntStream.Rewind">
421            <summary>
422            Rewind to the input position of the last marker.
423            </summary>
424            <remarks>
425            Used currently only after a cyclic DFA and just before starting
426            a sem/syn predicate to get the input position back to the start
427            of the decision. Do not "pop" the marker off the state.  Mark(i)
428            and Rewind(i) should balance still. It is like invoking
429            Rewind(last marker) but it should not "pop" the marker off.
430            It's like Seek(last marker's input position).
431            </remarks>
432        </member>
433        <member name="M:Antlr.Runtime.IIntStream.Release(System.Int32)">
434            <summary>
435            You may want to commit to a backtrack but don't want to force the
436            stream to keep bookkeeping objects around for a marker that is
437            no longer necessary.  This will have the same behavior as
438            <see cref="M:Antlr.Runtime.IIntStream.Rewind(System.Int32)" /> except it releases resources without
439            the backward seek.
440            </summary>
441            <remarks>
442            This must throw away resources for all markers back to the marker
443            argument. So if you're nested 5 levels of Mark(), and then Release(2)
444            you have to release resources for depths 2..5.
445            </remarks>
446        </member>
447        <member name="M:Antlr.Runtime.IIntStream.Seek(System.Int32)">
448            <summary>
449            Set the input cursor to the position indicated by index.  This is
450            normally used to seek ahead in the input stream.
451            </summary>
452            <remarks>
453            No buffering is required to do this unless you know your stream
454            will use seek to move backwards such as when backtracking.
455            This is different from rewind in its multi-directional requirement
456            and in that its argument is strictly an input cursor (index).
457            For char streams, seeking forward must update the stream state such
458            as line number.  For seeking backwards, you will be presumably
459            backtracking using the
460            <see cref="M:Antlr.Runtime.IIntStream.Mark" />/<see cref="M:Antlr.Runtime.IIntStream.Rewind(System.Int32)" />
461            mechanism that restores state and so this method does not need to
462            update state when seeking backwards.
463            Currently, this method is only used for efficient backtracking using
464            memoization, but in the future it may be used for incremental parsing.
465            The index is 0..n-1. A seek to position i means that LA(1) will return
466            the ith symbol.  So, seeking to 0 means LA(1) will return the first
467            element in the stream.
468            </remarks>
469        </member>
470        <member name="M:Antlr.Runtime.IIntStream.Size">
471            <summary>Returns the size of the entire stream.</summary>
472            <remarks>
473            Only makes sense for streams that buffer everything up probably,
474            but might be useful to display the entire stream or for testing.
475            This value includes a single EOF.
476            </remarks>
477        </member>
478        <member name="M:Antlr.Runtime.MismatchedNotSetException.#ctor">
479            <summary>Used for remote debugger deserialization </summary>
480        </member>
481        <member name="M:Antlr.Runtime.MismatchedRangeException.#ctor">
482            <summary>
483            Used for remote debugger deserialization
484            </summary>
485        </member>
486        <member name="M:Antlr.Runtime.MismatchedSetException.#ctor">
487            <summary>Used for remote debugger deserialization </summary>
488        </member>
489        <member name="T:Antlr.Runtime.MismatchedTokenException">
490            <summary>
491            A mismatched char or Token or tree node.
492            </summary>
493        </member>
494        <member name="M:Antlr.Runtime.MismatchedTokenException.#ctor">
495            <summary>
496            Used for remote debugger deserialization
497            </summary>
498        </member>
499        <member name="M:Antlr.Runtime.NoViableAltException.#ctor">
500            <summary>Used for remote debugger deserialization</summary>
501        </member>
502        <member name="T:Antlr.Runtime.Parser">
503            <summary>A parser for TokenStreams.  Parser grammars result in a subclass
504            of this.
505            </summary>
506        </member>
507        <member name="P:Antlr.Runtime.Parser.TokenStream">
508            <summary>Set the token stream and reset the parser </summary>
509        </member>
510        <member name="T:Antlr.Runtime.ParserRuleReturnScope">
511            <summary>
512            Rules that return more than a single value must return an object
513            containing all the values.  Besides the properties defined in
514            RuleLabelScope.PredefinedRulePropertiesScope there may be user-defined
515            return values.  This class simply defines the minimum properties that
516            are always defined and methods to access the others that might be
517            available depending on output option such as template and tree.
518            Note text is not an actual property of the return value, it is computed
519            from start and stop using the input stream's ToString() method.  I
520            could add a ctor to this so that we can pass in and store the input
521            stream, but I'm not sure we want to do that.  It would seem to be undefined
522            to get the .text property anyway if the rule matches tokens from multiple
523            input streams.
524            I do not use getters for fields of objects that are used simply to
525            group values such as this aggregate.
526            </summary>
527        </member>
528        <member name="P:Antlr.Runtime.ParserRuleReturnScope.Start">
529            <summary>Return the start token or tree </summary>
530        </member>
531        <member name="P:Antlr.Runtime.ParserRuleReturnScope.Stop">
532            <summary>Return the stop token or tree </summary>
533        </member>
534        <member name="T:Antlr.Runtime.RecognitionException">
535            <summary>The root of the ANTLR exception hierarchy.</summary>
536            <remarks>
537            To avoid English-only error messages and to generally make things
538            as flexible as possible, these exceptions are not created with strings,
539            but rather the information necessary to generate an error.  Then
540            the various reporting methods in Parser and Lexer can be overridden
541            to generate a localized error message.  For example, MismatchedToken
542            exceptions are built with the expected token type.
543            So, don't expect getMessage() to return anything.
544            You can access the stack trace, which means that you can compute the
545            complete trace of rules from the start symbol. This gives you considerable
546            context information with which to generate useful error messages.
547            ANTLR generates code that throws exceptions upon recognition error and
548            also generates code to catch these exceptions in each rule.  If you
549            want to quit upon first error, you can turn off the automatic error
550            handling mechanism using rulecatch action, but you still need to
551            override methods mismatch and recoverFromMismatchSet.
552            In general, the recognition exceptions can track where in a grammar a
553            problem occurred and/or what was the expected input.  While the parser
554            knows its state (such as current input symbol and line info) that
555            state can change before the exception is reported so current token index
556            is computed and stored at exception time.  From this info, you can
557            perhaps print an entire line of input not just a single token, for example.
558            Better to just say the recognizer had a problem and then let the parser
559            figure out a fancy report.
560            </remarks>
561        </member>
562        <member name="M:Antlr.Runtime.RecognitionException.#ctor">
563            <summary>Used for remote debugger deserialization </summary>
564        </member>
565        <member name="F:Antlr.Runtime.RecognitionException.input">
566            <summary>What input stream did the error occur in? </summary>
567        </member>
568        <member name="F:Antlr.Runtime.RecognitionException.index">
569            <summary>
570            What is index of token/char were we looking at when the error occurred?
571            </summary>
572        </member>
573        <member name="F:Antlr.Runtime.RecognitionException.token">
574            <summary>
575            The current Token when an error occurred.  Since not all streams
576            can retrieve the ith Token, we have to track the Token object.
577            </summary>
578        </member>
579        <member name="F:Antlr.Runtime.RecognitionException.node">
580            <summary>[Tree parser] Node with the problem.</summary>
581        </member>
582        <member name="F:Antlr.Runtime.RecognitionException.c">
583            <summary>The current char when an error occurred. For lexers. </summary>
584        </member>
585        <member name="F:Antlr.Runtime.RecognitionException.line">
586            <summary>Track the line at which the error occurred in case this is
587            generated from a lexer.  We need to track this since the
588            unexpected char doesn't carry the line info.
589            </summary>
590        </member>
591        <member name="F:Antlr.Runtime.RecognitionException.approximateLineInfo">
592            <summary>
593            If you are parsing a tree node stream, you will encounter some
594            imaginary nodes w/o line/col info.  We now search backwards looking
595            for most recent token with line/col info, but notify getErrorHeader()
596            that info is approximate.
597            </summary>
598        </member>
599        <member name="P:Antlr.Runtime.RecognitionException.Input">
600            <summary>Returns the input stream in which the error occurred</summary>
601        </member>
602        <member name="P:Antlr.Runtime.RecognitionException.Index">
603            <summary>
604            Returns the token/char index in the stream when the error occurred
605            </summary>
606        </member>
607        <member name="P:Antlr.Runtime.RecognitionException.Token">
608            <summary>
609            Returns the current Token when the error occurred (for parsers
610            although a tree parser might also set the token)
611            </summary>
612        </member>
613        <member name="P:Antlr.Runtime.RecognitionException.Node">
614            <summary>
615            Returns the [tree parser] node where the error occured (for tree parsers).
616            </summary>
617        </member>
618        <member name="P:Antlr.Runtime.RecognitionException.Char">
619            <summary>
620            Returns the current char when the error occurred (for lexers)
621            </summary>
622        </member>
623        <member name="P:Antlr.Runtime.RecognitionException.CharPositionInLine">
624            <summary>
625            Returns the character position in the line when the error
626            occurred (for lexers)
627            </summary>
628        </member>
629        <member name="P:Antlr.Runtime.RecognitionException.Line">
630            <summary>
631            Returns the line at which the error occurred (for lexers)
632            </summary>
633        </member>
634        <member name="P:Antlr.Runtime.RecognitionException.UnexpectedType">
635            <summary>
636            Returns the token type or char of the unexpected input element
637            </summary>
638        </member>
639        <member name="T:Antlr.Runtime.RuleReturnScope">
640            <summary>
641            Rules can return start/stop info as well as possible trees and templates
642            </summary>
643        </member>
644        <member name="P:Antlr.Runtime.RuleReturnScope.Start">
645            <summary>Return the start token or tree </summary>
646        </member>
647        <member name="P:Antlr.Runtime.RuleReturnScope.Stop">
648            <summary>Return the stop token or tree </summary>
649        </member>
650        <member name="P:Antlr.Runtime.RuleReturnScope.Tree">
651            <summary>Has a value potentially if output=AST; </summary>
652        </member>
653        <member name="P:Antlr.Runtime.RuleReturnScope.Template">
654            <summary>
655            Has a value potentially if output=template;
656            Don't use StringTemplate type to avoid dependency on ST assembly
657            </summary>
658        </member>
659        <member name="F:Antlr.Runtime.Token.DOWN">
660            <summary>imaginary tree navigation type; traverse "get child" link </summary>
661        </member>
662        <member name="F:Antlr.Runtime.Token.UP">
663            <summary>imaginary tree navigation type; finish with a child list </summary>
664        </member>
665        <member name="F:Antlr.Runtime.Token.DEFAULT_CHANNEL">
666            <summary>
667            All tokens go to the parser (unless skip() is called in that rule)
668            on a particular "channel".  The parser tunes to a particular channel
669            so that whitespace etc... can go to the parser on a "hidden" channel.
670            </summary>
671        </member>
672        <member name="F:Antlr.Runtime.Token.HIDDEN_CHANNEL">
673            <summary>
674            Anything on different channel than DEFAULT_CHANNEL is not parsed by parser.
675            </summary>
676        </member>
677        <member name="F:Antlr.Runtime.Token.SKIP_TOKEN">
678            <summary>
679            In an action, a lexer rule can set token to this SKIP_TOKEN and ANTLR
680            will avoid creating a token for this symbol and try to fetch another.
681            </summary>
682        </member>
683        <member name="T:Antlr.Runtime.ITokenSource">
684            <summary>
685            A source of tokens must provide a sequence of tokens via NextToken()
686            and also must reveal it's source of characters; CommonToken's text is
687            computed from a CharStream; it only store indices into the char stream.
688            Errors from the lexer are never passed to the parser.  Either you want
689            to keep going or you do not upon token recognition error.  If you do not
690            want to continue lexing then you do not want to continue parsing.  Just
691            throw an exception not under RecognitionException and Java will naturally
692            toss you all the way out of the recognizers.  If you want to continue
693            lexing then you should not throw an exception to the parser--it has already
694            requested a token.  Keep lexing until you get a valid one.  Just report
695            errors and keep going, looking for a valid token.
696            </summary>
697        </member>
698        <member name="P:Antlr.Runtime.ITokenSource.SourceName">
699            <summary>
700            Where are you getting tokens from? normally the implication will simply
701            ask lexers input stream.
702            </summary>
703        </member>
704        <member name="M:Antlr.Runtime.ITokenSource.NextToken">
705            <summary>
706            Returns a Token object from the input stream (usually a CharStream).
707            Does not fail/return upon lexing error; just keeps chewing on the
708            characters until it gets a good one; errors are not passed through
709            to the parser.
710            </summary>
711        </member>
712        <member name="T:Antlr.Runtime.MissingTokenException">
713            <summary>
714            We were expecting a token but it's not found. The current token
715            is actually what we wanted next. Used for tree node errors too.
716            </summary>
717        </member>
718        <member name="M:Antlr.Runtime.MissingTokenException.#ctor">
719            <summary>
720            Used for remote debugger deserialization
721            </summary>
722        </member>
723        <member name="T:Antlr.Runtime.CommonErrorNode">
724             A node representing erroneous token range in token stream</member>
725        <member name="T:Antlr.Runtime.UnwantedTokenException">
726            <summary>
727            An extra token while parsing a TokenStream.
728            </summary>
729        </member>
730        <member name="M:Antlr.Runtime.UnwantedTokenException.#ctor">
731            <summary>
732            Used for remote debugger deserialization
733            </summary>
734        </member>
735        <member name="M:Antlr.Runtime.Collections.CollectionUtils.ListToString(System.Collections.IList)">
736            <summary>
737            Returns a string representation of this IList.
738            </summary>
739            <remarks>
740            The string representation is a list of the collection's elements in the order
741            they are returned by its IEnumerator, enclosed in square brackets ("[]").
742            The separator is a comma followed by a space i.e. ", ".
743            </remarks>
744            <param name="coll">Collection whose string representation will be returned</param>
745            <returns>A string representation of the specified collection or "null"</returns>
746        </member>
747        <member name="M:Antlr.Runtime.Collections.CollectionUtils.DictionaryToString(System.Collections.IDictionary)">
748            <summary>
749            Returns a string representation of this IDictionary.
750            </summary>
751            <remarks>
752            The string representation is a list of the collection's elements in the order
753            they are returned by its IEnumerator, enclosed in curly brackets ("{}").
754            The separator is a comma followed by a space i.e. ", ".
755            </remarks>
756            <param name="dict">Dictionary whose string representation will be returned</param>
757            <returns>A string representation of the specified dictionary or "null"</returns>
758        </member>
759        <member name="T:Antlr.Runtime.Collections.HashList">
760            <summary>
761            An Hashtable-backed dictionary that enumerates Keys and Values in
762            insertion order.
763            </summary>
764        </member>
765        <member name="T:Antlr.Runtime.Collections.StackList">
766            <summary>
767            Stack abstraction that also supports the IList interface
768            </summary>
769        </member>
770        <member name="M:Antlr.Runtime.Collections.StackList.Push(System.Object)">
771            <summary>
772            Adds an element to the top of the stack list.
773            </summary>
774        </member>
775        <member name="M:Antlr.Runtime.Collections.StackList.Pop">
776            <summary>
777            Removes the element at the top of the stack list and returns it.
778            </summary>
779            <returns>The element at the top of the stack.</returns>
780        </member>
781        <member name="M:Antlr.Runtime.Collections.StackList.Peek">
782            <summary>
783            Removes the element at the top of the stack list without removing it.
784            </summary>
785            <returns>The element at the top of the stack.</returns>
786        </member>
787        <member name="T:Antlr.Runtime.Tree.BaseTree">
788            <summary>
789            A generic tree implementation with no payload.  You must subclass to
790            actually have any user data.  ANTLR v3 uses a list of children approach
791            instead of the child-sibling approach in v2.  A flat tree (a list) is
792            an empty node whose children represent the list.  An empty, but
793            non-null node is called "nil".
794            </summary>
795        </member>
796        <member name="M:Antlr.Runtime.Tree.BaseTree.#ctor(Antlr.Runtime.Tree.ITree)">
797            <summary>Create a new node from an existing node does nothing for BaseTree
798            as there are no fields other than the children list, which cannot
799            be copied as the children are not considered part of this node.
800            </summary>
801        </member>
802        <member name="P:Antlr.Runtime.Tree.BaseTree.Children">
803            <summary>
804            Get the children internal list of children. Manipulating the list
805            directly is not a supported operation (i.e. you do so at your own risk)
806            </summary>
807        </member>
808        <member name="P:Antlr.Runtime.Tree.BaseTree.ChildIndex">
809            <summary>BaseTree doesn't track child indexes.</summary>
810        </member>
811        <member name="P:Antlr.Runtime.Tree.BaseTree.Parent">
812            <summary>BaseTree doesn't track parent pointers.</summary>
813        </member>
814        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChild(Antlr.Runtime.Tree.ITree)">
815            <summary>
816            Add t as child of this node.
817            </summary>
818            <remarks>
819            Warning: if t has no children, but child does and child isNil then
820            this routine moves children to t via t.children = child.children;
821            i.e., without copying the array.
822            </remarks>
823            <param name="t">
824            </param>
825        </member>
826        <member name="M:Antlr.Runtime.Tree.BaseTree.AddChildren(System.Collections.IList)">
827            <summary>
828            Add all elements of kids list as children of this node
829            </summary>
830            <param name="kids">
831            </param>
832        </member>
833        <member name="M:Antlr.Runtime.Tree.BaseTree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
834            <summary>
835            Delete children from start to stop and replace with t even if t is
836            a list (nil-root tree).
837            </summary>
838            <remarks>
839            Number of children can increase or decrease.
840            For huge child lists, inserting children can force walking rest of
841            children to set their childindex; could be slow.
842            </remarks>
843        </member>
844        <member name="M:Antlr.Runtime.Tree.BaseTree.CreateChildrenList">
845            <summary>Override in a subclass to change the impl of children list </summary>
846        </member>
847        <member name="M:Antlr.Runtime.Tree.BaseTree.FreshenParentAndChildIndexes">
848            <summary>Set the parent and child index values for all child of t</summary>
849        </member>
850        <member name="M:Antlr.Runtime.Tree.BaseTree.HasAncestor(System.Int32)">
851            <summary>
852            Walk upwards looking for ancestor with this token type.
853            </summary>
854        </member>
855        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestor(System.Int32)">
856            <summary>
857            Walk upwards and get first ancestor with this token type.
858            </summary>
859        </member>
860        <member name="M:Antlr.Runtime.Tree.BaseTree.GetAncestors">
861            <summary>
862            Return a list of all ancestors of this node.  The first node of
863            list is the root and the last is the parent of this node.
864            </summary>
865        </member>
866        <member name="M:Antlr.Runtime.Tree.BaseTree.ToStringTree">
867            <summary>
868            Print out a whole tree not just a node
869            </summary>
870        </member>
871        <member name="M:Antlr.Runtime.Tree.BaseTree.ToString">
872            <summary>
873            Force base classes override and say how a node (not a tree)
874            should look as text
875            </summary>
876        </member>
877        <member name="T:Antlr.Runtime.Tree.BaseTreeAdaptor">
878            <summary>
879            A TreeAdaptor that works with any Tree implementation
880            </summary>
881        </member>
882        <member name="F:Antlr.Runtime.Tree.BaseTreeAdaptor.treeToUniqueIDMap">
883            <summary>A map of tree node to unique IDs.</summary>
884        </member>
885        <member name="F:Antlr.Runtime.Tree.BaseTreeAdaptor.uniqueNodeID">
886            <summary>Next available unique ID.</summary>
887        </member>
888        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
889            <summary>
890            Create tree node that holds the start and stop tokens associated
891            with an error.
892            </summary>
893            <remarks>
894                <para>If you specify your own kind of tree nodes, you will likely have to
895            override this method. CommonTree returns Token.INVALID_TOKEN_TYPE
896            if no token payload but you might have to set token type for diff
897            node type.</para>
898                <para>You don't have to subclass CommonErrorNode; you will likely need to
899            subclass your own tree node class to avoid class cast exception.</para>
900            </remarks>
901        </member>
902        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.DupTree(System.Object,System.Object)">
903            <summary>
904            This is generic in the sense that it will work with any kind of
905            tree (not just the ITree interface).  It invokes the adaptor routines
906            not the tree node routines to do the construction.
907            </summary>
908        </member>
909        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.AddChild(System.Object,System.Object)">
910            <summary>
911            Add a child to the tree t.  If child is a flat tree (a list), make all
912            in list children of t.
913            </summary>
914            <remarks>
915                <para>
916            Warning: if t has no children, but child does and child isNil
917            then you can decide it is ok to move children to t via
918            t.children = child.children; i.e., without copying the array.
919            Just make sure that this is consistent with how the user will build
920            ASTs.
921                </para>
922            </remarks>
923        </member>
924        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.BecomeRoot(System.Object,System.Object)">
925            <summary>
926            If oldRoot is a nil root, just copy or move the children to newRoot.
927            If not a nil root, make oldRoot a child of newRoot.
928            </summary>
929            <remarks>
930            old=^(nil a b c), new=r yields ^(r a b c)
931            old=^(a b c), new=r yields ^(r ^(a b c))
932            If newRoot is a nil-rooted single child tree, use the single
933            child as the new root node.
934            old=^(nil a b c), new=^(nil r) yields ^(r a b c)
935            old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
936            If oldRoot was null, it's ok, just return newRoot (even if isNil).
937            old=null, new=r yields r
938            old=null, new=^(nil r) yields ^(nil r)
939            Return newRoot.  Throw an exception if newRoot is not a
940            simple node or nil root with a single child node--it must be a root
941            node.  If newRoot is ^(nil x) return x as newRoot.
942            Be advised that it's ok for newRoot to point at oldRoot's
943            children; i.e., you don't have to copy the list.  We are
944            constructing these nodes so we should have this control for
945            efficiency.
946            </remarks>
947        </member>
948        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.RulePostProcessing(System.Object)">
949            <summary>Transform ^(nil x) to x and nil to null</summary>
950        </member>
951        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.GetUniqueID(System.Object)">
952            <summary>
953            For identifying trees. How to identify nodes so we can say "add node
954            to a prior node"?
955            </summary>
956            <remarks>
957                <para>
958            System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode() is
959            not available in .NET 1.0. It is "broken/buggy" in .NET 1.1
960            (for multi-appdomain scenarios).
961            </para>
962                <para>
963            We are tracking uniqueness of IDs ourselves manually since ANTLR
964            v3.1 release using hashtables. We will be tracking . Even though
965            it is expensive, we will create a hashtable with all tree nodes
966            in it as this is only for debugging.
967            </para>
968            </remarks>
969        </member>
970        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(System.Int32,System.String)">
971            <summary>
972            Tell me how to create a token for use with imaginary token nodes.
973            For example, there is probably no input symbol associated with imaginary
974            token DECL, but you need to create it as a payload or whatever for
975            the DECL node as in ^(DECL type ID).
976            If you care what the token payload objects' type is, you should
977            override this method and any other createToken variant.
978            </summary>
979        </member>
980        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
981            <summary>
982            Tell me how to create a token for use with imaginary token nodes.
983            For example, there is probably no input symbol associated with imaginary
984            token DECL, but you need to create it as a payload or whatever for
985            the DECL node as in ^(DECL type ID).
986            This is a variant of createToken where the new token is derived from
987            an actual real input token.  Typically this is for converting '{'
988            tokens to BLOCK etc...  You'll see
989            r : lc='{' ID+ '}' -&gt; ^(BLOCK[$lc] ID+) ;
990            If you care what the token payload objects' type is, you should
991            override this method and any other createToken variant.
992            </summary>
993        </member>
994        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.GetParent(System.Object)">
995            <summary>
996            Who is the parent node of this node; if null, implies node is root.
997            </summary>
998            <remarks>
999            If your node type doesn't handle this, it's ok but the tree rewrites
1000            in tree parsers need this functionality.
1001            </remarks>
1002        </member>
1003        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.GetChildIndex(System.Object)">
1004            <summary>
1005            What index is this node in the child list? Range: 0..n-1
1006            </summary>
1007            <remarks>
1008            If your node type doesn't handle this, it's ok but the tree rewrites
1009            in tree parsers need this functionality.
1010            </remarks>
1011        </member>
1012        <member name="M:Antlr.Runtime.Tree.BaseTreeAdaptor.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
1013            <summary>
1014            Replace from start to stop child index of parent with t, which might
1015            be a list.  Number of children may be different after this call.
1016            </summary>
1017            <remarks>
1018            If parent is null, don't do anything; must be at root of overall tree.
1019            Can't replace whatever points to the parent externally.  Do nothing.
1020            </remarks>
1021        </member>
1022        <member name="T:Antlr.Runtime.Tree.CommonTree">
1023            <summary>A tree node that is wrapper for a Token object. </summary>
1024            <remarks>
1025            After 3.0 release while building tree rewrite stuff, it became clear
1026            that computing parent and child index is very difficult and cumbersome.
1027            Better to spend the space in every tree node.  If you don't want these
1028            extra fields, it's easy to cut them out in your own BaseTree subclass.
1029            </remarks>
1030        </member>
1031        <member name="F:Antlr.Runtime.Tree.CommonTree.startIndex">
1032            <summary>
1033            What token indexes bracket all tokens associated with this node
1034            and below?
1035            </summary>
1036        </member>
1037        <member name="F:Antlr.Runtime.Tree.CommonTree.token">
1038            <summary>A single token is the payload </summary>
1039        </member>
1040        <member name="F:Antlr.Runtime.Tree.CommonTree.parent">
1041            <summary>Who is the parent node of this node; if null, implies node is root</summary>
1042        </member>
1043        <member name="F:Antlr.Runtime.Tree.CommonTree.childIndex">
1044            <summary>What index is this node in the child list? Range: 0..n-1</summary>
1045        </member>
1046        <!--FIXME: Invalid documentation markup was found for member M:Antlr.Runtime.Tree.CommonTree.SetUnknownTokenBoundaries-->
1047        <member name="T:Antlr.Runtime.Tree.CommonTreeAdaptor">
1048            <summary>
1049            A TreeAdaptor that works with any Tree implementation.  It provides
1050            really just factory methods; all the work is done by BaseTreeAdaptor.
1051            If you would like to have different tokens created than ClassicToken
1052            objects, you need to override this and then set the parser tree adaptor to
1053            use your subclass.
1054            To get your parser to build nodes of a different type, override
1055            Create(Token), ErrorNode(), and to be safe, YourTreeClass.DupNode().
1056            DupNode() is called to duplicate nodes during rewrite operations.
1057            </summary>
1058        </member>
1059        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.DupNode(System.Object)">
1060            <summary>
1061            Duplicate a node.  This is part of the factory;
1062            override if you want another kind of node to be built.
1063            I could use reflection to prevent having to override this
1064            but reflection is slow.
1065            </summary>
1066        </member>
1067        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(System.Int32,System.String)">
1068            <summary>Create an imaginary token from a type and text </summary>
1069            <remarks>
1070            Tell me how to create a token for use with imaginary token nodes.
1071            For example, there is probably no input symbol associated with imaginary
1072            token DECL, but you need to create it as a payload or whatever for
1073            the DECL node as in ^(DECL type ID).
1074            If you care what the token payload objects' type is, you should
1075            override this method and any other createToken variant.
1076            </remarks>
1077        </member>
1078        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.CreateToken(Antlr.Runtime.IToken)">
1079            <summary>Create an imaginary token, copying the contents of a previous token </summary>
1080            <remarks>
1081            Tell me how to create a token for use with imaginary token nodes.
1082            For example, there is probably no input symbol associated with imaginary
1083            token DECL, but you need to create it as a payload or whatever for
1084            the DECL node as in ^(DECL type ID).
1085            This is a variant of createToken where the new token is derived from
1086            an actual real input token.  Typically this is for converting '{'
1087            tokens to BLOCK etc...  You'll see
1088            r : lc='{' ID+ '}' -&gt; ^(BLOCK[$lc] ID+) ;
1089            If you care what the token payload objects' type is, you should
1090            override this method and any other createToken variant.
1091            </remarks>
1092        </member>
1093        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
1094            <summary>track start/stop token for subtree root created for a rule </summary>
1095            <remarks>
1096            Track start/stop token for subtree root created for a rule.
1097            Only works with Tree nodes.  For rules that match nothing,
1098            seems like this will yield start=i and stop=i-1 in a nil node.
1099            Might be useful info so I'll not force to be i..i.
1100            </remarks>
1101        </member>
1102        <member name="M:Antlr.Runtime.Tree.CommonTreeAdaptor.GetToken(System.Object)">
1103            <summary>
1104            What is the Token associated with this node?
1105            </summary>
1106            <remarks>
1107            If you are not using CommonTree, then you must override this in your
1108            own adaptor.
1109            </remarks>
1110        </member>
1111        <member name="T:Antlr.Runtime.Tree.CommonTreeNodeStream">
1112            <summary>
1113            A buffered stream of tree nodes.  Nodes can be from a tree of ANY kind.
1114            </summary>
1115            <remarks>
1116            This node stream sucks all nodes out of the tree specified in the
1117            constructor during construction and makes pointers into the tree
1118            using an array of Object pointers. The stream necessarily includes
1119            pointers to DOWN and UP and EOF nodes.
1120            This stream knows how to mark/release for backtracking.
1121            This stream is most suitable for tree interpreters that need to
1122            jump around a lot or for tree parsers requiring speed (at cost of memory).
1123            There is some duplicated functionality here with UnBufferedTreeNodeStream
1124            but just in bookkeeping, not tree walking etc...
1125            <see cref="T:Antlr.Runtime.Tree.UnBufferedTreeNodeStream" /></remarks>
1126        </member>
1127        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.nodes">
1128            <summary>
1129            The complete mapping from stream index to tree node. This buffer
1130            includes pointers to DOWN, UP, and EOF nodes.
1131            It is built upon ctor invocation.  The elements are type Object
1132            as we don't what the trees look like. Load upon first need of
1133            the buffer so we can set token types of interest for reverseIndexing.
1134            Slows us down a wee bit  to do all of the if p==-1 testing everywhere though.
1135            </summary>
1136        </member>
1137        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.root">
1138            <summary>Pull nodes from which tree? </summary>
1139        </member>
1140        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.tokens">
1141            <summary>IF this tree (root) was created from a token stream, track it</summary>
1142        </member>
1143        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.adaptor">
1144            <summary>What tree adaptor was used to build these trees</summary>
1145        </member>
1146        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.uniqueNavigationNodes">
1147            <summary>
1148            Reuse same DOWN, UP navigation nodes unless this is true
1149            </summary>
1150        </member>
1151        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.p">
1152            <summary>
1153            The index into the nodes list of the current node (next node
1154            to consume).  If -1, nodes array not filled yet.
1155            </summary>
1156        </member>
1157        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.lastMarker">
1158            <summary>
1159            Track the last mark() call result value for use in rewind().
1160            </summary>
1161        </member>
1162        <member name="F:Antlr.Runtime.Tree.CommonTreeNodeStream.calls">
1163            <summary>
1164            Stack of indexes used for push/pop calls
1165            </summary>
1166        </member>
1167        <member name="P:Antlr.Runtime.Tree.CommonTreeNodeStream.TreeSource">
1168            <summary>
1169            Where is this stream pulling nodes from?  This is not the name, but
1170            the object that provides node objects.
1171            </summary>
1172        </member>
1173        <member name="P:Antlr.Runtime.Tree.CommonTreeNodeStream.Count">
1174            <summary>
1175            Expensive to compute so I won't bother doing the right thing.
1176            This method only returns how much input has been seen so far.  So
1177            after parsing it returns true size.
1178            </summary>
1179        </member>
1180        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.FillBuffer">
1181            <summary>
1182            Walk tree with depth-first-search and fill nodes buffer.
1183            Don't do DOWN, UP nodes if its a list (t is isNil).
1184            </summary>
1185        </member>
1186        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.GetNodeIndex(System.Object)">
1187            <summary>
1188            Returns the stream index for the spcified node in the range 0..n-1 or,
1189            -1 if node not found.
1190            </summary>
1191        </member>
1192        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.AddNavigationNode(System.Int32)">
1193            <summary>
1194            As we flatten the tree, we use UP, DOWN nodes to represent
1195            the tree structure.  When debugging we need unique nodes
1196            so instantiate new ones when uniqueNavigationNodes is true.
1197            </summary>
1198        </member>
1199        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.LB(System.Int32)">
1200            <summary>
1201            Look backwards k nodes
1202            </summary>
1203        </member>
1204        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Push(System.Int32)">
1205            <summary>
1206            Make stream jump to a new location, saving old location.
1207            Switch back with pop().
1208            </summary>
1209        </member>
1210        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Pop">
1211            <summary>
1212            Seek back to previous index saved during last Push() call.
1213            Return top of stack (return index).
1214            </summary>
1215        </member>
1216        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Mark">
1217            <summary>
1218            Record the current state of the tree walk which includes
1219            the current node and stack state.
1220            </summary>
1221        </member>
1222        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Rewind(System.Int32)">
1223            <summary>
1224            Rewind the current state of the tree walk to the state it
1225            was in when Mark() was called and it returned marker.  Also,
1226            wipe out the lookahead which will force reloading a few nodes
1227            but it is better than making a copy of the lookahead buffer
1228            upon Mark().
1229            </summary>
1230        </member>
1231        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Seek(System.Int32)">
1232            <summary>
1233            Consume() ahead until we hit index.  Can't just jump ahead--must
1234            spit out the navigation nodes.
1235            </summary>
1236        </member>
1237        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.Size">
1238            <summary>
1239            Expensive to compute so I won't bother doing the right thing.
1240            This method only returns how much input has been seen so far.  So
1241            after parsing it returns true size.
1242            </summary>
1243        </member>
1244        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.ToString">
1245            <summary>
1246            Used for testing, just return the token type stream
1247            </summary>
1248        </member>
1249        <member name="M:Antlr.Runtime.Tree.CommonTreeNodeStream.ToTokenString(System.Int32,System.Int32)">
1250             Debugging</member>
1251        <member name="T:Antlr.Runtime.Tree.ITree">
1252            <summary>
1253            What does a tree look like?  ANTLR has a number of support classes
1254            such as CommonTreeNodeStream that work on these kinds of trees.  You
1255            don't have to make your trees implement this interface, but if you do,
1256            you'll be able to use more support code.
1257            NOTE: When constructing trees, ANTLR can build any kind of tree; it can
1258            even use Token objects as trees if you add a child list to your tokens.
1259            This is a tree node without any payload; just navigation and factory stuff.
1260            </summary>
1261        </member>
1262        <member name="P:Antlr.Runtime.Tree.ITree.ChildIndex">
1263            <summary>This node is what child index? 0..n-1</summary>
1264        </member>
1265        <member name="P:Antlr.Runtime.Tree.ITree.IsNil">
1266            <summary>
1267            Indicates the node is a nil node but may still have children, meaning
1268            the tree is a flat list.
1269            </summary>
1270        </member>
1271        <member name="P:Antlr.Runtime.Tree.ITree.Type">
1272            <summary>Return a token type; needed for tree parsing </summary>
1273        </member>
1274        <member name="P:Antlr.Runtime.Tree.ITree.Line">
1275            <summary>In case we don't have a token payload, what is the line for errors? </summary>
1276        </member>
1277        <member name="P:Antlr.Runtime.Tree.ITree.TokenStartIndex">
1278            <summary>
1279            What is the smallest token index (indexing from 0) for this node
1280            and its children?
1281            </summary>
1282        </member>
1283        <member name="P:Antlr.Runtime.Tree.ITree.TokenStopIndex">
1284            <summary>
1285            What is the largest token index (indexing from 0) for this node
1286            and its children?
1287            </summary>
1288        </member>
1289        <member name="M:Antlr.Runtime.Tree.ITree.HasAncestor(System.Int32)">
1290            <summary>
1291            Is there is a node above with token type ttype?
1292            </summary>
1293        </member>
1294        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestor(System.Int32)">
1295            <summary>
1296            Walk upwards and get first ancestor with this token type.
1297            </summary>
1298            <param name="ttype">
1299            A <see cref="T:System.Int32" /></param>
1300            <returns>
1301            A <see cref="T:Antlr.Runtime.Tree.ITree" /></returns>
1302        </member>
1303        <member name="M:Antlr.Runtime.Tree.ITree.GetAncestors">
1304            <summary>
1305            Return a list of all ancestors of this node.  The first node of
1306            list is the root and the last is the parent of this node.
1307            </summary>
1308            <returns>
1309            A <see cref="T:System.Collections.IList" /></returns>
1310        </member>
1311        <member name="M:Antlr.Runtime.Tree.ITree.FreshenParentAndChildIndexes">
1312            <summary>Set (or reset) the parent and child index values for all children</summary>
1313        </member>
1314        <member name="M:Antlr.Runtime.Tree.ITree.AddChild(Antlr.Runtime.Tree.ITree)">
1315            <summary>
1316            Add t as a child to this node.  If t is null, do nothing.  If t
1317            is nil, add all children of t to this' children.
1318            </summary>
1319            <param name="t">Tree to add</param>
1320        </member>
1321        <member name="M:Antlr.Runtime.Tree.ITree.SetChild(System.Int32,Antlr.Runtime.Tree.ITree)">
1322            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary>
1323        </member>
1324        <member name="M:Antlr.Runtime.Tree.ITree.ReplaceChildren(System.Int32,System.Int32,System.Object)">
1325            <summary>
1326            Delete children from start to stop and replace with t even if t is
1327            a list (nil-root tree).  num of children can increase or decrease.
1328            For huge child lists, inserting children can force walking rest of
1329            children to set their childindex; could be slow.
1330            </summary>
1331        </member>
1332        <member name="T:Antlr.Runtime.Tree.ITreeAdaptor">
1333            <summary>
1334            How to create and navigate trees.  Rather than have a separate factory
1335            and adaptor, I've merged them.  Makes sense to encapsulate.
1336            This takes the place of the tree construction code generated in the
1337            generated code in 2.x and the ASTFactory.
1338            I do not need to know the type of a tree at all so they are all
1339            generic Objects.  This may increase the amount of typecasting needed. :(
1340            </summary>
1341        </member>
1342        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(Antlr.Runtime.IToken)">
1343            <summary>
1344            Create a tree node from Token object; for CommonTree type trees,
1345            then the token just becomes the payload.
1346            </summary>
1347            <remarks>
1348            This is the most common create call. Override if you want another kind of node to be built.
1349            </remarks>
1350        </member>
1351        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupNode(System.Object)">
1352            <summary>Duplicate a single tree node </summary>
1353            <remarks> Override if you want another kind of node to be built.</remarks>
1354        </member>
1355        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DupTree(System.Object)">
1356            <summary>Duplicate tree recursively, using DupNode() for each node </summary>
1357        </member>
1358        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetNilNode">
1359            <summary>
1360            Return a nil node (an empty but non-null node) that can hold
1361            a list of element as the children.  If you want a flat tree (a list)
1362            use "t=adaptor.nil(); t.AddChild(x); t.AddChild(y);"
1363            </summary>
1364        </member>
1365        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ErrorNode(Antlr.Runtime.ITokenStream,Antlr.Runtime.IToken,Antlr.Runtime.IToken,Antlr.Runtime.RecognitionException)">
1366            <summary>
1367            Return a tree node representing an error. This node records the
1368            tokens consumed during error recovery. The start token indicates the
1369            input symbol at which the error was detected. The stop token indicates
1370            the last symbol consumed during recovery.
1371            </summary>
1372            <remarks>
1373                <para>You must specify the input stream so that the erroneous text can
1374            be packaged up in the error node. The exception could be useful
1375            to some applications; default implementation stores ptr to it in
1376            the CommonErrorNode.</para>
1377                <para>This only makes sense during token parsing, not tree parsing.
1378            Tree parsing should happen only when parsing and tree construction
1379            succeed.</para>
1380            </remarks>
1381        </member>
1382        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.IsNil(System.Object)">
1383            <summary>
1384            Is tree considered a nil node used to make lists of child nodes?
1385            </summary>
1386        </member>
1387        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)">
1388            <summary>
1389            Add a child to the tree t.  If child is a flat tree (a list), make all
1390            in list children of t.
1391            </summary>
1392            <remarks>
1393                <para>
1394            Warning: if t has no children, but child does and child isNil then you
1395            can decide it is ok to move children to t via t.children = child.children;
1396            i.e., without copying the array.  Just make sure that this is consistent
1397            with have the user will build ASTs. Do nothing if t or child is null.
1398            </para>
1399                <para>
1400            This is for construction and I'm not sure it's completely general for
1401            a tree's addChild method to work this way.  Make sure you differentiate
1402            between your tree's addChild and this parser tree construction addChild
1403            if it's not ok to move children to t with a simple assignment.
1404            </para>
1405            </remarks>
1406        </member>
1407        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)">
1408            <summary>
1409            If oldRoot is a nil root, just copy or move the children to newRoot.
1410            If not a nil root, make oldRoot a child of newRoot.
1411            </summary>
1412            <remarks>
1413            old=^(nil a b c), new=r yields ^(r a b c)
1414            old=^(a b c), new=r yields ^(r ^(a b c))
1415            If newRoot is a nil-rooted single child tree, use the single
1416            child as the new root node.
1417            old=^(nil a b c), new=^(nil r) yields ^(r a b c)
1418            old=^(a b c), new=^(nil r) yields ^(r ^(a b c))
1419            If oldRoot was null, it's ok, just return newRoot (even if isNil).
1420            old=null, new=r yields r
1421            old=null, new=^(nil r) yields ^(nil r)
1422            Return newRoot.  Throw an exception if newRoot is not a
1423            simple node or nil root with a single child node--it must be a root
1424            node.  If newRoot is ^(nil x) return x as newRoot.
1425            Be advised that it's ok for newRoot to point at oldRoot's
1426            children; i.e., you don't have to copy the list.  We are
1427            constructing these nodes so we should have this control for
1428            efficiency.
1429            </remarks>
1430        </member>
1431        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.RulePostProcessing(System.Object)">
1432            <summary>
1433            Given the root of the subtree created for this rule, post process
1434            it to do any simplifications or whatever you want.  A required
1435            behavior is to convert ^(nil singleSubtree) to singleSubtree
1436            as the setting of start/stop indexes relies on a single non-nil root
1437            for non-flat trees.
1438            Flat trees such as for lists like "idlist : ID+ ;" are left alone
1439            unless there is only one ID.  For a list, the start/stop indexes
1440            are set in the nil node.
1441            This method is executed after all rule tree construction and right
1442            before SetTokenBoundaries().
1443            </summary>
1444        </member>
1445        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetUniqueID(System.Object)">
1446            <summary>
1447            For identifying trees. How to identify nodes so we can say "add node
1448            to a prior node"?
1449            </summary>
1450            <remarks>
1451            Even BecomeRoot is an issue. Ok, we could:
1452            <list type="number"><item>Number the nodes as they are created?</item><item>
1453                                Use the original framework assigned hashcode that's unique
1454                                across instances of a given type.
1455                                WARNING: This is usually implemented either as IL to make a
1456                                non-virt call to object.GetHashCode() or by via a call to
1457                                System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode().
1458                                Both have issues especially on .NET 1.x and Mono.
1459                        </item></list></remarks>
1460        </member>
1461        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(Antlr.Runtime.IToken,System.Object)">
1462            <summary>
1463            Create a node for newRoot make it the root of oldRoot.
1464            If oldRoot is a nil root, just copy or move the children to newRoot.
1465            If not a nil root, make oldRoot a child of newRoot.
1466            Return node created for newRoot.
1467            </summary>
1468        </member>
1469        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken)">
1470            <summary>Create a new node derived from a token, with a new token type.
1471            This is invoked from an imaginary node ref on right side of a
1472            rewrite rule as IMAG[$tokenLabel].
1473            This should invoke createToken(Token).
1474            </summary>
1475        </member>
1476        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,Antlr.Runtime.IToken,System.String)">
1477            <summary>Same as Create(tokenType,fromToken) except set the text too.
1478            This is invoked from an imaginary node ref on right side of a
1479            rewrite rule as IMAG[$tokenLabel, "IMAG"].
1480            This should invoke createToken(Token).
1481            </summary>
1482        </member>
1483        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.Create(System.Int32,System.String)">
1484            <summary>Create a new node derived from a token, with a new token type.
1485            This is invoked from an imaginary node ref on right side of a
1486            rewrite rule as IMAG["IMAG"].
1487            This should invoke createToken(int,String).
1488            </summary>
1489        </member>
1490        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetNodeType(System.Object)">
1491            <summary>For tree parsing, I need to know the token type of a node </summary>
1492        </member>
1493        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetNodeType(System.Object,System.Int32)">
1494            <summary>Node constructors can set the type of a node </summary>
1495        </member>
1496        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetNodeText(System.Object,System.String)">
1497            <summary>Node constructors can set the text of a node </summary>
1498        </member>
1499        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetToken(System.Object)">
1500            <summary>
1501            Return the token object from which this node was created.
1502            </summary>
1503            <remarks>
1504            Currently used only for printing an error message. The error
1505            display routine in BaseRecognizer needs to display where the
1506            input the error occurred. If your tree of limitation does not
1507            store information that can lead you to the token, you can create
1508            a token filled with the appropriate information and pass that back.
1509            <see cref="M:Antlr.Runtime.BaseRecognizer.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])" /></remarks>
1510        </member>
1511        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetTokenBoundaries(System.Object,Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
1512            <summary>
1513            Where are the bounds in the input token stream for this node and
1514            all children?
1515            </summary>
1516            <remarks>
1517            Each rule that creates AST nodes will call this
1518            method right before returning.  Flat trees (i.e., lists) will
1519            still usually have a nil root node just to hold the children list.
1520            That node would contain the start/stop indexes then.
1521            </remarks>
1522        </member>
1523        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStartIndex(System.Object)">
1524            <summary>
1525            Get the token start index for this subtree; return -1 if no such index
1526            </summary>
1527        </member>
1528        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetTokenStopIndex(System.Object)">
1529            <summary>
1530            Get the token stop index for this subtree; return -1 if no such index
1531            </summary>
1532        </member>
1533        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChild(System.Object,System.Int32)">
1534            <summary>Get a child 0..n-1 node </summary>
1535        </member>
1536        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.SetChild(System.Object,System.Int32,System.Object)">
1537            <summary>Set ith child (0..n-1) to t; t must be non-null and non-nil node</summary>
1538        </member>
1539        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.DeleteChild(System.Object,System.Int32)">
1540            <summary>Remove ith child and shift children down from right.</summary>
1541        </member>
1542        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildCount(System.Object)">
1543            <summary>How many children?  If 0, then this is a leaf node </summary>
1544        </member>
1545        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetParent(System.Object)">
1546            <summary>
1547            Who is the parent node of this node; if null, implies node is root.
1548            </summary>
1549            <remarks>
1550            If your node type doesn't handle this, it's ok but the tree rewrites
1551            in tree parsers need this functionality.
1552            </remarks>
1553        </member>
1554        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.GetChildIndex(System.Object)">
1555            <summary>
1556            What index is this node in the child list? Range: 0..n-1
1557            </summary>
1558            <remarks>
1559            If your node type doesn't handle this, it's ok but the tree rewrites
1560            in tree parsers need this functionality.
1561            </remarks>
1562        </member>
1563        <member name="M:Antlr.Runtime.Tree.ITreeAdaptor.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
1564            <summary>
1565            Replace from start to stop child index of parent with t, which might
1566            be a list.  Number of children may be different after this call.
1567            </summary>
1568            <remarks>
1569            If parent is null, don't do anything; must be at root of overall tree.
1570            Can't replace whatever points to the parent externally.  Do nothing.
1571            </remarks>
1572        </member>
1573        <member name="T:Antlr.Runtime.Tree.ITreeNodeStream">
1574            <summary>A stream of tree nodes, accessing nodes from a tree of some kind </summary>
1575        </member>
1576        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeSource">
1577            <summary>
1578            Where is this stream pulling nodes from?  This is not the name, but
1579            the object that provides node objects.
1580            TODO: do we really need this?
1581            </summary>
1582        </member>
1583        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TokenStream">
1584            <summary>
1585            Get the ITokenStream from which this stream's Tree was created
1586            (may be null)
1587            </summary>
1588            <remarks>
1589            If the tree associated with this stream was created from a
1590            TokenStream, you can specify it here.  Used to do rule $text
1591            attribute in tree parser.  Optional unless you use tree parser
1592            rule text attribute or output=template and rewrite=true options.
1593            </remarks>
1594        </member>
1595        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.TreeAdaptor">
1596            <summary>
1597            What adaptor can tell me how to interpret/navigate nodes and trees.
1598            E.g., get text of a node.
1599            </summary>
1600        </member>
1601        <member name="P:Antlr.Runtime.Tree.ITreeNodeStream.HasUniqueNavigationNodes">
1602            <summary>
1603            As we flatten the tree, we use UP, DOWN nodes to represent
1604            the tree structure.  When debugging we need unique nodes
1605            so we have to instantiate new ones.  When doing normal tree
1606            parsing, it's slow and a waste of memory to create unique
1607            navigation nodes.  Default should be false;
1608            </summary>
1609        </member>
1610        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.Get(System.Int32)">
1611            <summary>Get a tree node at an absolute index i; 0..n-1.</summary>
1612            <remarks>
1613            If you don't want to buffer up nodes, then this method makes no
1614            sense for you.
1615            </remarks>
1616        </member>
1617        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.LT(System.Int32)">
1618            <summary>
1619            Get tree node at current input pointer + i ahead where i=1 is next node.
1620            i&lt;0 indicates nodes in the past.  So LT(-1) is previous node, but
1621            implementations are not required to provide results for k &lt; -1.
1622            LT(0) is undefined.  For i&gt;=n, return null.
1623            Return null for LT(0) and any index that results in an absolute address
1624            that is negative.
1625            This is analogus to the LT() method of the TokenStream, but this
1626            returns a tree node instead of a token.  Makes code gen identical
1627            for both parser and tree grammars. :)
1628            </summary>
1629        </member>
1630        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ToString(System.Object,System.Object)">
1631            <summary>Return the text of all nodes from start to stop, inclusive.
1632            If the stream does not buffer all the nodes then it can still
1633            walk recursively from start until stop.  You can always return
1634            null or "" too, but users should not access $ruleLabel.text in
1635            an action of course in that case.
1636            </summary>
1637        </member>
1638        <member name="M:Antlr.Runtime.Tree.ITreeNodeStream.ReplaceChildren(System.Object,System.Int32,System.Int32,System.Object)">
1639            <summary>
1640            Replace from start to stop child index of parent with t, which might
1641            be a list.  Number of children may be different after this call.
1642            </summary>
1643            <remarks>
1644            The stream is notified because it is walking the tree and might need
1645            to know you are monkeying with the underlying tree.  Also, it might be
1646            able to modify the node stream to avoid restreaming for future phases.
1647            If parent is null, don't do anything; must be at root of overall tree.
1648            Can't replace whatever points to the parent externally.  Do nothing.
1649            </remarks>
1650        </member>
1651        <member name="T:Antlr.Runtime.Tree.ParseTree">
1652            <summary>
1653            A record of the rules used to Match a token sequence.  The tokens
1654            end up as the leaves of this tree and rule nodes are the interior nodes.
1655            This really adds no functionality, it is just an alias for CommonTree
1656            that is more meaningful (specific) and holds a String to display for a node.
1657            </summary>
1658        </member>
1659        <member name="M:Antlr.Runtime.Tree.ParseTree.ToStringWithHiddenTokens">
1660             Emit a token and all hidden nodes before.  EOF node holds all
1661                         *  hidden tokens after last real token.</member>
1662        <member name="M:Antlr.Runtime.Tree.ParseTree.ToInputString">
1663             Print out the leaves of this tree, which means printing original
1664                         *  input back out.</member>
1665        <member name="T:Antlr.Runtime.Tree.TreeParser">
1666            <summary>
1667            A parser for a stream of tree nodes.  "tree grammars" result in a subclass
1668            of this.  All the error reporting and recovery is shared with Parser via
1669            the BaseRecognizer superclass.
1670            </summary>
1671        </member>
1672        <member name="P:Antlr.Runtime.Tree.TreeParser.TreeNodeStream">
1673            <summary>Set the input stream</summary>
1674        </member>
1675        <member name="M:Antlr.Runtime.Tree.TreeParser.Reset">
1676            <summary>Reset the parser </summary>
1677        </member>
1678        <member name="M:Antlr.Runtime.Tree.TreeParser.MatchAny(Antlr.Runtime.IIntStream)">
1679            <summary>
1680            Match '.' in tree parser.
1681            </summary>
1682            <remarks>
1683            Match '.' in tree parser has special meaning.  Skip node or
1684            entire tree if node has children.  If children, scan until
1685            corresponding UP node.
1686            </remarks>
1687        </member>
1688        <member name="M:Antlr.Runtime.Tree.TreeParser.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
1689            <summary>We have DOWN/UP nodes in the stream that have no line info; override.
1690            plus we want to alter the exception type. Don't try to recover
1691            from tree parser errors inline...
1692            </summary>
1693        </member>
1694        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorHeader(Antlr.Runtime.RecognitionException)">
1695            <summary>
1696            Prefix error message with the grammar name because message is
1697            always intended for the programmer because the parser built
1698            the input tree not the user.
1699            </summary>
1700        </member>
1701        <member name="M:Antlr.Runtime.Tree.TreeParser.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
1702            <summary>
1703            Tree parsers parse nodes they usually have a token object as
1704            payload. Set the exception token and do the default behavior.
1705            </summary>
1706        </member>
1707        <member name="T:Antlr.Runtime.Tree.TreeRuleReturnScope">
1708            <summary>
1709            This is identical to the ParserRuleReturnScope except that
1710            the start property is a tree node and not a Token object
1711            when you are parsing trees.  To be generic the tree node types
1712            have to be Object :(
1713            </summary>
1714        </member>
1715        <member name="F:Antlr.Runtime.Tree.TreeRuleReturnScope.start">
1716            <summary>First node or root node of tree matched for this rule.</summary>
1717        </member>
1718        <member name="P:Antlr.Runtime.Tree.TreeRuleReturnScope.Start">
1719            <summary>Return the start token or tree </summary>
1720        </member>
1721        <member name="T:Antlr.Runtime.Debug.DebugEventSocketProxy">
1722            <summary>
1723            A proxy debug event listener that forwards events over a socket to
1724            debugger (or any other listener) using a simple text-based protocol;
1725            one event per line.
1726            </summary>
1727            <remarks>
1728            ANTLRWorks listens on server socket with a
1729            RemoteDebugEventSocketListener instance.  These two objects must therefore
1730            be kept in sync.  New events must be handled on both sides of socket.
1731            </remarks>
1732        </member>
1733        <member name="F:Antlr.Runtime.Debug.DebugEventSocketProxy.adaptor">
1734            <summary>
1735            Almost certainly the recognizer will have adaptor set, but
1736            we don't know how to cast it (Parser or TreeParser) to get
1737            the adaptor field.  Must be set with a constructor. :(
1738            </summary>
1739        </member>
1740        <member name="M:Antlr.Runtime.Debug.DebugParser.#ctor(Antlr.Runtime.ITokenStream,Antlr.Runtime.Debug.IDebugEventListener,Antlr.Runtime.RecognizerSharedState)">
1741            <summary>
1742            Create a normal parser except wrap the token stream in a debug
1743            proxy that fires consume events.
1744            </summary>
1745        </member>
1746        <member name="F:Antlr.Runtime.Debug.DebugParser.dbg">
1747            <summary>Who to notify when events in the parser occur. </summary>
1748        </member>
1749        <member name="F:Antlr.Runtime.Debug.DebugParser.isCyclicDecision">
1750            <summary>
1751            Used to differentiate between fixed lookahead and cyclic DFA decisions
1752            while profiling.
1753            </summary>
1754        </member>
1755        <member name="P:Antlr.Runtime.Debug.DebugParser.DebugListener">
1756            <summary>
1757            Provide a new debug event listener for this parser.  Notify the
1758            input stream too that it should send events to this listener.
1759            </summary>
1760        </member>
1761        <member name="F:Antlr.Runtime.Debug.DebugTokenStream.lastMarker">
1762            <summary>
1763            Track the last Mark() call result value for use in Rewind().
1764            </summary>
1765        </member>
1766        <member name="M:Antlr.Runtime.Debug.DebugTokenStream.ConsumeInitialHiddenTokens">
1767            <summary>consume all initial off-channel tokens</summary>
1768        </member>
1769        <member name="T:Antlr.Runtime.Debug.IDebugEventListener">
1770            <summary>
1771            All debugging events that a recognizer can trigger.
1772            </summary>
1773            <remarks>
1774            I did not create a separate AST debugging interface as it would create
1775            lots of extra classes and DebugParser has a dbg var defined, which makes
1776            it hard to change to ASTDebugEventListener.  I looked hard at this issue
1777            and it is easier to understand as one monolithic event interface for all
1778            possible events.  Hopefully, adding ST debugging stuff won't be bad.  Leave
1779            for future. 4/26/2006.
1780            </remarks>
1781        </member>
1782        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterRule(System.String,System.String)">
1783            <summary>
1784            The parser has just entered a rule.  No decision has been made about
1785            which alt is predicted.  This is fired AFTER init actions have been
1786            executed.  Attributes are defined and available etc...
1787            The grammarFileName allows composite grammars to jump around among
1788            multiple grammar files.
1789            </summary>
1790        </member>
1791        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterAlt(System.Int32)">
1792            <summary>
1793            Because rules can have lots of alternatives, it is very useful to
1794            know which alt you are entering.  This is 1..n for n alts.
1795            </summary>
1796        </member>
1797        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ExitRule(System.String,System.String)">
1798            <summary>
1799            This is the last thing executed before leaving a rule.  It is
1800            executed even if an exception is thrown.  This is triggered after
1801            error reporting and recovery have occurred (unless the exception is
1802            not caught in this rule).  This implies an "exitAlt" event.
1803            The grammarFileName allows composite grammars to jump around among
1804            multiple grammar files.
1805            </summary>
1806        </member>
1807        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterSubRule(System.Int32)">
1808            <summary>Track entry into any (...) subrule other EBNF construct </summary>
1809        </member>
1810        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EnterDecision(System.Int32)">
1811            <summary>
1812            Every decision, fixed k or arbitrary, has an enter/exit event
1813            so that a GUI can easily track what LT/Consume events are
1814            associated with prediction.  You will see a single enter/exit
1815            subrule but multiple enter/exit decision events, one for each
1816            loop iteration.
1817            </summary>
1818        </member>
1819        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeToken(Antlr.Runtime.IToken)">
1820            <summary>
1821            An input token was consumed; matched by any kind of element.
1822            Trigger after the token was matched by things like Match(), MatchAny().
1823            </summary>
1824        </member>
1825        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeHiddenToken(Antlr.Runtime.IToken)">
1826            <summary>
1827            An off-channel input token was consumed.
1828            Trigger after the token was matched by things like Match(), MatchAny().
1829            (unless of course the hidden token is first stuff in the input stream).
1830            </summary>
1831        </member>
1832        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,Antlr.Runtime.IToken)">
1833            <summary>
1834            Somebody (anybody) looked ahead.  Note that this actually gets
1835            triggered by both LA and LT calls.  The debugger will want to know
1836            which Token object was examined.  Like ConsumeToken, this indicates
1837            what token was seen at that depth.  A remote debugger cannot look
1838            ahead into a file it doesn't have so LT events must pass the token
1839            even if the info is redundant.
1840            </summary>
1841        </member>
1842        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Mark(System.Int32)">
1843            <summary>
1844            The parser is going to look arbitrarily ahead; mark this location,
1845            the token stream's marker is sent in case you need it.
1846            </summary>
1847        </member>
1848        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind(System.Int32)">
1849            <summary>
1850            After an arbitrairly long lookahead as with a cyclic DFA (or with
1851            any backtrack), this informs the debugger that stream should be
1852            rewound to the position associated with marker.
1853            </summary>
1854        </member>
1855        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Rewind">
1856            <summary>
1857            Rewind to the input position of the last marker.
1858            Used currently only after a cyclic DFA and just
1859            before starting a sem/syn predicate to get the
1860            input position back to the start of the decision.
1861            Do not "pop" the marker off the state.  Mark(i)
1862            and Rewind(i) should balance still.
1863            </summary>
1864        </member>
1865        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Location(System.Int32,System.Int32)">
1866            <summary>
1867            To watch a parser move through the grammar, the parser needs to
1868            inform the debugger what line/charPos it is passing in the grammar.
1869            For now, this does not know how to switch from one grammar to the
1870            other and back for island grammars etc...
1871            This should also allow breakpoints because the debugger can stop
1872            the parser whenever it hits this line/pos.
1873            </summary>
1874        </member>
1875        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.RecognitionException(Antlr.Runtime.RecognitionException)">
1876            <summary>
1877            A recognition exception occurred such as NoViableAltException.  I made
1878            this a generic event so that I can alter the exception hierachy later
1879            without having to alter all the debug objects.
1880            Upon error, the stack of enter rule/subrule must be properly unwound.
1881            If no viable alt occurs it is within an enter/exit decision, which
1882            also must be rewound.  Even the rewind for each mark must be unwount.
1883            In the C# target this is pretty easy using try/finally, if a bit
1884            ugly in the generated code.  The rewind is generated in DFA.Predict()
1885            actually so no code needs to be generated for that.  For languages
1886            w/o this "finally" feature (C++?), the target implementor will have
1887            to build an event stack or something.
1888            Across a socket for remote debugging, only the RecognitionException
1889            data fields are transmitted.  The token object or whatever that
1890            caused the problem was the last object referenced by LT.  The
1891            immediately preceding LT event should hold the unexpected Token or
1892            char.
1893            Here is a sample event trace for grammar:
1894            b : C ({;}A|B) // {;} is there to prevent A|B becoming a set
1895            | D
1896            ;
1897            The sequence for this rule (with no viable alt in the subrule) for
1898            input 'c c' (there are 3 tokens) is:
1899            Commence
1900            LT(1)
1901            EnterRule b
1902            Location 7 1
1903            enter decision 3
1904            LT(1)
1905            exit decision 3
1906            enterAlt1
1907            Location 7 5
1908            LT(1)
1909            ConsumeToken <![CDATA[[c/<4>,1:0]]]>
1910            Location 7 7
1911            EnterSubRule 2
1912            enter decision 2
1913            LT(1)
1914            LT(1)
1915            RecognitionException NoViableAltException 2 1 2
1916            exit decision 2
1917            ExitSubRule 2
1918            BeginResync
1919            LT(1)
1920            ConsumeToken <![CDATA[[c/<4>,1:1]]]>
1921            LT(1)
1922            EndResync
1923            LT(-1)
1924            ExitRule b
1925            Terminate
1926            </summary>
1927        </member>
1928        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BeginResync">
1929            <summary>
1930            Indicates the recognizer is about to consume tokens to resynchronize
1931            the parser.  Any Consume events from here until the recovered event
1932            are not part of the parse--they are dead tokens.
1933            </summary>
1934        </member>
1935        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.EndResync">
1936            <summary>
1937            Indicates that the recognizer has finished consuming tokens in order
1938            to resychronize.  There may be multiple BeginResync/EndResync pairs
1939            before the recognizer comes out of errorRecovery mode (in which
1940            multiple errors are suppressed).  This will be useful
1941            in a gui where you want to probably grey out tokens that are consumed
1942            but not matched to anything in grammar.  Anything between
1943            a BeginResync/EndResync pair was tossed out by the parser.
1944            </summary>
1945        </member>
1946        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SemanticPredicate(System.Boolean,System.String)">
1947            <summary>
1948            A semantic predicate was evaluate with this result and action text
1949            </summary>
1950        </member>
1951        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Commence">
1952            <summary>
1953            Announce that parsing has begun.  Not technically useful except for
1954            sending events over a socket.  A GUI for example will launch a thread
1955            to connect and communicate with a remote parser.  The thread will want
1956            to notify the GUI when a connection is made.  ANTLR parsers
1957            trigger this upon entry to the first rule (the ruleLevel is used to
1958            figure this out).
1959            </summary>
1960        </member>
1961        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.Terminate">
1962            <summary>
1963            Parsing is over; successfully or not.  Mostly useful for telling
1964            remote debugging listeners that it's time to quit.  When the rule
1965            invocation level goes to zero at the end of a rule, we are done
1966            parsing.
1967            </summary>
1968        </member>
1969        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ConsumeNode(System.Object)">
1970            <summary>
1971            Input for a tree parser is an AST, but we know nothing for sure
1972            about a node except its type and text (obtained from the adaptor).
1973            This is the analog of the ConsumeToken method.  Again, the ID is
1974            the hashCode usually of the node so it only works if hashCode is
1975            not implemented.  If the type is UP or DOWN, then
1976            the ID is not really meaningful as it's fixed--there is
1977            just one UP node and one DOWN navigation node.
1978            </summary>
1979        </member>
1980        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.LT(System.Int32,System.Object)">
1981            <summary>
1982            The tree parser lookedahead.  If the type is UP or DOWN,
1983            then the ID is not really meaningful as it's fixed--there is
1984            just one UP node and one DOWN navigation node.
1985            </summary>
1986        </member>
1987        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.GetNilNode(System.Object)">
1988            <summary>
1989            Announce the creation of a nil node
1990            </summary>
1991            <remarks>
1992            A nil was created (even nil nodes have a unique ID...
1993            they are not "null" per se).  As of 4/28/2006, this
1994            seems to be uniquely triggered when starting a new subtree
1995            such as when entering a subrule in automatic mode and when
1996            building a tree in rewrite mode.
1997            If you are receiving this event over a socket via
1998            RemoteDebugEventSocketListener then only t.ID is set.
1999            </remarks>
2000        </member>
2001        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.ErrorNode(System.Object)">
2002            <summary>
2003            Upon syntax error, recognizers bracket the error with an error node
2004            if they are building ASTs.
2005            </summary>
2006            <param name="t">The object</param>
2007        </member>
2008        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object)">
2009            <summary>
2010            Announce a new node built from token elements such as type etc...
2011            </summary>
2012            <remarks>
2013            If you are receiving this event over a socket via
2014            RemoteDebugEventSocketListener then only t.ID, type,
2015            text are set.
2016            </remarks>
2017        </member>
2018        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.CreateNode(System.Object,Antlr.Runtime.IToken)">
2019            <summary>
2020            Announce a new node built from an existing token.
2021            </summary>
2022            <remarks>
2023            If you are receiving this event over a socket via
2024            RemoteDebugEventSocketListener then only node.ID
2025            and token.tokenIndex are set.
2026            </remarks>
2027        </member>
2028        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.BecomeRoot(System.Object,System.Object)">
2029            <summary>
2030            Make a node the new root of an existing root.
2031            </summary>
2032            <remarks>
2033            Note: the newRootID parameter is possibly different
2034            than the TreeAdaptor.BecomeRoot() newRoot parameter.
2035            In our case, it will always be the result of calling
2036            TreeAdaptor.BecomeRoot() and not root_n or whatever.
2037            The listener should assume that this event occurs
2038            only when the current subrule (or rule) subtree is
2039            being reset to newRootID.
2040            <see cref="M:Antlr.Runtime.Tree.ITreeAdaptor.BecomeRoot(System.Object,System.Object)" />
2041            If you are receiving this event over a socket via
2042            RemoteDebugEventSocketListener then only IDs are set.
2043            </remarks>
2044        </member>
2045        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.AddChild(System.Object,System.Object)">
2046            <summary>
2047            Make childID a child of rootID.
2048            </summary>
2049            <remarks>
2050            If you are receiving this event over a socket via
2051            RemoteDebugEventSocketListener then only IDs are set.
2052            </remarks>
2053            <see cref="M:Antlr.Runtime.Tree.ITreeAdaptor.AddChild(System.Object,System.Object)" />
2054        </member>
2055        <member name="M:Antlr.Runtime.Debug.IDebugEventListener.SetTokenBoundaries(System.Object,System.Int32,System.Int32)">
2056            <summary>
2057            Set the token start/stop token index for a subtree root or node
2058            </summary>
2059            <remarks>
2060            If you are receiving this event over a socket via
2061            RemoteDebugEventSocketListener then only IDs are set.
2062            </remarks>
2063        </member>
2064        <member name="T:Antlr.Runtime.Debug.DebugTreeAdaptor">
2065            <summary>
2066            A TreeAdaptor proxy that fires debugging events to a DebugEventListener
2067            delegate and uses the TreeAdaptor delegate to do the actual work.  All
2068            AST events are triggered by this adaptor; no code gen changes are needed
2069            in generated rules.  Debugging events are triggered *after* invoking
2070            tree adaptor routines.
2071            Trees created with actions in rewrite actions like "-&gt; ^(ADD {foo} {bar})"
2072            cannot be tracked as they might not use the adaptor to create foo, bar.
2073            The debug listener has to deal with tree node IDs for which it did
2074            not see a CreateNode event.  A single &lt;unknown&gt; node is sufficient even
2075            if it represents a whole tree.
2076            </summary>
2077        </member>
2078        <member name="M:Antlr.Runtime.Debug.DebugTreeAdaptor.SimulateTreeConstruction(System.Object)">
2079             ^(A B C): emit create A, create B, add child, ...</member>
2080        <member name="T:Antlr.Runtime.Constants">
2081            <summary>
2082            Global constants
2083            </summary>
2084        </member>
2085        <member name="T:Antlr.Runtime.Messages">
2086            <summary>
2087            A strongly-typed resource class, for looking up localized strings, etc.
2088            </summary>
2089        </member>
2090        <member name="P:Antlr.Runtime.Messages.ResourceManager">
2091            <summary>
2092            Returns the cached ResourceManager instance used by this class.
2093            </summary>
2094        </member>
2095        <member name="P:Antlr.Runtime.Messages.Culture">
2096            <summary>
2097            Overrides the current thread's CurrentUICulture property for all
2098            resource lookups using this strongly typed resource class.
2099            </summary>
2100        </member>
2101        <member name="T:Antlr.Runtime.Debug.DebugTreeNodeStream">
2102            <summary>
2103            Debug any tree node stream.  The constructor accepts the stream
2104            and a debug listener.  As node stream calls come in, debug events
2105            are triggered.
2106            </summary>
2107        </member>
2108        <member name="F:Antlr.Runtime.Debug.DebugTreeNodeStream.lastMarker">
2109            <summary>Track the last mark() call result value for use in rewind().</summary>
2110        </member>
2111        <member name="P:Antlr.Runtime.Debug.DebugTreeNodeStream.HasUniqueNavigationNodes">
2112            <summary>
2113            It is normally this object that instructs the node stream to
2114            create unique nav nodes, but to satisfy interface, we have to
2115            define it.  It might be better to ignore the parameter but
2116            there might be a use for it later, so I'll leave.
2117            </summary>
2118        </member>
2119        <member name="T:Antlr.Runtime.Debug.BlankDebugEventListener">
2120            <summary>
2121            A blank listener that does nothing; useful for real classes so
2122            they don't have to have lots of blank methods and are less
2123            sensitive to updates to debug interface.
2124            </summary>
2125        </member>
2126        <member name="F:Antlr.Runtime.Debug.RemoteDebugEventSocketListener.version">
2127            <summary>Version of ANTLR (dictates events)</summary>
2128        </member>
2129        <member name="F:Antlr.Runtime.Debug.RemoteDebugEventSocketListener.previousTokenIndex">
2130            <summary>
2131            Track the last token index we saw during a consume.  If same, then
2132            set a flag that we have a problem.
2133            </summary>
2134        </member>
2135        <member name="M:Antlr.Runtime.Debug.RemoteDebugEventSocketListener.start">
2136            <summary>Create a thread to listen to the remote running recognizer </summary>
2137        </member>
2138        <member name="T:Antlr.Runtime.Debug.TraceDebugEventListener">
2139            <summary>
2140            Print out (most of) the events... Useful for debugging, testing...
2141            </summary>
2142        </member>
2143        <member name="T:Antlr.Runtime.Debug.DebugEventHub">
2144            <summary>
2145            Broadcast debug events to multiple listeners.
2146            </summary>
2147            <remarks>
2148            Lets you debug and still use the event mechanism to build
2149            parse trees etc...
2150            Not thread-safe. Don't add events in one thread while parser
2151            fires events in another.
2152            </remarks>
2153        </member>
2154        <member name="M:Antlr.Runtime.Debug.DebugEventHub.AddListener(Antlr.Runtime.Debug.IDebugEventListener)">
2155            <summary>
2156            Add another listener to broadcast events too.
2157            </summary>
2158            <remarks>
2159            Not thread-safe. Don't add events in one thread while parser
2160            fires events in another.
2161            </remarks>
2162        </member>
2163        <member name="T:Antlr.Runtime.Debug.DebugEventRepeater">
2164            <summary>
2165            A simple event repeater (proxy) that delegates all functionality to
2166            the listener sent into the ctor.
2167            </summary>
2168            <remarks>
2169            Useful if you want to listen in on a few debug events w/o
2170            interrupting the debugger.  Just subclass the repeater and override
2171            the methods you want to listen in on.  Remember to call the method
2172            in this class so the event will continue on to the original recipient.
2173            </remarks>
2174        </member>
2175        <member name="M:Antlr.Runtime.Debug.DebugTreeParser.#ctor(Antlr.Runtime.Tree.ITreeNodeStream,Antlr.Runtime.Debug.IDebugEventListener,Antlr.Runtime.RecognizerSharedState)">
2176            <summary>
2177            Create a normal parser except wrap the token stream in a debug
2178            proxy that fires consume events.
2179            </summary>
2180        </member>
2181        <member name="F:Antlr.Runtime.Debug.DebugTreeParser.dbg">
2182            <summary>Who to notify when events in the parser occur.</summary>
2183        </member>
2184        <member name="F:Antlr.Runtime.Debug.DebugTreeParser.isCyclicDecision">
2185            <summary>
2186            Used to differentiate between fixed lookahead and cyclic DFA decisions
2187            while profiling.
2188            </summary>
2189        </member>
2190        <member name="P:Antlr.Runtime.Debug.DebugTreeParser.DebugListener">
2191            <summary>
2192            Provide a new debug event listener for this parser.  Notify the
2193            input stream too that it should send events to this listener.
2194            </summary>
2195        </member>
2196        <member name="T:Antlr.Runtime.Debug.ParseTreeBuilder">
2197            <summary>
2198            This parser listener tracks rule entry/exit and token matches
2199            to build a simple parse tree using ParseTree nodes.
2200            </summary>
2201        </member>
2202        <member name="M:Antlr.Runtime.Debug.ParseTreeBuilder.Create(System.Object)">
2203            <summary>
2204            What kind of node to create.  You might want to override
2205            so I factored out creation here.
2206            </summary>
2207        </member>
2208        <member name="M:Antlr.Runtime.Debug.ParseTreeBuilder.EnterDecision(System.Int32)">
2209             Backtracking or cyclic DFA, don't want to add nodes to tree</member>
2210        <member name="T:Antlr.Runtime.Debug.Profiler">
2211            <summary>
2212            Using the debug event interface, track what is happening in the parser
2213            and record statistics about the runtime.
2214            </summary>
2215        </member>
2216        <member name="F:Antlr.Runtime.Debug.Profiler.Version">
2217            <summary>
2218            Because I may change the stats, I need to track that for later
2219            computations to be consistent.
2220            </summary>
2221        </member>
2222        <member name="M:Antlr.Runtime.Debug.Profiler.ExamineRuleMemoization(Antlr.Runtime.IIntStream,System.Int32,System.String)">
2223            <summary>Track memoization</summary>
2224            <remarks>
2225            This is not part of standard debug interface but is triggered by
2226            profiling.  Code gen inserts an override for this method in the
2227            recognizer, which triggers this method.
2228            </remarks>
2229        </member>
2230        <member name="M:Antlr.Runtime.Debug.Profiler.InDecision">
2231            <summary>
2232            The parser is in a decision if the decision depth &gt; 0.  This works
2233            for backtracking also, which can have nested decisions.
2234            </summary>
2235        </member>
2236        <member name="M:Antlr.Runtime.Debug.Profiler.LT(System.Int32,Antlr.Runtime.IToken)">
2237            <summary>
2238            Track refs to lookahead if in a fixed/nonfixed decision.
2239            </summary>
2240        </member>
2241        <member name="M:Antlr.Runtime.Debug.Profiler.BeginBacktrack(System.Int32)">
2242            <summary>
2243            Track backtracking decisions.  You'll see a fixed or cyclic decision
2244            and then a backtrack.
2245            </summary>
2246            <remarks>
2247                enter rule
2248                ...
2249                enter decision
2250                LA and possibly consumes (for cyclic DFAs)
2251                begin backtrack level
2252                mark m
2253                rewind m
2254                end backtrack level, success
2255                exit decision
2256                ...
2257                exit rule
2258            </remarks>
2259        </member>
2260        <member name="M:Antlr.Runtime.Debug.Profiler.EndBacktrack(System.Int32,System.Boolean)">
2261            <summary>Successful or not, track how much lookahead synpreds use</summary>
2262        </member>
2263        <member name="M:Antlr.Runtime.Debug.Profiler.GetNumberOfHiddenTokens(System.Int32,System.Int32)">
2264            <summary>Get num hidden tokens between i..j inclusive</summary>
2265        </member>
2266        <member name="T:Antlr.Runtime.Debug.Tracer">
2267            <summary>
2268            The default tracer mimics the traceParser behavior of ANTLR 2.x.
2269            This listens for debugging events from the parser and implies
2270            that you cannot debug and trace at the same time.
2271            </summary>
2272        </member>
2273        <member name="T:Antlr.Runtime.Misc.Stats">
2274            <summary>Stats routines needed by profiler etc...</summary>
2275            <remarks>
2276            Note that these routines return 0.0 if no values exist in X[]
2277            which is not "correct" but, it is useful so I don't generate NaN
2278            in my output
2279            </remarks>
2280        </member>
2281        <member name="M:Antlr.Runtime.Misc.Stats.Stddev(System.Int32[])">
2282            <summary>Compute the sample (unbiased estimator) standard deviation</summary>
2283            <remarks>
2284            The computation follows:
2285            Computing Deviations: Standard Accuracy
2286            Tony F. Chan and John Gregg Lewis
2287            Stanford University
2288            Communications of ACM September 1979 of Volume 22 the ACM Number 9
2289            The "two-pass" method from the paper; supposed to have better
2290            numerical properties than the textbook summation/sqrt.  To me
2291            this looks like the textbook method, but I ain't no numerical
2292            methods guy.
2293            </remarks>
2294        </member>
2295        <member name="M:Antlr.Runtime.Misc.Stats.Avg(System.Int32[])">
2296            <summary>Compute the sample mean</summary>
2297        </member>
2298        <member name="T:Antlr.Runtime.Misc.ErrorManager">
2299            <summary>A minimal ANTLR3 error [message] manager with the ST bits</summary>
2300        </member>
2301        <member name="M:Antlr.Runtime.Misc.ErrorManager.GetLastNonErrorManagerCodeLocation(System.Exception)">
2302            <summary>
2303            Return first non ErrorManager code location for generating messages
2304            </summary>
2305            <param name="e">Current exception</param>
2306            <returns>
2307            </returns>
2308        </member>
2309        <member name="T:Antlr.Runtime.Tree.TreeWizard">
2310            <summary>
2311            Build and navigate trees with this object.  Must know about the names
2312            of tokens so you have to pass in a map or array of token names (from which
2313            this class can build the map).  I.e., Token DECL means nothing unless the
2314            class can translate it to a token type.
2315            </summary>
2316            <remarks>
2317            In order to create nodes and navigate, this class needs a TreeAdaptor.
2318            This class can build a token type -&gt; node index for repeated use or for
2319            iterating over the various nodes with a particular type.
2320            This class works in conjunction with the TreeAdaptor rather than moving
2321            all this functionality into the adaptor.  An adaptor helps build and
2322            navigate trees using methods.  This class helps you do it with string
2323            patterns like "(A B C)".  You can create a tree from that pattern or
2324            match subtrees against it.
2325            </remarks>
2326        </member>
2327        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePattern">
2328            <summary>
2329            When using %label:TOKENNAME in a tree for parse(), we must track the label.
2330            </summary>
2331        </member>
2332        <member name="T:Antlr.Runtime.Tree.TreeWizard.TreePatternTreeAdaptor">
2333            <summary>
2334            This adaptor creates TreePattern objects for use during scan()
2335            </summary>
2336        </member>
2337        <member name="M:Antlr.Runtime.Tree.TreeWizard.ComputeTokenTypes(System.String[])">
2338            <summary>
2339            Compute a Map&lt;String, Integer&gt; that is an inverted index of
2340            tokenNames (which maps int token types to names).
2341            </summary>
2342        </member>
2343        <member name="M:Antlr.Runtime.Tree.TreeWizard.GetTokenType(System.String)">
2344            <summary>
2345            Using the map of token names to token types, return the type.
2346            </summary>
2347        </member>
2348        <member name="M:Antlr.Runtime.Tree.TreeWizard.Index(System.Object)">
2349            <summary>
2350            Walk the entire tree and make a node name to nodes mapping.
2351            </summary>
2352            <remarks>
2353            For now, use recursion but later nonrecursive version may be
2354            more efficient.  Returns Map&lt;Integer, List&gt; where the List is
2355            of your AST node type.  The Integer is the token type of the node.
2356            TODO: save this index so that find and visit are faster
2357            </remarks>
2358        </member>
2359        <member name="M:Antlr.Runtime.Tree.TreeWizard._Index(System.Object,System.Collections.IDictionary)">
2360            <summary>Do the work for index</summary>
2361        </member>
2362        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.Int32)">
2363            <summary>Return a List of tree nodes with token type ttype</summary>
2364        </member>
2365        <member name="M:Antlr.Runtime.Tree.TreeWizard.Find(System.Object,System.String)">
2366            <summary>Return a List of subtrees matching pattern</summary>
2367        </member>
2368        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.Int32,Antlr.Runtime.Tree.TreeWizard.ContextVisitor)">
2369            <summary>
2370            Visit every ttype node in t, invoking the visitor.
2371            </summary>
2372            <remarks>
2373            This is a quicker
2374            version of the general visit(t, pattern) method.  The labels arg
2375            of the visitor action method is never set (it's null) since using
2376            a token type rather than a pattern doesn't let us set a label.
2377            </remarks>
2378        </member>
2379        <member name="M:Antlr.Runtime.Tree.TreeWizard._Visit(System.Object,System.Object,System.Int32,System.Int32,Antlr.Runtime.Tree.TreeWizard.ContextVisitor)">
2380            <summary>Do the recursive work for visit</summary>
2381        </member>
2382        <member name="M:Antlr.Runtime.Tree.TreeWizard.Visit(System.Object,System.String,Antlr.Runtime.Tree.TreeWizard.ContextVisitor)">
2383            <summary>
2384            For all subtrees that match the pattern, execute the visit action.
2385            </summary>
2386            <remarks>
2387            The implementation uses the root node of the pattern in combination
2388            with visit(t, ttype, visitor) so nil-rooted patterns are not allowed.
2389            Patterns with wildcard roots are also not allowed.
2390            </remarks>
2391        </member>
2392        <member name="M:Antlr.Runtime.Tree.TreeWizard.Parse(System.Object,System.String,System.Collections.IDictionary)">
2393            <summary>
2394            Given a pattern like (ASSIGN %lhs:ID %rhs:.) with optional labels
2395            on the various nodes and '.' (dot) as the node/subtree wildcard,
2396            return true if the pattern matches and fill the labels Map with
2397            the labels pointing at the appropriate nodes.  Return false if
2398            the pattern is malformed or the tree does not match.
2399            </summary>
2400            <remarks>
2401            If a node specifies a text arg in pattern, then that must match
2402            for that node in t.
2403            TODO: what's a better way to indicate bad pattern? Exceptions are a hassle
2404            </remarks>
2405        </member>
2406        <member name="M:Antlr.Runtime.Tree.TreeWizard._Parse(System.Object,Antlr.Runtime.Tree.TreeWizard.TreePattern,System.Collections.IDictionary)">
2407            <summary>
2408            Do the work for Parse(). Check to see if the t2 pattern fits the
2409            structure and token types in t1.  Check text if the pattern has
2410            text arguments on nodes.  Fill labels map with pointers to nodes
2411            in tree matched against nodes in pattern with labels.
2412            </summary>
2413        </member>
2414        <member name="M:Antlr.Runtime.Tree.TreeWizard.Create(System.String)">
2415            <summary>
2416            Create a tree or node from the indicated tree pattern that closely
2417            follows ANTLR tree grammar tree element syntax:
2418                        (root child1 ... child2).
2419            </summary>
2420            <remarks>
2421            You can also just pass in a node: ID
2422            Any node can have a text argument: ID[foo]
2423            (notice there are no quotes around foo--it's clear it's a string).
2424            nil is a special name meaning "give me a nil node".  Useful for
2425            making lists: (nil A B C) is a list of A B C.
2426            </remarks>
2427        </member>
2428        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object,Antlr.Runtime.Tree.ITreeAdaptor)">
2429            <summary>
2430            Compare t1 and t2; return true if token types/text, structure match exactly.
2431            The trees are examined in their entirety so that (A B) does not match
2432            (A B C) nor (A (B C)).
2433            </summary>
2434            <remarks>
2435            TODO: allow them to pass in a comparator
2436            TODO: have a version that is nonstatic so it can use instance adaptor
2437            I cannot rely on the tree node's equals() implementation as I make
2438            no constraints at all on the node types nor interface etc...
2439            </remarks>
2440        </member>
2441        <member name="M:Antlr.Runtime.Tree.TreeWizard.Equals(System.Object,System.Object)">
2442            <summary>
2443            Compare type, structure, and text of two trees, assuming adaptor in
2444            this instance of a TreeWizard.
2445            </summary>
2446        </member>
2447        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.pattern">
2448            <summary>The tree pattern to lex like "(A B C)"</summary>
2449        </member>
2450        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.p">
2451            <summary>Index into input string</summary>
2452        </member>
2453        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.c">
2454            <summary>Current char</summary>
2455        </member>
2456        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.n">
2457            <summary>How long is the pattern in char?</summary>
2458        </member>
2459        <member name="F:Antlr.Runtime.Tree.TreePatternLexer.sval">
2460            <summary>
2461            Set when token type is ID or ARG (name mimics Java's StreamTokenizer)
2462            </summary>
2463        </member>
2464        <member name="T:Antlr.Runtime.Tree.RewriteRuleNodeStream">
2465            <summary>
2466            Queues up nodes matched on left side of -&gt; in a tree parser. This is
2467            the analog of RewriteRuleTokenStream for normal parsers.
2468            </summary>
2469        </member>
2470        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
2471            <summary>Create a stream with one element</summary>
2472        </member>
2473        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.Generic.IList{System.Object})">
2474            <summary>Create a stream, but feed off an existing list</summary>
2475        </member>
2476        <member name="M:Antlr.Runtime.Tree.RewriteRuleNodeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
2477            <summary>Create a stream, but feed off an existing list</summary>
2478        </member>
2479        <member name="T:Antlr.Runtime.Tree.RewriteCardinalityException">
2480            <summary>Base class for all exceptions thrown during AST rewrite construction.</summary>
2481            <remarks>
2482            This signifies a case where the cardinality of two or more elements
2483            in a subrule are different: (ID INT)+ where |ID|!=|INT|
2484            </remarks>
2485        </member>
2486        <member name="P:Antlr.Runtime.Tree.RewriteCardinalityException.Message">
2487            <summary>
2488            Returns the line at which the error occurred (for lexers)
2489            </summary>
2490        </member>
2491        <member name="T:Antlr.Runtime.Tree.RewriteEarlyExitException">
2492            <summary>
2493            No elements within a (...)+ in a rewrite rule
2494            </summary>
2495        </member>
2496        <member name="T:Antlr.Runtime.Tree.RewriteEmptyStreamException">
2497            <summary>
2498            Ref to ID or expr but no tokens in ID stream or subtrees in expr stream
2499            </summary>
2500        </member>
2501        <member name="T:Antlr.Runtime.Tree.RewriteRuleElementStream`1">
2502            <summary>
2503            A generic list of elements tracked in an alternative to be used in
2504            a -&gt; rewrite rule.  We need to subclass to fill in the next() method,
2505            which returns either an AST node wrapped around a token payload or
2506            an existing subtree.
2507            Once you start next()ing, do not try to add more elements.  It will
2508            break the cursor tracking I believe.
2509            <see cref="T:Antlr.Runtime.Tree.RewriteRuleSubtreeStream" /><see cref="T:Antlr.Runtime.Tree.RewriteRuleTokenStream" />
2510            TODO: add mechanism to detect/puke on modification after reading from stream
2511            </summary>
2512        </member>
2513        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream`1.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,`0)">
2514            <summary>
2515            Create a stream with one element
2516            </summary>
2517        </member>
2518        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream`1.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.Generic.IList{`0})">
2519            <summary>
2520            Create a stream, but feed off an existing list
2521            </summary>
2522        </member>
2523        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream`1.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
2524            <summary>
2525            Create a stream, but feed off an existing list
2526            </summary>
2527        </member>
2528        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream`1.cursor">
2529            <summary>
2530            Cursor 0..n-1.  If singleElement!=null, cursor is 0 until you next(),
2531            which bumps it to 1 meaning no more elements.
2532            </summary>
2533        </member>
2534        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream`1.singleElement">
2535            <summary>
2536            Track single elements w/o creating a list.  Upon 2nd add, alloc list
2537            </summary>
2538        </member>
2539        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream`1.elements">
2540            <summary>
2541            The list of tokens or subtrees we are tracking
2542            </summary>
2543        </member>
2544        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream`1.dirty">
2545            <summary>
2546            Tracks whether a node or subtree has been used in a stream
2547            </summary>
2548            <remarks>
2549            Once a node or subtree has been used in a stream, it must be dup'd
2550            from then on.  Streams are reset after subrules so that the streams
2551            can be reused in future subrules.  So, reset must set a dirty bit.
2552            If dirty, then next() always returns a dup.
2553            </remarks>
2554        </member>
2555        <member name="F:Antlr.Runtime.Tree.RewriteRuleElementStream`1.elementDescription">
2556            <summary>
2557            The element or stream description; usually has name of the token or
2558            rule reference that this list tracks.  Can include rulename too, but
2559            the exception would track that info.
2560            </summary>
2561        </member>
2562        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream`1.Reset">
2563            <summary>
2564            Reset the condition of this stream so that it appears we have
2565            not consumed any of its elements.  Elements themselves are untouched.
2566            </summary>
2567            <remarks>
2568            Once we reset the stream, any future use will need duplicates.  Set
2569            the dirty bit.
2570            </remarks>
2571        </member>
2572        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream`1.NextTree">
2573            <summary>
2574            Return the next element in the stream.
2575            </summary>
2576        </member>
2577        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream`1._Next">
2578            <summary>
2579            Do the work of getting the next element, making sure that
2580            it's a tree node or subtree.
2581            </summary>
2582            <remarks>
2583            Deal with the optimization of single-element list versus
2584            list of size &gt; 1.  Throw an exception if the stream is
2585            empty or we're out of elements and size&gt;1.
2586            </remarks>
2587        </member>
2588        <member name="M:Antlr.Runtime.Tree.RewriteRuleElementStream`1.ToTree(`0)">
2589            <summary>
2590            Ensure stream emits trees; tokens must be converted to AST nodes.
2591            AST nodes can be passed through unmolested.
2592            </summary>
2593        </member>
2594        <member name="T:Antlr.Runtime.Tree.RewriteRuleSubtreeStream">
2595            <summary>
2596            </summary>
2597            <remarks>
2598            </remarks>
2599            <example>
2600            </example>
2601        </member>
2602        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Object)">
2603            <summary>
2604            Create a stream with one element
2605            </summary>
2606        </member>
2607        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.Generic.IList{System.Object})">
2608            <summary>Create a stream, but feed off an existing list</summary>
2609        </member>
2610        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
2611            <summary>Create a stream, but feed off an existing list</summary>
2612        </member>
2613        <member name="T:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.ProcessHandler">
2614            <summary>
2615            This delegate is used to allow the outfactoring of some common code.
2616            </summary>
2617            <param name="o">The to be processed object</param>
2618        </member>
2619        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.NextNode">
2620            <summary>
2621            Treat next element as a single node even if it's a subtree.
2622            </summary>
2623            <remarks>
2624            This is used instead of next() when the result has to be a
2625            tree root node.  Also prevents us from duplicating recently-added
2626            children; e.g., ^(type ID)+ adds ID to type and then 2nd iteration
2627            must dup the type node, but ID has been added.
2628            Referencing a rule result twice is ok; dup entire tree as
2629            we can't be adding trees as root; e.g., expr expr.
2630            </remarks>
2631        </member>
2632        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.FetchObject(Antlr.Runtime.Tree.RewriteRuleSubtreeStream.ProcessHandler)">
2633            <summary>
2634            This method has the common code of two other methods, which differed in only one
2635            function call.
2636            </summary>
2637            <param name="ph">The delegate, which has the chosen function</param>
2638            <returns>The required object</returns>
2639        </member>
2640        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.RequiresDuplication">
2641            <summary>
2642            Tests, if the to be returned object requires duplication
2643            </summary>
2644            <returns>
2645                <code>true</code>, if positive, <code>false</code>, if negative.</returns>
2646        </member>
2647        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.NextTree">
2648            <summary>
2649            Return the next element in the stream.
2650            </summary>
2651            <remarks>
2652            If out of elements, throw an exception unless Count==1.
2653            If Count is 1, then return elements[0].
2654            Return a duplicate node/subtree if stream is out of
2655            elements and Count==1.
2656            If we've already used the element, dup (dirty bit set).
2657            </remarks>
2658        </member>
2659        <member name="M:Antlr.Runtime.Tree.RewriteRuleSubtreeStream.Dup(System.Object)">
2660            <summary>
2661            When constructing trees, sometimes we need to dup a token or AST
2662            subtree. Dup'ing a token means just creating another AST node
2663            around it. For trees, you must call the adaptor.dupTree()
2664            unless the element is for a tree root; then it must be a node dup
2665            </summary>
2666        </member>
2667        <member name="T:Antlr.Runtime.Tree.RewriteRuleTokenStream">
2668            <summary>
2669            </summary>
2670            <remarks>
2671            </remarks>
2672            <example>
2673            </example>
2674        </member>
2675        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,Antlr.Runtime.IToken)">
2676            <summary>
2677            Create a stream with one element
2678            </summary>
2679        </member>
2680        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.Generic.IList{Antlr.Runtime.IToken})">
2681            <summary>Create a stream, but feed off an existing list</summary>
2682        </member>
2683        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.#ctor(Antlr.Runtime.Tree.ITreeAdaptor,System.String,System.Collections.IList)">
2684            <summary>Create a stream, but feed off an existing list</summary>
2685        </member>
2686        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.NextNode">
2687            <summary>
2688            Get next token from stream and make a node for it.
2689            </summary>
2690            <remarks>
2691            ITreeAdaptor.Create() returns an object, so no further restrictions possible.
2692            </remarks>
2693        </member>
2694        <member name="M:Antlr.Runtime.Tree.RewriteRuleTokenStream.ToTree(Antlr.Runtime.IToken)">
2695            <summary>
2696            Don't convert to a tree unless they explicitly call NextTree().
2697            This way we can do hetero tree nodes in rewrite.
2698            </summary>
2699        </member>
2700        <member name="T:Antlr.Runtime.Tree.UnBufferedTreeNodeStream">
2701            <summary>
2702            A stream of tree nodes, accessing nodes from a tree of ANY kind.
2703            </summary>
2704            <remarks>
2705            No new nodes should be created in tree during the walk.  A small buffer
2706            of tokens is kept to efficiently and easily handle LT(i) calls, though
2707            the lookahead mechanism is fairly complicated.
2708            For tree rewriting during tree parsing, this must also be able
2709            to replace a set of children without "losing its place".
2710            That part is not yet implemented.  Will permit a rule to return
2711            a different tree and have it stitched into the output tree probably.
2712            <see cref="T:Antlr.Runtime.Tree.CommonTreeNodeStream" /></remarks>
2713        </member>
2714        <member name="T:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.TreeWalkState">
2715            <summary>
2716            When walking ahead with cyclic DFA or for syntactic predicates,
2717            we need to record the state of the tree node stream.  This
2718            class wraps up the current state of the UnBufferedTreeNodeStream.
2719            Calling Mark() will push another of these on the markers stack.
2720            </summary>
2721        </member>
2722        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.TreeWalkState.nodeStackSize">
2723            <summary>Record state of the nodeStack</summary>
2724        </member>
2725        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.TreeWalkState.indexStackSize">
2726            <summary>Record state of the indexStack</summary>
2727        </member>
2728        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.uniqueNavigationNodes">
2729            <summary>Reuse same DOWN, UP navigation nodes unless this is true</summary>
2730        </member>
2731        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.root">
2732            <summary>Pull nodes from which tree? </summary>
2733        </member>
2734        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.tokens">
2735            <summary>IF this tree (root) was created from a token stream, track it.</summary>
2736        </member>
2737        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.adaptor">
2738            <summary>What tree adaptor was used to build these trees</summary>
2739        </member>
2740        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.nodeStack">
2741            <summary>
2742            As we walk down the nodes, we must track parent nodes so we know
2743            where to go after walking the last child of a node.  When visiting
2744            a child, push current node and current index.
2745            </summary>
2746        </member>
2747        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.indexStack">
2748            <summary>
2749            Track which child index you are visiting for each node we push.
2750            TODO: pretty inefficient...use int[] when you have time
2751            </summary>
2752        </member>
2753        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.currentNode">
2754            <summary>Which node are we currently visiting? </summary>
2755        </member>
2756        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.previousNode">
2757            <summary>Which node did we visit last?  Used for LT(-1) calls. </summary>
2758        </member>
2759        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.currentChildIndex">
2760            <summary>
2761            Which child are we currently visiting?  If -1 we have not visited
2762            this node yet; next Consume() request will set currentIndex to 0.
2763            </summary>
2764        </member>
2765        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.absoluteNodeIndex">
2766            <summary>
2767            What node index did we just consume?  i=0..n-1 for n node trees.
2768            IntStream.next is hence 1 + this value.  Size will be same.
2769            </summary>
2770        </member>
2771        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.lookahead">
2772            <summary>
2773            Buffer tree node stream for use with LT(i).  This list grows
2774            to fit new lookahead depths, but Consume() wraps like a circular
2775            buffer.
2776            </summary>
2777        </member>
2778        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.head">
2779            <summary>lookahead[head] is the first symbol of lookahead, LT(1). </summary>
2780        </member>
2781        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.tail">
2782            <summary>
2783            Add new lookahead at lookahead[tail].  tail wraps around at the
2784            end of the lookahead buffer so tail could be less than head.
2785            </summary>
2786        </member>
2787        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.markers">
2788            <summary>
2789            Calls to Mark() may be nested so we have to track a stack of them.
2790            The marker is an index into this stack. This is a List&lt;TreeWalkState&gt;.
2791            Indexed from 1..markDepth. A null is kept at index 0. It is created
2792            upon first call to Mark().
2793            </summary>
2794        </member>
2795        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.markDepth">
2796            <summary>
2797            tracks how deep Mark() calls are nested
2798            </summary>
2799        </member>
2800        <member name="F:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.lastMarker">
2801            <summary>
2802            Track the last Mark() call result value for use in Rewind().
2803            </summary>
2804        </member>
2805        <member name="P:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.TreeSource">
2806            <summary>
2807            Where is this stream pulling nodes from?  This is not the name, but
2808            the object that provides node objects.
2809            </summary>
2810        </member>
2811        <member name="P:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.Count">
2812            <summary>
2813            Expensive to compute; recursively walk tree to find size;
2814            include navigation nodes and EOF.  Reuse functionality
2815            in CommonTreeNodeStream as we only really use this
2816            for testing.
2817            </summary>
2818        </member>
2819        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.MoveNext">
2820            <summary>
2821            Navigates to the next node found during a depth-first walk of root.
2822            Also, adds these nodes and DOWN/UP imaginary nodes into the lokoahead
2823            buffer as a side-effect.  Normally side-effects are bad, but because
2824            we can Emit many tokens for every MoveNext() call, it's pretty hard to
2825            use a single return value for that.  We must add these tokens to
2826            the lookahead buffer.
2827            This routine does *not* cause the 'Current' property to ever return the
2828            DOWN/UP nodes; those are only returned by the LT() method.
2829            Ugh.  This mechanism is much more complicated than a recursive
2830            solution, but it's the only way to provide nodes on-demand instead
2831            of walking once completely through and buffering up the nodes. :(
2832            </summary>
2833        </member>
2834        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.LT(System.Int32)">
2835            <summary>
2836            Get tree node at current input pointer + i ahead where i=1 is next node.
2837            i &lt; 0 indicates nodes in the past.  So -1 is previous node and -2 is
2838            two nodes ago. LT(0) is undefined.  For i&gt;=n, return null.
2839            Return null for LT(0) and any index that results in an absolute address
2840            that is negative.
2841            This is analogus to the LT() method of the TokenStream, but this
2842            returns a tree node instead of a token.  Makes code gen identical
2843            for both parser and tree grammars. :)
2844            </summary>
2845        </member>
2846        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.fill(System.Int32)">
2847            <summary>Make sure we have at least k symbols in lookahead buffer </summary>
2848        </member>
2849        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.AddLookahead(System.Object)">
2850            <summary>
2851            Add a node to the lookahead buffer.  Add at lookahead[tail].
2852            If you tail+1 == head, then we must create a bigger buffer
2853            and copy all the nodes over plus reset head, tail.  After
2854            this method, LT(1) will be lookahead[0].
2855            </summary>
2856        </member>
2857        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.Mark">
2858            <summary>
2859            Record the current state of the tree walk which includes
2860            the current node and stack state as well as the lookahead
2861            buffer.
2862            </summary>
2863        </member>
2864        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.Rewind(System.Int32)">
2865            <summary>
2866            Rewind the current state of the tree walk to the state it
2867            was in when Mark() was called and it returned marker.  Also,
2868            wipe out the lookahead which will force reloading a few nodes
2869            but it is better than making a copy of the lookahead buffer
2870            upon Mark().
2871            </summary>
2872        </member>
2873        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.Seek(System.Int32)">
2874            <summary>
2875            Consume() ahead until we hit index.  Can't just jump ahead--must
2876            spit out the navigation nodes.
2877            </summary>
2878        </member>
2879        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.Size">
2880            <summary>
2881            Expensive to compute; recursively walk tree to find size;
2882            include navigation nodes and EOF.  Reuse functionality
2883            in CommonTreeNodeStream as we only really use this
2884            for testing.
2885            </summary>
2886        </member>
2887        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.AddNavigationNode(System.Int32)">
2888            <summary>
2889            As we flatten the tree, we use UP, DOWN nodes to represent
2890            the tree structure.  When debugging we need unique nodes
2891            so instantiate new ones when uniqueNavigationNodes is true.
2892            </summary>
2893        </member>
2894        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.WalkBackToMostRecentNodeWithUnvisitedChildren">
2895            <summary>
2896            Walk upwards looking for a node with more children to walk.
2897            </summary>
2898        </member>
2899        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.ToString">
2900            <summary>
2901            Print out the entire tree including DOWN/UP nodes.  Uses
2902            a recursive walk.  Mostly useful for testing as it yields
2903            the token types not text.
2904            </summary>
2905        </member>
2906        <member name="M:Antlr.Runtime.Tree.UnBufferedTreeNodeStream.ToString(System.Object,System.Object)">
2907            <summary>TODO: not sure this is what we want for trees. </summary>
2908        </member>
2909        <member name="T:Antlr.Runtime.ANTLRInputStream">
2910            <summary>
2911            A character stream - an <see cref="T:Antlr.Runtime.ICharStream" /> - that loads
2912            and caches the contents of it's underlying
2913            <see cref="T:System.IO.Stream" /> fully during object construction
2914            </summary>
2915            <remarks>
2916            Useful for reading from stdin and, for specifying file encodings etc...
2917            </remarks>
2918        </member>
2919        <member name="M:Antlr.Runtime.ANTLRInputStream.#ctor">
2920            <summary>
2921            Initializes a new instance of the ANTLRInputStream class
2922            </summary>
2923        </member>
2924        <member name="M:Antlr.Runtime.ANTLRInputStream.#ctor(System.IO.Stream)">
2925            <summary>
2926            Initializes a new instance of the ANTLRInputStream class for the
2927            specified stream
2928            </summary>
2929        </member>
2930        <member name="M:Antlr.Runtime.ANTLRInputStream.#ctor(System.IO.Stream,System.Text.Encoding)">
2931            <summary>
2932            Initializes a new instance of the ANTLRInputStream class for the
2933            specified stream and encoding
2934            </summary>
2935        </member>
2936        <member name="M:Antlr.Runtime.ANTLRInputStream.#ctor(System.IO.Stream,System.Int32)">
2937            <summary>
2938            Initializes a new instance of the ANTLRInputStream class for the
2939            specified stream and initial data buffer size
2940            </summary>
2941        </member>
2942        <member name="M:Antlr.Runtime.ANTLRInputStream.#ctor(System.IO.Stream,System.Int32,System.Text.Encoding)">
2943            <summary>
2944            Initializes a new instance of the ANTLRInputStream class for the
2945            specified stream, encoding and initial data buffer size
2946            </summary>
2947        </member>
2948        <member name="M:Antlr.Runtime.ANTLRInputStream.#ctor(System.IO.Stream,System.Int32,System.Int32,System.Text.Encoding)">
2949            <summary>
2950            Initializes a new instance of the ANTLRInputStream class for the
2951            specified stream, encoding, initial data buffer size and, using
2952            a read buffer of the specified size
2953            </summary>
2954        </member>
2955        <member name="T:Antlr.Runtime.ANTLRReaderStream">
2956            <summary>
2957            An ANTLRStringStream that caches all the input from a TextReader. It
2958            behaves just like a plain ANTLRStringStream
2959            </summary>
2960            <remarks>
2961            Manages the buffer manually to avoid unnecessary data copying.
2962            If you need encoding, use ANTLRInputStream.
2963            </remarks>
2964        </member>
2965        <member name="M:Antlr.Runtime.ANTLRReaderStream.#ctor">
2966            <summary>
2967            Initializes a new instance of the ANTLRReaderStream class
2968            </summary>
2969        </member>
2970        <member name="M:Antlr.Runtime.ANTLRReaderStream.#ctor(System.IO.TextReader)">
2971            <summary>
2972            Initializes a new instance of the ANTLRReaderStream class for the
2973            specified TextReader
2974            </summary>
2975        </member>
2976        <member name="M:Antlr.Runtime.ANTLRReaderStream.#ctor(System.IO.TextReader,System.Int32)">
2977            <summary>
2978            Initializes a new instance of the ANTLRReaderStream class for the
2979            specified TextReader and initial data buffer size
2980            </summary>
2981        </member>
2982        <member name="M:Antlr.Runtime.ANTLRReaderStream.#ctor(System.IO.TextReader,System.Int32,System.Int32)">
2983            <summary>
2984            Initializes a new instance of the ANTLRReaderStream class for the
2985            specified TextReader, initial data buffer size and, using
2986            a read buffer of the specified size
2987            </summary>
2988        </member>
2989        <member name="F:Antlr.Runtime.ANTLRReaderStream.READ_BUFFER_SIZE">
2990            <summary>Default size (in characters) of the buffer used for IO reads</summary>
2991        </member>
2992        <member name="F:Antlr.Runtime.ANTLRReaderStream.INITIAL_BUFFER_SIZE">
2993            <summary>Initial size (in characters) of the data cache</summary>
2994        </member>
2995        <member name="M:Antlr.Runtime.ANTLRReaderStream.Load(System.IO.TextReader,System.Int32,System.Int32)">
2996            <summary>
2997            Loads and buffers the contents of the specified reader to be
2998            used as this ANTLRReaderStream's source
2999            </summary>
3000        </member>
3001        <member name="T:Antlr.Runtime.BaseRecognizer">
3002            <summary>
3003            A generic recognizer that can handle recognizers generated from
3004            lexer, parser, and tree grammars.  This is all the parsing
3005            support code essentially; most of it is error recovery stuff and
3006            backtracking.
3007            </summary>
3008        </member>
3009        <member name="F:Antlr.Runtime.BaseRecognizer.state">
3010            <summary>
3011            An externalized representation of the - shareable - internal state of
3012            this lexer, parser or tree parser.
3013            </summary>
3014            <remarks>
3015            The state of a lexer, parser, or tree parser are collected into
3016            external state objects so that the state can be shared. This sharing
3017            is needed to have one grammar import others and share same error
3018            variables and other state variables.  It's a kind of explicit multiple
3019            inheritance via delegation of methods and shared state.
3020            </remarks>
3021        </member>
3022        <member name="P:Antlr.Runtime.BaseRecognizer.NumberOfSyntaxErrors">
3023            <summary>
3024            Get number of recognition errors (lexer, parser, tree parser).  Each
3025            recognizer tracks its own number.  So parser and lexer each have
3026            separate count.  Does not count the spurious errors found between
3027            an error and next valid token match
3028            See also ReportError()
3029            </summary>
3030        </member>
3031        <member name="P:Antlr.Runtime.BaseRecognizer.GrammarFileName">
3032            <summary>
3033            For debugging and other purposes, might want the grammar name.
3034            Have ANTLR generate an implementation for this property.
3035            </summary>
3036            <returns>
3037            </returns>
3038        </member>
3039        <member name="P:Antlr.Runtime.BaseRecognizer.SourceName">
3040            <summary>
3041            For debugging and other purposes, might want the source name.
3042            Have ANTLR provide a hook for this property.
3043            </summary>
3044            <returns>The source name</returns>
3045        </member>
3046        <member name="P:Antlr.Runtime.BaseRecognizer.TokenNames">
3047            <summary>
3048            Used to print out token names like ID during debugging and
3049            error reporting.  The generated parsers implement a method
3050            that overrides this to point to their string[] tokenNames.
3051            </summary>
3052        </member>
3053        <member name="M:Antlr.Runtime.BaseRecognizer.Failed">
3054             Return whether or not a backtracking attempt failed.</member>
3055        <member name="M:Antlr.Runtime.BaseRecognizer.Reset">
3056            <summary>Reset the parser's state. Subclasses must rewind the input stream.</summary>
3057        </member>
3058        <member name="M:Antlr.Runtime.BaseRecognizer.Match(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
3059            <summary>
3060            Match current input symbol against ttype.  Attempt
3061            single token insertion or deletion error recovery.  If
3062            that fails, throw MismatchedTokenException.
3063            </summary>
3064            <remarks>
3065            To turn off single token insertion or deletion error
3066            recovery, override RecoverFromMismatchedToken() and have it call
3067            pthrow an exception. See TreeParser.RecoverFromMismatchedToken().
3068            This way any error in a rule will cause an exception and
3069            immediate exit from rule.  Rule would recover by resynchronizing
3070            to the set of symbols that can follow rule ref.
3071            </remarks>
3072        </member>
3073        <member name="M:Antlr.Runtime.BaseRecognizer.MatchAny(Antlr.Runtime.IIntStream)">
3074            <summary> Match the wildcard: in a symbol</summary>
3075        </member>
3076        <member name="M:Antlr.Runtime.BaseRecognizer.ReportError(Antlr.Runtime.RecognitionException)">
3077            <summary>
3078            Report a recognition problem.
3079            </summary>
3080            <remarks>
3081            This method sets errorRecovery to indicate the parser is recovering
3082            not parsing.  Once in recovery mode, no errors are generated.
3083            To get out of recovery mode, the parser must successfully Match
3084            a token (after a resync).  So it will go:
3085            1. error occurs
3086            2. enter recovery mode, report error
3087            3. consume until token found in resynch set
3088            4. try to resume parsing
3089            5. next Match() will reset errorRecovery mode
3090            If you override, make sure to update syntaxErrors if you care about that.
3091            </remarks>
3092        </member>
3093        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorMessage(Antlr.Runtime.RecognitionException,System.String[])">
3094            <summary>
3095            What error message should be generated for the various exception types?
3096            Not very object-oriented code, but I like having all error message generation
3097            within one method rather than spread among all of the exception classes. This
3098            also makes it much easier for the exception handling because the exception
3099            classes do not have to have pointers back to this object to access utility
3100            routines and so on. Also, changing the message for an exception type would be
3101            difficult because you would have to subclassing exception, but then somehow get
3102            ANTLR to make those kinds of exception objects instead of the default.
3103            This looks weird, but trust me--it makes the most sense in terms of flexibility.
3104            For grammar debugging, you will want to override this to add more information
3105            such as the stack frame with GetRuleInvocationStack(e, this.GetType().Fullname)
3106            and, for no viable alts, the decision description and state etc...
3107            Override this to change the message generated for one or more exception types.
3108            </summary>
3109        </member>
3110        <member name="M:Antlr.Runtime.BaseRecognizer.GetErrorHeader(Antlr.Runtime.RecognitionException)">
3111            <summary>
3112            What is the error header, normally line/character position information?
3113            </summary>
3114        </member>
3115        <member name="M:Antlr.Runtime.BaseRecognizer.GetTokenErrorDisplay(Antlr.Runtime.IToken)">
3116            <summary>
3117            How should a token be displayed in an error message? The default
3118            is to display just the text, but during development you might
3119            want to have a lot of information spit out.  Override in that case
3120            to use t.ToString() (which, for CommonToken, dumps everything about
3121            the token). This is better than forcing you to override a method in
3122            your token objects because you don't have to go modify your lexer
3123            so that it creates a new type.
3124            </summary>
3125        </member>
3126        <member name="M:Antlr.Runtime.BaseRecognizer.EmitErrorMessage(System.String)">
3127            <summary>
3128            Override this method to change where error messages go
3129            </summary>
3130        </member>
3131        <member name="M:Antlr.Runtime.BaseRecognizer.Recover(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException)">
3132            <summary>
3133            Recover from an error found on the input stream.  This is
3134            for NoViableAlt and mismatched symbol exceptions.  If you enable
3135            single token insertion and deletion, this will usually not
3136            handle mismatched symbol exceptions but there could be a mismatched
3137            token that the Match() routine could not recover from.
3138            </summary>
3139        </member>
3140        <member name="M:Antlr.Runtime.BaseRecognizer.BeginResync">
3141            <summary>A hook to listen in on the token consumption during error recovery.
3142            The DebugParser subclasses this to fire events to the listenter.
3143            </summary>
3144        </member>
3145        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedToken(Antlr.Runtime.IIntStream,System.Int32,Antlr.Runtime.BitSet)">
3146            <summary>
3147            Attempt to Recover from a single missing or extra token.
3148            </summary>
3149            <remarks>
3150            EXTRA TOKEN
3151            LA(1) is not what we are looking for.  If LA(2) has the right token,
3152            however, then assume LA(1) is some extra spurious token.  Delete it
3153            and LA(2) as if we were doing a normal Match(), which advances the
3154            input.
3155            MISSING TOKEN
3156            If current token is consistent with what could come after
3157            ttype then it is ok to "insert" the missing token, else throw
3158            exception For example, Input "i=(3;" is clearly missing the
3159            ')'.  When the parser returns from the nested call to expr, it
3160            will have call chain:
3161            stat -&gt; expr -&gt; atom
3162            and it will be trying to Match the ')' at this point in the
3163            derivation:
3164            =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
3165            ^
3166            Match() will see that ';' doesn't Match ')' and report a
3167            mismatched token error.  To Recover, it sees that LA(1)==';'
3168            is in the set of tokens that can follow the ')' token
3169            reference in rule atom.  It can assume that you forgot the ')'.
3170            </remarks>
3171        </member>
3172        <member name="M:Antlr.Runtime.BaseRecognizer.RecoverFromMismatchedSet(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,Antlr.Runtime.BitSet)">
3173             Not currently used</member>
3174        <member name="M:Antlr.Runtime.BaseRecognizer.ConsumeUntil(Antlr.Runtime.IIntStream,Antlr.Runtime.BitSet)">
3175            <summary>Consume tokens until one matches the given token set </summary>
3176        </member>
3177        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleInvocationStack">
3178            <summary>
3179            Returns List &lt;String&gt; of the rules in your parser instance
3180            leading up to a call to this method.  You could override if
3181            you want more details such as the file/line info of where
3182            in the parser source code a rule is invoked.
3183            </summary>
3184            <remarks>
3185            This is very useful for error messages and for context-sensitive
3186            error recovery.
3187            </remarks>
3188        </member>
3189        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleInvocationStack(System.Exception,System.String)">
3190            <summary>
3191            A more general version of GetRuleInvocationStack where you can
3192            pass in, for example, a RecognitionException to get it's rule
3193            stack trace.  This routine is shared with all recognizers, hence,
3194            static.
3195            TODO: move to a utility class or something; weird having lexer call this
3196            </summary>
3197        </member>
3198        <member name="M:Antlr.Runtime.BaseRecognizer.ToStrings(System.Collections.IList)">
3199            <summary>A convenience method for use most often with template rewrites.
3200            Convert a List&lt;Token&gt; to List&lt;String&gt;
3201            </summary>
3202        </member>
3203        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoization(System.Int32,System.Int32)">
3204            <summary>
3205            Given a rule number and a start token index number, return
3206            MEMO_RULE_UNKNOWN if the rule has not parsed input starting from
3207            start index.  If this rule has parsed input starting from the
3208            start index before, then return where the rule stopped parsing.
3209            It returns the index of the last token matched by the rule.
3210            </summary>
3211            <remarks>
3212            For now we use a hashtable and just the slow Object-based one.
3213            Later, we can make a special one for ints and also one that
3214            tosses out data after we commit past input position i.
3215            </remarks>
3216        </member>
3217        <member name="M:Antlr.Runtime.BaseRecognizer.AlreadyParsedRule(Antlr.Runtime.IIntStream,System.Int32)">
3218            <summary>
3219            Has this rule already parsed input at the current index in the
3220            input stream?  Return the stop token index or MEMO_RULE_UNKNOWN.
3221            If we attempted but failed to parse properly before, return
3222            MEMO_RULE_FAILED.
3223            This method has a side-effect: if we have seen this input for
3224            this rule and successfully parsed before, then seek ahead to
3225            1 past the stop token matched for this rule last time.
3226            </summary>
3227        </member>
3228        <member name="M:Antlr.Runtime.BaseRecognizer.Memoize(Antlr.Runtime.IIntStream,System.Int32,System.Int32)">
3229            <summary>
3230            Record whether or not this rule parsed the input at this position
3231            successfully.  Use a standard hashtable for now.
3232            </summary>
3233        </member>
3234        <member name="M:Antlr.Runtime.BaseRecognizer.GetRuleMemoizationCacheSize">
3235            <summary>
3236            Return how many rule/input-index pairs there are in total.
3237            TODO: this includes synpreds. :(
3238            </summary>
3239            <returns>
3240            </returns>
3241        </member>
3242        <member name="M:Antlr.Runtime.BaseRecognizer.ComputeErrorRecoverySet">
3243            <summary>
3244            Factor out what to do upon token mismatch so tree parsers can behave
3245            differently.  Override and call RecoverFromMismatchedToken()
3246            to get single token insertion and deletion. Use this to turn off
3247            single token insertion and deletion. Override mismatchRecover
3248            to call this instead.
3249            TODO: fix this comment, mismatchRecover doesn't exist, for example
3250            </summary>
3251        </member>
3252        <member name="M:Antlr.Runtime.BaseRecognizer.ComputeContextSensitiveRuleFOLLOW">
3253            <summary>Compute the context-sensitive FOLLOW set for current rule.
3254            This is set of token types that can follow a specific rule
3255            reference given a specific call chain.  You get the set of
3256            viable tokens that can possibly come next (lookahead depth 1)
3257            given the current call chain.  Contrast this with the
3258            definition of plain FOLLOW for rule r:
3259            FOLLOW(r)={x | S=&gt;*alpha r beta in G and x in FIRST(beta)}
3260            where x in T* and alpha, beta in V*; T is set of terminals and
3261            V is the set of terminals and nonterminals.  In other words,
3262            FOLLOW(r) is the set of all tokens that can possibly follow
3263            references to r in *any* sentential form (context).  At
3264            runtime, however, we know precisely which context applies as
3265            we have the call chain.  We may compute the exact (rather
3266            than covering superset) set of following tokens.
3267            For example, consider grammar:
3268            stat : ID '=' expr ';'      // FOLLOW(stat)=={EOF}
3269            | "return" expr '.'
3270            ;
3271            expr : atom ('+' atom)* ;   // FOLLOW(expr)=={';','.',')'}
3272            atom : INT                  // FOLLOW(atom)=={'+',')',';','.'}
3273            | '(' expr ')'
3274            ;
3275            The FOLLOW sets are all inclusive whereas context-sensitive
3276            FOLLOW sets are precisely what could follow a rule reference.
3277            For input input "i=(3);", here is the derivation:
3278            stat =&gt; ID '=' expr ';'
3279            =&gt; ID '=' atom ('+' atom)* ';'
3280            =&gt; ID '=' '(' expr ')' ('+' atom)* ';'
3281            =&gt; ID '=' '(' atom ')' ('+' atom)* ';'
3282            =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
3283            =&gt; ID '=' '(' INT ')' ';'
3284            At the "3" token, you'd have a call chain of
3285            stat -&gt; expr -&gt; atom -&gt; expr -&gt; atom
3286            What can follow that specific nested ref to atom?  Exactly ')'
3287            as you can see by looking at the derivation of this specific
3288            input.  Contrast this with the FOLLOW(atom)={'+',')',';','.'}.
3289            You want the exact viable token set when recovering from a
3290            token mismatch.  Upon token mismatch, if LA(1) is member of
3291            the viable next token set, then you know there is most likely
3292            a missing token in the input stream.  "Insert" one by just not
3293            throwing an exception.
3294            </summary>
3295        </member>
3296        <member name="M:Antlr.Runtime.BaseRecognizer.GetCurrentInputSymbol(Antlr.Runtime.IIntStream)">
3297            <summary>
3298            Match needs to return the current input symbol, which gets put
3299            into the label for the associated token ref; e.g., x=ID.  Token
3300            and tree parsers need to return different objects. Rather than test
3301            for input stream type or change the IntStream interface, I use
3302            a simple method to ask the recognizer to tell me what the current
3303            input symbol is.
3304            </summary>
3305            <remarks>This is ignored for lexers.</remarks>
3306        </member>
3307        <member name="M:Antlr.Runtime.BaseRecognizer.GetMissingSymbol(Antlr.Runtime.IIntStream,Antlr.Runtime.RecognitionException,System.Int32,Antlr.Runtime.BitSet)">
3308            <summary>
3309            Conjure up a missing token during error recovery.
3310            </summary>
3311            <remarks>
3312            The recognizer attempts to recover from single missing
3313            symbols. But, actions might refer to that missing symbol.
3314            For example, x=ID {f($x);}. The action clearly assumes
3315            that there has been an identifier matched previously and that
3316            $x points at that token. If that token is missing, but
3317            the next token in the stream is what we want we assume that
3318            this token is missing and we keep going. Because we
3319            have to return some token to replace the missing token,
3320            we have to conjure one up. This method gives the user control
3321            over the tokens returned for missing tokens. Mostly,
3322            you will want to create something special for identifier
3323            tokens. For literals such as '{' and ',', the default
3324            action in the parser or tree parser works. It simply creates
3325            a CommonToken of the appropriate type. The text will be the token.
3326            If you change what tokens must be created by the lexer,
3327            override this method to create the appropriate tokens.
3328            </remarks>
3329        </member>
3330        <member name="M:Antlr.Runtime.BaseRecognizer.PushFollow(Antlr.Runtime.BitSet)">
3331            <summary>
3332            Push a rule's follow set using our own hardcoded stack
3333            </summary>
3334            <param name="fset">
3335            </param>
3336        </member>
3337        <member name="T:Antlr.Runtime.CommonTokenStream">
3338            <summary>
3339            The most common stream of tokens is one where every token is buffered up
3340            and tokens are prefiltered for a certain channel (the parser will only
3341            see these tokens and cannot change the filter channel number during the
3342            parse).
3343            TODO: how to access the full token stream?  How to track all tokens matched per rule?
3344            </summary>
3345        </member>
3346        <member name="F:Antlr.Runtime.CommonTokenStream.tokens">
3347            <summary>Record every single token pulled from the source so we can reproduce
3348            chunks of it later.
3349            </summary>
3350        </member>
3351        <member name="F:Antlr.Runtime.CommonTokenStream.channelOverrideMap">
3352            <summary><![CDATA[Map<tokentype, channel>]]> to override some Tokens' channel numbers </summary>
3353        </member>
3354        <member name="F:Antlr.Runtime.CommonTokenStream.discardSet">
3355            <summary><![CDATA[Set<tokentype>;]]> discard any tokens with this type </summary>
3356        </member>
3357        <member name="F:Antlr.Runtime.CommonTokenStream.channel">
3358            <summary>Skip tokens on any channel but this one; this is how we skip whitespace... </summary>
3359        </member>
3360        <member name="F:Antlr.Runtime.CommonTokenStream.discardOffChannelTokens">
3361            <summary>By default, track all incoming tokens </summary>
3362        </member>
3363        <member name="F:Antlr.Runtime.CommonTokenStream.lastMarker">
3364            <summary>Track the last Mark() call result value for use in Rewind().</summary>
3365        </member>
3366        <member name="F:Antlr.Runtime.CommonTokenStream.p">
3367            <summary>
3368            The index into the tokens list of the current token (next token
3369            to consume).  p==-1 indicates that the tokens list is empty
3370            </summary>
3371        </member>
3372        <member name="P:Antlr.Runtime.CommonTokenStream.TokenSource">
3373            <summary>
3374            Gets or sets the token source for this stream (i.e. the source
3375            that supplies the stream with Token objects).
3376            </summary>
3377            <remarks>
3378            Setting the token source resets the stream.
3379            </remarks>
3380        </member>
3381        <member name="M:Antlr.Runtime.CommonTokenStream.LT(System.Int32)">
3382            <summary>Get the ith token from the current position 1..n where k=1 is the
3383            first symbol of lookahead.
3384            </summary>
3385        </member>
3386        <member name="M:Antlr.Runtime.CommonTokenStream.Get(System.Int32)">
3387            <summary>Return absolute token i; ignore which channel the tokens are on;
3388            that is, count all tokens not just on-channel tokens.
3389            </summary>
3390        </member>
3391        <member name="M:Antlr.Runtime.CommonTokenStream.Consume">
3392            <summary>Move the input pointer to the next incoming token.  The stream
3393            must become active with LT(1) available.  Consume() simply
3394            moves the input pointer so that LT(1) points at the next
3395            input symbol. Consume at least one token.
3396            Walk past any token not on the channel the parser is listening to.
3397            </summary>
3398        </member>
3399        <member name="M:Antlr.Runtime.CommonTokenStream.FillBuffer">
3400            <summary>Load all tokens from the token source and put in tokens.
3401            This is done upon first LT request because you might want to
3402            set some token type / channel overrides before filling buffer.
3403            </summary>
3404        </member>
3405        <member name="M:Antlr.Runtime.CommonTokenStream.SkipOffTokenChannels(System.Int32)">
3406            <summary>Given a starting index, return the index of the first on-channel
3407            token.
3408            </summary>
3409        </member>
3410        <member name="M:Antlr.Runtime.CommonTokenStream.SetTokenTypeChannel(System.Int32,System.Int32)">
3411            <summary>
3412            A simple filter mechanism whereby you can tell this token stream
3413            to force all tokens of type ttype to be on channel.
3414            </summary>
3415            <remarks>
3416            For example,
3417            when interpreting, we cannot exec actions so we need to tell
3418            the stream to force all WS and NEWLINE to be a different, ignored
3419            channel.
3420            </remarks>
3421        </member>
3422        <member name="M:Antlr.Runtime.CommonTokenStream.GetTokens(System.Int32,System.Int32,Antlr.Runtime.BitSet)">
3423            <summary>Given a start and stop index, return a List of all tokens in
3424            the token type BitSet.  Return null if no tokens were found.  This
3425            method looks at both on and off channel tokens.
3426            </summary>
3427        </member>
3428        <member name="M:Antlr.Runtime.CommonTokenStream.LB(System.Int32)">
3429            <summary>Look backwards k tokens on-channel tokens </summary>
3430        </member>
3431        <member name="T:Antlr.Runtime.RecognizerSharedState">
3432            <summary>
3433            The set of fields needed by an abstract recognizer to recognize input
3434            and recover from errors
3435            </summary>
3436            <remarks>
3437            As a separate state object, it can be shared among multiple grammars;
3438            e.g., when one grammar imports another.
3439            These fields are publicly visible but the actual state pointer per
3440            parser is protected.
3441            </remarks>
3442        </member>
3443        <member name="F:Antlr.Runtime.RecognizerSharedState.following">
3444            <summary>
3445            Tracks the set of token types that can follow any rule invocation.
3446            Stack grows upwards.  When it hits the max, it grows 2x in size
3447            and keeps going.
3448            </summary>
3449        </member>
3450        <member name="F:Antlr.Runtime.RecognizerSharedState.errorRecovery">
3451            <summary>
3452            This is true when we see an error and before having successfully
3453            matched a token.  Prevents generation of more than one error message
3454            per error.
3455            </summary>
3456        </member>
3457        <member name="F:Antlr.Runtime.RecognizerSharedState.lastErrorIndex">
3458            <summary>
3459            The index into the input stream where the last error occurred.
3460            </summary>
3461            <remarks>
3462            This is used to prevent infinite loops where an error is found
3463            but no token is consumed during recovery...another error is found,
3464            ad naseum.  This is a failsafe mechanism to guarantee that at least
3465            one token/tree node is consumed for two errors.
3466            </remarks>
3467        </member>
3468        <member name="F:Antlr.Runtime.RecognizerSharedState.failed">
3469            <summary>
3470            In lieu of a return value, this indicates that a rule or token
3471            has failed to match.  Reset to false upon valid token match.
3472            </summary>
3473        </member>
3474        <member name="F:Antlr.Runtime.RecognizerSharedState.syntaxErrors">
3475            <summary>
3476            Did the recognizer encounter a syntax error?  Track how many.
3477            </summary>
3478        </member>
3479        <member name="F:Antlr.Runtime.RecognizerSharedState.backtracking">
3480            <summary>
3481            If 0, no backtracking is going on.  Safe to exec actions etc...
3482            If &gt;0 then it's the level of backtracking.
3483            </summary>
3484        </member>
3485        <member name="F:Antlr.Runtime.RecognizerSharedState.ruleMemo">
3486            <summary>
3487            An array[size num rules] of Map&lt;Integer,Integer&gt; that tracks
3488            the stop token index for each rule.
3489            </summary>
3490            <remarks>
3491            ruleMemo[ruleIndex] is the memoization table for ruleIndex.
3492            For key ruleStartIndex, you get back the stop token for
3493            associated rule or MEMO_RULE_FAILED.
3494            This is only used if rule memoization is on (which it is by default).
3495            </remarks>
3496        </member>
3497        <member name="F:Antlr.Runtime.RecognizerSharedState.token">
3498            <summary>
3499            Token object normally returned by NextToken() after matching lexer rules.
3500            </summary>
3501            <remarks>
3502            The goal of all lexer rules/methods is to create a token object.
3503            This is an instance variable as multiple rules may collaborate to
3504            create a single token.  nextToken will return this object after
3505            matching lexer rule(s).  If you subclass to allow multiple token
3506            emissions, then set this to the last token to be matched or
3507            something nonnull so that the auto token emit mechanism will not
3508            emit another token.
3509            </remarks>
3510        </member>
3511        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharIndex">
3512            <summary>
3513            What character index in the stream did the current token start at?
3514            </summary>
3515            <remarks>
3516            Needed, for example, to get the text for current token.  Set at
3517            the start of nextToken.
3518            </remarks>
3519        </member>
3520        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartLine">
3521            <summary>
3522            The line on which the first character of the token resides
3523            </summary>
3524        </member>
3525        <member name="F:Antlr.Runtime.RecognizerSharedState.tokenStartCharPositionInLine">
3526            <summary>The character position of first character within the line</summary>
3527        </member>
3528        <member name="F:Antlr.Runtime.RecognizerSharedState.channel">
3529            <summary>The channel number for the current token</summary>
3530        </member>
3531        <member name="F:Antlr.Runtime.RecognizerSharedState.type">
3532            <summary>The token type for the current token</summary>
3533        </member>
3534        <member name="F:Antlr.Runtime.RecognizerSharedState.text">
3535            <summary>
3536            You can set the text for the current token to override what is in
3537            the input char buffer.  Use setText() or can set this instance var.
3538            </summary>
3539        </member>
3540        <member name="P:Antlr.Runtime.IToken.Line">
3541            <summary>The line number on which this token was matched; line=1..n</summary>
3542        </member>
3543        <member name="P:Antlr.Runtime.IToken.CharPositionInLine">
3544            <summary>
3545            The index of the first character relative to the beginning of the line 0..n-1
3546            </summary>
3547        </member>
3548        <member name="P:Antlr.Runtime.IToken.TokenIndex">
3549            <summary>
3550            An index from 0..n-1 of the token object in the input stream
3551            </summary>
3552            <remarks>
3553            This must be valid in order to use the ANTLRWorks debugger.
3554            </remarks>
3555        </member>
3556        <member name="P:Antlr.Runtime.IToken.Text">
3557            <summary>The text of the token</summary>
3558            <remarks>
3559            When setting the text, it might be a NOP such as for the CommonToken,
3560            which doesn't have string pointers, just indexes into a char buffer.
3561            </remarks>
3562        </member>
3563        <member name="T:Antlr.Runtime.ITokenStream">
3564            <summary>A stream of tokens accessing tokens from a TokenSource </summary>
3565        </member>
3566        <member name="P:Antlr.Runtime.ITokenStream.TokenSource">
3567            <summary>Where is this stream pulling tokens from?  This is not the name, but
3568            the object that provides Token objects.
3569            </summary>
3570        </member>
3571        <member name="M:Antlr.Runtime.ITokenStream.LT(System.Int32)">
3572            <summary>
3573            Get Token at current input pointer + i ahead (where i=1 is next
3574            Token).
3575            i &lt; 0 indicates tokens in the past.  So -1 is previous token and -2 is
3576            two tokens ago. LT(0) is undefined.  For i&gt;=n, return Token.EOFToken.
3577            Return null for LT(0) and any index that results in an absolute address
3578            that is negative.
3579            </summary>
3580        </member>
3581        <member name="M:Antlr.Runtime.ITokenStream.Get(System.Int32)">
3582            <summary>
3583            Get a token at an absolute index i; 0..n-1.  This is really only
3584            needed for profiling and debugging and token stream rewriting.
3585            If you don't want to buffer up tokens, then this method makes no
3586            sense for you.  Naturally you can't use the rewrite stream feature.
3587            I believe DebugTokenStream can easily be altered to not use
3588            this method, removing the dependency.
3589            </summary>
3590        </member>
3591        <member name="M:Antlr.Runtime.ITokenStream.ToString(System.Int32,System.Int32)">
3592            <summary>Return the text of all tokens from start to stop, inclusive.
3593            If the stream does not buffer all the tokens then it can just
3594            return "" or null;  Users should not access $ruleLabel.text in
3595            an action of course in that case.
3596            </summary>
3597        </member>
3598        <member name="M:Antlr.Runtime.ITokenStream.ToString(Antlr.Runtime.IToken,Antlr.Runtime.IToken)">
3599            <summary>Because the user is not required to use a token with an index stored
3600            in it, we must provide a means for two token objects themselves to
3601            indicate the start/end location.  Most often this will just delegate
3602            to the other toString(int,int).  This is also parallel with
3603            the TreeNodeStream.toString(Object,Object).
3604            </summary>
3605        </member>
3606        <member name="T:Antlr.Runtime.Lexer">
3607            <summary>
3608            A lexer is recognizer that draws input symbols from a character stream.
3609            lexer grammars result in a subclass of this object. A Lexer object
3610            uses simplified Match() and error recovery mechanisms in the interest
3611            of speed.
3612            </summary>
3613        </member>
3614        <member name="F:Antlr.Runtime.Lexer.input">
3615            <summary>Where is the lexer drawing characters from? </summary>
3616        </member>
3617        <member name="P:Antlr.Runtime.Lexer.CharStream">
3618            <summary>Set the char stream and reset the lexer </summary>
3619        </member>
3620        <member name="P:Antlr.Runtime.Lexer.CharIndex">
3621            <summary>What is the index of the current character of lookahead? </summary>
3622        </member>
3623        <member name="P:Antlr.Runtime.Lexer.Text">
3624            <summary>
3625            Gets or sets the 'lexeme' for the current token.
3626            </summary>
3627            <remarks>
3628                <para>
3629            The getter returns the text matched so far for the current token or any
3630            text override.
3631            </para>
3632                <para>
3633            The setter sets the complete text of this token. It overrides/wipes any
3634            previous changes to the text.
3635            </para>
3636            </remarks>
3637        </member>
3638        <member name="M:Antlr.Runtime.Lexer.NextToken">
3639            <summary>
3640            Return a token from this source; i.e., Match a token on the char stream.
3641            </summary>
3642        </member>
3643        <member name="M:Antlr.Runtime.Lexer.Skip">
3644            <summary>
3645            Instruct the lexer to skip creating a token for current lexer rule and
3646            look for another token.  NextToken() knows to keep looking when a lexer
3647            rule finishes with token set to SKIP_TOKEN.  Recall that if token==null
3648            at end of any token rule, it creates one for you and emits it.
3649            </summary>
3650        </member>
3651        <member name="M:Antlr.Runtime.Lexer.mTokens">
3652            <summary>This is the lexer entry point that sets instance var 'token' </summary>
3653        </member>
3654        <member name="M:Antlr.Runtime.Lexer.Emit(Antlr.Runtime.IToken)">
3655            <summary>
3656            Currently does not support multiple emits per nextToken invocation
3657            for efficiency reasons.  Subclass and override this method and
3658            nextToken (to push tokens into a list and pull from that list rather
3659            than a single variable as this implementation does).
3660            </summary>
3661        </member>
3662        <member name="M:Antlr.Runtime.Lexer.Emit">
3663            <summary>
3664            The standard method called to automatically emit a token at the
3665            outermost lexical rule.  The token object should point into the
3666            char buffer start..stop.  If there is a text override in 'text',
3667            use that to set the token's text.
3668            </summary>
3669            <remarks>
3670                <para>Override this method to emit custom Token objects.</para>
3671                <para>If you are building trees, then you should also override
3672            Parser or TreeParser.getMissingSymbol().</para>
3673            </remarks>
3674        </member>
3675        <member name="M:Antlr.Runtime.Lexer.Recover(Antlr.Runtime.RecognitionException)">
3676            <summary>
3677            Lexers can normally Match any char in it's vocabulary after matching
3678            a token, so do the easy thing and just kill a character and hope
3679            it all works out.  You can instead use the rule invocation stack
3680            to do sophisticated error recovery if you are in a Fragment rule.
3681            </summary>
3682        </member>
3683        <member name="T:Antlr.Runtime.TokenRewriteStream">
3684            <summary>Useful for dumping out the input stream after doing some
3685            augmentation or other manipulations.
3686            </summary>
3687            <remarks>
3688            You can insert stuff, Replace, and delete chunks.  Note that the
3689            operations are done lazily--only if you convert the buffer to a
3690            String.  This is very efficient because you are not moving data around
3691            all the time.  As the buffer of tokens is converted to strings, the
3692            ToString() method(s) check to see if there is an operation at the
3693            current index.  If so, the operation is done and then normal String
3694            rendering continues on the buffer.  This is like having multiple Turing
3695            machine instruction streams (programs) operating on a single input tape. :)
3696            Since the operations are done lazily at ToString-time, operations do not
3697            screw up the token index values.  That is, an insert operation at token
3698            index i does not change the index values for tokens i+1..n-1.
3699            Because operations never actually alter the buffer, you may always get
3700            the original token stream back without undoing anything.  Since
3701            the instructions are queued up, you can easily simulate transactions and
3702            roll back any changes if there is an error just by removing instructions.
3703            For example,
3704            CharStream input = new ANTLRFileStream("input");
3705            TLexer lex = new TLexer(input);
3706            TokenRewriteStream tokens = new TokenRewriteStream(lex);
3707            T parser = new T(tokens);
3708            parser.startRule();
3709            Then in the rules, you can execute
3710            IToken t,u;
3711            ...
3712            input.InsertAfter(t, "text to put after t");}
3713            input.InsertAfter(u, "text after u");}
3714            System.out.println(tokens.ToString());
3715            Actually, you have to cast the 'input' to a TokenRewriteStream. :(
3716            You can also have multiple "instruction streams" and get multiple
3717            rewrites from a single pass over the input.  Just name the instruction
3718            streams and use that name again when printing the buffer.  This could be
3719            useful for generating a C file and also its header file--all from the
3720            same buffer:
3721            tokens.InsertAfter("pass1", t, "text to put after t");}
3722            tokens.InsertAfter("pass2", u, "text after u");}
3723            System.out.println(tokens.ToString("pass1"));
3724            System.out.println(tokens.ToString("pass2"));
3725            If you don't use named rewrite streams, a "default" stream is used as
3726            the first example shows.
3727            </remarks>
3728        </member>
3729        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.instructionIndex">
3730             What index into rewrites List are we?</member>
3731        <member name="F:Antlr.Runtime.TokenRewriteStream.RewriteOperation.index">
3732             Token buffer index.</member>
3733        <member name="M:Antlr.Runtime.TokenRewriteStream.RewriteOperation.Execute(System.Text.StringBuilder)">
3734            <summary>Execute the rewrite operation by possibly adding to the buffer.
3735            Return the index of the next token to operate on.
3736            </summary>
3737        </member>
3738        <member name="T:Antlr.Runtime.TokenRewriteStream.ReplaceOp">
3739            <summary>I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp
3740            instructions.
3741            </summary>
3742        </member>
3743        <member name="F:Antlr.Runtime.TokenRewriteStream.programs">
3744            <summary>You may have multiple, named streams of rewrite operations.
3745            I'm calling these things "programs."
3746            Maps String (name) -&gt; rewrite (IList)
3747            </summary>
3748        </member>
3749        <member name="F:Antlr.Runtime.TokenRewriteStream.lastRewriteTokenIndexes">
3750            <summary>Map String (program name) -&gt; Integer index </summary>
3751        </member>
3752        <member name="M:Antlr.Runtime.TokenRewriteStream.Rollback(System.String,System.Int32)">
3753            <summary>Rollback the instruction stream for a program so that
3754            the indicated instruction (via instructionIndex) is no
3755            longer in the stream.  UNTESTED!
3756            </summary>
3757        </member>
3758        <member name="M:Antlr.Runtime.TokenRewriteStream.DeleteProgram(System.String)">
3759            <summary>Reset the program so that no instructions exist </summary>
3760        </member>
3761        <member name="M:Antlr.Runtime.TokenRewriteStream.ReduceToSingleOperationPerIndex(System.Collections.IList)">
3762            <summary>
3763            Return a map from token index to operation.
3764            </summary>
3765            <remarks>We need to combine operations and report invalid operations (like
3766            overlapping replaces that are not completed nested).  Inserts to
3767            same index need to be combined etc...   Here are the cases:
3768            I.i.u I.j.v                                                         leave alone, nonoverlapping
3769            I.i.u I.i.v                                                         combine: Iivu
3770            R.i-j.u R.x-y.v     | i-j in x-y                    delete first R
3771            R.i-j.u R.i-j.v                                                     delete first R
3772            R.i-j.u R.x-y.v     | x-y in i-j                    ERROR
3773            R.i-j.u R.x-y.v     | boundaries overlap    ERROR
3774            I.i.u R.x-y.v | i in x-y                            delete I
3775            I.i.u R.x-y.v | i not in x-y                        leave alone, nonoverlapping
3776            R.x-y.v I.i.u | i in x-y                            ERROR
3777            R.x-y.v I.x.u                                                       R.x-y.uv (combine, delete I)
3778            R.x-y.v I.i.u | i not in x-y                        leave alone, nonoverlapping
3779            I.i.u = insert u before op @ index i
3780            R.x-y.u = replace x-y indexed tokens with u
3781            First we need to examine replaces.  For any replace op:
3782                        1. wipe out any insertions before op within that range.
3783                        2. Drop any replace op before that is contained completely within
3784            that range.
3785                        3. Throw exception upon boundary overlap with any previous replace.
3786            Then we can deal with inserts:
3787                        1. for any inserts to same index, combine even if not adjacent.
3788                        2. for any prior replace with same left boundary, combine this
3789            insert with replace and delete this replace.
3790                        3. throw exception if index in same range as previous replace
3791            Don't actually delete; make op null in list. Easier to walk list.
3792            Later we can throw as we add to index -&gt; op map.
3793            Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
3794            inserted stuff would be before the replace range.  But, if you
3795            add tokens in front of a method body '{' and then delete the method
3796            body, I think the stuff before the '{' you added should disappear too.
3797            </remarks>
3798        </member>
3799        <member name="M:Antlr.Runtime.TokenRewriteStream.GetKindOfOps(System.Collections.IList,System.Type,System.Int32)">
3800            <summary>
3801            Get all operations before an index of a particular kind
3802            </summary>
3803        </member>
3804        <member name="T:Antlr.Runtime.Tree.ITreeVisitorAction">
3805            <summary>
3806            How to execute code for node t when a visitor visits node t.  Execute
3807            Pre() before visiting children and execute Post() after visiting children.
3808            </summary>
3809        </member>
3810        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Pre(System.Object)">
3811            <summary>
3812            Execute an action before visiting children of t.  Return t or
3813            a rewritten t.  Children of returned value will be visited.
3814            </summary>
3815        </member>
3816        <member name="M:Antlr.Runtime.Tree.ITreeVisitorAction.Post(System.Object)">
3817            <summary>
3818            Execute an action after visiting children of t. Return t or
3819            a rewritten t. It is up to the visitor to decide what to do
3820            with the return value.
3821            </summary>
3822        </member>
3823        <member name="T:Antlr.Runtime.Tree.TreeVisitor">
3824            <summary>
3825            Do a depth first walk of a tree, applying pre() and post() actions
3826            as we discover and finish nodes.
3827            </summary>
3828        </member>
3829        <member name="M:Antlr.Runtime.Tree.TreeVisitor.Visit(System.Object,Antlr.Runtime.Tree.ITreeVisitorAction)">
3830            <summary>
3831            Visit every node in tree t and trigger an action for each node
3832            before/after having visited all of its children.
3833            Execute both actions even if t has no children.
3834            If a child visit yields a new child, it can update its
3835            parent's child list or just return the new child.  The
3836            child update code works even if the child visit alters its parent
3837            and returns the new tree.
3838            Return result of applying post action to this node.
3839            </summary>
3840        </member>
3841    </members>
3842</doc>
Note: See TracBrowser for help on using the repository browser.