1 /// \file
2 /// Defines the implementation of the common node stream the default
3 /// tree node stream used by ANTLR.
4 ///
5
6 // [The "BSD licence"]
7 // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
8 // http://www.temporal-wave.com
9 // http://www.linkedin.com/in/jimidle
10 //
11 // All rights reserved.
12 //
13 // Redistribution and use in source and binary forms, with or without
14 // modification, are permitted provided that the following conditions
15 // are met:
16 // 1. Redistributions of source code must retain the above copyright
17 // notice, this list of conditions and the following disclaimer.
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 // 3. The name of the author may not be used to endorse or promote products
22 // derived from this software without specific prior written permission.
23 //
24 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
25 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27 // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
28 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34
35 #include <antlr3commontreenodestream.h>
36
37 #ifdef ANTLR3_WINDOWS
38 #pragma warning( disable : 4100 )
39 #endif
40
41 // COMMON TREE STREAM API
42 //
43 static void addNavigationNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns, ANTLR3_UINT32 ttype);
44 static ANTLR3_BOOLEAN hasUniqueNavigationNodes (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
45 static pANTLR3_BASE_TREE newDownNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
46 static pANTLR3_BASE_TREE newUpNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
47 static void reset (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
48 static void push (pANTLR3_COMMON_TREE_NODE_STREAM ctns, ANTLR3_INT32 index);
49 static ANTLR3_INT32 pop (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
50 //static ANTLR3_INT32 index (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
51 static ANTLR3_UINT32 getLookaheadSize (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
52 // TREE NODE STREAM API
53 //
54 static pANTLR3_BASE_TREE_ADAPTOR getTreeAdaptor (pANTLR3_TREE_NODE_STREAM tns);
55 static pANTLR3_BASE_TREE getTreeSource (pANTLR3_TREE_NODE_STREAM tns);
56 static pANTLR3_BASE_TREE _LT (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k);
57 static pANTLR3_BASE_TREE get (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k);
58 static void setUniqueNavigationNodes (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_BOOLEAN uniqueNavigationNodes);
59 static pANTLR3_STRING toString (pANTLR3_TREE_NODE_STREAM tns);
60 static pANTLR3_STRING toStringSS (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop);
61 static void toStringWork (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop, pANTLR3_STRING buf);
62 static void replaceChildren (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t);
63
64 // INT STREAM API
65 //
66 static void consume (pANTLR3_INT_STREAM is);
67 static ANTLR3_MARKER tindex (pANTLR3_INT_STREAM is);
68 static ANTLR3_UINT32 _LA (pANTLR3_INT_STREAM is, ANTLR3_INT32 i);
69 static ANTLR3_MARKER mark (pANTLR3_INT_STREAM is);
70 static void release (pANTLR3_INT_STREAM is, ANTLR3_MARKER marker);
71 static void rewindMark (pANTLR3_INT_STREAM is, ANTLR3_MARKER marker);
72 static void rewindLast (pANTLR3_INT_STREAM is);
73 static void seek (pANTLR3_INT_STREAM is, ANTLR3_MARKER index);
74 static ANTLR3_UINT32 size (pANTLR3_INT_STREAM is);
75
76
77 // Helper functions
78 //
79 static void fillBuffer (pANTLR3_COMMON_TREE_NODE_STREAM ctns, pANTLR3_BASE_TREE t);
80 static void fillBufferRoot (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
81
82 // Constructors
83 //
84 static void antlr3TreeNodeStreamFree (pANTLR3_TREE_NODE_STREAM tns);
85 static void antlr3CommonTreeNodeStreamFree (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
86
87 ANTLR3_API pANTLR3_TREE_NODE_STREAM
antlr3TreeNodeStreamNew()88 antlr3TreeNodeStreamNew()
89 {
90 pANTLR3_TREE_NODE_STREAM stream;
91
92 // Memory for the interface structure
93 //
94 stream = (pANTLR3_TREE_NODE_STREAM) ANTLR3_CALLOC(1, sizeof(ANTLR3_TREE_NODE_STREAM));
95
96 if (stream == NULL)
97 {
98 return NULL;
99 }
100
101 // Install basic API
102 //
103 stream->replaceChildren = replaceChildren;
104 stream->free = antlr3TreeNodeStreamFree;
105
106 return stream;
107 }
108
109 static void
antlr3TreeNodeStreamFree(pANTLR3_TREE_NODE_STREAM stream)110 antlr3TreeNodeStreamFree(pANTLR3_TREE_NODE_STREAM stream)
111 {
112 ANTLR3_FREE(stream);
113 }
114
115 ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM
antlr3CommonTreeNodeStreamNewTree(pANTLR3_BASE_TREE tree,ANTLR3_UINT32 hint)116 antlr3CommonTreeNodeStreamNewTree(pANTLR3_BASE_TREE tree, ANTLR3_UINT32 hint)
117 {
118 pANTLR3_COMMON_TREE_NODE_STREAM stream;
119
120 stream = antlr3CommonTreeNodeStreamNew(tree->strFactory, hint);
121
122 if (stream == NULL)
123 {
124 return NULL;
125 }
126 stream->root = tree;
127
128 return stream;
129 }
130
131 ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM
antlr3CommonTreeNodeStreamNewStream(pANTLR3_COMMON_TREE_NODE_STREAM inStream)132 antlr3CommonTreeNodeStreamNewStream(pANTLR3_COMMON_TREE_NODE_STREAM inStream)
133 {
134 pANTLR3_COMMON_TREE_NODE_STREAM stream;
135
136 // Memory for the interface structure
137 //
138 stream = (pANTLR3_COMMON_TREE_NODE_STREAM) ANTLR3_CALLOC(1, sizeof(ANTLR3_COMMON_TREE_NODE_STREAM));
139
140 if (stream == NULL)
141 {
142 return NULL;
143 }
144
145 // Copy in all the reusable parts of the originating stream and create new
146 // pieces where necessary.
147 //
148
149 // String factory for tree walker
150 //
151 stream->stringFactory = inStream->stringFactory;
152
153 // Create an adaptor for the common tree node stream
154 //
155 stream->adaptor = inStream->adaptor;
156
157 // Create space for the tree node stream interface
158 //
159 stream->tnstream = antlr3TreeNodeStreamNew();
160
161 if (stream->tnstream == NULL)
162 {
163 stream->free (stream);
164
165 return NULL;
166 }
167
168 // Create space for the INT_STREAM interface
169 //
170 stream->tnstream->istream = antlr3IntStreamNew();
171
172 if (stream->tnstream->istream == NULL)
173 {
174 stream->tnstream->free (stream->tnstream);
175 stream->free (stream);
176
177 return NULL;
178 }
179
180 // Install the common tree node stream API
181 //
182 stream->addNavigationNode = addNavigationNode;
183 stream->hasUniqueNavigationNodes = hasUniqueNavigationNodes;
184 stream->newDownNode = newDownNode;
185 stream->newUpNode = newUpNode;
186 stream->reset = reset;
187 stream->push = push;
188 stream->pop = pop;
189 stream->getLookaheadSize = getLookaheadSize;
190
191 stream->free = antlr3CommonTreeNodeStreamFree;
192
193 // Install the tree node stream API
194 //
195 stream->tnstream->getTreeAdaptor = getTreeAdaptor;
196 stream->tnstream->getTreeSource = getTreeSource;
197 stream->tnstream->_LT = _LT;
198 stream->tnstream->setUniqueNavigationNodes = setUniqueNavigationNodes;
199 stream->tnstream->toString = toString;
200 stream->tnstream->toStringSS = toStringSS;
201 stream->tnstream->toStringWork = toStringWork;
202 stream->tnstream->get = get;
203
204 // Install INT_STREAM interface
205 //
206 stream->tnstream->istream->consume = consume;
207 stream->tnstream->istream->index = tindex;
208 stream->tnstream->istream->_LA = _LA;
209 stream->tnstream->istream->mark = mark;
210 stream->tnstream->istream->release = release;
211 stream->tnstream->istream->rewind = rewindMark;
212 stream->tnstream->istream->rewindLast = rewindLast;
213 stream->tnstream->istream->seek = seek;
214 stream->tnstream->istream->size = size;
215
216 // Initialize data elements of INT stream
217 //
218 stream->tnstream->istream->type = ANTLR3_COMMONTREENODE;
219 stream->tnstream->istream->super = (stream->tnstream);
220
221 // Initialize data elements of TREE stream
222 //
223 stream->tnstream->ctns = stream;
224
225 // Initialize data elements of the COMMON TREE NODE stream
226 //
227 stream->super = NULL;
228 stream->uniqueNavigationNodes = ANTLR3_FALSE;
229 stream->markers = NULL;
230 stream->nodeStack = inStream->nodeStack;
231
232 // Create the node list map
233 //
234 stream->nodes = antlr3VectorNew(DEFAULT_INITIAL_BUFFER_SIZE);
235 stream->p = -1;
236
237 // Install the navigation nodes
238 //
239
240 // Install the navigation nodes
241 //
242 antlr3SetCTAPI(&(stream->UP));
243 antlr3SetCTAPI(&(stream->DOWN));
244 antlr3SetCTAPI(&(stream->EOF_NODE));
245 antlr3SetCTAPI(&(stream->INVALID_NODE));
246
247 stream->UP.token = inStream->UP.token;
248 inStream->UP.token->strFactory = stream->stringFactory;
249 stream->DOWN.token = inStream->DOWN.token;
250 inStream->DOWN.token->strFactory = stream->stringFactory;
251 stream->EOF_NODE.token = inStream->EOF_NODE.token;
252 inStream->EOF_NODE.token->strFactory = stream->stringFactory;
253 stream->INVALID_NODE.token = inStream->INVALID_NODE.token;
254 inStream->INVALID_NODE.token->strFactory= stream->stringFactory;
255
256 // Reuse the root tree of the originating stream
257 //
258 stream->root = inStream->root;
259
260 // Signal that this is a rewriting stream so we don't
261 // free the originating tree. Anything that we rewrite or
262 // duplicate here will be done through the adaptor or
263 // the original tree factory.
264 //
265 stream->isRewriter = ANTLR3_TRUE;
266 return stream;
267 }
268
269 ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM
antlr3CommonTreeNodeStreamNew(pANTLR3_STRING_FACTORY strFactory,ANTLR3_UINT32 hint)270 antlr3CommonTreeNodeStreamNew(pANTLR3_STRING_FACTORY strFactory, ANTLR3_UINT32 hint)
271 {
272 pANTLR3_COMMON_TREE_NODE_STREAM stream;
273 pANTLR3_COMMON_TOKEN token;
274
275 // Memory for the interface structure
276 //
277 stream = (pANTLR3_COMMON_TREE_NODE_STREAM) ANTLR3_CALLOC(1, sizeof(ANTLR3_COMMON_TREE_NODE_STREAM));
278
279 if (stream == NULL)
280 {
281 return NULL;
282 }
283
284 // String factory for tree walker
285 //
286 stream->stringFactory = strFactory;
287
288 // Create an adaptor for the common tree node stream
289 //
290 stream->adaptor = ANTLR3_TREE_ADAPTORNew(strFactory);
291
292 if (stream->adaptor == NULL)
293 {
294 stream->free(stream);
295 return NULL;
296 }
297
298 // Create space for the tree node stream interface
299 //
300 stream->tnstream = antlr3TreeNodeStreamNew();
301
302 if (stream->tnstream == NULL)
303 {
304 stream->adaptor->free (stream->adaptor);
305 stream->free (stream);
306
307 return NULL;
308 }
309
310 // Create space for the INT_STREAM interface
311 //
312 stream->tnstream->istream = antlr3IntStreamNew();
313
314 if (stream->tnstream->istream == NULL)
315 {
316 stream->adaptor->free (stream->adaptor);
317 stream->tnstream->free (stream->tnstream);
318 stream->free (stream);
319
320 return NULL;
321 }
322
323 // Install the common tree node stream API
324 //
325 stream->addNavigationNode = addNavigationNode;
326 stream->hasUniqueNavigationNodes = hasUniqueNavigationNodes;
327 stream->newDownNode = newDownNode;
328 stream->newUpNode = newUpNode;
329 stream->reset = reset;
330 stream->push = push;
331 stream->pop = pop;
332
333 stream->free = antlr3CommonTreeNodeStreamFree;
334
335 // Install the tree node stream API
336 //
337 stream->tnstream->getTreeAdaptor = getTreeAdaptor;
338 stream->tnstream->getTreeSource = getTreeSource;
339 stream->tnstream->_LT = _LT;
340 stream->tnstream->setUniqueNavigationNodes = setUniqueNavigationNodes;
341 stream->tnstream->toString = toString;
342 stream->tnstream->toStringSS = toStringSS;
343 stream->tnstream->toStringWork = toStringWork;
344 stream->tnstream->get = get;
345
346 // Install INT_STREAM interface
347 //
348 stream->tnstream->istream->consume = consume;
349 stream->tnstream->istream->index = tindex;
350 stream->tnstream->istream->_LA = _LA;
351 stream->tnstream->istream->mark = mark;
352 stream->tnstream->istream->release = release;
353 stream->tnstream->istream->rewind = rewindMark;
354 stream->tnstream->istream->rewindLast = rewindLast;
355 stream->tnstream->istream->seek = seek;
356 stream->tnstream->istream->size = size;
357
358 // Initialize data elements of INT stream
359 //
360 stream->tnstream->istream->type = ANTLR3_COMMONTREENODE;
361 stream->tnstream->istream->super = (stream->tnstream);
362
363 // Initialize data elements of TREE stream
364 //
365 stream->tnstream->ctns = stream;
366
367 // Initialize data elements of the COMMON TREE NODE stream
368 //
369 stream->super = NULL;
370 stream->uniqueNavigationNodes = ANTLR3_FALSE;
371 stream->markers = NULL;
372 stream->nodeStack = antlr3StackNew(INITIAL_CALL_STACK_SIZE);
373
374 // Create the node list map
375 //
376 if (hint == 0)
377 {
378 hint = DEFAULT_INITIAL_BUFFER_SIZE;
379 }
380 stream->nodes = antlr3VectorNew(hint);
381 stream->p = -1;
382
383 // Install the navigation nodes
384 //
385 antlr3SetCTAPI(&(stream->UP));
386 antlr3SetCTAPI(&(stream->DOWN));
387 antlr3SetCTAPI(&(stream->EOF_NODE));
388 antlr3SetCTAPI(&(stream->INVALID_NODE));
389
390 token = antlr3CommonTokenNew(ANTLR3_TOKEN_UP);
391 token->strFactory = strFactory;
392 token->textState = ANTLR3_TEXT_CHARP;
393 token->tokText.chars = (pANTLR3_UCHAR)"UP";
394 stream->UP.token = token;
395
396 token = antlr3CommonTokenNew(ANTLR3_TOKEN_DOWN);
397 token->strFactory = strFactory;
398 token->textState = ANTLR3_TEXT_CHARP;
399 token->tokText.chars = (pANTLR3_UCHAR)"DOWN";
400 stream->DOWN.token = token;
401
402 token = antlr3CommonTokenNew(ANTLR3_TOKEN_EOF);
403 token->strFactory = strFactory;
404 token->textState = ANTLR3_TEXT_CHARP;
405 token->tokText.chars = (pANTLR3_UCHAR)"EOF";
406 stream->EOF_NODE.token = token;
407
408 token = antlr3CommonTokenNew(ANTLR3_TOKEN_INVALID);
409 token->strFactory = strFactory;
410 token->textState = ANTLR3_TEXT_CHARP;
411 token->tokText.chars = (pANTLR3_UCHAR)"INVALID";
412 stream->INVALID_NODE.token = token;
413
414
415 return stream;
416 }
417
418 /// Free up any resources that belong to this common tree node stream.
419 ///
antlr3CommonTreeNodeStreamFree(pANTLR3_COMMON_TREE_NODE_STREAM ctns)420 static void antlr3CommonTreeNodeStreamFree (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
421 {
422
423 // If this is a rewrting stream, then certain resources
424 // belong to the originating node stream and we do not
425 // free them here.
426 //
427 if (ctns->isRewriter != ANTLR3_TRUE)
428 {
429 ctns->adaptor ->free (ctns->adaptor);
430
431 if (ctns->nodeStack != NULL)
432 {
433 ctns->nodeStack->free(ctns->nodeStack);
434 }
435
436 ANTLR3_FREE(ctns->INVALID_NODE.token);
437 ANTLR3_FREE(ctns->EOF_NODE.token);
438 ANTLR3_FREE(ctns->DOWN.token);
439 ANTLR3_FREE(ctns->UP.token);
440 }
441
442 if (ctns->nodes != NULL)
443 {
444 ctns->nodes ->free (ctns->nodes);
445 }
446 ctns->tnstream->istream ->free (ctns->tnstream->istream);
447 ctns->tnstream ->free (ctns->tnstream);
448
449
450 ANTLR3_FREE(ctns);
451 }
452
453 // ------------------------------------------------------------------------------
454 // Local helpers
455 //
456
457 /// Walk and fill the tree node buffer from the root tree
458 ///
459 static void
fillBufferRoot(pANTLR3_COMMON_TREE_NODE_STREAM ctns)460 fillBufferRoot(pANTLR3_COMMON_TREE_NODE_STREAM ctns)
461 {
462 // Call the generic buffer routine with the root as the
463 // argument
464 //
465 fillBuffer(ctns, ctns->root);
466 ctns->p = 0; // Indicate we are at buffer start
467 }
468
469 /// Walk tree with depth-first-search and fill nodes buffer.
470 /// Don't add in DOWN, UP nodes if the supplied tree is a list (t is isNilNode)
471 // such as the root tree is.
472 ///
473 static void
fillBuffer(pANTLR3_COMMON_TREE_NODE_STREAM ctns,pANTLR3_BASE_TREE t)474 fillBuffer(pANTLR3_COMMON_TREE_NODE_STREAM ctns, pANTLR3_BASE_TREE t)
475 {
476 ANTLR3_BOOLEAN nilNode;
477 ANTLR3_UINT32 nCount;
478 ANTLR3_UINT32 c;
479
480 nilNode = ctns->adaptor->isNilNode(ctns->adaptor, t);
481
482 // If the supplied node is not a nil (list) node then we
483 // add in the node itself to the vector
484 //
485 if (nilNode == ANTLR3_FALSE)
486 {
487 ctns->nodes->add(ctns->nodes, t, NULL);
488 }
489
490 // Only add a DOWN node if the tree is not a nil tree and
491 // the tree does have children.
492 //
493 nCount = t->getChildCount(t);
494
495 if (nilNode == ANTLR3_FALSE && nCount>0)
496 {
497 ctns->addNavigationNode(ctns, ANTLR3_TOKEN_DOWN);
498 }
499
500 // We always add any children the tree contains, which is
501 // a recursive call to this function, which will cause similar
502 // recursion and implement a depth first addition
503 //
504 for (c = 0; c < nCount; c++)
505 {
506 fillBuffer(ctns, ctns->adaptor->getChild(ctns->adaptor, t, c));
507 }
508
509 // If the tree had children and was not a nil (list) node, then we
510 // we need to add an UP node here to match the DOWN node
511 //
512 if (nilNode == ANTLR3_FALSE && nCount > 0)
513 {
514 ctns->addNavigationNode(ctns, ANTLR3_TOKEN_UP);
515 }
516 }
517
518
519 // ------------------------------------------------------------------------------
520 // Interface functions
521 //
522
523 /// Reset the input stream to the start of the input nodes.
524 ///
525 static void
reset(pANTLR3_COMMON_TREE_NODE_STREAM ctns)526 reset (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
527 {
528 if (ctns->p != -1)
529 {
530 ctns->p = 0;
531 }
532 ctns->tnstream->istream->lastMarker = 0;
533
534
535 // Free and reset the node stack only if this is not
536 // a rewriter, which is going to reuse the originating
537 // node streams node stack
538 //
539 if (ctns->isRewriter != ANTLR3_TRUE)
540 {
541 if (ctns->nodeStack != NULL)
542 {
543 ctns->nodeStack->free(ctns->nodeStack);
544 ctns->nodeStack = antlr3StackNew(INITIAL_CALL_STACK_SIZE);
545 }
546 }
547 }
548
549
550 static pANTLR3_BASE_TREE
LB(pANTLR3_TREE_NODE_STREAM tns,ANTLR3_INT32 k)551 LB(pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k)
552 {
553 if ( k==0)
554 {
555 return &(tns->ctns->INVALID_NODE.baseTree);
556 }
557
558 if ( (tns->ctns->p - k) < 0)
559 {
560 return &(tns->ctns->INVALID_NODE.baseTree);
561 }
562
563 return tns->ctns->nodes->get(tns->ctns->nodes, tns->ctns->p - k);
564 }
565
566 /// Get tree node at current input pointer + i ahead where i=1 is next node.
567 /// i<0 indicates nodes in the past. So -1 is previous node and -2 is
568 /// two nodes ago. LT(0) is undefined. For i>=n, return null.
569 /// Return null for LT(0) and any index that results in an absolute address
570 /// that is negative.
571 ///
572 /// This is analogous to the _LT() method of the TokenStream, but this
573 /// returns a tree node instead of a token. Makes code gen identical
574 /// for both parser and tree grammars. :)
575 ///
576 static pANTLR3_BASE_TREE
_LT(pANTLR3_TREE_NODE_STREAM tns,ANTLR3_INT32 k)577 _LT (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k)
578 {
579 if (tns->ctns->p == -1)
580 {
581 fillBufferRoot(tns->ctns);
582 }
583
584 if (k < 0)
585 {
586 return LB(tns, -k);
587 }
588 else if (k == 0)
589 {
590 return &(tns->ctns->INVALID_NODE.baseTree);
591 }
592
593 // k was a legitimate request,
594 //
595 if (( tns->ctns->p + k - 1) >= (ANTLR3_INT32)(tns->ctns->nodes->count))
596 {
597 return &(tns->ctns->EOF_NODE.baseTree);
598 }
599
600 return tns->ctns->nodes->get(tns->ctns->nodes, tns->ctns->p + k - 1);
601 }
602
603 /// Where is this stream pulling nodes from? This is not the name, but
604 /// the object that provides node objects.
605 ///
606 static pANTLR3_BASE_TREE
getTreeSource(pANTLR3_TREE_NODE_STREAM tns)607 getTreeSource (pANTLR3_TREE_NODE_STREAM tns)
608 {
609 return tns->ctns->root;
610 }
611
612 /// Consume the next node from the input stream
613 ///
614 static void
consume(pANTLR3_INT_STREAM is)615 consume (pANTLR3_INT_STREAM is)
616 {
617 pANTLR3_TREE_NODE_STREAM tns;
618 pANTLR3_COMMON_TREE_NODE_STREAM ctns;
619
620 tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
621 ctns = tns->ctns;
622
623 if (ctns->p == -1)
624 {
625 fillBufferRoot(ctns);
626 }
627 ctns->p++;
628 }
629
630 static ANTLR3_UINT32
_LA(pANTLR3_INT_STREAM is,ANTLR3_INT32 i)631 _LA (pANTLR3_INT_STREAM is, ANTLR3_INT32 i)
632 {
633 pANTLR3_TREE_NODE_STREAM tns;
634 pANTLR3_BASE_TREE t;
635
636 tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
637
638 // Ask LT for the 'token' at that position
639 //
640 t = tns->_LT(tns, i);
641
642 if (t == NULL)
643 {
644 return ANTLR3_TOKEN_INVALID;
645 }
646
647 // Token node was there so return the type of it
648 //
649 return t->getType(t);
650 }
651
652 /// Mark the state of the input stream so that we can come back to it
653 /// after a syntactic predicate and so on.
654 ///
655 static ANTLR3_MARKER
mark(pANTLR3_INT_STREAM is)656 mark (pANTLR3_INT_STREAM is)
657 {
658 pANTLR3_TREE_NODE_STREAM tns;
659 pANTLR3_COMMON_TREE_NODE_STREAM ctns;
660
661 tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
662 ctns = tns->ctns;
663
664 if (tns->ctns->p == -1)
665 {
666 fillBufferRoot(tns->ctns);
667 }
668
669 // Return the current mark point
670 //
671 ctns->tnstream->istream->lastMarker = ctns->tnstream->istream->index(ctns->tnstream->istream);
672
673 return ctns->tnstream->istream->lastMarker;
674 }
675
676 static void
release(pANTLR3_INT_STREAM is,ANTLR3_MARKER marker)677 release (pANTLR3_INT_STREAM is, ANTLR3_MARKER marker)
678 {
679 }
680
681 /// Rewind the current state of the tree walk to the state it
682 /// was in when mark() was called and it returned marker. Also,
683 /// wipe out the lookahead which will force reloading a few nodes
684 /// but it is better than making a copy of the lookahead buffer
685 /// upon mark().
686 ///
687 static void
rewindMark(pANTLR3_INT_STREAM is,ANTLR3_MARKER marker)688 rewindMark (pANTLR3_INT_STREAM is, ANTLR3_MARKER marker)
689 {
690 is->seek(is, marker);
691 }
692
693 static void
rewindLast(pANTLR3_INT_STREAM is)694 rewindLast (pANTLR3_INT_STREAM is)
695 {
696 is->seek(is, is->lastMarker);
697 }
698
699 /// consume() ahead until we hit index. Can't just jump ahead--must
700 /// spit out the navigation nodes.
701 ///
702 static void
seek(pANTLR3_INT_STREAM is,ANTLR3_MARKER index)703 seek (pANTLR3_INT_STREAM is, ANTLR3_MARKER index)
704 {
705 pANTLR3_TREE_NODE_STREAM tns;
706 pANTLR3_COMMON_TREE_NODE_STREAM ctns;
707
708 tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
709 ctns = tns->ctns;
710
711 ctns->p = ANTLR3_UINT32_CAST(index);
712 }
713
714 static ANTLR3_MARKER
tindex(pANTLR3_INT_STREAM is)715 tindex (pANTLR3_INT_STREAM is)
716 {
717 pANTLR3_TREE_NODE_STREAM tns;
718 pANTLR3_COMMON_TREE_NODE_STREAM ctns;
719
720 tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
721 ctns = tns->ctns;
722
723 return (ANTLR3_MARKER)(ctns->p);
724 }
725
726 /// Expensive to compute the size of the whole tree while parsing.
727 /// This method only returns how much input has been seen so far. So
728 /// after parsing it returns true size.
729 ///
730 static ANTLR3_UINT32
size(pANTLR3_INT_STREAM is)731 size (pANTLR3_INT_STREAM is)
732 {
733 pANTLR3_TREE_NODE_STREAM tns;
734 pANTLR3_COMMON_TREE_NODE_STREAM ctns;
735
736 tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
737 ctns = tns->ctns;
738
739 if (ctns->p == -1)
740 {
741 fillBufferRoot(ctns);
742 }
743
744 return ctns->nodes->size(ctns->nodes);
745 }
746
747 /// As we flatten the tree, we use UP, DOWN nodes to represent
748 /// the tree structure. When debugging we need unique nodes
749 /// so instantiate new ones when uniqueNavigationNodes is true.
750 ///
751 static void
addNavigationNode(pANTLR3_COMMON_TREE_NODE_STREAM ctns,ANTLR3_UINT32 ttype)752 addNavigationNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns, ANTLR3_UINT32 ttype)
753 {
754 pANTLR3_BASE_TREE node;
755
756 node = NULL;
757
758 if (ttype == ANTLR3_TOKEN_DOWN)
759 {
760 if (ctns->hasUniqueNavigationNodes(ctns) == ANTLR3_TRUE)
761 {
762 node = ctns->newDownNode(ctns);
763 }
764 else
765 {
766 node = &(ctns->DOWN.baseTree);
767 }
768 }
769 else
770 {
771 if (ctns->hasUniqueNavigationNodes(ctns) == ANTLR3_TRUE)
772 {
773 node = ctns->newUpNode(ctns);
774 }
775 else
776 {
777 node = &(ctns->UP.baseTree);
778 }
779 }
780
781 // Now add the node we decided upon.
782 //
783 ctns->nodes->add(ctns->nodes, node, NULL);
784 }
785
786
787 static pANTLR3_BASE_TREE_ADAPTOR
getTreeAdaptor(pANTLR3_TREE_NODE_STREAM tns)788 getTreeAdaptor (pANTLR3_TREE_NODE_STREAM tns)
789 {
790 return tns->ctns->adaptor;
791 }
792
793 static ANTLR3_BOOLEAN
hasUniqueNavigationNodes(pANTLR3_COMMON_TREE_NODE_STREAM ctns)794 hasUniqueNavigationNodes (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
795 {
796 return ctns->uniqueNavigationNodes;
797 }
798
799 static void
setUniqueNavigationNodes(pANTLR3_TREE_NODE_STREAM tns,ANTLR3_BOOLEAN uniqueNavigationNodes)800 setUniqueNavigationNodes (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_BOOLEAN uniqueNavigationNodes)
801 {
802 tns->ctns->uniqueNavigationNodes = uniqueNavigationNodes;
803 }
804
805
806 /// Print out the entire tree including DOWN/UP nodes. Uses
807 /// a recursive walk. Mostly useful for testing as it yields
808 /// the token types not text.
809 ///
810 static pANTLR3_STRING
toString(pANTLR3_TREE_NODE_STREAM tns)811 toString (pANTLR3_TREE_NODE_STREAM tns)
812 {
813
814 return tns->toStringSS(tns, tns->ctns->root, NULL);
815 }
816
817 static pANTLR3_STRING
toStringSS(pANTLR3_TREE_NODE_STREAM tns,pANTLR3_BASE_TREE start,pANTLR3_BASE_TREE stop)818 toStringSS (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop)
819 {
820 pANTLR3_STRING buf;
821
822 buf = tns->ctns->stringFactory->newRaw(tns->ctns->stringFactory);
823
824 tns->toStringWork(tns, start, stop, buf);
825
826 return buf;
827 }
828
829 static void
toStringWork(pANTLR3_TREE_NODE_STREAM tns,pANTLR3_BASE_TREE p,pANTLR3_BASE_TREE stop,pANTLR3_STRING buf)830 toStringWork (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE p, pANTLR3_BASE_TREE stop, pANTLR3_STRING buf)
831 {
832
833 ANTLR3_UINT32 n;
834 ANTLR3_UINT32 c;
835
836 if (!p->isNilNode(p) )
837 {
838 pANTLR3_STRING text;
839
840 text = p->toString(p);
841
842 if (text == NULL)
843 {
844 text = tns->ctns->stringFactory->newRaw(tns->ctns->stringFactory);
845
846 text->addc (text, ' ');
847 text->addi (text, p->getType(p));
848 }
849
850 buf->appendS(buf, text);
851 }
852
853 if (p == stop)
854 {
855 return; /* Finished */
856 }
857
858 n = p->getChildCount(p);
859
860 if (n > 0 && ! p->isNilNode(p) )
861 {
862 buf->addc (buf, ' ');
863 buf->addi (buf, ANTLR3_TOKEN_DOWN);
864 }
865
866 for (c = 0; c<n ; c++)
867 {
868 pANTLR3_BASE_TREE child;
869
870 child = p->getChild(p, c);
871 tns->toStringWork(tns, child, stop, buf);
872 }
873
874 if (n > 0 && ! p->isNilNode(p) )
875 {
876 buf->addc (buf, ' ');
877 buf->addi (buf, ANTLR3_TOKEN_UP);
878 }
879 }
880
881 static ANTLR3_UINT32
getLookaheadSize(pANTLR3_COMMON_TREE_NODE_STREAM ctns)882 getLookaheadSize (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
883 {
884 return ctns->tail < ctns->head
885 ? (ctns->lookAheadLength - ctns->head + ctns->tail)
886 : (ctns->tail - ctns->head);
887 }
888
889 static pANTLR3_BASE_TREE
newDownNode(pANTLR3_COMMON_TREE_NODE_STREAM ctns)890 newDownNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
891 {
892 pANTLR3_COMMON_TREE dNode;
893 pANTLR3_COMMON_TOKEN token;
894
895 token = antlr3CommonTokenNew(ANTLR3_TOKEN_DOWN);
896 token->textState = ANTLR3_TEXT_CHARP;
897 token->tokText.chars = (pANTLR3_UCHAR)"DOWN";
898 dNode = antlr3CommonTreeNewFromToken(token);
899
900 return &(dNode->baseTree);
901 }
902
903 static pANTLR3_BASE_TREE
newUpNode(pANTLR3_COMMON_TREE_NODE_STREAM ctns)904 newUpNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
905 {
906 pANTLR3_COMMON_TREE uNode;
907 pANTLR3_COMMON_TOKEN token;
908
909 token = antlr3CommonTokenNew(ANTLR3_TOKEN_UP);
910 token->textState = ANTLR3_TEXT_CHARP;
911 token->tokText.chars = (pANTLR3_UCHAR)"UP";
912 uNode = antlr3CommonTreeNewFromToken(token);
913
914 return &(uNode->baseTree);
915 }
916
917 /// Replace from start to stop child index of parent with t, which might
918 /// be a list. Number of children may be different
919 /// after this call. The stream is notified because it is walking the
920 /// tree and might need to know you are monkey-ing with the underlying
921 /// tree. Also, it might be able to modify the node stream to avoid
922 /// re-streaming for future phases.
923 ///
924 /// If parent is null, don't do anything; must be at root of overall tree.
925 /// Can't replace whatever points to the parent externally. Do nothing.
926 ///
927 static void
replaceChildren(pANTLR3_TREE_NODE_STREAM tns,pANTLR3_BASE_TREE parent,ANTLR3_INT32 startChildIndex,ANTLR3_INT32 stopChildIndex,pANTLR3_BASE_TREE t)928 replaceChildren (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t)
929 {
930 if (parent != NULL)
931 {
932 pANTLR3_BASE_TREE_ADAPTOR adaptor;
933 pANTLR3_COMMON_TREE_ADAPTOR cta;
934
935 adaptor = tns->getTreeAdaptor(tns);
936 cta = (pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super);
937
938 adaptor->replaceChildren(adaptor, parent, startChildIndex, stopChildIndex, t);
939 }
940 }
941
942 static pANTLR3_BASE_TREE
get(pANTLR3_TREE_NODE_STREAM tns,ANTLR3_INT32 k)943 get (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k)
944 {
945 if (tns->ctns->p == -1)
946 {
947 fillBufferRoot(tns->ctns);
948 }
949
950 return tns->ctns->nodes->get(tns->ctns->nodes, k);
951 }
952
953 static void
push(pANTLR3_COMMON_TREE_NODE_STREAM ctns,ANTLR3_INT32 index)954 push (pANTLR3_COMMON_TREE_NODE_STREAM ctns, ANTLR3_INT32 index)
955 {
956 ctns->nodeStack->push(ctns->nodeStack, ANTLR3_FUNC_PTR(ctns->p), NULL); // Save current index
957 ctns->tnstream->istream->seek(ctns->tnstream->istream, index);
958 }
959
960 static ANTLR3_INT32
pop(pANTLR3_COMMON_TREE_NODE_STREAM ctns)961 pop (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
962 {
963 ANTLR3_INT32 retVal;
964
965 retVal = ANTLR3_UINT32_CAST(ctns->nodeStack->pop(ctns->nodeStack));
966 ctns->tnstream->istream->seek(ctns->tnstream->istream, retVal);
967 return retVal;
968 }
969