antlr-net 3.1.3.42154
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/lib/README.TXT +38 -0
- data/lib/net-2.0/Antlr3.Runtime.dll +0 -0
- data/lib/net-2.0/Antlr3.Runtime.dll.mdb +0 -0
- data/lib/net-2.0/Antlr3.Runtime.xml +3842 -0
- data/lib/net-2.0/Antlr3.Utility.XML +61 -0
- data/lib/net-2.0/Antlr3.Utility.dll +0 -0
- data/lib/net-2.0/Antlr3.Utility.dll.mdb +0 -0
- data/lib/net-2.0/StringTemplate.dll +0 -0
- data/lib/net-2.0/antlr.runtime.dll +0 -0
- metadata +81 -0
data/lib/README.TXT
ADDED
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
THIS IS THE C# TARGET RUNTIME DISTRIBUTION FOR ANTLR 3.1.3.
|
|
2
|
+
|
|
3
|
+
Please be aware that the maintainer wasn't able to create
|
|
4
|
+
neither a .chm file from the .xml files nor separate
|
|
5
|
+
assemblies for .NET 1.1 users. Anyone has to compile the
|
|
6
|
+
source code themselves. The maintainer would appreciate if
|
|
7
|
+
the assemblies are send to him, so he can update the runtime
|
|
8
|
+
distribution.
|
|
9
|
+
|
|
10
|
+
For the compilation one has to update the VS 2003 file as
|
|
11
|
+
described in the following:
|
|
12
|
+
|
|
13
|
+
UnwantedTokenException.cs and MissingTokenException.cs have to
|
|
14
|
+
be added to the "Antlr.Runtime" directory of the
|
|
15
|
+
Antlr3.Runtime project (they are in the associated directory)
|
|
16
|
+
and CommonErrorNode.cs has to be added to the
|
|
17
|
+
"Antlr.Runtime.Tree" directory.
|
|
18
|
+
|
|
19
|
+
To update the distribution correctly the following files are
|
|
20
|
+
required:
|
|
21
|
+
|
|
22
|
+
- The changed VS 2003 project file. (A working project file
|
|
23
|
+
should be in the repository.)
|
|
24
|
+
|
|
25
|
+
- The assemblies Antlr3.Runtime.dll and Antlr3.Utility.dll
|
|
26
|
+
generated via release mode.
|
|
27
|
+
|
|
28
|
+
- The associated .pdb and .xml files for stack traces and
|
|
29
|
+
intellisense.
|
|
30
|
+
|
|
31
|
+
- If possible, also the .chm file created from the .xml
|
|
32
|
+
files. There are some differences between the .NET 1.1 and
|
|
33
|
+
.NET 2.0 versions which can confuse users otherwise.
|
|
34
|
+
|
|
35
|
+
Thanks in advance!
|
|
36
|
+
Johannes Luber
|
|
37
|
+
Maintainer
|
|
38
|
+
jaluber AT gmx DOT de
|
|
Binary file
|
|
Binary file
|
|
@@ -0,0 +1,3842 @@
|
|
|
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; < 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+ '}' -> ^(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+ '}' -> ^(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<0 indicates nodes in the past. So LT(-1) is previous node, but
|
|
1621
|
+
implementations are not required to provide results for k < -1.
|
|
1622
|
+
LT(0) is undefined. For i>=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 "-> ^(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 <unknown> 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 > 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 -> 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<String, Integer> 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<Integer, List> 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 -> 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 -> 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 > 1. Throw an exception if the stream is
|
|
2585
|
+
empty or we're out of elements and size>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<TreeWalkState>.
|
|
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 < 0 indicates nodes in the past. So -1 is previous node and -2 is
|
|
2838
|
+
two nodes ago. LT(0) is undefined. For i>=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 -> expr -> atom
|
|
3162
|
+
and it will be trying to Match the ')' at this point in the
|
|
3163
|
+
derivation:
|
|
3164
|
+
=> 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 <String> 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<Token> to List<String>
|
|
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=>*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 => ID '=' expr ';'
|
|
3279
|
+
=> ID '=' atom ('+' atom)* ';'
|
|
3280
|
+
=> ID '=' '(' expr ')' ('+' atom)* ';'
|
|
3281
|
+
=> ID '=' '(' atom ')' ('+' atom)* ';'
|
|
3282
|
+
=> ID '=' '(' INT ')' ('+' atom)* ';'
|
|
3283
|
+
=> ID '=' '(' INT ')' ';'
|
|
3284
|
+
At the "3" token, you'd have a call chain of
|
|
3285
|
+
stat -> expr -> atom -> expr -> 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 >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<Integer,Integer> 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 < 0 indicates tokens in the past. So -1 is previous token and -2 is
|
|
3576
|
+
two tokens ago. LT(0) is undefined. For i>=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) -> rewrite (IList)
|
|
3747
|
+
</summary>
|
|
3748
|
+
</member>
|
|
3749
|
+
<member name="F:Antlr.Runtime.TokenRewriteStream.lastRewriteTokenIndexes">
|
|
3750
|
+
<summary>Map String (program name) -> 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 -> 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>
|