2 * This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23
\r
4 * - From the grammar source file : Lang.g
\r
5 * - On : 2010-02-24 13:27:52
\r
6 * - for the parser : LangParserParser *
\r
7 * Editing it, at least manually, is not wise.
\r
9 * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
\r
13 // [The "BSD licence"]
\r
14 // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
\r
15 // http://www.temporal-wave.com
\r
16 // http://www.linkedin.com/in/jimidle
\r
18 // All rights reserved.
\r
20 // Redistribution and use in source and binary forms, with or without
\r
21 // modification, are permitted provided that the following conditions
\r
23 // 1. Redistributions of source code must retain the above copyright
\r
24 // notice, this list of conditions and the following disclaimer.
\r
25 // 2. Redistributions in binary form must reproduce the above copyright
\r
26 // notice, this list of conditions and the following disclaimer in the
\r
27 // documentation and/or other materials provided with the distribution.
\r
28 // 3. The name of the author may not be used to endorse or promote products
\r
29 // derived from this software without specific prior written permission.
\r
31 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
\r
32 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
\r
33 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
\r
34 // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
\r
35 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
\r
36 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
\r
37 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
\r
38 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
\r
39 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
\r
40 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
42 /* -----------------------------------------
\r
43 * Include the ANTLR3 generated header file.
\r
45 #include "LangParser.h"
\r
46 /* ----------------------------------------- */
\r
52 /* MACROS that hide the C interface implementations from the
\r
53 * generated code, which makes it a little more understandable to the human eye.
\r
54 * I am very much against using C pre-processor macros for function calls and bits
\r
55 * of code as you cannot see what is happening when single stepping in debuggers
\r
56 * and so on. The exception (in my book at least) is for generated code, where you are
\r
57 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
\r
58 * hides some indirect calls, but is always referring to the input stream. This is
\r
59 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
\r
60 * the runtime interfaces without changing the generated code too often, without
\r
61 * confusing the reader of the generated output, who may not wish to know the gory
\r
62 * details of the interface inheritance.
\r
67 /* Aids in accessing scopes for grammar programmers
\r
72 #define SCOPE_TYPE(scope) pLangParser_##scope##_SCOPE
\r
73 #define SCOPE_STACK(scope) pLangParser_##scope##Stack
\r
74 #define SCOPE_TOP(scope) ctx->pLangParser_##scope##Top
\r
75 #define SCOPE_SIZE(scope) ctx->pLangParser_##scope##Stack_limit
\r
76 #define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
\r
78 /* Macros for accessing things in the parser
\r
83 #undef HAVEPARSEDRULE
\r
103 #undef PERRORRECOVERY
\r
106 #undef RECOVERFROMMISMATCHEDSET
\r
107 #undef RECOVERFROMMISMATCHEDELEMENT
\r
114 #define PARSER ctx->pParser
\r
115 #define RECOGNIZER PARSER->rec
\r
116 #define PSRSTATE RECOGNIZER->state
\r
117 #define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
\r
118 #define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
\r
119 #define INPUT PARSER->tstream
\r
120 #define STRSTREAM INPUT
\r
121 #define ISTREAM INPUT->istream
\r
122 #define INDEX() ISTREAM->index(INPUT->istream)
\r
123 #define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
\r
124 #define EXCEPTION PSRSTATE->exception
\r
125 #define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
\r
126 #define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
\r
127 #define FOLLOWSTACK PSRSTATE->following
\r
128 #define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
\r
129 #define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
\r
130 #define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
\r
131 #define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
\r
132 #define LA(n) INPUT->istream->_LA(ISTREAM, n)
\r
133 #define LT(n) INPUT->_LT(INPUT, n)
\r
134 #define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
\r
135 #define CONSUME() ISTREAM->consume(ISTREAM)
\r
136 #define MARK() ISTREAM->mark(ISTREAM)
\r
137 #define REWIND(m) ISTREAM->rewind(ISTREAM, m)
\r
138 #define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
\r
139 #define SEEK(n) ISTREAM->seek(ISTREAM, n)
\r
140 #define PERRORRECOVERY PSRSTATE->errorRecovery
\r
141 #define FAILEDFLAG PSRSTATE->failed
\r
142 #define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
\r
143 #define BACKTRACKING PSRSTATE->backtracking
\r
144 #define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
\r
145 #define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
\r
146 #define ADAPTOR ctx->adaptor
\r
147 #define RULEMEMO PSRSTATE->ruleMemo
\r
148 #define DBG RECOGNIZER->debugger
\r
150 #define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
\r
152 /* The 4 tokens defined below may well clash with your own #defines or token types. If so
\r
153 * then for the present you must use different names for your defines as these are hard coded
\r
154 * in the code generator. It would be better not to use such names internally, and maybe
\r
155 * we can change this in a forthcoming release. I deliberately do not #undef these
\r
156 * here as this will at least give you a redefined error somewhere if they clash.
\r
158 #define UP ANTLR3_TOKEN_UP
\r
159 #define DOWN ANTLR3_TOKEN_DOWN
\r
160 #define EOR ANTLR3_TOKEN_EOR
\r
161 #define INVALID ANTLR3_TOKEN_INVALID
\r
164 /* =============================================================================
\r
165 * Functions to create and destroy scopes. First come the rule scopes, followed
\r
166 * by the global declared scopes.
\r
171 /* ============================================================================= */
\r
173 /* =============================================================================
\r
174 * Start of recognizer
\r
179 /** \brief Table of all token names in symbolic order, mainly used for
\r
182 pANTLR3_UINT8 LangParserTokenNames[7+4]
\r
184 (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
\r
185 (pANTLR3_UINT8) "<EOR>",
\r
186 (pANTLR3_UINT8) "<DOWN>",
\r
187 (pANTLR3_UINT8) "<UP>",
\r
188 (pANTLR3_UINT8) "DECL",
\r
189 (pANTLR3_UINT8) "ID",
\r
190 (pANTLR3_UINT8) "INTTYPE",
\r
191 (pANTLR3_UINT8) "FLOATTYPE",
\r
192 (pANTLR3_UINT8) "INT",
\r
193 (pANTLR3_UINT8) "WS",
\r
194 (pANTLR3_UINT8) "';'"
\r
199 // Forward declare the locally static matching functions we have generated.
\r
201 static LangParser_start_return start (pLangParser ctx);
\r
202 static LangParser_decl_return decl (pLangParser ctx);
\r
203 static LangParser_type_return type (pLangParser ctx);
\r
204 static void LangParserFree(pLangParser ctx);
\r
205 /* For use in tree output where we are accumulating rule labels via label += ruleRef
\r
206 * we need a function that knows how to free a return scope when the list is destroyed.
\r
207 * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
\r
209 static void ANTLR3_CDECL freeScope(void * scope)
\r
211 ANTLR3_FREE(scope);
\r
214 /** \brief Name of the grammar file that generated this code
\r
216 static const char fileName[] = "Lang.g";
\r
218 /** \brief Return the name of the grammar file that generated this code.
\r
220 static const char * getGrammarFileName()
\r
224 /** \brief Create a new LangParser parser and return a context for it.
\r
226 * \param[in] instream Pointer to an input stream interface.
\r
228 * \return Pointer to new parser context upon success.
\r
230 ANTLR3_API pLangParser
\r
231 LangParserNew (pANTLR3_COMMON_TOKEN_STREAM instream)
\r
233 // See if we can create a new parser with the standard constructor
\r
235 return LangParserNewSSD(instream, NULL);
\r
238 /** \brief Create a new LangParser parser and return a context for it.
\r
240 * \param[in] instream Pointer to an input stream interface.
\r
242 * \return Pointer to new parser context upon success.
\r
244 ANTLR3_API pLangParser
\r
245 LangParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
\r
247 pLangParser ctx; /* Context structure we will build and return */
\r
249 ctx = (pLangParser) ANTLR3_CALLOC(1, sizeof(LangParser));
\r
253 // Failed to allocate memory for parser context
\r
258 /* -------------------------------------------------------------------
\r
259 * Memory for basic structure is allocated, now to fill in
\r
260 * the base ANTLR3 structures. We initialize the function pointers
\r
261 * for the standard ANTLR3 parser function set, but upon return
\r
262 * from here, the programmer may set the pointers to provide custom
\r
263 * implementations of each function.
\r
265 * We don't use the macros defined in LangParser.h here, in order that you can get a sense
\r
266 * of what goes where.
\r
269 /* Create a base parser/recognizer, using the supplied token stream
\r
271 ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);
\r
272 /* Install the implementation of our LangParser interface
\r
274 ctx->start = start;
\r
277 ctx->free = LangParserFree;
\r
278 ctx->getGrammarFileName = getGrammarFileName;
\r
280 /* Install the scope pushing methods.
\r
282 ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);
\r
283 ctx->vectors = antlr3VectorFactoryNew(0);
\r
287 /* Install the token table
\r
289 PSRSTATE->tokenNames = LangParserTokenNames;
\r
292 /* Return the newly built parser to the caller
\r
297 /** Free the parser resources
\r
300 LangParserFree(pLangParser ctx)
\r
302 /* Free any scope memory
\r
305 ctx->vectors->close(ctx->vectors);
\r
306 /* We created the adaptor so we must free it
\r
308 ADAPTOR->free(ADAPTOR);
\r
309 // Free this parser
\r
311 ctx->pParser->free(ctx->pParser);
\r
314 /* Everything is released, so we can return
\r
319 /** Return token names used by this parser
\r
321 * The returned pointer is used as an index into the token names table (using the token
\r
322 * number as the index).
\r
324 * \return Pointer to first char * in the table.
\r
326 static pANTLR3_UINT8 *getTokenNames()
\r
328 return LangParserTokenNames;
\r
332 /* Declare the bitsets
\r
335 /** Bitset defining follow set for error recovery in rule state: FOLLOW_decl_in_start91 */
\r
336 static ANTLR3_BITWORD FOLLOW_decl_in_start91_bits[] = { ANTLR3_UINT64_LIT(0x00000000000000C2) };
\r
337 static ANTLR3_BITSET_LIST FOLLOW_decl_in_start91 = { FOLLOW_decl_in_start91_bits, 1 };
\r
338 /** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_decl103 */
\r
339 static ANTLR3_BITWORD FOLLOW_type_in_decl103_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000020) };
\r
340 static ANTLR3_BITSET_LIST FOLLOW_type_in_decl103 = { FOLLOW_type_in_decl103_bits, 1 };
\r
341 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_decl105 */
\r
342 static ANTLR3_BITWORD FOLLOW_ID_in_decl105_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) };
\r
343 static ANTLR3_BITSET_LIST FOLLOW_ID_in_decl105 = { FOLLOW_ID_in_decl105_bits, 1 };
\r
344 /** Bitset defining follow set for error recovery in rule state: FOLLOW_10_in_decl107 */
\r
345 static ANTLR3_BITWORD FOLLOW_10_in_decl107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
346 static ANTLR3_BITSET_LIST FOLLOW_10_in_decl107 = { FOLLOW_10_in_decl107_bits, 1 };
\r
347 /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_type0 */
\r
348 static ANTLR3_BITWORD FOLLOW_set_in_type0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
349 static ANTLR3_BITSET_LIST FOLLOW_set_in_type0 = { FOLLOW_set_in_type0_bits, 1 };
\r
354 /* ==============================================
\r
358 * $ANTLR start start
\r
359 * Lang.g:20:1: start : ( decl )+ ;
\r
361 static LangParser_start_return
\r
362 start(pLangParser ctx)
\r
364 LangParser_start_return retval;
\r
366 pANTLR3_BASE_TREE root_0;
\r
368 LangParser_decl_return decl1;
\r
369 #undef RETURN_TYPE_decl1
\r
370 #define RETURN_TYPE_decl1 LangParser_decl_return
\r
373 /* Initialize rule variables
\r
381 retval.start = LT(1); retval.stop = retval.start;
\r
385 retval.tree = NULL;
\r
387 // Lang.g:20:7: ( ( decl )+ )
\r
388 // Lang.g:20:9: ( decl )+
\r
390 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
392 // Lang.g:20:9: ( decl )+
\r
413 // Lang.g:20:9: decl
\r
415 FOLLOWPUSH(FOLLOW_decl_in_start91);
\r
419 if (HASEXCEPTION())
\r
424 ADAPTOR->addChild(ADAPTOR, root_0, decl1.tree);
\r
435 /* mismatchedSetEx()
\r
438 EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
\r
439 EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
\r
446 loop1: ; /* Jump to here if this rule does not match */
\r
454 // This is where rules clean up and exit
\r
456 goto rulestartEx; /* Prevent compiler warnings */
\r
458 retval.stop = LT(-1);
\r
460 retval.stop = LT(-1);
\r
461 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
462 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
464 if (HASEXCEPTION())
\r
468 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
474 /* $ANTLR end start */
\r
477 * $ANTLR start decl
\r
478 * Lang.g:23:1: decl : type ID ';' -> ^( DECL type ID ) ;
\r
480 static LangParser_decl_return
\r
481 decl(pLangParser ctx)
\r
483 LangParser_decl_return retval;
\r
485 pANTLR3_BASE_TREE root_0;
\r
487 pANTLR3_COMMON_TOKEN ID3;
\r
488 pANTLR3_COMMON_TOKEN char_literal4;
\r
489 LangParser_type_return type2;
\r
490 #undef RETURN_TYPE_type2
\r
491 #define RETURN_TYPE_type2 LangParser_type_return
\r
493 pANTLR3_BASE_TREE ID3_tree;
\r
494 pANTLR3_BASE_TREE char_literal4_tree;
\r
495 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_10;
\r
496 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;
\r
497 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_type;
\r
498 /* Initialize rule variables
\r
505 char_literal4 = NULL;
\r
508 retval.start = LT(1); retval.stop = retval.start;
\r
511 char_literal4_tree = NULL;
\r
514 #define CREATE_stream_10 if (stream_10 == NULL) {stream_10 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 10"); }
\r
516 #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); }
\r
517 stream_type = NULL;
\r
518 #define CREATE_stream_type if (stream_type == NULL) {stream_type = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule type"); }
\r
520 retval.tree = NULL;
\r
522 // Lang.g:23:6: ( type ID ';' -> ^( DECL type ID ) )
\r
523 // Lang.g:23:8: type ID ';'
\r
525 FOLLOWPUSH(FOLLOW_type_in_decl103);
\r
529 if (HASEXCEPTION())
\r
534 CREATE_stream_type; stream_type->add(stream_type, type2.tree, NULL);
\r
535 ID3 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_decl105);
\r
536 if (HASEXCEPTION())
\r
541 CREATE_stream_ID; stream_ID->add(stream_ID, ID3, NULL);
\r
543 char_literal4 = (pANTLR3_COMMON_TOKEN) MATCHT(10, &FOLLOW_10_in_decl107);
\r
544 if (HASEXCEPTION())
\r
549 CREATE_stream_10; stream_10->add(stream_10, char_literal4, NULL);
\r
554 * elements : ID, type
\r
556 * rule labels : retval
\r
557 * token list labels :
\r
558 * rule list labels :
\r
561 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
563 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
565 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
566 retval.tree = root_0;
\r
567 // 23:20: -> ^( DECL type ID )
\r
569 // Lang.g:23:23: ^( DECL type ID )
\r
571 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
572 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, DECL, (pANTLR3_UINT8)"DECL"), root_1));
\r
574 ADAPTOR->addChild(ADAPTOR, root_1, stream_type == NULL ? NULL : stream_type->nextTree(stream_type));
\r
575 ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));
\r
577 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
582 retval.tree = root_0; // set result root
\r
583 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
592 // This is where rules clean up and exit
\r
594 goto ruledeclEx; /* Prevent compiler warnings */
\r
596 retval.stop = LT(-1);
\r
598 retval.stop = LT(-1);
\r
599 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
600 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
601 if (stream_10 != NULL) stream_10->free(stream_10);
\r
602 if (stream_ID != NULL) stream_ID->free(stream_ID);
\r
603 if (stream_type != NULL) stream_type->free(stream_type);
\r
605 if (HASEXCEPTION())
\r
609 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
615 /* $ANTLR end decl */
\r
618 * $ANTLR start type
\r
619 * Lang.g:26:1: type : ( INTTYPE | FLOATTYPE );
\r
621 static LangParser_type_return
\r
622 type(pLangParser ctx)
\r
624 LangParser_type_return retval;
\r
626 pANTLR3_BASE_TREE root_0;
\r
628 pANTLR3_COMMON_TOKEN set5;
\r
630 pANTLR3_BASE_TREE set5_tree;
\r
632 /* Initialize rule variables
\r
639 retval.start = LT(1); retval.stop = retval.start;
\r
644 retval.tree = NULL;
\r
646 // Lang.g:26:6: ( INTTYPE | FLOATTYPE )
\r
649 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
651 set5=(pANTLR3_COMMON_TOKEN)LT(1);
\r
652 if ( ((LA(1) >= INTTYPE) && (LA(1) <= FLOATTYPE)) )
\r
655 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set5)));
\r
656 PERRORRECOVERY=ANTLR3_FALSE;
\r
661 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
\r
662 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
\r
663 EXCEPTION->expectingSet = &FOLLOW_set_in_type0;
\r
664 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_type0); goto ruletypeEx;
\r
673 // This is where rules clean up and exit
\r
675 goto ruletypeEx; /* Prevent compiler warnings */
\r
677 retval.stop = LT(-1);
\r
679 retval.stop = LT(-1);
\r
680 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
681 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
683 if (HASEXCEPTION())
\r
687 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
693 /* $ANTLR end type */
\r
694 /* End of parsing rules
\r
695 * ==============================================
\r
698 /* ==============================================
\r
699 * Syntactic predicates
\r
701 /* End of syntactic predicates
\r
702 * ==============================================
\r
711 * =============================================================================
\r