bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/LangParser.c

   1 /** \file\r
   2  *  This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23\r
   3  *\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
   8  *\r
   9  * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.\r
  10  *\r
  11  *\r
  12 */\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
  17 //\r
  18 // All rights reserved.\r
  19 //\r
  20 // Redistribution and use in source and binary forms, with or without\r
  21 // modification, are permitted provided that the following conditions\r
  22 // are met:\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
  30 //\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
  41 \r
  42 /* -----------------------------------------\r
  43  * Include the ANTLR3 generated header file.\r
  44  */\r
  45 #include    "LangParser.h"\r
  46 /* ----------------------------------------- */\r
  47 \r
  48 \r
  49 \r
  50 \r
  51 \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
  63  */\r
  64  \r
  65 #define         CTX     ctx\r
  66 \r
  67 /* Aids in accessing scopes for grammar programmers\r
  68  */\r
  69 #undef  SCOPE_TYPE\r
  70 #undef  SCOPE_STACK\r
  71 #undef  SCOPE_TOP\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
  77 \r
  78 /* Macros for accessing things in the parser\r
  79  */\r
  80  \r
  81 #undef      PARSER                  \r
  82 #undef      RECOGNIZER              \r
  83 #undef      HAVEPARSEDRULE\r
  84 #undef          MEMOIZE\r
  85 #undef      INPUT\r
  86 #undef      STRSTREAM\r
  87 #undef      HASEXCEPTION\r
  88 #undef      EXCEPTION\r
  89 #undef      MATCHT\r
  90 #undef      MATCHANYT\r
  91 #undef      FOLLOWSTACK\r
  92 #undef      FOLLOWPUSH\r
  93 #undef      FOLLOWPOP\r
  94 #undef      PRECOVER\r
  95 #undef      PREPORTERROR\r
  96 #undef      LA\r
  97 #undef      LT\r
  98 #undef      CONSTRUCTEX\r
  99 #undef      CONSUME\r
 100 #undef      MARK\r
 101 #undef      REWIND\r
 102 #undef      REWINDLAST\r
 103 #undef      PERRORRECOVERY\r
 104 #undef      HASFAILED\r
 105 #undef      FAILEDFLAG\r
 106 #undef      RECOVERFROMMISMATCHEDSET\r
 107 #undef      RECOVERFROMMISMATCHEDELEMENT\r
 108 #undef          INDEX\r
 109 #undef      ADAPTOR\r
 110 #undef          SEEK\r
 111 #undef      RULEMEMO                \r
 112 #undef          DBG\r
 113 \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
 149 \r
 150 #define         TOKTEXT(tok, txt)                               tok, (pANTLR3_UINT8)txt\r
 151 \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
 157  */\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
 162 \r
 163 \r
 164 /* =============================================================================\r
 165  * Functions to create and destroy scopes. First come the rule scopes, followed\r
 166  * by the global declared scopes.\r
 167  */\r
 168 \r
 169 \r
 170 \r
 171 /* ============================================================================= */\r
 172 \r
 173 /* =============================================================================\r
 174  * Start of recognizer\r
 175  */\r
 176 \r
 177 \r
 178 \r
 179 /** \brief Table of all token names in symbolic order, mainly used for\r
 180  *         error reporting.\r
 181  */\r
 182 pANTLR3_UINT8   LangParserTokenNames[7+4]\r
 183      = {\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
 195        };\r
 196 \r
 197         \r
 198 \r
 199 // Forward declare the locally static matching functions we have generated.\r
 200 //\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
 208  */\r
 209 static  void ANTLR3_CDECL freeScope(void * scope)\r
 210 {\r
 211     ANTLR3_FREE(scope);\r
 212 }\r
 213 \r
 214 /** \brief Name of the grammar file that generated this code\r
 215  */\r
 216 static const char fileName[] = "Lang.g";\r
 217 \r
 218 /** \brief Return the name of the grammar file that generated this code.\r
 219  */\r
 220 static const char * getGrammarFileName()\r
 221 {\r
 222         return fileName;\r
 223 }\r
 224 /** \brief Create a new LangParser parser and return a context for it.\r
 225  *\r
 226  * \param[in] instream Pointer to an input stream interface.\r
 227  *\r
 228  * \return Pointer to new parser context upon success.\r
 229  */\r
 230 ANTLR3_API pLangParser\r
 231 LangParserNew   (pANTLR3_COMMON_TOKEN_STREAM instream)\r
 232 {\r
 233         // See if we can create a new parser with the standard constructor\r
 234         //\r
 235         return LangParserNewSSD(instream, NULL);\r
 236 }\r
 237 \r
 238 /** \brief Create a new LangParser parser and return a context for it.\r
 239  *\r
 240  * \param[in] instream Pointer to an input stream interface.\r
 241  *\r
 242  * \return Pointer to new parser context upon success.\r
 243  */\r
 244 ANTLR3_API pLangParser\r
 245 LangParserNewSSD   (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)\r
 246 {\r
 247     pLangParser ctx;        /* Context structure we will build and return   */\r
 248     \r
 249     ctx = (pLangParser) ANTLR3_CALLOC(1, sizeof(LangParser));\r
 250     \r
 251     if  (ctx == NULL)\r
 252     {\r
 253                 // Failed to allocate memory for parser context\r
 254                 //\r
 255         return  NULL;\r
 256     }\r
 257     \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
 264      *\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
 267      */\r
 268 \r
 269     /* Create a base parser/recognizer, using the supplied token stream\r
 270      */\r
 271     ctx->pParser            = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);\r
 272     /* Install the implementation of our LangParser interface\r
 273      */\r
 274     ctx->start  = start;\r
 275     ctx->decl   = decl;\r
 276     ctx->type   = type;\r
 277     ctx->free                   = LangParserFree;\r
 278     ctx->getGrammarFileName     = getGrammarFileName;\r
 279     \r
 280     /* Install the scope pushing methods.\r
 281      */\r
 282     ADAPTOR     = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);\r
 283     ctx->vectors        = antlr3VectorFactoryNew(0);\r
 284     \r
 285 \r
 286         \r
 287     /* Install the token table\r
 288      */\r
 289     PSRSTATE->tokenNames   = LangParserTokenNames;\r
 290     \r
 291     \r
 292     /* Return the newly built parser to the caller\r
 293      */\r
 294     return  ctx;\r
 295 }\r
 296 \r
 297 /** Free the parser resources\r
 298  */\r
 299  static void\r
 300  LangParserFree(pLangParser ctx)\r
 301  {\r
 302     /* Free any scope memory\r
 303      */\r
 304     \r
 305     ctx->vectors->close(ctx->vectors);\r
 306     /* We created the adaptor so we must free it\r
 307      */\r
 308     ADAPTOR->free(ADAPTOR);\r
 309         // Free this parser\r
 310         //\r
 311     ctx->pParser->free(ctx->pParser);\r
 312     ANTLR3_FREE(ctx);\r
 313 \r
 314     /* Everything is released, so we can return\r
 315      */\r
 316     return;\r
 317  }\r
 318  \r
 319 /** Return token names used by this parser\r
 320  *\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
 323  * \r
 324  * \return Pointer to first char * in the table.\r
 325  */\r
 326 static pANTLR3_UINT8    *getTokenNames() \r
 327 {\r
 328         return LangParserTokenNames; \r
 329 }\r
 330 \r
 331     \r
 332 /* Declare the bitsets\r
 333  */\r
 334 \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
 350      \r
 351 \r
 352  \r
 353  \r
 354 /* ==============================================\r
 355  * Parsing rules\r
 356  */\r
 357 /** \r
 358  * $ANTLR start start\r
 359  * Lang.g:20:1: start : ( decl )+ ;\r
 360  */\r
 361 static LangParser_start_return\r
 362 start(pLangParser ctx)\r
 363 {   \r
 364     LangParser_start_return retval;\r
 365 \r
 366     pANTLR3_BASE_TREE root_0;\r
 367 \r
 368     LangParser_decl_return decl1;\r
 369     #undef      RETURN_TYPE_decl1\r
 370     #define     RETURN_TYPE_decl1 LangParser_decl_return\r
 371 \r
 372 \r
 373     /* Initialize rule variables\r
 374      */\r
 375 \r
 376 \r
 377     root_0 = NULL;\r
 378 \r
 379     decl1.tree = NULL;\r
 380 \r
 381     retval.start = LT(1); retval.stop = retval.start;\r
 382 \r
 383 \r
 384 \r
 385     retval.tree  = NULL;\r
 386     {\r
 387         // Lang.g:20:7: ( ( decl )+ )\r
 388         // Lang.g:20:9: ( decl )+\r
 389         {\r
 390             root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
 391 \r
 392             // Lang.g:20:9: ( decl )+\r
 393             {\r
 394                 int cnt1=0;\r
 395 \r
 396                 for (;;)\r
 397                 {\r
 398                     int alt1=2;\r
 399                 switch ( LA(1) ) \r
 400                 {\r
 401                 case INTTYPE:\r
 402                 case FLOATTYPE:\r
 403                         {\r
 404                                 alt1=1;\r
 405                         }\r
 406                     break;\r
 407 \r
 408                 }\r
 409 \r
 410                 switch (alt1) \r
 411                 {\r
 412                     case 1:\r
 413                         // Lang.g:20:9: decl\r
 414                         {\r
 415                             FOLLOWPUSH(FOLLOW_decl_in_start91);\r
 416                             decl1=decl(ctx);\r
 417 \r
 418                             FOLLOWPOP();\r
 419                             if  (HASEXCEPTION())\r
 420                             {\r
 421                                 goto rulestartEx;\r
 422                             }\r
 423 \r
 424                             ADAPTOR->addChild(ADAPTOR, root_0, decl1.tree);\r
 425 \r
 426                         }\r
 427                         break;\r
 428 \r
 429                     default:\r
 430                     \r
 431                         if ( cnt1 >= 1 )\r
 432                         {\r
 433                             goto loop1;\r
 434                         }\r
 435                         /* mismatchedSetEx()\r
 436                          */\r
 437                         CONSTRUCTEX();\r
 438                         EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;\r
 439                         EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;\r
 440 \r
 441 \r
 442                         goto rulestartEx;\r
 443                 }\r
 444                 cnt1++;\r
 445                 }\r
 446                 loop1: ;        /* Jump to here if this rule does not match */\r
 447             }\r
 448 \r
 449         }\r
 450 \r
 451     }\r
 452     \r
 453 \r
 454     // This is where rules clean up and exit\r
 455     //\r
 456     goto rulestartEx; /* Prevent compiler warnings */\r
 457     rulestartEx: ;\r
 458     retval.stop = LT(-1);\r
 459 \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
 463 \r
 464             if (HASEXCEPTION())\r
 465             {\r
 466                 PREPORTERROR();\r
 467                 PRECOVER();\r
 468                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
 469             }\r
 470 \r
 471 \r
 472     return retval;\r
 473 }\r
 474 /* $ANTLR end start */\r
 475 \r
 476 /** \r
 477  * $ANTLR start decl\r
 478  * Lang.g:23:1: decl : type ID ';' -> ^( DECL type ID ) ;\r
 479  */\r
 480 static LangParser_decl_return\r
 481 decl(pLangParser ctx)\r
 482 {   \r
 483     LangParser_decl_return retval;\r
 484 \r
 485     pANTLR3_BASE_TREE root_0;\r
 486 \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
 492 \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
 499      */\r
 500 \r
 501 \r
 502     root_0 = NULL;\r
 503 \r
 504     ID3       = NULL;\r
 505     char_literal4       = NULL;\r
 506     type2.tree = NULL;\r
 507 \r
 508     retval.start = LT(1); retval.stop = retval.start;\r
 509 \r
 510     ID3_tree   = NULL;\r
 511     char_literal4_tree   = NULL;\r
 512 \r
 513     stream_10   = NULL;\r
 514     #define CREATE_stream_10  if (stream_10 == NULL) {stream_10 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 10"); } \r
 515     stream_ID   = NULL;\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
 519 \r
 520     retval.tree  = NULL;\r
 521     {\r
 522         // Lang.g:23:6: ( type ID ';' -> ^( DECL type ID ) )\r
 523         // Lang.g:23:8: type ID ';'\r
 524         {\r
 525             FOLLOWPUSH(FOLLOW_type_in_decl103);\r
 526             type2=type(ctx);\r
 527 \r
 528             FOLLOWPOP();\r
 529             if  (HASEXCEPTION())\r
 530             {\r
 531                 goto ruledeclEx;\r
 532             }\r
 533 \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
 537             {\r
 538                 goto ruledeclEx;\r
 539             }\r
 540              \r
 541             CREATE_stream_ID; stream_ID->add(stream_ID, ID3, NULL);\r
 542 \r
 543             char_literal4 = (pANTLR3_COMMON_TOKEN) MATCHT(10, &FOLLOW_10_in_decl107); \r
 544             if  (HASEXCEPTION())\r
 545             {\r
 546                 goto ruledeclEx;\r
 547             }\r
 548              \r
 549             CREATE_stream_10; stream_10->add(stream_10, char_literal4, NULL);\r
 550 \r
 551 \r
 552              \r
 553             /* AST REWRITE\r
 554              * elements          : ID, type\r
 555              * token labels      : \r
 556              * rule labels       : retval\r
 557              * token list labels : \r
 558              * rule list labels  : \r
 559              */\r
 560             {\r
 561                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
 562 \r
 563                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
 564 \r
 565                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
 566                 retval.tree    = root_0;\r
 567                 // 23:20: -> ^( DECL type ID )\r
 568                 {\r
 569                     // Lang.g:23:23: ^( DECL type ID )\r
 570                     {\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
 573 \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
 576 \r
 577                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
 578                     }\r
 579 \r
 580                 }\r
 581 \r
 582                 retval.tree = root_0; // set result root\r
 583                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
 584 \r
 585 \r
 586             }\r
 587         }\r
 588 \r
 589     }\r
 590     \r
 591 \r
 592     // This is where rules clean up and exit\r
 593     //\r
 594     goto ruledeclEx; /* Prevent compiler warnings */\r
 595     ruledeclEx: ;\r
 596     retval.stop = LT(-1);\r
 597 \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
 604 \r
 605             if (HASEXCEPTION())\r
 606             {\r
 607                 PREPORTERROR();\r
 608                 PRECOVER();\r
 609                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
 610             }\r
 611 \r
 612 \r
 613     return retval;\r
 614 }\r
 615 /* $ANTLR end decl */\r
 616 \r
 617 /** \r
 618  * $ANTLR start type\r
 619  * Lang.g:26:1: type : ( INTTYPE | FLOATTYPE );\r
 620  */\r
 621 static LangParser_type_return\r
 622 type(pLangParser ctx)\r
 623 {   \r
 624     LangParser_type_return retval;\r
 625 \r
 626     pANTLR3_BASE_TREE root_0;\r
 627 \r
 628     pANTLR3_COMMON_TOKEN    set5;\r
 629 \r
 630     pANTLR3_BASE_TREE set5_tree;\r
 631 \r
 632     /* Initialize rule variables\r
 633      */\r
 634 \r
 635 \r
 636     root_0 = NULL;\r
 637 \r
 638     set5       = NULL;\r
 639     retval.start = LT(1); retval.stop = retval.start;\r
 640 \r
 641     set5_tree   = NULL;\r
 642 \r
 643 \r
 644     retval.tree  = NULL;\r
 645     {\r
 646         // Lang.g:26:6: ( INTTYPE | FLOATTYPE )\r
 647         // Lang.g:\r
 648         {\r
 649             root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
 650 \r
 651             set5=(pANTLR3_COMMON_TOKEN)LT(1);\r
 652             if ( ((LA(1) >= INTTYPE) && (LA(1) <= FLOATTYPE)) )\r
 653             {\r
 654                 CONSUME();\r
 655                 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set5)));\r
 656                 PERRORRECOVERY=ANTLR3_FALSE;\r
 657             }\r
 658             else \r
 659             {\r
 660                 CONSTRUCTEX();\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
 665             }\r
 666 \r
 667 \r
 668         }\r
 669 \r
 670     }\r
 671     \r
 672 \r
 673     // This is where rules clean up and exit\r
 674     //\r
 675     goto ruletypeEx; /* Prevent compiler warnings */\r
 676     ruletypeEx: ;\r
 677     retval.stop = LT(-1);\r
 678 \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
 682 \r
 683             if (HASEXCEPTION())\r
 684             {\r
 685                 PREPORTERROR();\r
 686                 PRECOVER();\r
 687                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
 688             }\r
 689 \r
 690 \r
 691     return retval;\r
 692 }\r
 693 /* $ANTLR end type */\r
 694 /* End of parsing rules\r
 695  * ==============================================\r
 696  */\r
 697 \r
 698 /* ==============================================\r
 699  * Syntactic predicates\r
 700  */\r
 701 /* End of syntactic predicates\r
 702  * ==============================================\r
 703  */\r
 704 \r
 705  \r
 706  \r
 707 \r
 708 \r
 709 \r
 710 /* End of code\r
 711  * =============================================================================\r
 712  */\r