bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/SimanticsDataParser.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 : C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g\r
   5  *     -                            On : 2010-03-26 13:33:27\r
   6  *     -                for the parser : SimanticsDataParserParser *\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    "SimanticsDataParser.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)   pSimanticsDataParser_##scope##_SCOPE\r
  73 #define SCOPE_STACK(scope)  pSimanticsDataParser_##scope##Stack\r
  74 #define SCOPE_TOP(scope)    ctx->pSimanticsDataParser_##scope##Top\r
  75 #define SCOPE_SIZE(scope)               ctx->pSimanticsDataParser_##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   SimanticsDataParserTokenNames[46+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) "TYPE_DEFINITIONS",\r
 189         (pANTLR3_UINT8) "TYPE_DEFINITION",\r
 190         (pANTLR3_UINT8) "UNION_TYPE",\r
 191         (pANTLR3_UINT8) "RECORD_TYPE",\r
 192         (pANTLR3_UINT8) "TUPLE_TYPE",\r
 193         (pANTLR3_UINT8) "ARRAY_TYPE",\r
 194         (pANTLR3_UINT8) "TYPE_REFERENCE",\r
 195         (pANTLR3_UINT8) "TYPE_ANNOTATION",\r
 196         (pANTLR3_UINT8) "TYPE_COMPONENT",\r
 197         (pANTLR3_UINT8) "VALUE_DEFINITIONS",\r
 198         (pANTLR3_UINT8) "VALUE_DEFINITION",\r
 199         (pANTLR3_UINT8) "NO_VALUE",\r
 200         (pANTLR3_UINT8) "VARIANT",\r
 201         (pANTLR3_UINT8) "ARRAY",\r
 202         (pANTLR3_UINT8) "TUPLE",\r
 203         (pANTLR3_UINT8) "TAGGED_VALUE",\r
 204         (pANTLR3_UINT8) "RECORD",\r
 205         (pANTLR3_UINT8) "MAP",\r
 206         (pANTLR3_UINT8) "ASSIGNMENT",\r
 207         (pANTLR3_UINT8) "ID",\r
 208         (pANTLR3_UINT8) "INT",\r
 209         (pANTLR3_UINT8) "EXPONENT",\r
 210         (pANTLR3_UINT8) "FLOAT",\r
 211         (pANTLR3_UINT8) "COMMENT",\r
 212         (pANTLR3_UINT8) "WS",\r
 213         (pANTLR3_UINT8) "ESC_SEQ",\r
 214         (pANTLR3_UINT8) "STRING",\r
 215         (pANTLR3_UINT8) "HEX_DIGIT",\r
 216         (pANTLR3_UINT8) "UNICODE_ESC",\r
 217         (pANTLR3_UINT8) "OCTAL_ESC",\r
 218         (pANTLR3_UINT8) "'type'",\r
 219         (pANTLR3_UINT8) "'='",\r
 220         (pANTLR3_UINT8) "'|'",\r
 221         (pANTLR3_UINT8) "'['",\r
 222         (pANTLR3_UINT8) "']'",\r
 223         (pANTLR3_UINT8) "'..'",\r
 224         (pANTLR3_UINT8) "'('",\r
 225         (pANTLR3_UINT8) "','",\r
 226         (pANTLR3_UINT8) "')'",\r
 227         (pANTLR3_UINT8) "'{'",\r
 228         (pANTLR3_UINT8) "'}'",\r
 229         (pANTLR3_UINT8) "':'",\r
 230         (pANTLR3_UINT8) "'true'",\r
 231         (pANTLR3_UINT8) "'false'",\r
 232         (pANTLR3_UINT8) "'null'",\r
 233         (pANTLR3_UINT8) "'map'"\r
 234        };\r
 235 \r
 236         \r
 237 \r
 238 // Forward declare the locally static matching functions we have generated.\r
 239 //\r
 240 static SimanticsDataParser_typeDefinitions_return       typeDefinitions    (pSimanticsDataParser ctx);\r
 241 static SimanticsDataParser_typeDefinition_return        typeDefinition    (pSimanticsDataParser ctx);\r
 242 static SimanticsDataParser_unionType_return     unionType    (pSimanticsDataParser ctx);\r
 243 static SimanticsDataParser_unionComponent_return        unionComponent    (pSimanticsDataParser ctx);\r
 244 static SimanticsDataParser_type_return  type    (pSimanticsDataParser ctx);\r
 245 static SimanticsDataParser_arrayLength_return   arrayLength    (pSimanticsDataParser ctx);\r
 246 static SimanticsDataParser_basicType_return     basicType    (pSimanticsDataParser ctx);\r
 247 static SimanticsDataParser_tupleType_return     tupleType    (pSimanticsDataParser ctx);\r
 248 static SimanticsDataParser_recordType_return    recordType    (pSimanticsDataParser ctx);\r
 249 static SimanticsDataParser_component_return     component    (pSimanticsDataParser ctx);\r
 250 static SimanticsDataParser_typeReference_return typeReference    (pSimanticsDataParser ctx);\r
 251 static SimanticsDataParser_parameter_return     parameter    (pSimanticsDataParser ctx);\r
 252 static SimanticsDataParser_parameterValue_return        parameterValue    (pSimanticsDataParser ctx);\r
 253 static SimanticsDataParser_range_return range    (pSimanticsDataParser ctx);\r
 254 static SimanticsDataParser_number_return        number    (pSimanticsDataParser ctx);\r
 255 static SimanticsDataParser_string_return        string    (pSimanticsDataParser ctx);\r
 256 static SimanticsDataParser_boolean_return       boolean    (pSimanticsDataParser ctx);\r
 257 static SimanticsDataParser_valueDefinitions_return      valueDefinitions    (pSimanticsDataParser ctx);\r
 258 static SimanticsDataParser_valueDefinition_return       valueDefinition    (pSimanticsDataParser ctx);\r
 259 static SimanticsDataParser_value_return value    (pSimanticsDataParser ctx);\r
 260 static SimanticsDataParser_basicValue_return    basicValue    (pSimanticsDataParser ctx);\r
 261 static SimanticsDataParser_array_return array    (pSimanticsDataParser ctx);\r
 262 static SimanticsDataParser_tuple_return tuple    (pSimanticsDataParser ctx);\r
 263 static SimanticsDataParser_taggedValue_return   taggedValue    (pSimanticsDataParser ctx);\r
 264 static SimanticsDataParser_record_return        record    (pSimanticsDataParser ctx);\r
 265 static SimanticsDataParser_recordAssignment_return      recordAssignment    (pSimanticsDataParser ctx);\r
 266 static SimanticsDataParser_map_return   map    (pSimanticsDataParser ctx);\r
 267 static SimanticsDataParser_mapAssignment_return mapAssignment    (pSimanticsDataParser ctx);\r
 268 static void     SimanticsDataParserFree(pSimanticsDataParser ctx);\r
 269 /* For use in tree output where we are accumulating rule labels via label += ruleRef\r
 270  * we need a function that knows how to free a return scope when the list is destroyed. \r
 271  * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.\r
 272  */\r
 273 static  void ANTLR3_CDECL freeScope(void * scope)\r
 274 {\r
 275     ANTLR3_FREE(scope);\r
 276 }\r
 277 \r
 278 /** \brief Name of the grammar file that generated this code\r
 279  */\r
 280 static const char fileName[] = "C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g";\r
 281 \r
 282 /** \brief Return the name of the grammar file that generated this code.\r
 283  */\r
 284 static const char * getGrammarFileName()\r
 285 {\r
 286         return fileName;\r
 287 }\r
 288 /** \brief Create a new SimanticsDataParser parser and return a context for it.\r
 289  *\r
 290  * \param[in] instream Pointer to an input stream interface.\r
 291  *\r
 292  * \return Pointer to new parser context upon success.\r
 293  */\r
 294 ANTLR3_API pSimanticsDataParser\r
 295 SimanticsDataParserNew   (pANTLR3_COMMON_TOKEN_STREAM instream)\r
 296 {\r
 297         // See if we can create a new parser with the standard constructor\r
 298         //\r
 299         return SimanticsDataParserNewSSD(instream, NULL);\r
 300 }\r
 301 \r
 302 /** \brief Create a new SimanticsDataParser parser and return a context for it.\r
 303  *\r
 304  * \param[in] instream Pointer to an input stream interface.\r
 305  *\r
 306  * \return Pointer to new parser context upon success.\r
 307  */\r
 308 ANTLR3_API pSimanticsDataParser\r
 309 SimanticsDataParserNewSSD   (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)\r
 310 {\r
 311     pSimanticsDataParser ctx;       /* Context structure we will build and return   */\r
 312     \r
 313     ctx = (pSimanticsDataParser) ANTLR3_CALLOC(1, sizeof(SimanticsDataParser));\r
 314     \r
 315     if  (ctx == NULL)\r
 316     {\r
 317                 // Failed to allocate memory for parser context\r
 318                 //\r
 319         return  NULL;\r
 320     }\r
 321     \r
 322     /* -------------------------------------------------------------------\r
 323      * Memory for basic structure is allocated, now to fill in\r
 324      * the base ANTLR3 structures. We initialize the function pointers\r
 325      * for the standard ANTLR3 parser function set, but upon return\r
 326      * from here, the programmer may set the pointers to provide custom\r
 327      * implementations of each function. \r
 328      *\r
 329      * We don't use the macros defined in SimanticsDataParser.h here, in order that you can get a sense\r
 330      * of what goes where.\r
 331      */\r
 332 \r
 333     /* Create a base parser/recognizer, using the supplied token stream\r
 334      */\r
 335     ctx->pParser            = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);\r
 336     /* Install the implementation of our SimanticsDataParser interface\r
 337      */\r
 338     ctx->typeDefinitions        = typeDefinitions;\r
 339     ctx->typeDefinition = typeDefinition;\r
 340     ctx->unionType      = unionType;\r
 341     ctx->unionComponent = unionComponent;\r
 342     ctx->type   = type;\r
 343     ctx->arrayLength    = arrayLength;\r
 344     ctx->basicType      = basicType;\r
 345     ctx->tupleType      = tupleType;\r
 346     ctx->recordType     = recordType;\r
 347     ctx->component      = component;\r
 348     ctx->typeReference  = typeReference;\r
 349     ctx->parameter      = parameter;\r
 350     ctx->parameterValue = parameterValue;\r
 351     ctx->range  = range;\r
 352     ctx->number = number;\r
 353     ctx->string = string;\r
 354     ctx->boolean        = boolean;\r
 355     ctx->valueDefinitions       = valueDefinitions;\r
 356     ctx->valueDefinition        = valueDefinition;\r
 357     ctx->value  = value;\r
 358     ctx->basicValue     = basicValue;\r
 359     ctx->array  = array;\r
 360     ctx->tuple  = tuple;\r
 361     ctx->taggedValue    = taggedValue;\r
 362     ctx->record = record;\r
 363     ctx->recordAssignment       = recordAssignment;\r
 364     ctx->map    = map;\r
 365     ctx->mapAssignment  = mapAssignment;\r
 366     ctx->free                   = SimanticsDataParserFree;\r
 367     ctx->getGrammarFileName     = getGrammarFileName;\r
 368     \r
 369     /* Install the scope pushing methods.\r
 370      */\r
 371     ADAPTOR     = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);\r
 372     ctx->vectors        = antlr3VectorFactoryNew(0);\r
 373     \r
 374 \r
 375         \r
 376     /* Install the token table\r
 377      */\r
 378     PSRSTATE->tokenNames   = SimanticsDataParserTokenNames;\r
 379     \r
 380     \r
 381     /* Return the newly built parser to the caller\r
 382      */\r
 383     return  ctx;\r
 384 }\r
 385 \r
 386 /** Free the parser resources\r
 387  */\r
 388  static void\r
 389  SimanticsDataParserFree(pSimanticsDataParser ctx)\r
 390  {\r
 391     /* Free any scope memory\r
 392      */\r
 393     \r
 394     ctx->vectors->close(ctx->vectors);\r
 395     /* We created the adaptor so we must free it\r
 396      */\r
 397     ADAPTOR->free(ADAPTOR);\r
 398         // Free this parser\r
 399         //\r
 400     ctx->pParser->free(ctx->pParser);\r
 401     ANTLR3_FREE(ctx);\r
 402 \r
 403     /* Everything is released, so we can return\r
 404      */\r
 405     return;\r
 406  }\r
 407  \r
 408 /** Return token names used by this parser\r
 409  *\r
 410  * The returned pointer is used as an index into the token names table (using the token \r
 411  * number as the index).\r
 412  * \r
 413  * \return Pointer to first char * in the table.\r
 414  */\r
 415 static pANTLR3_UINT8    *getTokenNames() \r
 416 {\r
 417         return SimanticsDataParserTokenNames; \r
 418 }\r
 419 \r
 420     \r
 421 /* Declare the bitsets\r
 422  */\r
 423 \r
 424 /** Bitset defining follow set for error recovery in rule state: FOLLOW_typeDefinition_in_typeDefinitions768  */\r
 425 static  ANTLR3_BITWORD FOLLOW_typeDefinition_in_typeDefinitions768_bits[]       = { ANTLR3_UINT64_LIT(0x0000000400000002) };\r
 426 static  ANTLR3_BITSET_LIST FOLLOW_typeDefinition_in_typeDefinitions768  = { FOLLOW_typeDefinition_in_typeDefinitions768_bits, 1 };\r
 427 /** Bitset defining follow set for error recovery in rule state: FOLLOW_34_in_typeDefinition791  */\r
 428 static  ANTLR3_BITWORD FOLLOW_34_in_typeDefinition791_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000800000) };\r
 429 static  ANTLR3_BITSET_LIST FOLLOW_34_in_typeDefinition791       = { FOLLOW_34_in_typeDefinition791_bits, 1      };\r
 430 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_typeDefinition793  */\r
 431 static  ANTLR3_BITWORD FOLLOW_ID_in_typeDefinition793_bits[]    = { ANTLR3_UINT64_LIT(0x0000000800000000) };\r
 432 static  ANTLR3_BITSET_LIST FOLLOW_ID_in_typeDefinition793       = { FOLLOW_ID_in_typeDefinition793_bits, 1      };\r
 433 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_typeDefinition795  */\r
 434 static  ANTLR3_BITWORD FOLLOW_35_in_typeDefinition795_bits[]    = { ANTLR3_UINT64_LIT(0x0000091000800000) };\r
 435 static  ANTLR3_BITSET_LIST FOLLOW_35_in_typeDefinition795       = { FOLLOW_35_in_typeDefinition795_bits, 1      };\r
 436 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_typeDefinition797  */\r
 437 static  ANTLR3_BITWORD FOLLOW_unionType_in_typeDefinition797_bits[]     = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 438 static  ANTLR3_BITSET_LIST FOLLOW_unionType_in_typeDefinition797        = { FOLLOW_unionType_in_typeDefinition797_bits, 1       };\r
 439 /** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_unionType829  */\r
 440 static  ANTLR3_BITWORD FOLLOW_type_in_unionType829_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 441 static  ANTLR3_BITSET_LIST FOLLOW_type_in_unionType829  = { FOLLOW_type_in_unionType829_bits, 1 };\r
 442 /** Bitset defining follow set for error recovery in rule state: FOLLOW_36_in_unionType838  */\r
 443 static  ANTLR3_BITWORD FOLLOW_36_in_unionType838_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) };\r
 444 static  ANTLR3_BITSET_LIST FOLLOW_36_in_unionType838    = { FOLLOW_36_in_unionType838_bits, 1   };\r
 445 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionComponent_in_unionType840  */\r
 446 static  ANTLR3_BITWORD FOLLOW_unionComponent_in_unionType840_bits[]     = { ANTLR3_UINT64_LIT(0x0000001000000002) };\r
 447 static  ANTLR3_BITSET_LIST FOLLOW_unionComponent_in_unionType840        = { FOLLOW_unionComponent_in_unionType840_bits, 1       };\r
 448 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_unionComponent871  */\r
 449 static  ANTLR3_BITWORD FOLLOW_ID_in_unionComponent871_bits[]    = { ANTLR3_UINT64_LIT(0x0000090000800002) };\r
 450 static  ANTLR3_BITSET_LIST FOLLOW_ID_in_unionComponent871       = { FOLLOW_ID_in_unionComponent871_bits, 1      };\r
 451 /** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_unionComponent873  */\r
 452 static  ANTLR3_BITWORD FOLLOW_type_in_unionComponent873_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 453 static  ANTLR3_BITSET_LIST FOLLOW_type_in_unionComponent873     = { FOLLOW_type_in_unionComponent873_bits, 1    };\r
 454 /** Bitset defining follow set for error recovery in rule state: FOLLOW_basicType_in_type900  */\r
 455 static  ANTLR3_BITWORD FOLLOW_basicType_in_type900_bits[]       = { ANTLR3_UINT64_LIT(0x0000002000000002) };\r
 456 static  ANTLR3_BITSET_LIST FOLLOW_basicType_in_type900  = { FOLLOW_basicType_in_type900_bits, 1 };\r
 457 /** Bitset defining follow set for error recovery in rule state: FOLLOW_37_in_type914  */\r
 458 static  ANTLR3_BITWORD FOLLOW_37_in_type914_bits[]      = { ANTLR3_UINT64_LIT(0x000000C001000000) };\r
 459 static  ANTLR3_BITSET_LIST FOLLOW_37_in_type914 = { FOLLOW_37_in_type914_bits, 1        };\r
 460 /** Bitset defining follow set for error recovery in rule state: FOLLOW_arrayLength_in_type916  */\r
 461 static  ANTLR3_BITWORD FOLLOW_arrayLength_in_type916_bits[]     = { ANTLR3_UINT64_LIT(0x0000004000000000) };\r
 462 static  ANTLR3_BITSET_LIST FOLLOW_arrayLength_in_type916        = { FOLLOW_arrayLength_in_type916_bits, 1       };\r
 463 /** Bitset defining follow set for error recovery in rule state: FOLLOW_38_in_type919  */\r
 464 static  ANTLR3_BITWORD FOLLOW_38_in_type919_bits[]      = { ANTLR3_UINT64_LIT(0x0000002000000002) };\r
 465 static  ANTLR3_BITSET_LIST FOLLOW_38_in_type919 = { FOLLOW_38_in_type919_bits, 1        };\r
 466 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength947  */\r
 467 static  ANTLR3_BITWORD FOLLOW_INT_in_arrayLength947_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 468 static  ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength947 = { FOLLOW_INT_in_arrayLength947_bits, 1        };\r
 469 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength955  */\r
 470 static  ANTLR3_BITWORD FOLLOW_INT_in_arrayLength955_bits[]      = { ANTLR3_UINT64_LIT(0x0000008000000000) };\r
 471 static  ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength955 = { FOLLOW_INT_in_arrayLength955_bits, 1        };\r
 472 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_arrayLength957  */\r
 473 static  ANTLR3_BITWORD FOLLOW_39_in_arrayLength957_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 474 static  ANTLR3_BITSET_LIST FOLLOW_39_in_arrayLength957  = { FOLLOW_39_in_arrayLength957_bits, 1 };\r
 475 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_arrayLength965  */\r
 476 static  ANTLR3_BITWORD FOLLOW_39_in_arrayLength965_bits[]       = { ANTLR3_UINT64_LIT(0x0000000001000000) };\r
 477 static  ANTLR3_BITSET_LIST FOLLOW_39_in_arrayLength965  = { FOLLOW_39_in_arrayLength965_bits, 1 };\r
 478 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength967  */\r
 479 static  ANTLR3_BITWORD FOLLOW_INT_in_arrayLength967_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 480 static  ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength967 = { FOLLOW_INT_in_arrayLength967_bits, 1        };\r
 481 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength976  */\r
 482 static  ANTLR3_BITWORD FOLLOW_INT_in_arrayLength976_bits[]      = { ANTLR3_UINT64_LIT(0x0000008000000000) };\r
 483 static  ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength976 = { FOLLOW_INT_in_arrayLength976_bits, 1        };\r
 484 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_arrayLength978  */\r
 485 static  ANTLR3_BITWORD FOLLOW_39_in_arrayLength978_bits[]       = { ANTLR3_UINT64_LIT(0x0000000001000000) };\r
 486 static  ANTLR3_BITSET_LIST FOLLOW_39_in_arrayLength978  = { FOLLOW_39_in_arrayLength978_bits, 1 };\r
 487 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength980  */\r
 488 static  ANTLR3_BITWORD FOLLOW_INT_in_arrayLength980_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 489 static  ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength980 = { FOLLOW_INT_in_arrayLength980_bits, 1        };\r
 490 /** Bitset defining follow set for error recovery in rule state: FOLLOW_tupleType_in_basicType998  */\r
 491 static  ANTLR3_BITWORD FOLLOW_tupleType_in_basicType998_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 492 static  ANTLR3_BITSET_LIST FOLLOW_tupleType_in_basicType998     = { FOLLOW_tupleType_in_basicType998_bits, 1    };\r
 493 /** Bitset defining follow set for error recovery in rule state: FOLLOW_recordType_in_basicType1006  */\r
 494 static  ANTLR3_BITWORD FOLLOW_recordType_in_basicType1006_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 495 static  ANTLR3_BITSET_LIST FOLLOW_recordType_in_basicType1006   = { FOLLOW_recordType_in_basicType1006_bits, 1  };\r
 496 /** Bitset defining follow set for error recovery in rule state: FOLLOW_typeReference_in_basicType1014  */\r
 497 static  ANTLR3_BITWORD FOLLOW_typeReference_in_basicType1014_bits[]     = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 498 static  ANTLR3_BITSET_LIST FOLLOW_typeReference_in_basicType1014        = { FOLLOW_typeReference_in_basicType1014_bits, 1       };\r
 499 /** Bitset defining follow set for error recovery in rule state: FOLLOW_40_in_tupleType1036  */\r
 500 static  ANTLR3_BITWORD FOLLOW_40_in_tupleType1036_bits[]        = { ANTLR3_UINT64_LIT(0x00000D1000800000) };\r
 501 static  ANTLR3_BITSET_LIST FOLLOW_40_in_tupleType1036   = { FOLLOW_40_in_tupleType1036_bits, 1  };\r
 502 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_tupleType1039  */\r
 503 static  ANTLR3_BITWORD FOLLOW_unionType_in_tupleType1039_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };\r
 504 static  ANTLR3_BITSET_LIST FOLLOW_unionType_in_tupleType1039    = { FOLLOW_unionType_in_tupleType1039_bits, 1   };\r
 505 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_tupleType1042  */\r
 506 static  ANTLR3_BITWORD FOLLOW_41_in_tupleType1042_bits[]        = { ANTLR3_UINT64_LIT(0x0000091000800000) };\r
 507 static  ANTLR3_BITSET_LIST FOLLOW_41_in_tupleType1042   = { FOLLOW_41_in_tupleType1042_bits, 1  };\r
 508 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_tupleType1044  */\r
 509 static  ANTLR3_BITWORD FOLLOW_unionType_in_tupleType1044_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };\r
 510 static  ANTLR3_BITSET_LIST FOLLOW_unionType_in_tupleType1044    = { FOLLOW_unionType_in_tupleType1044_bits, 1   };\r
 511 /** Bitset defining follow set for error recovery in rule state: FOLLOW_42_in_tupleType1050  */\r
 512 static  ANTLR3_BITWORD FOLLOW_42_in_tupleType1050_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 513 static  ANTLR3_BITSET_LIST FOLLOW_42_in_tupleType1050   = { FOLLOW_42_in_tupleType1050_bits, 1  };\r
 514 /** Bitset defining follow set for error recovery in rule state: FOLLOW_43_in_recordType1083  */\r
 515 static  ANTLR3_BITWORD FOLLOW_43_in_recordType1083_bits[]       = { ANTLR3_UINT64_LIT(0x0000100000800000) };\r
 516 static  ANTLR3_BITSET_LIST FOLLOW_43_in_recordType1083  = { FOLLOW_43_in_recordType1083_bits, 1 };\r
 517 /** Bitset defining follow set for error recovery in rule state: FOLLOW_component_in_recordType1086  */\r
 518 static  ANTLR3_BITWORD FOLLOW_component_in_recordType1086_bits[]        = { ANTLR3_UINT64_LIT(0x0000120000000000) };\r
 519 static  ANTLR3_BITSET_LIST FOLLOW_component_in_recordType1086   = { FOLLOW_component_in_recordType1086_bits, 1  };\r
 520 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_recordType1089  */\r
 521 static  ANTLR3_BITWORD FOLLOW_41_in_recordType1089_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000800000) };\r
 522 static  ANTLR3_BITSET_LIST FOLLOW_41_in_recordType1089  = { FOLLOW_41_in_recordType1089_bits, 1 };\r
 523 /** Bitset defining follow set for error recovery in rule state: FOLLOW_component_in_recordType1091  */\r
 524 static  ANTLR3_BITWORD FOLLOW_component_in_recordType1091_bits[]        = { ANTLR3_UINT64_LIT(0x0000120000000000) };\r
 525 static  ANTLR3_BITSET_LIST FOLLOW_component_in_recordType1091   = { FOLLOW_component_in_recordType1091_bits, 1  };\r
 526 /** Bitset defining follow set for error recovery in rule state: FOLLOW_44_in_recordType1097  */\r
 527 static  ANTLR3_BITWORD FOLLOW_44_in_recordType1097_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 528 static  ANTLR3_BITSET_LIST FOLLOW_44_in_recordType1097  = { FOLLOW_44_in_recordType1097_bits, 1 };\r
 529 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_component1129  */\r
 530 static  ANTLR3_BITWORD FOLLOW_ID_in_component1129_bits[]        = { ANTLR3_UINT64_LIT(0x0000200000000000) };\r
 531 static  ANTLR3_BITSET_LIST FOLLOW_ID_in_component1129   = { FOLLOW_ID_in_component1129_bits, 1  };\r
 532 /** Bitset defining follow set for error recovery in rule state: FOLLOW_45_in_component1131  */\r
 533 static  ANTLR3_BITWORD FOLLOW_45_in_component1131_bits[]        = { ANTLR3_UINT64_LIT(0x0000091000800000) };\r
 534 static  ANTLR3_BITSET_LIST FOLLOW_45_in_component1131   = { FOLLOW_45_in_component1131_bits, 1  };\r
 535 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_component1133  */\r
 536 static  ANTLR3_BITWORD FOLLOW_unionType_in_component1133_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 537 static  ANTLR3_BITSET_LIST FOLLOW_unionType_in_component1133    = { FOLLOW_unionType_in_component1133_bits, 1   };\r
 538 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_typeReference1167  */\r
 539 static  ANTLR3_BITWORD FOLLOW_ID_in_typeReference1167_bits[]    = { ANTLR3_UINT64_LIT(0x0000010000000002) };\r
 540 static  ANTLR3_BITSET_LIST FOLLOW_ID_in_typeReference1167       = { FOLLOW_ID_in_typeReference1167_bits, 1      };\r
 541 /** Bitset defining follow set for error recovery in rule state: FOLLOW_40_in_typeReference1170  */\r
 542 static  ANTLR3_BITWORD FOLLOW_40_in_typeReference1170_bits[]    = { ANTLR3_UINT64_LIT(0x0000091000800000) };\r
 543 static  ANTLR3_BITSET_LIST FOLLOW_40_in_typeReference1170       = { FOLLOW_40_in_typeReference1170_bits, 1      };\r
 544 /** Bitset defining follow set for error recovery in rule state: FOLLOW_parameter_in_typeReference1172  */\r
 545 static  ANTLR3_BITWORD FOLLOW_parameter_in_typeReference1172_bits[]     = { ANTLR3_UINT64_LIT(0x0000060000000000) };\r
 546 static  ANTLR3_BITSET_LIST FOLLOW_parameter_in_typeReference1172        = { FOLLOW_parameter_in_typeReference1172_bits, 1       };\r
 547 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_typeReference1175  */\r
 548 static  ANTLR3_BITWORD FOLLOW_41_in_typeReference1175_bits[]    = { ANTLR3_UINT64_LIT(0x0000091000800000) };\r
 549 static  ANTLR3_BITSET_LIST FOLLOW_41_in_typeReference1175       = { FOLLOW_41_in_typeReference1175_bits, 1      };\r
 550 /** Bitset defining follow set for error recovery in rule state: FOLLOW_parameter_in_typeReference1177  */\r
 551 static  ANTLR3_BITWORD FOLLOW_parameter_in_typeReference1177_bits[]     = { ANTLR3_UINT64_LIT(0x0000060000000000) };\r
 552 static  ANTLR3_BITSET_LIST FOLLOW_parameter_in_typeReference1177        = { FOLLOW_parameter_in_typeReference1177_bits, 1       };\r
 553 /** Bitset defining follow set for error recovery in rule state: FOLLOW_42_in_typeReference1181  */\r
 554 static  ANTLR3_BITWORD FOLLOW_42_in_typeReference1181_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 555 static  ANTLR3_BITSET_LIST FOLLOW_42_in_typeReference1181       = { FOLLOW_42_in_typeReference1181_bits, 1      };\r
 556 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_parameter1217  */\r
 557 static  ANTLR3_BITWORD FOLLOW_ID_in_parameter1217_bits[]        = { ANTLR3_UINT64_LIT(0x0000000800000000) };\r
 558 static  ANTLR3_BITSET_LIST FOLLOW_ID_in_parameter1217   = { FOLLOW_ID_in_parameter1217_bits, 1  };\r
 559 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_parameter1219  */\r
 560 static  ANTLR3_BITWORD FOLLOW_35_in_parameter1219_bits[]        = { ANTLR3_UINT64_LIT(0x0000C12045000000) };\r
 561 static  ANTLR3_BITSET_LIST FOLLOW_35_in_parameter1219   = { FOLLOW_35_in_parameter1219_bits, 1  };\r
 562 /** Bitset defining follow set for error recovery in rule state: FOLLOW_parameterValue_in_parameter1221  */\r
 563 static  ANTLR3_BITWORD FOLLOW_parameterValue_in_parameter1221_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 564 static  ANTLR3_BITSET_LIST FOLLOW_parameterValue_in_parameter1221       = { FOLLOW_parameterValue_in_parameter1221_bits, 1      };\r
 565 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_parameter1239  */\r
 566 static  ANTLR3_BITWORD FOLLOW_unionType_in_parameter1239_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 567 static  ANTLR3_BITSET_LIST FOLLOW_unionType_in_parameter1239    = { FOLLOW_unionType_in_parameter1239_bits, 1   };\r
 568 /** Bitset defining follow set for error recovery in rule state: FOLLOW_string_in_parameterValue1258  */\r
 569 static  ANTLR3_BITWORD FOLLOW_string_in_parameterValue1258_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 570 static  ANTLR3_BITSET_LIST FOLLOW_string_in_parameterValue1258  = { FOLLOW_string_in_parameterValue1258_bits, 1 };\r
 571 /** Bitset defining follow set for error recovery in rule state: FOLLOW_boolean_in_parameterValue1266  */\r
 572 static  ANTLR3_BITWORD FOLLOW_boolean_in_parameterValue1266_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 573 static  ANTLR3_BITSET_LIST FOLLOW_boolean_in_parameterValue1266 = { FOLLOW_boolean_in_parameterValue1266_bits, 1        };\r
 574 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_parameterValue1274  */\r
 575 static  ANTLR3_BITWORD FOLLOW_number_in_parameterValue1274_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 576 static  ANTLR3_BITSET_LIST FOLLOW_number_in_parameterValue1274  = { FOLLOW_number_in_parameterValue1274_bits, 1 };\r
 577 /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_parameterValue1282  */\r
 578 static  ANTLR3_BITWORD FOLLOW_set_in_parameterValue1282_bits[]  = { ANTLR3_UINT64_LIT(0x0000008005000000) };\r
 579 static  ANTLR3_BITSET_LIST FOLLOW_set_in_parameterValue1282     = { FOLLOW_set_in_parameterValue1282_bits, 1    };\r
 580 /** Bitset defining follow set for error recovery in rule state: FOLLOW_range_in_parameterValue1290  */\r
 581 static  ANTLR3_BITWORD FOLLOW_range_in_parameterValue1290_bits[]        = { ANTLR3_UINT64_LIT(0x0000044000000000) };\r
 582 static  ANTLR3_BITSET_LIST FOLLOW_range_in_parameterValue1290   = { FOLLOW_range_in_parameterValue1290_bits, 1  };\r
 583 /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_parameterValue1292  */\r
 584 static  ANTLR3_BITWORD FOLLOW_set_in_parameterValue1292_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 585 static  ANTLR3_BITSET_LIST FOLLOW_set_in_parameterValue1292     = { FOLLOW_set_in_parameterValue1292_bits, 1    };\r
 586 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1319  */\r
 587 static  ANTLR3_BITWORD FOLLOW_number_in_range1319_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 588 static  ANTLR3_BITSET_LIST FOLLOW_number_in_range1319   = { FOLLOW_number_in_range1319_bits, 1  };\r
 589 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1327  */\r
 590 static  ANTLR3_BITWORD FOLLOW_number_in_range1327_bits[]        = { ANTLR3_UINT64_LIT(0x0000008000000000) };\r
 591 static  ANTLR3_BITSET_LIST FOLLOW_number_in_range1327   = { FOLLOW_number_in_range1327_bits, 1  };\r
 592 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_range1329  */\r
 593 static  ANTLR3_BITWORD FOLLOW_39_in_range1329_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 594 static  ANTLR3_BITSET_LIST FOLLOW_39_in_range1329       = { FOLLOW_39_in_range1329_bits, 1      };\r
 595 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_range1337  */\r
 596 static  ANTLR3_BITWORD FOLLOW_39_in_range1337_bits[]    = { ANTLR3_UINT64_LIT(0x0000000005000000) };\r
 597 static  ANTLR3_BITSET_LIST FOLLOW_39_in_range1337       = { FOLLOW_39_in_range1337_bits, 1      };\r
 598 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1339  */\r
 599 static  ANTLR3_BITWORD FOLLOW_number_in_range1339_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 600 static  ANTLR3_BITSET_LIST FOLLOW_number_in_range1339   = { FOLLOW_number_in_range1339_bits, 1  };\r
 601 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1348  */\r
 602 static  ANTLR3_BITWORD FOLLOW_number_in_range1348_bits[]        = { ANTLR3_UINT64_LIT(0x0000008000000000) };\r
 603 static  ANTLR3_BITSET_LIST FOLLOW_number_in_range1348   = { FOLLOW_number_in_range1348_bits, 1  };\r
 604 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_range1350  */\r
 605 static  ANTLR3_BITWORD FOLLOW_39_in_range1350_bits[]    = { ANTLR3_UINT64_LIT(0x0000000005000000) };\r
 606 static  ANTLR3_BITSET_LIST FOLLOW_39_in_range1350       = { FOLLOW_39_in_range1350_bits, 1      };\r
 607 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1352  */\r
 608 static  ANTLR3_BITWORD FOLLOW_number_in_range1352_bits[]        = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 609 static  ANTLR3_BITSET_LIST FOLLOW_number_in_range1352   = { FOLLOW_number_in_range1352_bits, 1  };\r
 610 /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_number0  */\r
 611 static  ANTLR3_BITWORD FOLLOW_set_in_number0_bits[]     = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 612 static  ANTLR3_BITSET_LIST FOLLOW_set_in_number0        = { FOLLOW_set_in_number0_bits, 1       };\r
 613 /** Bitset defining follow set for error recovery in rule state: FOLLOW_STRING_in_string1402  */\r
 614 static  ANTLR3_BITWORD FOLLOW_STRING_in_string1402_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 615 static  ANTLR3_BITSET_LIST FOLLOW_STRING_in_string1402  = { FOLLOW_STRING_in_string1402_bits, 1 };\r
 616 /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_boolean0  */\r
 617 static  ANTLR3_BITWORD FOLLOW_set_in_boolean0_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 618 static  ANTLR3_BITSET_LIST FOLLOW_set_in_boolean0       = { FOLLOW_set_in_boolean0_bits, 1      };\r
 619 /** Bitset defining follow set for error recovery in rule state: FOLLOW_valueDefinition_in_valueDefinitions1447  */\r
 620 static  ANTLR3_BITWORD FOLLOW_valueDefinition_in_valueDefinitions1447_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000800002) };\r
 621 static  ANTLR3_BITSET_LIST FOLLOW_valueDefinition_in_valueDefinitions1447       = { FOLLOW_valueDefinition_in_valueDefinitions1447_bits, 1      };\r
 622 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_valueDefinition1470  */\r
 623 static  ANTLR3_BITWORD FOLLOW_ID_in_valueDefinition1470_bits[]  = { ANTLR3_UINT64_LIT(0x0000200000000000) };\r
 624 static  ANTLR3_BITSET_LIST FOLLOW_ID_in_valueDefinition1470     = { FOLLOW_ID_in_valueDefinition1470_bits, 1    };\r
 625 /** Bitset defining follow set for error recovery in rule state: FOLLOW_45_in_valueDefinition1472  */\r
 626 static  ANTLR3_BITWORD FOLLOW_45_in_valueDefinition1472_bits[]  = { ANTLR3_UINT64_LIT(0x0000091000800000) };\r
 627 static  ANTLR3_BITSET_LIST FOLLOW_45_in_valueDefinition1472     = { FOLLOW_45_in_valueDefinition1472_bits, 1    };\r
 628 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_valueDefinition1474  */\r
 629 static  ANTLR3_BITWORD FOLLOW_unionType_in_valueDefinition1474_bits[]   = { ANTLR3_UINT64_LIT(0x0000000800000000) };\r
 630 static  ANTLR3_BITSET_LIST FOLLOW_unionType_in_valueDefinition1474      = { FOLLOW_unionType_in_valueDefinition1474_bits, 1     };\r
 631 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_valueDefinition1476  */\r
 632 static  ANTLR3_BITWORD FOLLOW_35_in_valueDefinition1476_bits[]  = { ANTLR3_UINT64_LIT(0x0003C92045800000) };\r
 633 static  ANTLR3_BITSET_LIST FOLLOW_35_in_valueDefinition1476     = { FOLLOW_35_in_valueDefinition1476_bits, 1    };\r
 634 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_valueDefinition1478  */\r
 635 static  ANTLR3_BITWORD FOLLOW_value_in_valueDefinition1478_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 636 static  ANTLR3_BITSET_LIST FOLLOW_value_in_valueDefinition1478  = { FOLLOW_value_in_valueDefinition1478_bits, 1 };\r
 637 /** Bitset defining follow set for error recovery in rule state: FOLLOW_basicValue_in_value1514  */\r
 638 static  ANTLR3_BITWORD FOLLOW_basicValue_in_value1514_bits[]    = { ANTLR3_UINT64_LIT(0x0000200000000002) };\r
 639 static  ANTLR3_BITSET_LIST FOLLOW_basicValue_in_value1514       = { FOLLOW_basicValue_in_value1514_bits, 1      };\r
 640 /** Bitset defining follow set for error recovery in rule state: FOLLOW_45_in_value1528  */\r
 641 static  ANTLR3_BITWORD FOLLOW_45_in_value1528_bits[]    = { ANTLR3_UINT64_LIT(0x0000090000800000) };\r
 642 static  ANTLR3_BITSET_LIST FOLLOW_45_in_value1528       = { FOLLOW_45_in_value1528_bits, 1      };\r
 643 /** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_value1530  */\r
 644 static  ANTLR3_BITWORD FOLLOW_type_in_value1530_bits[]  = { ANTLR3_UINT64_LIT(0x0000200000000002) };\r
 645 static  ANTLR3_BITSET_LIST FOLLOW_type_in_value1530     = { FOLLOW_type_in_value1530_bits, 1    };\r
 646 /** Bitset defining follow set for error recovery in rule state: FOLLOW_48_in_basicValue1562  */\r
 647 static  ANTLR3_BITWORD FOLLOW_48_in_basicValue1562_bits[]       = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 648 static  ANTLR3_BITSET_LIST FOLLOW_48_in_basicValue1562  = { FOLLOW_48_in_basicValue1562_bits, 1 };\r
 649 /** Bitset defining follow set for error recovery in rule state: FOLLOW_string_in_basicValue1574  */\r
 650 static  ANTLR3_BITWORD FOLLOW_string_in_basicValue1574_bits[]   = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 651 static  ANTLR3_BITSET_LIST FOLLOW_string_in_basicValue1574      = { FOLLOW_string_in_basicValue1574_bits, 1     };\r
 652 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_basicValue1582  */\r
 653 static  ANTLR3_BITWORD FOLLOW_number_in_basicValue1582_bits[]   = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 654 static  ANTLR3_BITSET_LIST FOLLOW_number_in_basicValue1582      = { FOLLOW_number_in_basicValue1582_bits, 1     };\r
 655 /** Bitset defining follow set for error recovery in rule state: FOLLOW_boolean_in_basicValue1590  */\r
 656 static  ANTLR3_BITWORD FOLLOW_boolean_in_basicValue1590_bits[]  = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 657 static  ANTLR3_BITSET_LIST FOLLOW_boolean_in_basicValue1590     = { FOLLOW_boolean_in_basicValue1590_bits, 1    };\r
 658 /** Bitset defining follow set for error recovery in rule state: FOLLOW_array_in_basicValue1598  */\r
 659 static  ANTLR3_BITWORD FOLLOW_array_in_basicValue1598_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 660 static  ANTLR3_BITSET_LIST FOLLOW_array_in_basicValue1598       = { FOLLOW_array_in_basicValue1598_bits, 1      };\r
 661 /** Bitset defining follow set for error recovery in rule state: FOLLOW_tuple_in_basicValue1606  */\r
 662 static  ANTLR3_BITWORD FOLLOW_tuple_in_basicValue1606_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 663 static  ANTLR3_BITSET_LIST FOLLOW_tuple_in_basicValue1606       = { FOLLOW_tuple_in_basicValue1606_bits, 1      };\r
 664 /** Bitset defining follow set for error recovery in rule state: FOLLOW_taggedValue_in_basicValue1614  */\r
 665 static  ANTLR3_BITWORD FOLLOW_taggedValue_in_basicValue1614_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 666 static  ANTLR3_BITSET_LIST FOLLOW_taggedValue_in_basicValue1614 = { FOLLOW_taggedValue_in_basicValue1614_bits, 1        };\r
 667 /** Bitset defining follow set for error recovery in rule state: FOLLOW_map_in_basicValue1622  */\r
 668 static  ANTLR3_BITWORD FOLLOW_map_in_basicValue1622_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 669 static  ANTLR3_BITSET_LIST FOLLOW_map_in_basicValue1622 = { FOLLOW_map_in_basicValue1622_bits, 1        };\r
 670 /** Bitset defining follow set for error recovery in rule state: FOLLOW_record_in_basicValue1630  */\r
 671 static  ANTLR3_BITWORD FOLLOW_record_in_basicValue1630_bits[]   = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 672 static  ANTLR3_BITSET_LIST FOLLOW_record_in_basicValue1630      = { FOLLOW_record_in_basicValue1630_bits, 1     };\r
 673 /** Bitset defining follow set for error recovery in rule state: FOLLOW_37_in_array1648  */\r
 674 static  ANTLR3_BITWORD FOLLOW_37_in_array1648_bits[]    = { ANTLR3_UINT64_LIT(0x0003C96045800000) };\r
 675 static  ANTLR3_BITSET_LIST FOLLOW_37_in_array1648       = { FOLLOW_37_in_array1648_bits, 1      };\r
 676 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_array1651  */\r
 677 static  ANTLR3_BITWORD FOLLOW_value_in_array1651_bits[] = { ANTLR3_UINT64_LIT(0x0000024000000000) };\r
 678 static  ANTLR3_BITSET_LIST FOLLOW_value_in_array1651    = { FOLLOW_value_in_array1651_bits, 1   };\r
 679 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_array1654  */\r
 680 static  ANTLR3_BITWORD FOLLOW_41_in_array1654_bits[]    = { ANTLR3_UINT64_LIT(0x0003C92045800000) };\r
 681 static  ANTLR3_BITSET_LIST FOLLOW_41_in_array1654       = { FOLLOW_41_in_array1654_bits, 1      };\r
 682 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_array1656  */\r
 683 static  ANTLR3_BITWORD FOLLOW_value_in_array1656_bits[] = { ANTLR3_UINT64_LIT(0x0000024000000000) };\r
 684 static  ANTLR3_BITSET_LIST FOLLOW_value_in_array1656    = { FOLLOW_value_in_array1656_bits, 1   };\r
 685 /** Bitset defining follow set for error recovery in rule state: FOLLOW_38_in_array1662  */\r
 686 static  ANTLR3_BITWORD FOLLOW_38_in_array1662_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 687 static  ANTLR3_BITSET_LIST FOLLOW_38_in_array1662       = { FOLLOW_38_in_array1662_bits, 1      };\r
 688 /** Bitset defining follow set for error recovery in rule state: FOLLOW_40_in_tuple1694  */\r
 689 static  ANTLR3_BITWORD FOLLOW_40_in_tuple1694_bits[]    = { ANTLR3_UINT64_LIT(0x0003CD2045800000) };\r
 690 static  ANTLR3_BITSET_LIST FOLLOW_40_in_tuple1694       = { FOLLOW_40_in_tuple1694_bits, 1      };\r
 691 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_tuple1697  */\r
 692 static  ANTLR3_BITWORD FOLLOW_value_in_tuple1697_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };\r
 693 static  ANTLR3_BITSET_LIST FOLLOW_value_in_tuple1697    = { FOLLOW_value_in_tuple1697_bits, 1   };\r
 694 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_tuple1700  */\r
 695 static  ANTLR3_BITWORD FOLLOW_41_in_tuple1700_bits[]    = { ANTLR3_UINT64_LIT(0x0003C92045800000) };\r
 696 static  ANTLR3_BITSET_LIST FOLLOW_41_in_tuple1700       = { FOLLOW_41_in_tuple1700_bits, 1      };\r
 697 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_tuple1702  */\r
 698 static  ANTLR3_BITWORD FOLLOW_value_in_tuple1702_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };\r
 699 static  ANTLR3_BITSET_LIST FOLLOW_value_in_tuple1702    = { FOLLOW_value_in_tuple1702_bits, 1   };\r
 700 /** Bitset defining follow set for error recovery in rule state: FOLLOW_42_in_tuple1708  */\r
 701 static  ANTLR3_BITWORD FOLLOW_42_in_tuple1708_bits[]    = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 702 static  ANTLR3_BITSET_LIST FOLLOW_42_in_tuple1708       = { FOLLOW_42_in_tuple1708_bits, 1      };\r
 703 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_taggedValue1740  */\r
 704 static  ANTLR3_BITWORD FOLLOW_ID_in_taggedValue1740_bits[]      = { ANTLR3_UINT64_LIT(0x0003C92045800000) };\r
 705 static  ANTLR3_BITSET_LIST FOLLOW_ID_in_taggedValue1740 = { FOLLOW_ID_in_taggedValue1740_bits, 1        };\r
 706 /** Bitset defining follow set for error recovery in rule state: FOLLOW_basicValue_in_taggedValue1742  */\r
 707 static  ANTLR3_BITWORD FOLLOW_basicValue_in_taggedValue1742_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 708 static  ANTLR3_BITSET_LIST FOLLOW_basicValue_in_taggedValue1742 = { FOLLOW_basicValue_in_taggedValue1742_bits, 1        };\r
 709 /** Bitset defining follow set for error recovery in rule state: FOLLOW_43_in_record1775  */\r
 710 static  ANTLR3_BITWORD FOLLOW_43_in_record1775_bits[]   = { ANTLR3_UINT64_LIT(0x0000100000800000) };\r
 711 static  ANTLR3_BITSET_LIST FOLLOW_43_in_record1775      = { FOLLOW_43_in_record1775_bits, 1     };\r
 712 /** Bitset defining follow set for error recovery in rule state: FOLLOW_recordAssignment_in_record1778  */\r
 713 static  ANTLR3_BITWORD FOLLOW_recordAssignment_in_record1778_bits[]     = { ANTLR3_UINT64_LIT(0x0000120000000000) };\r
 714 static  ANTLR3_BITSET_LIST FOLLOW_recordAssignment_in_record1778        = { FOLLOW_recordAssignment_in_record1778_bits, 1       };\r
 715 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_record1781  */\r
 716 static  ANTLR3_BITWORD FOLLOW_41_in_record1781_bits[]   = { ANTLR3_UINT64_LIT(0x0000000000800000) };\r
 717 static  ANTLR3_BITSET_LIST FOLLOW_41_in_record1781      = { FOLLOW_41_in_record1781_bits, 1     };\r
 718 /** Bitset defining follow set for error recovery in rule state: FOLLOW_recordAssignment_in_record1783  */\r
 719 static  ANTLR3_BITWORD FOLLOW_recordAssignment_in_record1783_bits[]     = { ANTLR3_UINT64_LIT(0x0000120000000000) };\r
 720 static  ANTLR3_BITSET_LIST FOLLOW_recordAssignment_in_record1783        = { FOLLOW_recordAssignment_in_record1783_bits, 1       };\r
 721 /** Bitset defining follow set for error recovery in rule state: FOLLOW_44_in_record1789  */\r
 722 static  ANTLR3_BITWORD FOLLOW_44_in_record1789_bits[]   = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 723 static  ANTLR3_BITSET_LIST FOLLOW_44_in_record1789      = { FOLLOW_44_in_record1789_bits, 1     };\r
 724 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_recordAssignment1821  */\r
 725 static  ANTLR3_BITWORD FOLLOW_ID_in_recordAssignment1821_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) };\r
 726 static  ANTLR3_BITSET_LIST FOLLOW_ID_in_recordAssignment1821    = { FOLLOW_ID_in_recordAssignment1821_bits, 1   };\r
 727 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_recordAssignment1823  */\r
 728 static  ANTLR3_BITWORD FOLLOW_35_in_recordAssignment1823_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) };\r
 729 static  ANTLR3_BITSET_LIST FOLLOW_35_in_recordAssignment1823    = { FOLLOW_35_in_recordAssignment1823_bits, 1   };\r
 730 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_recordAssignment1825  */\r
 731 static  ANTLR3_BITWORD FOLLOW_value_in_recordAssignment1825_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 732 static  ANTLR3_BITSET_LIST FOLLOW_value_in_recordAssignment1825 = { FOLLOW_value_in_recordAssignment1825_bits, 1        };\r
 733 /** Bitset defining follow set for error recovery in rule state: FOLLOW_49_in_map1852  */\r
 734 static  ANTLR3_BITWORD FOLLOW_49_in_map1852_bits[]      = { ANTLR3_UINT64_LIT(0x0000080000000000) };\r
 735 static  ANTLR3_BITSET_LIST FOLLOW_49_in_map1852 = { FOLLOW_49_in_map1852_bits, 1        };\r
 736 /** Bitset defining follow set for error recovery in rule state: FOLLOW_43_in_map1854  */\r
 737 static  ANTLR3_BITWORD FOLLOW_43_in_map1854_bits[]      = { ANTLR3_UINT64_LIT(0x0003D92045800000) };\r
 738 static  ANTLR3_BITSET_LIST FOLLOW_43_in_map1854 = { FOLLOW_43_in_map1854_bits, 1        };\r
 739 /** Bitset defining follow set for error recovery in rule state: FOLLOW_mapAssignment_in_map1857  */\r
 740 static  ANTLR3_BITWORD FOLLOW_mapAssignment_in_map1857_bits[]   = { ANTLR3_UINT64_LIT(0x0000120000000000) };\r
 741 static  ANTLR3_BITSET_LIST FOLLOW_mapAssignment_in_map1857      = { FOLLOW_mapAssignment_in_map1857_bits, 1     };\r
 742 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_map1860  */\r
 743 static  ANTLR3_BITWORD FOLLOW_41_in_map1860_bits[]      = { ANTLR3_UINT64_LIT(0x0003C92045800000) };\r
 744 static  ANTLR3_BITSET_LIST FOLLOW_41_in_map1860 = { FOLLOW_41_in_map1860_bits, 1        };\r
 745 /** Bitset defining follow set for error recovery in rule state: FOLLOW_mapAssignment_in_map1862  */\r
 746 static  ANTLR3_BITWORD FOLLOW_mapAssignment_in_map1862_bits[]   = { ANTLR3_UINT64_LIT(0x0000120000000000) };\r
 747 static  ANTLR3_BITSET_LIST FOLLOW_mapAssignment_in_map1862      = { FOLLOW_mapAssignment_in_map1862_bits, 1     };\r
 748 /** Bitset defining follow set for error recovery in rule state: FOLLOW_44_in_map1868  */\r
 749 static  ANTLR3_BITWORD FOLLOW_44_in_map1868_bits[]      = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 750 static  ANTLR3_BITSET_LIST FOLLOW_44_in_map1868 = { FOLLOW_44_in_map1868_bits, 1        };\r
 751 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_mapAssignment1900  */\r
 752 static  ANTLR3_BITWORD FOLLOW_value_in_mapAssignment1900_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) };\r
 753 static  ANTLR3_BITSET_LIST FOLLOW_value_in_mapAssignment1900    = { FOLLOW_value_in_mapAssignment1900_bits, 1   };\r
 754 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_mapAssignment1902  */\r
 755 static  ANTLR3_BITWORD FOLLOW_35_in_mapAssignment1902_bits[]    = { ANTLR3_UINT64_LIT(0x0003C92045800000) };\r
 756 static  ANTLR3_BITSET_LIST FOLLOW_35_in_mapAssignment1902       = { FOLLOW_35_in_mapAssignment1902_bits, 1      };\r
 757 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_mapAssignment1904  */\r
 758 static  ANTLR3_BITWORD FOLLOW_value_in_mapAssignment1904_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
 759 static  ANTLR3_BITSET_LIST FOLLOW_value_in_mapAssignment1904    = { FOLLOW_value_in_mapAssignment1904_bits, 1   };\r
 760      \r
 761 \r
 762  \r
 763  \r
 764 /* ==============================================\r
 765  * Parsing rules\r
 766  */\r
 767 /** \r
 768  * $ANTLR start typeDefinitions\r
 769  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:1: typeDefinitions : ( typeDefinition )* -> ^( TYPE_DEFINITIONS ( typeDefinition )* ) ;\r
 770  */\r
 771 static SimanticsDataParser_typeDefinitions_return\r
 772 typeDefinitions(pSimanticsDataParser ctx)\r
 773 {   \r
 774     SimanticsDataParser_typeDefinitions_return retval;\r
 775 \r
 776     pANTLR3_BASE_TREE root_0;\r
 777 \r
 778     SimanticsDataParser_typeDefinition_return typeDefinition1;\r
 779     #undef      RETURN_TYPE_typeDefinition1\r
 780     #define     RETURN_TYPE_typeDefinition1 SimanticsDataParser_typeDefinition_return\r
 781 \r
 782     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_typeDefinition;\r
 783     /* Initialize rule variables\r
 784      */\r
 785 \r
 786 \r
 787     root_0 = NULL;\r
 788 \r
 789     typeDefinition1.tree = NULL;\r
 790 \r
 791     retval.start = LT(1); retval.stop = retval.start;\r
 792 \r
 793 \r
 794     stream_typeDefinition   = NULL;\r
 795     #define CREATE_stream_typeDefinition  if (stream_typeDefinition == NULL) {stream_typeDefinition = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule typeDefinition"); }\r
 796 \r
 797     retval.tree  = NULL;\r
 798     {\r
 799         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:17: ( ( typeDefinition )* -> ^( TYPE_DEFINITIONS ( typeDefinition )* ) )\r
 800         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:19: ( typeDefinition )*\r
 801         {\r
 802 \r
 803             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:19: ( typeDefinition )*\r
 804 \r
 805             for (;;)\r
 806             {\r
 807                 int alt1=2;\r
 808                 switch ( LA(1) ) \r
 809                 {\r
 810                 case 34:\r
 811                         {\r
 812                                 alt1=1;\r
 813                         }\r
 814                     break;\r
 815 \r
 816                 }\r
 817 \r
 818                 switch (alt1) \r
 819                 {\r
 820                 case 1:\r
 821                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:19: typeDefinition\r
 822                     {\r
 823                         FOLLOWPUSH(FOLLOW_typeDefinition_in_typeDefinitions768);\r
 824                         typeDefinition1=typeDefinition(ctx);\r
 825 \r
 826                         FOLLOWPOP();\r
 827                         if  (HASEXCEPTION())\r
 828                         {\r
 829                             goto ruletypeDefinitionsEx;\r
 830                         }\r
 831 \r
 832                         CREATE_stream_typeDefinition; stream_typeDefinition->add(stream_typeDefinition, typeDefinition1.tree, NULL);\r
 833 \r
 834                     }\r
 835                     break;\r
 836 \r
 837                 default:\r
 838                     goto loop1; /* break out of the loop */\r
 839                     break;\r
 840                 }\r
 841             }\r
 842             loop1: ; /* Jump out to here if this rule does not match */\r
 843 \r
 844 \r
 845              \r
 846             /* AST REWRITE\r
 847              * elements          : typeDefinition\r
 848              * token labels      : \r
 849              * rule labels       : retval\r
 850              * token list labels : \r
 851              * rule list labels  : \r
 852              */\r
 853             {\r
 854                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
 855 \r
 856                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
 857 \r
 858                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
 859                 retval.tree    = root_0;\r
 860                 // 93:35: -> ^( TYPE_DEFINITIONS ( typeDefinition )* )\r
 861                 {\r
 862                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:38: ^( TYPE_DEFINITIONS ( typeDefinition )* )\r
 863                     {\r
 864                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
 865                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_DEFINITIONS, (pANTLR3_UINT8)"TYPE_DEFINITIONS"), root_1));\r
 866 \r
 867                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:57: ( typeDefinition )*\r
 868                         {\r
 869                                 while ( (stream_typeDefinition != NULL && stream_typeDefinition->hasNext(stream_typeDefinition))  )\r
 870                                 {\r
 871                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_typeDefinition == NULL ? NULL : stream_typeDefinition->nextTree(stream_typeDefinition));\r
 872 \r
 873                                 }\r
 874                                 if (stream_typeDefinition != NULL) stream_typeDefinition->reset(stream_typeDefinition);\r
 875 \r
 876                         }\r
 877 \r
 878                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
 879                     }\r
 880 \r
 881                 }\r
 882 \r
 883                 retval.tree = root_0; // set result root\r
 884                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
 885 \r
 886 \r
 887             }\r
 888         }\r
 889 \r
 890     }\r
 891     \r
 892 \r
 893     // This is where rules clean up and exit\r
 894     //\r
 895     goto ruletypeDefinitionsEx; /* Prevent compiler warnings */\r
 896     ruletypeDefinitionsEx: ;\r
 897     retval.stop = LT(-1);\r
 898 \r
 899         retval.stop = LT(-1);\r
 900         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
 901         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
 902         if (stream_typeDefinition != NULL) stream_typeDefinition->free(stream_typeDefinition);\r
 903 \r
 904             if (HASEXCEPTION())\r
 905             {\r
 906                 PREPORTERROR();\r
 907                 PRECOVER();\r
 908                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
 909             }\r
 910 \r
 911 \r
 912     return retval;\r
 913 }\r
 914 /* $ANTLR end typeDefinitions */\r
 915 \r
 916 /** \r
 917  * $ANTLR start typeDefinition\r
 918  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:95:1: typeDefinition : 'type' ID '=' unionType -> ^( TYPE_DEFINITION ID unionType ) ;\r
 919  */\r
 920 static SimanticsDataParser_typeDefinition_return\r
 921 typeDefinition(pSimanticsDataParser ctx)\r
 922 {   \r
 923     SimanticsDataParser_typeDefinition_return retval;\r
 924 \r
 925     pANTLR3_BASE_TREE root_0;\r
 926 \r
 927     pANTLR3_COMMON_TOKEN    string_literal2;\r
 928     pANTLR3_COMMON_TOKEN    ID3;\r
 929     pANTLR3_COMMON_TOKEN    char_literal4;\r
 930     SimanticsDataParser_unionType_return unionType5;\r
 931     #undef      RETURN_TYPE_unionType5\r
 932     #define     RETURN_TYPE_unionType5 SimanticsDataParser_unionType_return\r
 933 \r
 934     pANTLR3_BASE_TREE string_literal2_tree;\r
 935     pANTLR3_BASE_TREE ID3_tree;\r
 936     pANTLR3_BASE_TREE char_literal4_tree;\r
 937     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;\r
 938     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;\r
 939     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_34;\r
 940     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType;\r
 941     /* Initialize rule variables\r
 942      */\r
 943 \r
 944 \r
 945     root_0 = NULL;\r
 946 \r
 947     string_literal2       = NULL;\r
 948     ID3       = NULL;\r
 949     char_literal4       = NULL;\r
 950     unionType5.tree = NULL;\r
 951 \r
 952     retval.start = LT(1); retval.stop = retval.start;\r
 953 \r
 954     string_literal2_tree   = NULL;\r
 955     ID3_tree   = NULL;\r
 956     char_literal4_tree   = NULL;\r
 957 \r
 958     stream_ID   = NULL;\r
 959     #define CREATE_stream_ID  if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } \r
 960     stream_35   = NULL;\r
 961     #define CREATE_stream_35  if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } \r
 962     stream_34   = NULL;\r
 963     #define CREATE_stream_34  if (stream_34 == NULL) {stream_34 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 34"); } \r
 964     stream_unionType   = NULL;\r
 965     #define CREATE_stream_unionType  if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); }\r
 966 \r
 967     retval.tree  = NULL;\r
 968     {\r
 969         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:96:5: ( 'type' ID '=' unionType -> ^( TYPE_DEFINITION ID unionType ) )\r
 970         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:96:7: 'type' ID '=' unionType\r
 971         {\r
 972             string_literal2 = (pANTLR3_COMMON_TOKEN) MATCHT(34, &FOLLOW_34_in_typeDefinition791); \r
 973             if  (HASEXCEPTION())\r
 974             {\r
 975                 goto ruletypeDefinitionEx;\r
 976             }\r
 977              \r
 978             CREATE_stream_34; stream_34->add(stream_34, string_literal2, NULL);\r
 979 \r
 980             ID3 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_typeDefinition793); \r
 981             if  (HASEXCEPTION())\r
 982             {\r
 983                 goto ruletypeDefinitionEx;\r
 984             }\r
 985              \r
 986             CREATE_stream_ID; stream_ID->add(stream_ID, ID3, NULL);\r
 987 \r
 988             char_literal4 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_typeDefinition795); \r
 989             if  (HASEXCEPTION())\r
 990             {\r
 991                 goto ruletypeDefinitionEx;\r
 992             }\r
 993              \r
 994             CREATE_stream_35; stream_35->add(stream_35, char_literal4, NULL);\r
 995 \r
 996             FOLLOWPUSH(FOLLOW_unionType_in_typeDefinition797);\r
 997             unionType5=unionType(ctx);\r
 998 \r
 999             FOLLOWPOP();\r
1000             if  (HASEXCEPTION())\r
1001             {\r
1002                 goto ruletypeDefinitionEx;\r
1003             }\r
1004 \r
1005             CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType5.tree, NULL);\r
1006 \r
1007              \r
1008             /* AST REWRITE\r
1009              * elements          : unionType, ID\r
1010              * token labels      : \r
1011              * rule labels       : retval\r
1012              * token list labels : \r
1013              * rule list labels  : \r
1014              */\r
1015             {\r
1016                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
1017 \r
1018                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
1019 \r
1020                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1021                 retval.tree    = root_0;\r
1022                 // 96:31: -> ^( TYPE_DEFINITION ID unionType )\r
1023                 {\r
1024                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:96:34: ^( TYPE_DEFINITION ID unionType )\r
1025                     {\r
1026                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1027                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_DEFINITION, (pANTLR3_UINT8)"TYPE_DEFINITION"), root_1));\r
1028 \r
1029                         ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));\r
1030                         ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType));\r
1031 \r
1032                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
1033                     }\r
1034 \r
1035                 }\r
1036 \r
1037                 retval.tree = root_0; // set result root\r
1038                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
1039 \r
1040 \r
1041             }\r
1042         }\r
1043 \r
1044     }\r
1045     \r
1046 \r
1047     // This is where rules clean up and exit\r
1048     //\r
1049     goto ruletypeDefinitionEx; /* Prevent compiler warnings */\r
1050     ruletypeDefinitionEx: ;\r
1051     retval.stop = LT(-1);\r
1052 \r
1053         retval.stop = LT(-1);\r
1054         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
1055         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
1056         if (stream_ID != NULL) stream_ID->free(stream_ID);\r
1057         if (stream_35 != NULL) stream_35->free(stream_35);\r
1058         if (stream_34 != NULL) stream_34->free(stream_34);\r
1059         if (stream_unionType != NULL) stream_unionType->free(stream_unionType);\r
1060 \r
1061             if (HASEXCEPTION())\r
1062             {\r
1063                 PREPORTERROR();\r
1064                 PRECOVER();\r
1065                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
1066             }\r
1067 \r
1068 \r
1069     return retval;\r
1070 }\r
1071 /* $ANTLR end typeDefinition */\r
1072 \r
1073 /** \r
1074  * $ANTLR start unionType\r
1075  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:99:1: unionType : ( type | ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) );\r
1076  */\r
1077 static SimanticsDataParser_unionType_return\r
1078 unionType(pSimanticsDataParser ctx)\r
1079 {   \r
1080     SimanticsDataParser_unionType_return retval;\r
1081 \r
1082     pANTLR3_BASE_TREE root_0;\r
1083 \r
1084     pANTLR3_COMMON_TOKEN    char_literal7;\r
1085     SimanticsDataParser_type_return type6;\r
1086     #undef      RETURN_TYPE_type6\r
1087     #define     RETURN_TYPE_type6 SimanticsDataParser_type_return\r
1088 \r
1089     SimanticsDataParser_unionComponent_return unionComponent8;\r
1090     #undef      RETURN_TYPE_unionComponent8\r
1091     #define     RETURN_TYPE_unionComponent8 SimanticsDataParser_unionComponent_return\r
1092 \r
1093     pANTLR3_BASE_TREE char_literal7_tree;\r
1094     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_36;\r
1095     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionComponent;\r
1096     /* Initialize rule variables\r
1097      */\r
1098 \r
1099 \r
1100     root_0 = NULL;\r
1101 \r
1102     char_literal7       = NULL;\r
1103     type6.tree = NULL;\r
1104 \r
1105     unionComponent8.tree = NULL;\r
1106 \r
1107     retval.start = LT(1); retval.stop = retval.start;\r
1108 \r
1109     char_literal7_tree   = NULL;\r
1110 \r
1111     stream_36   = NULL;\r
1112     #define CREATE_stream_36  if (stream_36 == NULL) {stream_36 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 36"); } \r
1113     stream_unionComponent   = NULL;\r
1114     #define CREATE_stream_unionComponent  if (stream_unionComponent == NULL) {stream_unionComponent = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionComponent"); }\r
1115 \r
1116     retval.tree  = NULL;\r
1117     {\r
1118         {\r
1119             //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:100:5: ( type | ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) )\r
1120             \r
1121             ANTLR3_UINT32 alt3;\r
1122 \r
1123             alt3=2;\r
1124 \r
1125             switch ( LA(1) ) \r
1126             {\r
1127             case ID:\r
1128             case 40:\r
1129             case 43:\r
1130                 {\r
1131                         alt3=1;\r
1132                 }\r
1133                 break;\r
1134             case 36:\r
1135                 {\r
1136                         alt3=2;\r
1137                 }\r
1138                 break;\r
1139 \r
1140             default:\r
1141                 CONSTRUCTEX();\r
1142                 EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
1143                 EXCEPTION->message      = (void *)"";\r
1144                 EXCEPTION->decisionNum  = 3;\r
1145                 EXCEPTION->state        = 0;\r
1146 \r
1147 \r
1148                 goto ruleunionTypeEx;\r
1149             }\r
1150 \r
1151             switch (alt3) \r
1152             {\r
1153                 case 1:\r
1154                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:100:7: type\r
1155                     {\r
1156                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1157 \r
1158                         FOLLOWPUSH(FOLLOW_type_in_unionType829);\r
1159                         type6=type(ctx);\r
1160 \r
1161                         FOLLOWPOP();\r
1162                         if  (HASEXCEPTION())\r
1163                         {\r
1164                             goto ruleunionTypeEx;\r
1165                         }\r
1166 \r
1167                         ADAPTOR->addChild(ADAPTOR, root_0, type6.tree);\r
1168 \r
1169                     }\r
1170                     break;\r
1171                 case 2:\r
1172                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:101:7: ( '|' unionComponent )+\r
1173                     {\r
1174                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:101:7: ( '|' unionComponent )+\r
1175                         {\r
1176                             int cnt2=0;\r
1177 \r
1178                             for (;;)\r
1179                             {\r
1180                                 int alt2=2;\r
1181                                 switch ( LA(1) ) \r
1182                                 {\r
1183                                 case 36:\r
1184                                         {\r
1185                                                 alt2=1;\r
1186                                         }\r
1187                                     break;\r
1188 \r
1189                                 }\r
1190 \r
1191                                 switch (alt2) \r
1192                                 {\r
1193                                     case 1:\r
1194                                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:101:8: '|' unionComponent\r
1195                                         {\r
1196                                             char_literal7 = (pANTLR3_COMMON_TOKEN) MATCHT(36, &FOLLOW_36_in_unionType838); \r
1197                                             if  (HASEXCEPTION())\r
1198                                             {\r
1199                                                 goto ruleunionTypeEx;\r
1200                                             }\r
1201                                              \r
1202                                             CREATE_stream_36; stream_36->add(stream_36, char_literal7, NULL);\r
1203 \r
1204                                             FOLLOWPUSH(FOLLOW_unionComponent_in_unionType840);\r
1205                                             unionComponent8=unionComponent(ctx);\r
1206 \r
1207                                             FOLLOWPOP();\r
1208                                             if  (HASEXCEPTION())\r
1209                                             {\r
1210                                                 goto ruleunionTypeEx;\r
1211                                             }\r
1212 \r
1213                                             CREATE_stream_unionComponent; stream_unionComponent->add(stream_unionComponent, unionComponent8.tree, NULL);\r
1214 \r
1215                                         }\r
1216                                         break;\r
1217 \r
1218                                     default:\r
1219                                     \r
1220                                         if ( cnt2 >= 1 )\r
1221                                         {\r
1222                                             goto loop2;\r
1223                                         }\r
1224                                         /* mismatchedSetEx()\r
1225                                          */\r
1226                                         CONSTRUCTEX();\r
1227                                         EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;\r
1228                                         EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;\r
1229 \r
1230 \r
1231                                         goto ruleunionTypeEx;\r
1232                                 }\r
1233                                 cnt2++;\r
1234                             }\r
1235                             loop2: ;    /* Jump to here if this rule does not match */\r
1236                         }\r
1237 \r
1238                          \r
1239                         /* AST REWRITE\r
1240                          * elements          : unionComponent\r
1241                          * token labels      : \r
1242                          * rule labels       : retval\r
1243                          * token list labels : \r
1244                          * rule list labels  : \r
1245                          */\r
1246                         {\r
1247                                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
1248 \r
1249                                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
1250 \r
1251                                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1252                                 retval.tree    = root_0;\r
1253                                 // 102:5: -> ^( UNION_TYPE ( unionComponent )+ )\r
1254                                 {\r
1255                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:102:8: ^( UNION_TYPE ( unionComponent )+ )\r
1256                                     {\r
1257                                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1258                                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, UNION_TYPE, (pANTLR3_UINT8)"UNION_TYPE"), root_1));\r
1259 \r
1260                                         if ((stream_unionComponent == NULL || !stream_unionComponent->hasNext(stream_unionComponent))  )\r
1261                                         {\r
1262                                             CONSTRUCTEX();\r
1263                                             EXCEPTION->type         = ANTLR3_REWRITE_EARLY_EXCEPTION;\r
1264                                             EXCEPTION->name         = (void *)ANTLR3_REWRITE_EARLY_EXCEPTION_NAME;\r
1265                                         }\r
1266                                         else\r
1267                                         {\r
1268                                                 while ( (stream_unionComponent->hasNext(stream_unionComponent))  ) {\r
1269                                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_unionComponent == NULL ? NULL : stream_unionComponent->nextTree(stream_unionComponent));\r
1270 \r
1271                                                 }\r
1272                                                 stream_unionComponent->reset(stream_unionComponent);\r
1273 \r
1274                                         }\r
1275                                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
1276                                     }\r
1277 \r
1278                                 }\r
1279 \r
1280                                 retval.tree = root_0; // set result root\r
1281                                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
1282 \r
1283 \r
1284                         }\r
1285                     }\r
1286                     break;\r
1287 \r
1288             }\r
1289         }\r
1290     }\r
1291     \r
1292 \r
1293     // This is where rules clean up and exit\r
1294     //\r
1295     goto ruleunionTypeEx; /* Prevent compiler warnings */\r
1296     ruleunionTypeEx: ;\r
1297     retval.stop = LT(-1);\r
1298 \r
1299         retval.stop = LT(-1);\r
1300         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
1301         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
1302         if (stream_36 != NULL) stream_36->free(stream_36);\r
1303         if (stream_unionComponent != NULL) stream_unionComponent->free(stream_unionComponent);\r
1304 \r
1305             if (HASEXCEPTION())\r
1306             {\r
1307                 PREPORTERROR();\r
1308                 PRECOVER();\r
1309                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
1310             }\r
1311 \r
1312 \r
1313     return retval;\r
1314 }\r
1315 /* $ANTLR end unionType */\r
1316 \r
1317 /** \r
1318  * $ANTLR start unionComponent\r
1319  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:1: unionComponent : ID ( type )? -> ^( TYPE_COMPONENT ID ( type )? ) ;\r
1320  */\r
1321 static SimanticsDataParser_unionComponent_return\r
1322 unionComponent(pSimanticsDataParser ctx)\r
1323 {   \r
1324     SimanticsDataParser_unionComponent_return retval;\r
1325 \r
1326     pANTLR3_BASE_TREE root_0;\r
1327 \r
1328     pANTLR3_COMMON_TOKEN    ID9;\r
1329     SimanticsDataParser_type_return type10;\r
1330     #undef      RETURN_TYPE_type10\r
1331     #define     RETURN_TYPE_type10 SimanticsDataParser_type_return\r
1332 \r
1333     pANTLR3_BASE_TREE ID9_tree;\r
1334     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;\r
1335     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_type;\r
1336     /* Initialize rule variables\r
1337      */\r
1338 \r
1339 \r
1340     root_0 = NULL;\r
1341 \r
1342     ID9       = NULL;\r
1343     type10.tree = NULL;\r
1344 \r
1345     retval.start = LT(1); retval.stop = retval.start;\r
1346 \r
1347     ID9_tree   = NULL;\r
1348 \r
1349     stream_ID   = NULL;\r
1350     #define CREATE_stream_ID  if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } \r
1351     stream_type   = NULL;\r
1352     #define CREATE_stream_type  if (stream_type == NULL) {stream_type = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule type"); }\r
1353 \r
1354     retval.tree  = NULL;\r
1355     {\r
1356         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:16: ( ID ( type )? -> ^( TYPE_COMPONENT ID ( type )? ) )\r
1357         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:18: ID ( type )?\r
1358         {\r
1359             ID9 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_unionComponent871); \r
1360             if  (HASEXCEPTION())\r
1361             {\r
1362                 goto ruleunionComponentEx;\r
1363             }\r
1364              \r
1365             CREATE_stream_ID; stream_ID->add(stream_ID, ID9, NULL);\r
1366 \r
1367 \r
1368             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:21: ( type )?\r
1369             {\r
1370                 int alt4=2;\r
1371                 switch ( LA(1) ) \r
1372                 {\r
1373                     case ID:\r
1374                     case 40:\r
1375                     case 43:\r
1376                         {\r
1377                                 alt4=1;\r
1378                         }\r
1379                         break;\r
1380                 }\r
1381 \r
1382                 switch (alt4) \r
1383                 {\r
1384                 case 1:\r
1385                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:21: type\r
1386                     {\r
1387                         FOLLOWPUSH(FOLLOW_type_in_unionComponent873);\r
1388                         type10=type(ctx);\r
1389 \r
1390                         FOLLOWPOP();\r
1391                         if  (HASEXCEPTION())\r
1392                         {\r
1393                             goto ruleunionComponentEx;\r
1394                         }\r
1395 \r
1396                         CREATE_stream_type; stream_type->add(stream_type, type10.tree, NULL);\r
1397 \r
1398                     }\r
1399                     break;\r
1400 \r
1401                 }\r
1402             }\r
1403 \r
1404              \r
1405             /* AST REWRITE\r
1406              * elements          : ID, type\r
1407              * token labels      : \r
1408              * rule labels       : retval\r
1409              * token list labels : \r
1410              * rule list labels  : \r
1411              */\r
1412             {\r
1413                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
1414 \r
1415                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
1416 \r
1417                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1418                 retval.tree    = root_0;\r
1419                 // 105:27: -> ^( TYPE_COMPONENT ID ( type )? )\r
1420                 {\r
1421                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:30: ^( TYPE_COMPONENT ID ( type )? )\r
1422                     {\r
1423                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1424                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_COMPONENT, (pANTLR3_UINT8)"TYPE_COMPONENT"), root_1));\r
1425 \r
1426                         ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));\r
1427                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:50: ( type )?\r
1428                         {\r
1429                                 if ( (stream_type != NULL && stream_type->hasNext(stream_type))  )\r
1430                                 {\r
1431                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_type == NULL ? NULL : stream_type->nextTree(stream_type));\r
1432 \r
1433                                 }\r
1434                                 if ( stream_type != NULL) stream_type->reset(stream_type);\r
1435 \r
1436                         }\r
1437 \r
1438                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
1439                     }\r
1440 \r
1441                 }\r
1442 \r
1443                 retval.tree = root_0; // set result root\r
1444                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
1445 \r
1446 \r
1447             }\r
1448         }\r
1449 \r
1450     }\r
1451     \r
1452 \r
1453     // This is where rules clean up and exit\r
1454     //\r
1455     goto ruleunionComponentEx; /* Prevent compiler warnings */\r
1456     ruleunionComponentEx: ;\r
1457     retval.stop = LT(-1);\r
1458 \r
1459         retval.stop = LT(-1);\r
1460         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
1461         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
1462         if (stream_ID != NULL) stream_ID->free(stream_ID);\r
1463         if (stream_type != NULL) stream_type->free(stream_type);\r
1464 \r
1465             if (HASEXCEPTION())\r
1466             {\r
1467                 PREPORTERROR();\r
1468                 PRECOVER();\r
1469                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
1470             }\r
1471 \r
1472 \r
1473     return retval;\r
1474 }\r
1475 /* $ANTLR end unionComponent */\r
1476 \r
1477 /** \r
1478  * $ANTLR start type\r
1479  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:107:1: type : ( basicType -> basicType ) ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )* ;\r
1480  */\r
1481 static SimanticsDataParser_type_return\r
1482 type(pSimanticsDataParser ctx)\r
1483 {   \r
1484     SimanticsDataParser_type_return retval;\r
1485 \r
1486     pANTLR3_BASE_TREE root_0;\r
1487 \r
1488     pANTLR3_COMMON_TOKEN    char_literal12;\r
1489     pANTLR3_COMMON_TOKEN    char_literal14;\r
1490     SimanticsDataParser_basicType_return basicType11;\r
1491     #undef      RETURN_TYPE_basicType11\r
1492     #define     RETURN_TYPE_basicType11 SimanticsDataParser_basicType_return\r
1493 \r
1494     SimanticsDataParser_arrayLength_return arrayLength13;\r
1495     #undef      RETURN_TYPE_arrayLength13\r
1496     #define     RETURN_TYPE_arrayLength13 SimanticsDataParser_arrayLength_return\r
1497 \r
1498     pANTLR3_BASE_TREE char_literal12_tree;\r
1499     pANTLR3_BASE_TREE char_literal14_tree;\r
1500     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_37;\r
1501     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_38;\r
1502     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_arrayLength;\r
1503     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_basicType;\r
1504     /* Initialize rule variables\r
1505      */\r
1506 \r
1507 \r
1508     root_0 = NULL;\r
1509 \r
1510     char_literal12       = NULL;\r
1511     char_literal14       = NULL;\r
1512     basicType11.tree = NULL;\r
1513 \r
1514     arrayLength13.tree = NULL;\r
1515 \r
1516     retval.start = LT(1); retval.stop = retval.start;\r
1517 \r
1518     char_literal12_tree   = NULL;\r
1519     char_literal14_tree   = NULL;\r
1520 \r
1521     stream_37   = NULL;\r
1522     #define CREATE_stream_37  if (stream_37 == NULL) {stream_37 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 37"); } \r
1523     stream_38   = NULL;\r
1524     #define CREATE_stream_38  if (stream_38 == NULL) {stream_38 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 38"); } \r
1525     stream_arrayLength   = NULL;\r
1526     #define CREATE_stream_arrayLength  if (stream_arrayLength == NULL) {stream_arrayLength = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule arrayLength"); }\r
1527     stream_basicType   = NULL;\r
1528     #define CREATE_stream_basicType  if (stream_basicType == NULL) {stream_basicType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule basicType"); }\r
1529 \r
1530     retval.tree  = NULL;\r
1531     {\r
1532         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:5: ( ( basicType -> basicType ) ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )* )\r
1533         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:7: ( basicType -> basicType ) ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )*\r
1534         {\r
1535             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:7: ( basicType -> basicType )\r
1536             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:8: basicType\r
1537             {\r
1538                 FOLLOWPUSH(FOLLOW_basicType_in_type900);\r
1539                 basicType11=basicType(ctx);\r
1540 \r
1541                 FOLLOWPOP();\r
1542                 if  (HASEXCEPTION())\r
1543                 {\r
1544                     goto ruletypeEx;\r
1545                 }\r
1546 \r
1547                 CREATE_stream_basicType; stream_basicType->add(stream_basicType, basicType11.tree, NULL);\r
1548 \r
1549                  \r
1550                 /* AST REWRITE\r
1551                  * elements          : basicType\r
1552                  * token labels      : \r
1553                  * rule labels       : retval\r
1554                  * token list labels : \r
1555                  * rule list labels  : \r
1556                  */\r
1557                 {\r
1558                         pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
1559 \r
1560                         stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
1561 \r
1562                         root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1563                         retval.tree    = root_0;\r
1564                         // 108:18: -> basicType\r
1565                         {\r
1566                             ADAPTOR->addChild(ADAPTOR, root_0, stream_basicType == NULL ? NULL : stream_basicType->nextTree(stream_basicType));\r
1567 \r
1568                         }\r
1569 \r
1570                         retval.tree = root_0; // set result root\r
1571                         if (stream_retval != NULL) stream_retval->free(stream_retval);\r
1572 \r
1573 \r
1574                 }\r
1575             }\r
1576 \r
1577 \r
1578             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:7: ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )*\r
1579 \r
1580             for (;;)\r
1581             {\r
1582                 int alt6=2;\r
1583                 switch ( LA(1) ) \r
1584                 {\r
1585                 case 37:\r
1586                         {\r
1587                                 alt6=1;\r
1588                         }\r
1589                     break;\r
1590 \r
1591                 }\r
1592 \r
1593                 switch (alt6) \r
1594                 {\r
1595                 case 1:\r
1596                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:8: '[' ( arrayLength )? ']'\r
1597                     {\r
1598                         char_literal12 = (pANTLR3_COMMON_TOKEN) MATCHT(37, &FOLLOW_37_in_type914); \r
1599                         if  (HASEXCEPTION())\r
1600                         {\r
1601                             goto ruletypeEx;\r
1602                         }\r
1603                          \r
1604                         CREATE_stream_37; stream_37->add(stream_37, char_literal12, NULL);\r
1605 \r
1606 \r
1607                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:12: ( arrayLength )?\r
1608                         {\r
1609                             int alt5=2;\r
1610                             switch ( LA(1) ) \r
1611                             {\r
1612                                 case INT:\r
1613                                 case 39:\r
1614                                         {\r
1615                                                 alt5=1;\r
1616                                         }\r
1617                                     break;\r
1618                             }\r
1619 \r
1620                             switch (alt5) \r
1621                             {\r
1622                                 case 1:\r
1623                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:12: arrayLength\r
1624                                     {\r
1625                                         FOLLOWPUSH(FOLLOW_arrayLength_in_type916);\r
1626                                         arrayLength13=arrayLength(ctx);\r
1627 \r
1628                                         FOLLOWPOP();\r
1629                                         if  (HASEXCEPTION())\r
1630                                         {\r
1631                                             goto ruletypeEx;\r
1632                                         }\r
1633 \r
1634                                         CREATE_stream_arrayLength; stream_arrayLength->add(stream_arrayLength, arrayLength13.tree, NULL);\r
1635 \r
1636                                     }\r
1637                                     break;\r
1638 \r
1639                             }\r
1640                         }\r
1641                         char_literal14 = (pANTLR3_COMMON_TOKEN) MATCHT(38, &FOLLOW_38_in_type919); \r
1642                         if  (HASEXCEPTION())\r
1643                         {\r
1644                             goto ruletypeEx;\r
1645                         }\r
1646                          \r
1647                         CREATE_stream_38; stream_38->add(stream_38, char_literal14, NULL);\r
1648 \r
1649 \r
1650                          \r
1651                         /* AST REWRITE\r
1652                          * elements          : arrayLength, type\r
1653                          * token labels      : \r
1654                          * rule labels       : retval\r
1655                          * token list labels : \r
1656                          * rule list labels  : \r
1657                          */\r
1658                         {\r
1659                                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
1660 \r
1661                                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
1662 \r
1663                                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1664                                 retval.tree    = root_0;\r
1665                                 // 109:29: -> ^( ARRAY_TYPE $type ( arrayLength )? )\r
1666                                 {\r
1667                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:32: ^( ARRAY_TYPE $type ( arrayLength )? )\r
1668                                     {\r
1669                                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1670                                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ARRAY_TYPE, (pANTLR3_UINT8)"ARRAY_TYPE"), root_1));\r
1671 \r
1672                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_retval == NULL ? NULL : stream_retval->nextTree(stream_retval));\r
1673                                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:51: ( arrayLength )?\r
1674                                         {\r
1675                                                 if ( (stream_arrayLength != NULL && stream_arrayLength->hasNext(stream_arrayLength))  )\r
1676                                                 {\r
1677                                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_arrayLength == NULL ? NULL : stream_arrayLength->nextTree(stream_arrayLength));\r
1678 \r
1679                                                 }\r
1680                                                 if ( stream_arrayLength != NULL) stream_arrayLength->reset(stream_arrayLength);\r
1681 \r
1682                                         }\r
1683 \r
1684                                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
1685                                     }\r
1686 \r
1687                                 }\r
1688 \r
1689                                 retval.tree = root_0; // set result root\r
1690                                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
1691 \r
1692 \r
1693                         }\r
1694                     }\r
1695                     break;\r
1696 \r
1697                 default:\r
1698                     goto loop6; /* break out of the loop */\r
1699                     break;\r
1700                 }\r
1701             }\r
1702             loop6: ; /* Jump out to here if this rule does not match */\r
1703 \r
1704 \r
1705         }\r
1706 \r
1707     }\r
1708     \r
1709 \r
1710     // This is where rules clean up and exit\r
1711     //\r
1712     goto ruletypeEx; /* Prevent compiler warnings */\r
1713     ruletypeEx: ;\r
1714     retval.stop = LT(-1);\r
1715 \r
1716         retval.stop = LT(-1);\r
1717         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
1718         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
1719         if (stream_37 != NULL) stream_37->free(stream_37);\r
1720         if (stream_38 != NULL) stream_38->free(stream_38);\r
1721         if (stream_arrayLength != NULL) stream_arrayLength->free(stream_arrayLength);\r
1722         if (stream_basicType != NULL) stream_basicType->free(stream_basicType);\r
1723 \r
1724             if (HASEXCEPTION())\r
1725             {\r
1726                 PREPORTERROR();\r
1727                 PRECOVER();\r
1728                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
1729             }\r
1730 \r
1731 \r
1732     return retval;\r
1733 }\r
1734 /* $ANTLR end type */\r
1735 \r
1736 /** \r
1737  * $ANTLR start arrayLength\r
1738  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:111:1: arrayLength : ( INT | INT '..' | '..' INT | INT '..' INT );\r
1739  */\r
1740 static SimanticsDataParser_arrayLength_return\r
1741 arrayLength(pSimanticsDataParser ctx)\r
1742 {   \r
1743     SimanticsDataParser_arrayLength_return retval;\r
1744 \r
1745     pANTLR3_BASE_TREE root_0;\r
1746 \r
1747     pANTLR3_COMMON_TOKEN    INT15;\r
1748     pANTLR3_COMMON_TOKEN    INT16;\r
1749     pANTLR3_COMMON_TOKEN    string_literal17;\r
1750     pANTLR3_COMMON_TOKEN    string_literal18;\r
1751     pANTLR3_COMMON_TOKEN    INT19;\r
1752     pANTLR3_COMMON_TOKEN    INT20;\r
1753     pANTLR3_COMMON_TOKEN    string_literal21;\r
1754     pANTLR3_COMMON_TOKEN    INT22;\r
1755 \r
1756     pANTLR3_BASE_TREE INT15_tree;\r
1757     pANTLR3_BASE_TREE INT16_tree;\r
1758     pANTLR3_BASE_TREE string_literal17_tree;\r
1759     pANTLR3_BASE_TREE string_literal18_tree;\r
1760     pANTLR3_BASE_TREE INT19_tree;\r
1761     pANTLR3_BASE_TREE INT20_tree;\r
1762     pANTLR3_BASE_TREE string_literal21_tree;\r
1763     pANTLR3_BASE_TREE INT22_tree;\r
1764 \r
1765     /* Initialize rule variables\r
1766      */\r
1767 \r
1768 \r
1769     root_0 = NULL;\r
1770 \r
1771     INT15       = NULL;\r
1772     INT16       = NULL;\r
1773     string_literal17       = NULL;\r
1774     string_literal18       = NULL;\r
1775     INT19       = NULL;\r
1776     INT20       = NULL;\r
1777     string_literal21       = NULL;\r
1778     INT22       = NULL;\r
1779     retval.start = LT(1); retval.stop = retval.start;\r
1780 \r
1781     INT15_tree   = NULL;\r
1782     INT16_tree   = NULL;\r
1783     string_literal17_tree   = NULL;\r
1784     string_literal18_tree   = NULL;\r
1785     INT19_tree   = NULL;\r
1786     INT20_tree   = NULL;\r
1787     string_literal21_tree   = NULL;\r
1788     INT22_tree   = NULL;\r
1789 \r
1790 \r
1791     retval.tree  = NULL;\r
1792     {\r
1793         {\r
1794             //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:112:5: ( INT | INT '..' | '..' INT | INT '..' INT )\r
1795             \r
1796             ANTLR3_UINT32 alt7;\r
1797 \r
1798             alt7=4;\r
1799 \r
1800             switch ( LA(1) ) \r
1801             {\r
1802             case INT:\r
1803                 {\r
1804                         switch ( LA(2) ) \r
1805                         {\r
1806                         case 39:\r
1807                                 {\r
1808                                         switch ( LA(3) ) \r
1809                                         {\r
1810                                         case INT:\r
1811                                                 {\r
1812                                                         alt7=4;\r
1813                                                 }\r
1814                                             break;\r
1815                                         case 38:\r
1816                                                 {\r
1817                                                         alt7=2;\r
1818                                                 }\r
1819                                             break;\r
1820 \r
1821                                         default:\r
1822                                             CONSTRUCTEX();\r
1823                                             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
1824                                             EXCEPTION->message      = (void *)"";\r
1825                                             EXCEPTION->decisionNum  = 7;\r
1826                                             EXCEPTION->state        = 3;\r
1827 \r
1828 \r
1829                                             goto rulearrayLengthEx;\r
1830                                         }\r
1831 \r
1832                                 }\r
1833                             break;\r
1834                         case 38:\r
1835                                 {\r
1836                                         alt7=1;\r
1837                                 }\r
1838                             break;\r
1839 \r
1840                         default:\r
1841                             CONSTRUCTEX();\r
1842                             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
1843                             EXCEPTION->message      = (void *)"";\r
1844                             EXCEPTION->decisionNum  = 7;\r
1845                             EXCEPTION->state        = 1;\r
1846 \r
1847 \r
1848                             goto rulearrayLengthEx;\r
1849                         }\r
1850 \r
1851                 }\r
1852                 break;\r
1853             case 39:\r
1854                 {\r
1855                         alt7=3;\r
1856                 }\r
1857                 break;\r
1858 \r
1859             default:\r
1860                 CONSTRUCTEX();\r
1861                 EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
1862                 EXCEPTION->message      = (void *)"";\r
1863                 EXCEPTION->decisionNum  = 7;\r
1864                 EXCEPTION->state        = 0;\r
1865 \r
1866 \r
1867                 goto rulearrayLengthEx;\r
1868             }\r
1869 \r
1870             switch (alt7) \r
1871             {\r
1872                 case 1:\r
1873                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:112:7: INT\r
1874                     {\r
1875                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1876 \r
1877                         INT15 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength947); \r
1878                         if  (HASEXCEPTION())\r
1879                         {\r
1880                             goto rulearrayLengthEx;\r
1881                         }\r
1882 \r
1883                         INT15_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT15));\r
1884                         ADAPTOR->addChild(ADAPTOR, root_0, INT15_tree);\r
1885 \r
1886 \r
1887                     }\r
1888                     break;\r
1889                 case 2:\r
1890                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:113:7: INT '..'\r
1891                     {\r
1892                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1893 \r
1894                         INT16 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength955); \r
1895                         if  (HASEXCEPTION())\r
1896                         {\r
1897                             goto rulearrayLengthEx;\r
1898                         }\r
1899 \r
1900                         INT16_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT16));\r
1901                         ADAPTOR->addChild(ADAPTOR, root_0, INT16_tree);\r
1902 \r
1903                         string_literal17 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_arrayLength957); \r
1904                         if  (HASEXCEPTION())\r
1905                         {\r
1906                             goto rulearrayLengthEx;\r
1907                         }\r
1908 \r
1909                         string_literal17_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal17));\r
1910                         ADAPTOR->addChild(ADAPTOR, root_0, string_literal17_tree);\r
1911 \r
1912 \r
1913                     }\r
1914                     break;\r
1915                 case 3:\r
1916                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:114:7: '..' INT\r
1917                     {\r
1918                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1919 \r
1920                         string_literal18 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_arrayLength965); \r
1921                         if  (HASEXCEPTION())\r
1922                         {\r
1923                             goto rulearrayLengthEx;\r
1924                         }\r
1925 \r
1926                         string_literal18_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal18));\r
1927                         ADAPTOR->addChild(ADAPTOR, root_0, string_literal18_tree);\r
1928 \r
1929                         INT19 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength967); \r
1930                         if  (HASEXCEPTION())\r
1931                         {\r
1932                             goto rulearrayLengthEx;\r
1933                         }\r
1934 \r
1935                         INT19_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT19));\r
1936                         ADAPTOR->addChild(ADAPTOR, root_0, INT19_tree);\r
1937 \r
1938 \r
1939                     }\r
1940                     break;\r
1941                 case 4:\r
1942                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:115:7: INT '..' INT\r
1943                     {\r
1944                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
1945 \r
1946                         INT20 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength976); \r
1947                         if  (HASEXCEPTION())\r
1948                         {\r
1949                             goto rulearrayLengthEx;\r
1950                         }\r
1951 \r
1952                         INT20_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT20));\r
1953                         ADAPTOR->addChild(ADAPTOR, root_0, INT20_tree);\r
1954 \r
1955                         string_literal21 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_arrayLength978); \r
1956                         if  (HASEXCEPTION())\r
1957                         {\r
1958                             goto rulearrayLengthEx;\r
1959                         }\r
1960 \r
1961                         string_literal21_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal21));\r
1962                         ADAPTOR->addChild(ADAPTOR, root_0, string_literal21_tree);\r
1963 \r
1964                         INT22 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength980); \r
1965                         if  (HASEXCEPTION())\r
1966                         {\r
1967                             goto rulearrayLengthEx;\r
1968                         }\r
1969 \r
1970                         INT22_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT22));\r
1971                         ADAPTOR->addChild(ADAPTOR, root_0, INT22_tree);\r
1972 \r
1973 \r
1974                     }\r
1975                     break;\r
1976 \r
1977             }\r
1978         }\r
1979     }\r
1980     \r
1981 \r
1982     // This is where rules clean up and exit\r
1983     //\r
1984     goto rulearrayLengthEx; /* Prevent compiler warnings */\r
1985     rulearrayLengthEx: ;\r
1986     retval.stop = LT(-1);\r
1987 \r
1988         retval.stop = LT(-1);\r
1989         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
1990         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
1991 \r
1992             if (HASEXCEPTION())\r
1993             {\r
1994                 PREPORTERROR();\r
1995                 PRECOVER();\r
1996                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
1997             }\r
1998 \r
1999 \r
2000     return retval;\r
2001 }\r
2002 /* $ANTLR end arrayLength */\r
2003 \r
2004 /** \r
2005  * $ANTLR start basicType\r
2006  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:118:1: basicType : ( tupleType | recordType | typeReference );\r
2007  */\r
2008 static SimanticsDataParser_basicType_return\r
2009 basicType(pSimanticsDataParser ctx)\r
2010 {   \r
2011     SimanticsDataParser_basicType_return retval;\r
2012 \r
2013     pANTLR3_BASE_TREE root_0;\r
2014 \r
2015     SimanticsDataParser_tupleType_return tupleType23;\r
2016     #undef      RETURN_TYPE_tupleType23\r
2017     #define     RETURN_TYPE_tupleType23 SimanticsDataParser_tupleType_return\r
2018 \r
2019     SimanticsDataParser_recordType_return recordType24;\r
2020     #undef      RETURN_TYPE_recordType24\r
2021     #define     RETURN_TYPE_recordType24 SimanticsDataParser_recordType_return\r
2022 \r
2023     SimanticsDataParser_typeReference_return typeReference25;\r
2024     #undef      RETURN_TYPE_typeReference25\r
2025     #define     RETURN_TYPE_typeReference25 SimanticsDataParser_typeReference_return\r
2026 \r
2027 \r
2028     /* Initialize rule variables\r
2029      */\r
2030 \r
2031 \r
2032     root_0 = NULL;\r
2033 \r
2034     tupleType23.tree = NULL;\r
2035 \r
2036     recordType24.tree = NULL;\r
2037 \r
2038     typeReference25.tree = NULL;\r
2039 \r
2040     retval.start = LT(1); retval.stop = retval.start;\r
2041 \r
2042 \r
2043 \r
2044     retval.tree  = NULL;\r
2045     {\r
2046         {\r
2047             //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:119:5: ( tupleType | recordType | typeReference )\r
2048             \r
2049             ANTLR3_UINT32 alt8;\r
2050 \r
2051             alt8=3;\r
2052 \r
2053             switch ( LA(1) ) \r
2054             {\r
2055             case 40:\r
2056                 {\r
2057                         alt8=1;\r
2058                 }\r
2059                 break;\r
2060             case 43:\r
2061                 {\r
2062                         alt8=2;\r
2063                 }\r
2064                 break;\r
2065             case ID:\r
2066                 {\r
2067                         alt8=3;\r
2068                 }\r
2069                 break;\r
2070 \r
2071             default:\r
2072                 CONSTRUCTEX();\r
2073                 EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
2074                 EXCEPTION->message      = (void *)"";\r
2075                 EXCEPTION->decisionNum  = 8;\r
2076                 EXCEPTION->state        = 0;\r
2077 \r
2078 \r
2079                 goto rulebasicTypeEx;\r
2080             }\r
2081 \r
2082             switch (alt8) \r
2083             {\r
2084                 case 1:\r
2085                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:119:7: tupleType\r
2086                     {\r
2087                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2088 \r
2089                         FOLLOWPUSH(FOLLOW_tupleType_in_basicType998);\r
2090                         tupleType23=tupleType(ctx);\r
2091 \r
2092                         FOLLOWPOP();\r
2093                         if  (HASEXCEPTION())\r
2094                         {\r
2095                             goto rulebasicTypeEx;\r
2096                         }\r
2097 \r
2098                         ADAPTOR->addChild(ADAPTOR, root_0, tupleType23.tree);\r
2099 \r
2100                     }\r
2101                     break;\r
2102                 case 2:\r
2103                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:120:7: recordType\r
2104                     {\r
2105                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2106 \r
2107                         FOLLOWPUSH(FOLLOW_recordType_in_basicType1006);\r
2108                         recordType24=recordType(ctx);\r
2109 \r
2110                         FOLLOWPOP();\r
2111                         if  (HASEXCEPTION())\r
2112                         {\r
2113                             goto rulebasicTypeEx;\r
2114                         }\r
2115 \r
2116                         ADAPTOR->addChild(ADAPTOR, root_0, recordType24.tree);\r
2117 \r
2118                     }\r
2119                     break;\r
2120                 case 3:\r
2121                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:121:7: typeReference\r
2122                     {\r
2123                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2124 \r
2125                         FOLLOWPUSH(FOLLOW_typeReference_in_basicType1014);\r
2126                         typeReference25=typeReference(ctx);\r
2127 \r
2128                         FOLLOWPOP();\r
2129                         if  (HASEXCEPTION())\r
2130                         {\r
2131                             goto rulebasicTypeEx;\r
2132                         }\r
2133 \r
2134                         ADAPTOR->addChild(ADAPTOR, root_0, typeReference25.tree);\r
2135 \r
2136                     }\r
2137                     break;\r
2138 \r
2139             }\r
2140         }\r
2141     }\r
2142     \r
2143 \r
2144     // This is where rules clean up and exit\r
2145     //\r
2146     goto rulebasicTypeEx; /* Prevent compiler warnings */\r
2147     rulebasicTypeEx: ;\r
2148     retval.stop = LT(-1);\r
2149 \r
2150         retval.stop = LT(-1);\r
2151         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
2152         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
2153 \r
2154             if (HASEXCEPTION())\r
2155             {\r
2156                 PREPORTERROR();\r
2157                 PRECOVER();\r
2158                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
2159             }\r
2160 \r
2161 \r
2162     return retval;\r
2163 }\r
2164 /* $ANTLR end basicType */\r
2165 \r
2166 /** \r
2167  * $ANTLR start tupleType\r
2168  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:124:1: tupleType : '(' ( unionType ( ',' unionType )* )? ')' -> ^( TUPLE_TYPE ( unionType )* ) ;\r
2169  */\r
2170 static SimanticsDataParser_tupleType_return\r
2171 tupleType(pSimanticsDataParser ctx)\r
2172 {   \r
2173     SimanticsDataParser_tupleType_return retval;\r
2174 \r
2175     pANTLR3_BASE_TREE root_0;\r
2176 \r
2177     pANTLR3_COMMON_TOKEN    char_literal26;\r
2178     pANTLR3_COMMON_TOKEN    char_literal28;\r
2179     pANTLR3_COMMON_TOKEN    char_literal30;\r
2180     SimanticsDataParser_unionType_return unionType27;\r
2181     #undef      RETURN_TYPE_unionType27\r
2182     #define     RETURN_TYPE_unionType27 SimanticsDataParser_unionType_return\r
2183 \r
2184     SimanticsDataParser_unionType_return unionType29;\r
2185     #undef      RETURN_TYPE_unionType29\r
2186     #define     RETURN_TYPE_unionType29 SimanticsDataParser_unionType_return\r
2187 \r
2188     pANTLR3_BASE_TREE char_literal26_tree;\r
2189     pANTLR3_BASE_TREE char_literal28_tree;\r
2190     pANTLR3_BASE_TREE char_literal30_tree;\r
2191     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_42;\r
2192     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;\r
2193     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_40;\r
2194     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType;\r
2195     /* Initialize rule variables\r
2196      */\r
2197 \r
2198 \r
2199     root_0 = NULL;\r
2200 \r
2201     char_literal26       = NULL;\r
2202     char_literal28       = NULL;\r
2203     char_literal30       = NULL;\r
2204     unionType27.tree = NULL;\r
2205 \r
2206     unionType29.tree = NULL;\r
2207 \r
2208     retval.start = LT(1); retval.stop = retval.start;\r
2209 \r
2210     char_literal26_tree   = NULL;\r
2211     char_literal28_tree   = NULL;\r
2212     char_literal30_tree   = NULL;\r
2213 \r
2214     stream_42   = NULL;\r
2215     #define CREATE_stream_42  if (stream_42 == NULL) {stream_42 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 42"); } \r
2216     stream_41   = NULL;\r
2217     #define CREATE_stream_41  if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } \r
2218     stream_40   = NULL;\r
2219     #define CREATE_stream_40  if (stream_40 == NULL) {stream_40 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 40"); } \r
2220     stream_unionType   = NULL;\r
2221     #define CREATE_stream_unionType  if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); }\r
2222 \r
2223     retval.tree  = NULL;\r
2224     {\r
2225         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:5: ( '(' ( unionType ( ',' unionType )* )? ')' -> ^( TUPLE_TYPE ( unionType )* ) )\r
2226         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:7: '(' ( unionType ( ',' unionType )* )? ')'\r
2227         {\r
2228             char_literal26 = (pANTLR3_COMMON_TOKEN) MATCHT(40, &FOLLOW_40_in_tupleType1036); \r
2229             if  (HASEXCEPTION())\r
2230             {\r
2231                 goto ruletupleTypeEx;\r
2232             }\r
2233              \r
2234             CREATE_stream_40; stream_40->add(stream_40, char_literal26, NULL);\r
2235 \r
2236 \r
2237             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:11: ( unionType ( ',' unionType )* )?\r
2238             {\r
2239                 int alt10=2;\r
2240                 switch ( LA(1) ) \r
2241                 {\r
2242                     case ID:\r
2243                     case 36:\r
2244                     case 40:\r
2245                     case 43:\r
2246                         {\r
2247                                 alt10=1;\r
2248                         }\r
2249                         break;\r
2250                 }\r
2251 \r
2252                 switch (alt10) \r
2253                 {\r
2254                 case 1:\r
2255                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:12: unionType ( ',' unionType )*\r
2256                     {\r
2257                         FOLLOWPUSH(FOLLOW_unionType_in_tupleType1039);\r
2258                         unionType27=unionType(ctx);\r
2259 \r
2260                         FOLLOWPOP();\r
2261                         if  (HASEXCEPTION())\r
2262                         {\r
2263                             goto ruletupleTypeEx;\r
2264                         }\r
2265 \r
2266                         CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType27.tree, NULL);\r
2267 \r
2268                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:22: ( ',' unionType )*\r
2269 \r
2270                         for (;;)\r
2271                         {\r
2272                             int alt9=2;\r
2273                             switch ( LA(1) ) \r
2274                             {\r
2275                             case 41:\r
2276                                 {\r
2277                                         alt9=1;\r
2278                                 }\r
2279                                 break;\r
2280 \r
2281                             }\r
2282 \r
2283                             switch (alt9) \r
2284                             {\r
2285                                 case 1:\r
2286                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:23: ',' unionType\r
2287                                     {\r
2288                                         char_literal28 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_tupleType1042); \r
2289                                         if  (HASEXCEPTION())\r
2290                                         {\r
2291                                             goto ruletupleTypeEx;\r
2292                                         }\r
2293                                          \r
2294                                         CREATE_stream_41; stream_41->add(stream_41, char_literal28, NULL);\r
2295 \r
2296                                         FOLLOWPUSH(FOLLOW_unionType_in_tupleType1044);\r
2297                                         unionType29=unionType(ctx);\r
2298 \r
2299                                         FOLLOWPOP();\r
2300                                         if  (HASEXCEPTION())\r
2301                                         {\r
2302                                             goto ruletupleTypeEx;\r
2303                                         }\r
2304 \r
2305                                         CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType29.tree, NULL);\r
2306 \r
2307                                     }\r
2308                                     break;\r
2309 \r
2310                                 default:\r
2311                                     goto loop9; /* break out of the loop */\r
2312                                     break;\r
2313                             }\r
2314                         }\r
2315                         loop9: ; /* Jump out to here if this rule does not match */\r
2316 \r
2317 \r
2318                     }\r
2319                     break;\r
2320 \r
2321                 }\r
2322             }\r
2323             char_literal30 = (pANTLR3_COMMON_TOKEN) MATCHT(42, &FOLLOW_42_in_tupleType1050); \r
2324             if  (HASEXCEPTION())\r
2325             {\r
2326                 goto ruletupleTypeEx;\r
2327             }\r
2328              \r
2329             CREATE_stream_42; stream_42->add(stream_42, char_literal30, NULL);\r
2330 \r
2331 \r
2332              \r
2333             /* AST REWRITE\r
2334              * elements          : unionType\r
2335              * token labels      : \r
2336              * rule labels       : retval\r
2337              * token list labels : \r
2338              * rule list labels  : \r
2339              */\r
2340             {\r
2341                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
2342 \r
2343                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
2344 \r
2345                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2346                 retval.tree    = root_0;\r
2347                 // 126:5: -> ^( TUPLE_TYPE ( unionType )* )\r
2348                 {\r
2349                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:126:8: ^( TUPLE_TYPE ( unionType )* )\r
2350                     {\r
2351                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2352                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TUPLE_TYPE, (pANTLR3_UINT8)"TUPLE_TYPE"), root_1));\r
2353 \r
2354                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:126:21: ( unionType )*\r
2355                         {\r
2356                                 while ( (stream_unionType != NULL && stream_unionType->hasNext(stream_unionType))  )\r
2357                                 {\r
2358                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType));\r
2359 \r
2360                                 }\r
2361                                 if (stream_unionType != NULL) stream_unionType->reset(stream_unionType);\r
2362 \r
2363                         }\r
2364 \r
2365                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
2366                     }\r
2367 \r
2368                 }\r
2369 \r
2370                 retval.tree = root_0; // set result root\r
2371                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
2372 \r
2373 \r
2374             }\r
2375         }\r
2376 \r
2377     }\r
2378     \r
2379 \r
2380     // This is where rules clean up and exit\r
2381     //\r
2382     goto ruletupleTypeEx; /* Prevent compiler warnings */\r
2383     ruletupleTypeEx: ;\r
2384     retval.stop = LT(-1);\r
2385 \r
2386         retval.stop = LT(-1);\r
2387         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
2388         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
2389         if (stream_42 != NULL) stream_42->free(stream_42);\r
2390         if (stream_41 != NULL) stream_41->free(stream_41);\r
2391         if (stream_40 != NULL) stream_40->free(stream_40);\r
2392         if (stream_unionType != NULL) stream_unionType->free(stream_unionType);\r
2393 \r
2394             if (HASEXCEPTION())\r
2395             {\r
2396                 PREPORTERROR();\r
2397                 PRECOVER();\r
2398                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
2399             }\r
2400 \r
2401 \r
2402     return retval;\r
2403 }\r
2404 /* $ANTLR end tupleType */\r
2405 \r
2406 /** \r
2407  * $ANTLR start recordType\r
2408  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:129:1: recordType : '{' ( component ( ',' component )* )? '}' -> ^( RECORD_TYPE ( component )* ) ;\r
2409  */\r
2410 static SimanticsDataParser_recordType_return\r
2411 recordType(pSimanticsDataParser ctx)\r
2412 {   \r
2413     SimanticsDataParser_recordType_return retval;\r
2414 \r
2415     pANTLR3_BASE_TREE root_0;\r
2416 \r
2417     pANTLR3_COMMON_TOKEN    char_literal31;\r
2418     pANTLR3_COMMON_TOKEN    char_literal33;\r
2419     pANTLR3_COMMON_TOKEN    char_literal35;\r
2420     SimanticsDataParser_component_return component32;\r
2421     #undef      RETURN_TYPE_component32\r
2422     #define     RETURN_TYPE_component32 SimanticsDataParser_component_return\r
2423 \r
2424     SimanticsDataParser_component_return component34;\r
2425     #undef      RETURN_TYPE_component34\r
2426     #define     RETURN_TYPE_component34 SimanticsDataParser_component_return\r
2427 \r
2428     pANTLR3_BASE_TREE char_literal31_tree;\r
2429     pANTLR3_BASE_TREE char_literal33_tree;\r
2430     pANTLR3_BASE_TREE char_literal35_tree;\r
2431     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_43;\r
2432     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_44;\r
2433     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;\r
2434     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_component;\r
2435     /* Initialize rule variables\r
2436      */\r
2437 \r
2438 \r
2439     root_0 = NULL;\r
2440 \r
2441     char_literal31       = NULL;\r
2442     char_literal33       = NULL;\r
2443     char_literal35       = NULL;\r
2444     component32.tree = NULL;\r
2445 \r
2446     component34.tree = NULL;\r
2447 \r
2448     retval.start = LT(1); retval.stop = retval.start;\r
2449 \r
2450     char_literal31_tree   = NULL;\r
2451     char_literal33_tree   = NULL;\r
2452     char_literal35_tree   = NULL;\r
2453 \r
2454     stream_43   = NULL;\r
2455     #define CREATE_stream_43  if (stream_43 == NULL) {stream_43 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 43"); } \r
2456     stream_44   = NULL;\r
2457     #define CREATE_stream_44  if (stream_44 == NULL) {stream_44 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 44"); } \r
2458     stream_41   = NULL;\r
2459     #define CREATE_stream_41  if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } \r
2460     stream_component   = NULL;\r
2461     #define CREATE_stream_component  if (stream_component == NULL) {stream_component = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule component"); }\r
2462 \r
2463     retval.tree  = NULL;\r
2464     {\r
2465         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:5: ( '{' ( component ( ',' component )* )? '}' -> ^( RECORD_TYPE ( component )* ) )\r
2466         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:7: '{' ( component ( ',' component )* )? '}'\r
2467         {\r
2468             char_literal31 = (pANTLR3_COMMON_TOKEN) MATCHT(43, &FOLLOW_43_in_recordType1083); \r
2469             if  (HASEXCEPTION())\r
2470             {\r
2471                 goto rulerecordTypeEx;\r
2472             }\r
2473              \r
2474             CREATE_stream_43; stream_43->add(stream_43, char_literal31, NULL);\r
2475 \r
2476 \r
2477             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:11: ( component ( ',' component )* )?\r
2478             {\r
2479                 int alt12=2;\r
2480                 switch ( LA(1) ) \r
2481                 {\r
2482                     case ID:\r
2483                         {\r
2484                                 alt12=1;\r
2485                         }\r
2486                         break;\r
2487                 }\r
2488 \r
2489                 switch (alt12) \r
2490                 {\r
2491                 case 1:\r
2492                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:12: component ( ',' component )*\r
2493                     {\r
2494                         FOLLOWPUSH(FOLLOW_component_in_recordType1086);\r
2495                         component32=component(ctx);\r
2496 \r
2497                         FOLLOWPOP();\r
2498                         if  (HASEXCEPTION())\r
2499                         {\r
2500                             goto rulerecordTypeEx;\r
2501                         }\r
2502 \r
2503                         CREATE_stream_component; stream_component->add(stream_component, component32.tree, NULL);\r
2504 \r
2505                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:22: ( ',' component )*\r
2506 \r
2507                         for (;;)\r
2508                         {\r
2509                             int alt11=2;\r
2510                             switch ( LA(1) ) \r
2511                             {\r
2512                             case 41:\r
2513                                 {\r
2514                                         alt11=1;\r
2515                                 }\r
2516                                 break;\r
2517 \r
2518                             }\r
2519 \r
2520                             switch (alt11) \r
2521                             {\r
2522                                 case 1:\r
2523                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:23: ',' component\r
2524                                     {\r
2525                                         char_literal33 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_recordType1089); \r
2526                                         if  (HASEXCEPTION())\r
2527                                         {\r
2528                                             goto rulerecordTypeEx;\r
2529                                         }\r
2530                                          \r
2531                                         CREATE_stream_41; stream_41->add(stream_41, char_literal33, NULL);\r
2532 \r
2533                                         FOLLOWPUSH(FOLLOW_component_in_recordType1091);\r
2534                                         component34=component(ctx);\r
2535 \r
2536                                         FOLLOWPOP();\r
2537                                         if  (HASEXCEPTION())\r
2538                                         {\r
2539                                             goto rulerecordTypeEx;\r
2540                                         }\r
2541 \r
2542                                         CREATE_stream_component; stream_component->add(stream_component, component34.tree, NULL);\r
2543 \r
2544                                     }\r
2545                                     break;\r
2546 \r
2547                                 default:\r
2548                                     goto loop11;        /* break out of the loop */\r
2549                                     break;\r
2550                             }\r
2551                         }\r
2552                         loop11: ; /* Jump out to here if this rule does not match */\r
2553 \r
2554 \r
2555                     }\r
2556                     break;\r
2557 \r
2558                 }\r
2559             }\r
2560             char_literal35 = (pANTLR3_COMMON_TOKEN) MATCHT(44, &FOLLOW_44_in_recordType1097); \r
2561             if  (HASEXCEPTION())\r
2562             {\r
2563                 goto rulerecordTypeEx;\r
2564             }\r
2565              \r
2566             CREATE_stream_44; stream_44->add(stream_44, char_literal35, NULL);\r
2567 \r
2568 \r
2569              \r
2570             /* AST REWRITE\r
2571              * elements          : component\r
2572              * token labels      : \r
2573              * rule labels       : retval\r
2574              * token list labels : \r
2575              * rule list labels  : \r
2576              */\r
2577             {\r
2578                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
2579 \r
2580                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
2581 \r
2582                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2583                 retval.tree    = root_0;\r
2584                 // 131:5: -> ^( RECORD_TYPE ( component )* )\r
2585                 {\r
2586                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:131:8: ^( RECORD_TYPE ( component )* )\r
2587                     {\r
2588                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2589                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, RECORD_TYPE, (pANTLR3_UINT8)"RECORD_TYPE"), root_1));\r
2590 \r
2591                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:131:22: ( component )*\r
2592                         {\r
2593                                 while ( (stream_component != NULL && stream_component->hasNext(stream_component))  )\r
2594                                 {\r
2595                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_component == NULL ? NULL : stream_component->nextTree(stream_component));\r
2596 \r
2597                                 }\r
2598                                 if (stream_component != NULL) stream_component->reset(stream_component);\r
2599 \r
2600                         }\r
2601 \r
2602                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
2603                     }\r
2604 \r
2605                 }\r
2606 \r
2607                 retval.tree = root_0; // set result root\r
2608                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
2609 \r
2610 \r
2611             }\r
2612         }\r
2613 \r
2614     }\r
2615     \r
2616 \r
2617     // This is where rules clean up and exit\r
2618     //\r
2619     goto rulerecordTypeEx; /* Prevent compiler warnings */\r
2620     rulerecordTypeEx: ;\r
2621     retval.stop = LT(-1);\r
2622 \r
2623         retval.stop = LT(-1);\r
2624         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
2625         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
2626         if (stream_43 != NULL) stream_43->free(stream_43);\r
2627         if (stream_44 != NULL) stream_44->free(stream_44);\r
2628         if (stream_41 != NULL) stream_41->free(stream_41);\r
2629         if (stream_component != NULL) stream_component->free(stream_component);\r
2630 \r
2631             if (HASEXCEPTION())\r
2632             {\r
2633                 PREPORTERROR();\r
2634                 PRECOVER();\r
2635                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
2636             }\r
2637 \r
2638 \r
2639     return retval;\r
2640 }\r
2641 /* $ANTLR end recordType */\r
2642 \r
2643 /** \r
2644  * $ANTLR start component\r
2645  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:134:1: component : ID ':' unionType -> ^( TYPE_COMPONENT ID unionType ) ;\r
2646  */\r
2647 static SimanticsDataParser_component_return\r
2648 component(pSimanticsDataParser ctx)\r
2649 {   \r
2650     SimanticsDataParser_component_return retval;\r
2651 \r
2652     pANTLR3_BASE_TREE root_0;\r
2653 \r
2654     pANTLR3_COMMON_TOKEN    ID36;\r
2655     pANTLR3_COMMON_TOKEN    char_literal37;\r
2656     SimanticsDataParser_unionType_return unionType38;\r
2657     #undef      RETURN_TYPE_unionType38\r
2658     #define     RETURN_TYPE_unionType38 SimanticsDataParser_unionType_return\r
2659 \r
2660     pANTLR3_BASE_TREE ID36_tree;\r
2661     pANTLR3_BASE_TREE char_literal37_tree;\r
2662     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_45;\r
2663     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;\r
2664     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType;\r
2665     /* Initialize rule variables\r
2666      */\r
2667 \r
2668 \r
2669     root_0 = NULL;\r
2670 \r
2671     ID36       = NULL;\r
2672     char_literal37       = NULL;\r
2673     unionType38.tree = NULL;\r
2674 \r
2675     retval.start = LT(1); retval.stop = retval.start;\r
2676 \r
2677     ID36_tree   = NULL;\r
2678     char_literal37_tree   = NULL;\r
2679 \r
2680     stream_45   = NULL;\r
2681     #define CREATE_stream_45  if (stream_45 == NULL) {stream_45 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 45"); } \r
2682     stream_ID   = NULL;\r
2683     #define CREATE_stream_ID  if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } \r
2684     stream_unionType   = NULL;\r
2685     #define CREATE_stream_unionType  if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); }\r
2686 \r
2687     retval.tree  = NULL;\r
2688     {\r
2689         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:135:5: ( ID ':' unionType -> ^( TYPE_COMPONENT ID unionType ) )\r
2690         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:135:7: ID ':' unionType\r
2691         {\r
2692             ID36 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_component1129); \r
2693             if  (HASEXCEPTION())\r
2694             {\r
2695                 goto rulecomponentEx;\r
2696             }\r
2697              \r
2698             CREATE_stream_ID; stream_ID->add(stream_ID, ID36, NULL);\r
2699 \r
2700             char_literal37 = (pANTLR3_COMMON_TOKEN) MATCHT(45, &FOLLOW_45_in_component1131); \r
2701             if  (HASEXCEPTION())\r
2702             {\r
2703                 goto rulecomponentEx;\r
2704             }\r
2705              \r
2706             CREATE_stream_45; stream_45->add(stream_45, char_literal37, NULL);\r
2707 \r
2708             FOLLOWPUSH(FOLLOW_unionType_in_component1133);\r
2709             unionType38=unionType(ctx);\r
2710 \r
2711             FOLLOWPOP();\r
2712             if  (HASEXCEPTION())\r
2713             {\r
2714                 goto rulecomponentEx;\r
2715             }\r
2716 \r
2717             CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType38.tree, NULL);\r
2718 \r
2719              \r
2720             /* AST REWRITE\r
2721              * elements          : ID, unionType\r
2722              * token labels      : \r
2723              * rule labels       : retval\r
2724              * token list labels : \r
2725              * rule list labels  : \r
2726              */\r
2727             {\r
2728                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
2729 \r
2730                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
2731 \r
2732                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2733                 retval.tree    = root_0;\r
2734                 // 136:5: -> ^( TYPE_COMPONENT ID unionType )\r
2735                 {\r
2736                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:136:8: ^( TYPE_COMPONENT ID unionType )\r
2737                     {\r
2738                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2739                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_COMPONENT, (pANTLR3_UINT8)"TYPE_COMPONENT"), root_1));\r
2740 \r
2741                         ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));\r
2742                         ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType));\r
2743 \r
2744                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
2745                     }\r
2746 \r
2747                 }\r
2748 \r
2749                 retval.tree = root_0; // set result root\r
2750                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
2751 \r
2752 \r
2753             }\r
2754         }\r
2755 \r
2756     }\r
2757     \r
2758 \r
2759     // This is where rules clean up and exit\r
2760     //\r
2761     goto rulecomponentEx; /* Prevent compiler warnings */\r
2762     rulecomponentEx: ;\r
2763     retval.stop = LT(-1);\r
2764 \r
2765         retval.stop = LT(-1);\r
2766         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
2767         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
2768         if (stream_45 != NULL) stream_45->free(stream_45);\r
2769         if (stream_ID != NULL) stream_ID->free(stream_ID);\r
2770         if (stream_unionType != NULL) stream_unionType->free(stream_unionType);\r
2771 \r
2772             if (HASEXCEPTION())\r
2773             {\r
2774                 PREPORTERROR();\r
2775                 PRECOVER();\r
2776                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
2777             }\r
2778 \r
2779 \r
2780     return retval;\r
2781 }\r
2782 /* $ANTLR end component */\r
2783 \r
2784 /** \r
2785  * $ANTLR start typeReference\r
2786  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:139:1: typeReference : ID ( '(' parameter ( ',' parameter )* ')' )? -> ^( TYPE_REFERENCE ID ( parameter )* ) ;\r
2787  */\r
2788 static SimanticsDataParser_typeReference_return\r
2789 typeReference(pSimanticsDataParser ctx)\r
2790 {   \r
2791     SimanticsDataParser_typeReference_return retval;\r
2792 \r
2793     pANTLR3_BASE_TREE root_0;\r
2794 \r
2795     pANTLR3_COMMON_TOKEN    ID39;\r
2796     pANTLR3_COMMON_TOKEN    char_literal40;\r
2797     pANTLR3_COMMON_TOKEN    char_literal42;\r
2798     pANTLR3_COMMON_TOKEN    char_literal44;\r
2799     SimanticsDataParser_parameter_return parameter41;\r
2800     #undef      RETURN_TYPE_parameter41\r
2801     #define     RETURN_TYPE_parameter41 SimanticsDataParser_parameter_return\r
2802 \r
2803     SimanticsDataParser_parameter_return parameter43;\r
2804     #undef      RETURN_TYPE_parameter43\r
2805     #define     RETURN_TYPE_parameter43 SimanticsDataParser_parameter_return\r
2806 \r
2807     pANTLR3_BASE_TREE ID39_tree;\r
2808     pANTLR3_BASE_TREE char_literal40_tree;\r
2809     pANTLR3_BASE_TREE char_literal42_tree;\r
2810     pANTLR3_BASE_TREE char_literal44_tree;\r
2811     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_42;\r
2812     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;\r
2813     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_40;\r
2814     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;\r
2815     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_parameter;\r
2816     /* Initialize rule variables\r
2817      */\r
2818 \r
2819 \r
2820     root_0 = NULL;\r
2821 \r
2822     ID39       = NULL;\r
2823     char_literal40       = NULL;\r
2824     char_literal42       = NULL;\r
2825     char_literal44       = NULL;\r
2826     parameter41.tree = NULL;\r
2827 \r
2828     parameter43.tree = NULL;\r
2829 \r
2830     retval.start = LT(1); retval.stop = retval.start;\r
2831 \r
2832     ID39_tree   = NULL;\r
2833     char_literal40_tree   = NULL;\r
2834     char_literal42_tree   = NULL;\r
2835     char_literal44_tree   = NULL;\r
2836 \r
2837     stream_42   = NULL;\r
2838     #define CREATE_stream_42  if (stream_42 == NULL) {stream_42 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 42"); } \r
2839     stream_41   = NULL;\r
2840     #define CREATE_stream_41  if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } \r
2841     stream_40   = NULL;\r
2842     #define CREATE_stream_40  if (stream_40 == NULL) {stream_40 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 40"); } \r
2843     stream_ID   = NULL;\r
2844     #define CREATE_stream_ID  if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } \r
2845     stream_parameter   = NULL;\r
2846     #define CREATE_stream_parameter  if (stream_parameter == NULL) {stream_parameter = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule parameter"); }\r
2847 \r
2848     retval.tree  = NULL;\r
2849     {\r
2850         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:5: ( ID ( '(' parameter ( ',' parameter )* ')' )? -> ^( TYPE_REFERENCE ID ( parameter )* ) )\r
2851         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:7: ID ( '(' parameter ( ',' parameter )* ')' )?\r
2852         {\r
2853             ID39 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_typeReference1167); \r
2854             if  (HASEXCEPTION())\r
2855             {\r
2856                 goto ruletypeReferenceEx;\r
2857             }\r
2858              \r
2859             CREATE_stream_ID; stream_ID->add(stream_ID, ID39, NULL);\r
2860 \r
2861 \r
2862             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:10: ( '(' parameter ( ',' parameter )* ')' )?\r
2863             {\r
2864                 int alt14=2;\r
2865                 switch ( LA(1) ) \r
2866                 {\r
2867                     case 40:\r
2868                         {\r
2869                                 alt14=1;\r
2870                         }\r
2871                         break;\r
2872                 }\r
2873 \r
2874                 switch (alt14) \r
2875                 {\r
2876                 case 1:\r
2877                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:11: '(' parameter ( ',' parameter )* ')'\r
2878                     {\r
2879                         char_literal40 = (pANTLR3_COMMON_TOKEN) MATCHT(40, &FOLLOW_40_in_typeReference1170); \r
2880                         if  (HASEXCEPTION())\r
2881                         {\r
2882                             goto ruletypeReferenceEx;\r
2883                         }\r
2884                          \r
2885                         CREATE_stream_40; stream_40->add(stream_40, char_literal40, NULL);\r
2886 \r
2887                         FOLLOWPUSH(FOLLOW_parameter_in_typeReference1172);\r
2888                         parameter41=parameter(ctx);\r
2889 \r
2890                         FOLLOWPOP();\r
2891                         if  (HASEXCEPTION())\r
2892                         {\r
2893                             goto ruletypeReferenceEx;\r
2894                         }\r
2895 \r
2896                         CREATE_stream_parameter; stream_parameter->add(stream_parameter, parameter41.tree, NULL);\r
2897 \r
2898                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:25: ( ',' parameter )*\r
2899 \r
2900                         for (;;)\r
2901                         {\r
2902                             int alt13=2;\r
2903                             switch ( LA(1) ) \r
2904                             {\r
2905                             case 41:\r
2906                                 {\r
2907                                         alt13=1;\r
2908                                 }\r
2909                                 break;\r
2910 \r
2911                             }\r
2912 \r
2913                             switch (alt13) \r
2914                             {\r
2915                                 case 1:\r
2916                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:26: ',' parameter\r
2917                                     {\r
2918                                         char_literal42 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_typeReference1175); \r
2919                                         if  (HASEXCEPTION())\r
2920                                         {\r
2921                                             goto ruletypeReferenceEx;\r
2922                                         }\r
2923                                          \r
2924                                         CREATE_stream_41; stream_41->add(stream_41, char_literal42, NULL);\r
2925 \r
2926                                         FOLLOWPUSH(FOLLOW_parameter_in_typeReference1177);\r
2927                                         parameter43=parameter(ctx);\r
2928 \r
2929                                         FOLLOWPOP();\r
2930                                         if  (HASEXCEPTION())\r
2931                                         {\r
2932                                             goto ruletypeReferenceEx;\r
2933                                         }\r
2934 \r
2935                                         CREATE_stream_parameter; stream_parameter->add(stream_parameter, parameter43.tree, NULL);\r
2936 \r
2937                                     }\r
2938                                     break;\r
2939 \r
2940                                 default:\r
2941                                     goto loop13;        /* break out of the loop */\r
2942                                     break;\r
2943                             }\r
2944                         }\r
2945                         loop13: ; /* Jump out to here if this rule does not match */\r
2946 \r
2947                         char_literal44 = (pANTLR3_COMMON_TOKEN) MATCHT(42, &FOLLOW_42_in_typeReference1181); \r
2948                         if  (HASEXCEPTION())\r
2949                         {\r
2950                             goto ruletypeReferenceEx;\r
2951                         }\r
2952                          \r
2953                         CREATE_stream_42; stream_42->add(stream_42, char_literal44, NULL);\r
2954 \r
2955 \r
2956                     }\r
2957                     break;\r
2958 \r
2959                 }\r
2960             }\r
2961 \r
2962              \r
2963             /* AST REWRITE\r
2964              * elements          : ID, parameter\r
2965              * token labels      : \r
2966              * rule labels       : retval\r
2967              * token list labels : \r
2968              * rule list labels  : \r
2969              */\r
2970             {\r
2971                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
2972 \r
2973                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
2974 \r
2975                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2976                 retval.tree    = root_0;\r
2977                 // 141:5: -> ^( TYPE_REFERENCE ID ( parameter )* )\r
2978                 {\r
2979                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:141:8: ^( TYPE_REFERENCE ID ( parameter )* )\r
2980                     {\r
2981                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
2982                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_REFERENCE, (pANTLR3_UINT8)"TYPE_REFERENCE"), root_1));\r
2983 \r
2984                         ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));\r
2985                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:141:28: ( parameter )*\r
2986                         {\r
2987                                 while ( (stream_parameter != NULL && stream_parameter->hasNext(stream_parameter))  )\r
2988                                 {\r
2989                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_parameter == NULL ? NULL : stream_parameter->nextTree(stream_parameter));\r
2990 \r
2991                                 }\r
2992                                 if (stream_parameter != NULL) stream_parameter->reset(stream_parameter);\r
2993 \r
2994                         }\r
2995 \r
2996                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
2997                     }\r
2998 \r
2999                 }\r
3000 \r
3001                 retval.tree = root_0; // set result root\r
3002                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
3003 \r
3004 \r
3005             }\r
3006         }\r
3007 \r
3008     }\r
3009     \r
3010 \r
3011     // This is where rules clean up and exit\r
3012     //\r
3013     goto ruletypeReferenceEx; /* Prevent compiler warnings */\r
3014     ruletypeReferenceEx: ;\r
3015     retval.stop = LT(-1);\r
3016 \r
3017         retval.stop = LT(-1);\r
3018         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
3019         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
3020         if (stream_42 != NULL) stream_42->free(stream_42);\r
3021         if (stream_41 != NULL) stream_41->free(stream_41);\r
3022         if (stream_40 != NULL) stream_40->free(stream_40);\r
3023         if (stream_ID != NULL) stream_ID->free(stream_ID);\r
3024         if (stream_parameter != NULL) stream_parameter->free(stream_parameter);\r
3025 \r
3026             if (HASEXCEPTION())\r
3027             {\r
3028                 PREPORTERROR();\r
3029                 PRECOVER();\r
3030                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
3031             }\r
3032 \r
3033 \r
3034     return retval;\r
3035 }\r
3036 /* $ANTLR end typeReference */\r
3037 \r
3038 /** \r
3039  * $ANTLR start parameter\r
3040  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:144:1: parameter : ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | unionType );\r
3041  */\r
3042 static SimanticsDataParser_parameter_return\r
3043 parameter(pSimanticsDataParser ctx)\r
3044 {   \r
3045     SimanticsDataParser_parameter_return retval;\r
3046 \r
3047     pANTLR3_BASE_TREE root_0;\r
3048 \r
3049     pANTLR3_COMMON_TOKEN    ID45;\r
3050     pANTLR3_COMMON_TOKEN    char_literal46;\r
3051     SimanticsDataParser_parameterValue_return parameterValue47;\r
3052     #undef      RETURN_TYPE_parameterValue47\r
3053     #define     RETURN_TYPE_parameterValue47 SimanticsDataParser_parameterValue_return\r
3054 \r
3055     SimanticsDataParser_unionType_return unionType48;\r
3056     #undef      RETURN_TYPE_unionType48\r
3057     #define     RETURN_TYPE_unionType48 SimanticsDataParser_unionType_return\r
3058 \r
3059     pANTLR3_BASE_TREE ID45_tree;\r
3060     pANTLR3_BASE_TREE char_literal46_tree;\r
3061     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;\r
3062     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;\r
3063     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_parameterValue;\r
3064     /* Initialize rule variables\r
3065      */\r
3066 \r
3067 \r
3068     root_0 = NULL;\r
3069 \r
3070     ID45       = NULL;\r
3071     char_literal46       = NULL;\r
3072     parameterValue47.tree = NULL;\r
3073 \r
3074     unionType48.tree = NULL;\r
3075 \r
3076     retval.start = LT(1); retval.stop = retval.start;\r
3077 \r
3078     ID45_tree   = NULL;\r
3079     char_literal46_tree   = NULL;\r
3080 \r
3081     stream_ID   = NULL;\r
3082     #define CREATE_stream_ID  if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } \r
3083     stream_35   = NULL;\r
3084     #define CREATE_stream_35  if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } \r
3085     stream_parameterValue   = NULL;\r
3086     #define CREATE_stream_parameterValue  if (stream_parameterValue == NULL) {stream_parameterValue = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule parameterValue"); }\r
3087 \r
3088     retval.tree  = NULL;\r
3089     {\r
3090         {\r
3091             //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:145:5: ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | unionType )\r
3092             \r
3093             ANTLR3_UINT32 alt15;\r
3094 \r
3095             alt15=2;\r
3096 \r
3097             switch ( LA(1) ) \r
3098             {\r
3099             case ID:\r
3100                 {\r
3101                         switch ( LA(2) ) \r
3102                         {\r
3103                         case 35:\r
3104                                 {\r
3105                                         alt15=1;\r
3106                                 }\r
3107                             break;\r
3108                         case 37:\r
3109                         case 40:\r
3110                         case 41:\r
3111                         case 42:\r
3112                                 {\r
3113                                         alt15=2;\r
3114                                 }\r
3115                             break;\r
3116 \r
3117                         default:\r
3118                             CONSTRUCTEX();\r
3119                             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
3120                             EXCEPTION->message      = (void *)"";\r
3121                             EXCEPTION->decisionNum  = 15;\r
3122                             EXCEPTION->state        = 1;\r
3123 \r
3124 \r
3125                             goto ruleparameterEx;\r
3126                         }\r
3127 \r
3128                 }\r
3129                 break;\r
3130             case 36:\r
3131             case 40:\r
3132             case 43:\r
3133                 {\r
3134                         alt15=2;\r
3135                 }\r
3136                 break;\r
3137 \r
3138             default:\r
3139                 CONSTRUCTEX();\r
3140                 EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
3141                 EXCEPTION->message      = (void *)"";\r
3142                 EXCEPTION->decisionNum  = 15;\r
3143                 EXCEPTION->state        = 0;\r
3144 \r
3145 \r
3146                 goto ruleparameterEx;\r
3147             }\r
3148 \r
3149             switch (alt15) \r
3150             {\r
3151                 case 1:\r
3152                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:145:7: ID '=' parameterValue\r
3153                     {\r
3154                         ID45 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_parameter1217); \r
3155                         if  (HASEXCEPTION())\r
3156                         {\r
3157                             goto ruleparameterEx;\r
3158                         }\r
3159                          \r
3160                         CREATE_stream_ID; stream_ID->add(stream_ID, ID45, NULL);\r
3161 \r
3162                         char_literal46 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_parameter1219); \r
3163                         if  (HASEXCEPTION())\r
3164                         {\r
3165                             goto ruleparameterEx;\r
3166                         }\r
3167                          \r
3168                         CREATE_stream_35; stream_35->add(stream_35, char_literal46, NULL);\r
3169 \r
3170                         FOLLOWPUSH(FOLLOW_parameterValue_in_parameter1221);\r
3171                         parameterValue47=parameterValue(ctx);\r
3172 \r
3173                         FOLLOWPOP();\r
3174                         if  (HASEXCEPTION())\r
3175                         {\r
3176                             goto ruleparameterEx;\r
3177                         }\r
3178 \r
3179                         CREATE_stream_parameterValue; stream_parameterValue->add(stream_parameterValue, parameterValue47.tree, NULL);\r
3180 \r
3181                          \r
3182                         /* AST REWRITE\r
3183                          * elements          : ID, parameterValue\r
3184                          * token labels      : \r
3185                          * rule labels       : retval\r
3186                          * token list labels : \r
3187                          * rule list labels  : \r
3188                          */\r
3189                         {\r
3190                                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
3191 \r
3192                                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
3193 \r
3194                                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3195                                 retval.tree    = root_0;\r
3196                                 // 145:29: -> ^( TYPE_ANNOTATION ID parameterValue )\r
3197                                 {\r
3198                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:145:32: ^( TYPE_ANNOTATION ID parameterValue )\r
3199                                     {\r
3200                                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3201                                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_ANNOTATION, (pANTLR3_UINT8)"TYPE_ANNOTATION"), root_1));\r
3202 \r
3203                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));\r
3204                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_parameterValue == NULL ? NULL : stream_parameterValue->nextTree(stream_parameterValue));\r
3205 \r
3206                                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
3207                                     }\r
3208 \r
3209                                 }\r
3210 \r
3211                                 retval.tree = root_0; // set result root\r
3212                                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
3213 \r
3214 \r
3215                         }\r
3216                     }\r
3217                     break;\r
3218                 case 2:\r
3219                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:146:7: unionType\r
3220                     {\r
3221                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3222 \r
3223                         FOLLOWPUSH(FOLLOW_unionType_in_parameter1239);\r
3224                         unionType48=unionType(ctx);\r
3225 \r
3226                         FOLLOWPOP();\r
3227                         if  (HASEXCEPTION())\r
3228                         {\r
3229                             goto ruleparameterEx;\r
3230                         }\r
3231 \r
3232                         ADAPTOR->addChild(ADAPTOR, root_0, unionType48.tree);\r
3233 \r
3234                     }\r
3235                     break;\r
3236 \r
3237             }\r
3238         }\r
3239     }\r
3240     \r
3241 \r
3242     // This is where rules clean up and exit\r
3243     //\r
3244     goto ruleparameterEx; /* Prevent compiler warnings */\r
3245     ruleparameterEx: ;\r
3246     retval.stop = LT(-1);\r
3247 \r
3248         retval.stop = LT(-1);\r
3249         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
3250         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
3251         if (stream_ID != NULL) stream_ID->free(stream_ID);\r
3252         if (stream_35 != NULL) stream_35->free(stream_35);\r
3253         if (stream_parameterValue != NULL) stream_parameterValue->free(stream_parameterValue);\r
3254 \r
3255             if (HASEXCEPTION())\r
3256             {\r
3257                 PREPORTERROR();\r
3258                 PRECOVER();\r
3259                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
3260             }\r
3261 \r
3262 \r
3263     return retval;\r
3264 }\r
3265 /* $ANTLR end parameter */\r
3266 \r
3267 /** \r
3268  * $ANTLR start parameterValue\r
3269  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:149:1: parameterValue : ( string | boolean | number | ( '[' | '(' ) range ( ']' | ')' ) );\r
3270  */\r
3271 static SimanticsDataParser_parameterValue_return\r
3272 parameterValue(pSimanticsDataParser ctx)\r
3273 {   \r
3274     SimanticsDataParser_parameterValue_return retval;\r
3275 \r
3276     pANTLR3_BASE_TREE root_0;\r
3277 \r
3278     pANTLR3_COMMON_TOKEN    set52;\r
3279     pANTLR3_COMMON_TOKEN    set54;\r
3280     SimanticsDataParser_string_return string49;\r
3281     #undef      RETURN_TYPE_string49\r
3282     #define     RETURN_TYPE_string49 SimanticsDataParser_string_return\r
3283 \r
3284     SimanticsDataParser_boolean_return boolean50;\r
3285     #undef      RETURN_TYPE_boolean50\r
3286     #define     RETURN_TYPE_boolean50 SimanticsDataParser_boolean_return\r
3287 \r
3288     SimanticsDataParser_number_return number51;\r
3289     #undef      RETURN_TYPE_number51\r
3290     #define     RETURN_TYPE_number51 SimanticsDataParser_number_return\r
3291 \r
3292     SimanticsDataParser_range_return range53;\r
3293     #undef      RETURN_TYPE_range53\r
3294     #define     RETURN_TYPE_range53 SimanticsDataParser_range_return\r
3295 \r
3296     pANTLR3_BASE_TREE set52_tree;\r
3297     pANTLR3_BASE_TREE set54_tree;\r
3298 \r
3299     /* Initialize rule variables\r
3300      */\r
3301 \r
3302 \r
3303     root_0 = NULL;\r
3304 \r
3305     set52       = NULL;\r
3306     set54       = NULL;\r
3307     string49.tree = NULL;\r
3308 \r
3309     boolean50.tree = NULL;\r
3310 \r
3311     number51.tree = NULL;\r
3312 \r
3313     range53.tree = NULL;\r
3314 \r
3315     retval.start = LT(1); retval.stop = retval.start;\r
3316 \r
3317     set52_tree   = NULL;\r
3318     set54_tree   = NULL;\r
3319 \r
3320 \r
3321     retval.tree  = NULL;\r
3322     {\r
3323         {\r
3324             //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:150:5: ( string | boolean | number | ( '[' | '(' ) range ( ']' | ')' ) )\r
3325             \r
3326             ANTLR3_UINT32 alt16;\r
3327 \r
3328             alt16=4;\r
3329 \r
3330             switch ( LA(1) ) \r
3331             {\r
3332             case STRING:\r
3333                 {\r
3334                         alt16=1;\r
3335                 }\r
3336                 break;\r
3337             case 46:\r
3338             case 47:\r
3339                 {\r
3340                         alt16=2;\r
3341                 }\r
3342                 break;\r
3343             case INT:\r
3344             case FLOAT:\r
3345                 {\r
3346                         alt16=3;\r
3347                 }\r
3348                 break;\r
3349             case 37:\r
3350             case 40:\r
3351                 {\r
3352                         alt16=4;\r
3353                 }\r
3354                 break;\r
3355 \r
3356             default:\r
3357                 CONSTRUCTEX();\r
3358                 EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
3359                 EXCEPTION->message      = (void *)"";\r
3360                 EXCEPTION->decisionNum  = 16;\r
3361                 EXCEPTION->state        = 0;\r
3362 \r
3363 \r
3364                 goto ruleparameterValueEx;\r
3365             }\r
3366 \r
3367             switch (alt16) \r
3368             {\r
3369                 case 1:\r
3370                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:150:7: string\r
3371                     {\r
3372                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3373 \r
3374                         FOLLOWPUSH(FOLLOW_string_in_parameterValue1258);\r
3375                         string49=string(ctx);\r
3376 \r
3377                         FOLLOWPOP();\r
3378                         if  (HASEXCEPTION())\r
3379                         {\r
3380                             goto ruleparameterValueEx;\r
3381                         }\r
3382 \r
3383                         ADAPTOR->addChild(ADAPTOR, root_0, string49.tree);\r
3384 \r
3385                     }\r
3386                     break;\r
3387                 case 2:\r
3388                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:151:7: boolean\r
3389                     {\r
3390                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3391 \r
3392                         FOLLOWPUSH(FOLLOW_boolean_in_parameterValue1266);\r
3393                         boolean50=boolean(ctx);\r
3394 \r
3395                         FOLLOWPOP();\r
3396                         if  (HASEXCEPTION())\r
3397                         {\r
3398                             goto ruleparameterValueEx;\r
3399                         }\r
3400 \r
3401                         ADAPTOR->addChild(ADAPTOR, root_0, boolean50.tree);\r
3402 \r
3403                     }\r
3404                     break;\r
3405                 case 3:\r
3406                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:152:7: number\r
3407                     {\r
3408                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3409 \r
3410                         FOLLOWPUSH(FOLLOW_number_in_parameterValue1274);\r
3411                         number51=number(ctx);\r
3412 \r
3413                         FOLLOWPOP();\r
3414                         if  (HASEXCEPTION())\r
3415                         {\r
3416                             goto ruleparameterValueEx;\r
3417                         }\r
3418 \r
3419                         ADAPTOR->addChild(ADAPTOR, root_0, number51.tree);\r
3420 \r
3421                     }\r
3422                     break;\r
3423                 case 4:\r
3424                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:153:7: ( '[' | '(' ) range ( ']' | ')' )\r
3425                     {\r
3426                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3427 \r
3428                         set52=(pANTLR3_COMMON_TOKEN)LT(1);\r
3429                         if ( LA(1) == 37 || LA(1) == 40 )\r
3430                         {\r
3431                             CONSUME();\r
3432                             ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set52)));\r
3433                             PERRORRECOVERY=ANTLR3_FALSE;\r
3434                         }\r
3435                         else \r
3436                         {\r
3437                             CONSTRUCTEX();\r
3438                             EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
3439                             EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
3440                             EXCEPTION->expectingSet = &FOLLOW_set_in_parameterValue1282;\r
3441                             RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_parameterValue1282);    goto ruleparameterValueEx;\r
3442                         }\r
3443 \r
3444                         FOLLOWPUSH(FOLLOW_range_in_parameterValue1290);\r
3445                         range53=range(ctx);\r
3446 \r
3447                         FOLLOWPOP();\r
3448                         if  (HASEXCEPTION())\r
3449                         {\r
3450                             goto ruleparameterValueEx;\r
3451                         }\r
3452 \r
3453                         ADAPTOR->addChild(ADAPTOR, root_0, range53.tree);\r
3454                         set54=(pANTLR3_COMMON_TOKEN)LT(1);\r
3455                         if ( LA(1) == 38 || LA(1) == 42 )\r
3456                         {\r
3457                             CONSUME();\r
3458                             ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set54)));\r
3459                             PERRORRECOVERY=ANTLR3_FALSE;\r
3460                         }\r
3461                         else \r
3462                         {\r
3463                             CONSTRUCTEX();\r
3464                             EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
3465                             EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
3466                             EXCEPTION->expectingSet = &FOLLOW_set_in_parameterValue1292;\r
3467                             RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_parameterValue1292);    goto ruleparameterValueEx;\r
3468                         }\r
3469 \r
3470 \r
3471                     }\r
3472                     break;\r
3473 \r
3474             }\r
3475         }\r
3476     }\r
3477     \r
3478 \r
3479     // This is where rules clean up and exit\r
3480     //\r
3481     goto ruleparameterValueEx; /* Prevent compiler warnings */\r
3482     ruleparameterValueEx: ;\r
3483     retval.stop = LT(-1);\r
3484 \r
3485         retval.stop = LT(-1);\r
3486         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
3487         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
3488 \r
3489             if (HASEXCEPTION())\r
3490             {\r
3491                 PREPORTERROR();\r
3492                 PRECOVER();\r
3493                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
3494             }\r
3495 \r
3496 \r
3497     return retval;\r
3498 }\r
3499 /* $ANTLR end parameterValue */\r
3500 \r
3501 /** \r
3502  * $ANTLR start range\r
3503  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:156:1: range : ( number | number '..' | '..' number | number '..' number );\r
3504  */\r
3505 static SimanticsDataParser_range_return\r
3506 range(pSimanticsDataParser ctx)\r
3507 {   \r
3508     SimanticsDataParser_range_return retval;\r
3509 \r
3510     pANTLR3_BASE_TREE root_0;\r
3511 \r
3512     pANTLR3_COMMON_TOKEN    string_literal57;\r
3513     pANTLR3_COMMON_TOKEN    string_literal58;\r
3514     pANTLR3_COMMON_TOKEN    string_literal61;\r
3515     SimanticsDataParser_number_return number55;\r
3516     #undef      RETURN_TYPE_number55\r
3517     #define     RETURN_TYPE_number55 SimanticsDataParser_number_return\r
3518 \r
3519     SimanticsDataParser_number_return number56;\r
3520     #undef      RETURN_TYPE_number56\r
3521     #define     RETURN_TYPE_number56 SimanticsDataParser_number_return\r
3522 \r
3523     SimanticsDataParser_number_return number59;\r
3524     #undef      RETURN_TYPE_number59\r
3525     #define     RETURN_TYPE_number59 SimanticsDataParser_number_return\r
3526 \r
3527     SimanticsDataParser_number_return number60;\r
3528     #undef      RETURN_TYPE_number60\r
3529     #define     RETURN_TYPE_number60 SimanticsDataParser_number_return\r
3530 \r
3531     SimanticsDataParser_number_return number62;\r
3532     #undef      RETURN_TYPE_number62\r
3533     #define     RETURN_TYPE_number62 SimanticsDataParser_number_return\r
3534 \r
3535     pANTLR3_BASE_TREE string_literal57_tree;\r
3536     pANTLR3_BASE_TREE string_literal58_tree;\r
3537     pANTLR3_BASE_TREE string_literal61_tree;\r
3538 \r
3539     /* Initialize rule variables\r
3540      */\r
3541 \r
3542 \r
3543     root_0 = NULL;\r
3544 \r
3545     string_literal57       = NULL;\r
3546     string_literal58       = NULL;\r
3547     string_literal61       = NULL;\r
3548     number55.tree = NULL;\r
3549 \r
3550     number56.tree = NULL;\r
3551 \r
3552     number59.tree = NULL;\r
3553 \r
3554     number60.tree = NULL;\r
3555 \r
3556     number62.tree = NULL;\r
3557 \r
3558     retval.start = LT(1); retval.stop = retval.start;\r
3559 \r
3560     string_literal57_tree   = NULL;\r
3561     string_literal58_tree   = NULL;\r
3562     string_literal61_tree   = NULL;\r
3563 \r
3564 \r
3565     retval.tree  = NULL;\r
3566     {\r
3567         {\r
3568             //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:157:5: ( number | number '..' | '..' number | number '..' number )\r
3569             \r
3570             ANTLR3_UINT32 alt17;\r
3571 \r
3572             alt17=4;\r
3573 \r
3574             switch ( LA(1) ) \r
3575             {\r
3576             case INT:\r
3577             case FLOAT:\r
3578                 {\r
3579                         switch ( LA(2) ) \r
3580                         {\r
3581                         case 39:\r
3582                                 {\r
3583                                         switch ( LA(3) ) \r
3584                                         {\r
3585                                         case INT:\r
3586                                         case FLOAT:\r
3587                                                 {\r
3588                                                         alt17=4;\r
3589                                                 }\r
3590                                             break;\r
3591                                         case 38:\r
3592                                         case 42:\r
3593                                                 {\r
3594                                                         alt17=2;\r
3595                                                 }\r
3596                                             break;\r
3597 \r
3598                                         default:\r
3599                                             CONSTRUCTEX();\r
3600                                             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
3601                                             EXCEPTION->message      = (void *)"";\r
3602                                             EXCEPTION->decisionNum  = 17;\r
3603                                             EXCEPTION->state        = 3;\r
3604 \r
3605 \r
3606                                             goto rulerangeEx;\r
3607                                         }\r
3608 \r
3609                                 }\r
3610                             break;\r
3611                         case 38:\r
3612                         case 42:\r
3613                                 {\r
3614                                         alt17=1;\r
3615                                 }\r
3616                             break;\r
3617 \r
3618                         default:\r
3619                             CONSTRUCTEX();\r
3620                             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
3621                             EXCEPTION->message      = (void *)"";\r
3622                             EXCEPTION->decisionNum  = 17;\r
3623                             EXCEPTION->state        = 1;\r
3624 \r
3625 \r
3626                             goto rulerangeEx;\r
3627                         }\r
3628 \r
3629                 }\r
3630                 break;\r
3631             case 39:\r
3632                 {\r
3633                         alt17=3;\r
3634                 }\r
3635                 break;\r
3636 \r
3637             default:\r
3638                 CONSTRUCTEX();\r
3639                 EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
3640                 EXCEPTION->message      = (void *)"";\r
3641                 EXCEPTION->decisionNum  = 17;\r
3642                 EXCEPTION->state        = 0;\r
3643 \r
3644 \r
3645                 goto rulerangeEx;\r
3646             }\r
3647 \r
3648             switch (alt17) \r
3649             {\r
3650                 case 1:\r
3651                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:157:7: number\r
3652                     {\r
3653                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3654 \r
3655                         FOLLOWPUSH(FOLLOW_number_in_range1319);\r
3656                         number55=number(ctx);\r
3657 \r
3658                         FOLLOWPOP();\r
3659                         if  (HASEXCEPTION())\r
3660                         {\r
3661                             goto rulerangeEx;\r
3662                         }\r
3663 \r
3664                         ADAPTOR->addChild(ADAPTOR, root_0, number55.tree);\r
3665 \r
3666                     }\r
3667                     break;\r
3668                 case 2:\r
3669                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:158:7: number '..'\r
3670                     {\r
3671                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3672 \r
3673                         FOLLOWPUSH(FOLLOW_number_in_range1327);\r
3674                         number56=number(ctx);\r
3675 \r
3676                         FOLLOWPOP();\r
3677                         if  (HASEXCEPTION())\r
3678                         {\r
3679                             goto rulerangeEx;\r
3680                         }\r
3681 \r
3682                         ADAPTOR->addChild(ADAPTOR, root_0, number56.tree);\r
3683                         string_literal57 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_range1329); \r
3684                         if  (HASEXCEPTION())\r
3685                         {\r
3686                             goto rulerangeEx;\r
3687                         }\r
3688 \r
3689                         string_literal57_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal57));\r
3690                         ADAPTOR->addChild(ADAPTOR, root_0, string_literal57_tree);\r
3691 \r
3692 \r
3693                     }\r
3694                     break;\r
3695                 case 3:\r
3696                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:159:7: '..' number\r
3697                     {\r
3698                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3699 \r
3700                         string_literal58 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_range1337); \r
3701                         if  (HASEXCEPTION())\r
3702                         {\r
3703                             goto rulerangeEx;\r
3704                         }\r
3705 \r
3706                         string_literal58_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal58));\r
3707                         ADAPTOR->addChild(ADAPTOR, root_0, string_literal58_tree);\r
3708 \r
3709                         FOLLOWPUSH(FOLLOW_number_in_range1339);\r
3710                         number59=number(ctx);\r
3711 \r
3712                         FOLLOWPOP();\r
3713                         if  (HASEXCEPTION())\r
3714                         {\r
3715                             goto rulerangeEx;\r
3716                         }\r
3717 \r
3718                         ADAPTOR->addChild(ADAPTOR, root_0, number59.tree);\r
3719 \r
3720                     }\r
3721                     break;\r
3722                 case 4:\r
3723                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:160:7: number '..' number\r
3724                     {\r
3725                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3726 \r
3727                         FOLLOWPUSH(FOLLOW_number_in_range1348);\r
3728                         number60=number(ctx);\r
3729 \r
3730                         FOLLOWPOP();\r
3731                         if  (HASEXCEPTION())\r
3732                         {\r
3733                             goto rulerangeEx;\r
3734                         }\r
3735 \r
3736                         ADAPTOR->addChild(ADAPTOR, root_0, number60.tree);\r
3737                         string_literal61 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_range1350); \r
3738                         if  (HASEXCEPTION())\r
3739                         {\r
3740                             goto rulerangeEx;\r
3741                         }\r
3742 \r
3743                         string_literal61_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal61));\r
3744                         ADAPTOR->addChild(ADAPTOR, root_0, string_literal61_tree);\r
3745 \r
3746                         FOLLOWPUSH(FOLLOW_number_in_range1352);\r
3747                         number62=number(ctx);\r
3748 \r
3749                         FOLLOWPOP();\r
3750                         if  (HASEXCEPTION())\r
3751                         {\r
3752                             goto rulerangeEx;\r
3753                         }\r
3754 \r
3755                         ADAPTOR->addChild(ADAPTOR, root_0, number62.tree);\r
3756 \r
3757                     }\r
3758                     break;\r
3759 \r
3760             }\r
3761         }\r
3762     }\r
3763     \r
3764 \r
3765     // This is where rules clean up and exit\r
3766     //\r
3767     goto rulerangeEx; /* Prevent compiler warnings */\r
3768     rulerangeEx: ;\r
3769     retval.stop = LT(-1);\r
3770 \r
3771         retval.stop = LT(-1);\r
3772         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
3773         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
3774 \r
3775             if (HASEXCEPTION())\r
3776             {\r
3777                 PREPORTERROR();\r
3778                 PRECOVER();\r
3779                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
3780             }\r
3781 \r
3782 \r
3783     return retval;\r
3784 }\r
3785 /* $ANTLR end range */\r
3786 \r
3787 /** \r
3788  * $ANTLR start number\r
3789  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:163:1: number : ( INT | FLOAT );\r
3790  */\r
3791 static SimanticsDataParser_number_return\r
3792 number(pSimanticsDataParser ctx)\r
3793 {   \r
3794     SimanticsDataParser_number_return retval;\r
3795 \r
3796     pANTLR3_BASE_TREE root_0;\r
3797 \r
3798     pANTLR3_COMMON_TOKEN    set63;\r
3799 \r
3800     pANTLR3_BASE_TREE set63_tree;\r
3801 \r
3802     /* Initialize rule variables\r
3803      */\r
3804 \r
3805 \r
3806     root_0 = NULL;\r
3807 \r
3808     set63       = NULL;\r
3809     retval.start = LT(1); retval.stop = retval.start;\r
3810 \r
3811     set63_tree   = NULL;\r
3812 \r
3813 \r
3814     retval.tree  = NULL;\r
3815     {\r
3816         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:164:5: ( INT | FLOAT )\r
3817         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:\r
3818         {\r
3819             root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3820 \r
3821             set63=(pANTLR3_COMMON_TOKEN)LT(1);\r
3822             if ( LA(1) == INT || LA(1) == FLOAT )\r
3823             {\r
3824                 CONSUME();\r
3825                 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set63)));\r
3826                 PERRORRECOVERY=ANTLR3_FALSE;\r
3827             }\r
3828             else \r
3829             {\r
3830                 CONSTRUCTEX();\r
3831                 EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
3832                 EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
3833                 EXCEPTION->expectingSet = &FOLLOW_set_in_number0;\r
3834                 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_number0);    goto rulenumberEx;\r
3835             }\r
3836 \r
3837 \r
3838         }\r
3839 \r
3840     }\r
3841     \r
3842 \r
3843     // This is where rules clean up and exit\r
3844     //\r
3845     goto rulenumberEx; /* Prevent compiler warnings */\r
3846     rulenumberEx: ;\r
3847     retval.stop = LT(-1);\r
3848 \r
3849         retval.stop = LT(-1);\r
3850         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
3851         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
3852 \r
3853             if (HASEXCEPTION())\r
3854             {\r
3855                 PREPORTERROR();\r
3856                 PRECOVER();\r
3857                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
3858             }\r
3859 \r
3860 \r
3861     return retval;\r
3862 }\r
3863 /* $ANTLR end number */\r
3864 \r
3865 /** \r
3866  * $ANTLR start string\r
3867  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:168:1: string : STRING ;\r
3868  */\r
3869 static SimanticsDataParser_string_return\r
3870 string(pSimanticsDataParser ctx)\r
3871 {   \r
3872     SimanticsDataParser_string_return retval;\r
3873 \r
3874     pANTLR3_BASE_TREE root_0;\r
3875 \r
3876     pANTLR3_COMMON_TOKEN    STRING64;\r
3877 \r
3878     pANTLR3_BASE_TREE STRING64_tree;\r
3879 \r
3880     /* Initialize rule variables\r
3881      */\r
3882 \r
3883 \r
3884     root_0 = NULL;\r
3885 \r
3886     STRING64       = NULL;\r
3887     retval.start = LT(1); retval.stop = retval.start;\r
3888 \r
3889     STRING64_tree   = NULL;\r
3890 \r
3891 \r
3892     retval.tree  = NULL;\r
3893     {\r
3894         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:169:5: ( STRING )\r
3895         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:169:7: STRING\r
3896         {\r
3897             root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3898 \r
3899             STRING64 = (pANTLR3_COMMON_TOKEN) MATCHT(STRING, &FOLLOW_STRING_in_string1402); \r
3900             if  (HASEXCEPTION())\r
3901             {\r
3902                 goto rulestringEx;\r
3903             }\r
3904 \r
3905             STRING64_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STRING64));\r
3906             ADAPTOR->addChild(ADAPTOR, root_0, STRING64_tree);\r
3907 \r
3908 \r
3909         }\r
3910 \r
3911     }\r
3912     \r
3913 \r
3914     // This is where rules clean up and exit\r
3915     //\r
3916     goto rulestringEx; /* Prevent compiler warnings */\r
3917     rulestringEx: ;\r
3918     retval.stop = LT(-1);\r
3919 \r
3920         retval.stop = LT(-1);\r
3921         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
3922         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
3923 \r
3924             if (HASEXCEPTION())\r
3925             {\r
3926                 PREPORTERROR();\r
3927                 PRECOVER();\r
3928                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
3929             }\r
3930 \r
3931 \r
3932     return retval;\r
3933 }\r
3934 /* $ANTLR end string */\r
3935 \r
3936 /** \r
3937  * $ANTLR start boolean\r
3938  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:172:1: boolean : ( 'true' | 'false' );\r
3939  */\r
3940 static SimanticsDataParser_boolean_return\r
3941 boolean(pSimanticsDataParser ctx)\r
3942 {   \r
3943     SimanticsDataParser_boolean_return retval;\r
3944 \r
3945     pANTLR3_BASE_TREE root_0;\r
3946 \r
3947     pANTLR3_COMMON_TOKEN    set65;\r
3948 \r
3949     pANTLR3_BASE_TREE set65_tree;\r
3950 \r
3951     /* Initialize rule variables\r
3952      */\r
3953 \r
3954 \r
3955     root_0 = NULL;\r
3956 \r
3957     set65       = NULL;\r
3958     retval.start = LT(1); retval.stop = retval.start;\r
3959 \r
3960     set65_tree   = NULL;\r
3961 \r
3962 \r
3963     retval.tree  = NULL;\r
3964     {\r
3965         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:173:5: ( 'true' | 'false' )\r
3966         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:\r
3967         {\r
3968             root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
3969 \r
3970             set65=(pANTLR3_COMMON_TOKEN)LT(1);\r
3971             if ( ((LA(1) >= 46) && (LA(1) <= 47)) )\r
3972             {\r
3973                 CONSUME();\r
3974                 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set65)));\r
3975                 PERRORRECOVERY=ANTLR3_FALSE;\r
3976             }\r
3977             else \r
3978             {\r
3979                 CONSTRUCTEX();\r
3980                 EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
3981                 EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
3982                 EXCEPTION->expectingSet = &FOLLOW_set_in_boolean0;\r
3983                 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_boolean0);    goto rulebooleanEx;\r
3984             }\r
3985 \r
3986 \r
3987         }\r
3988 \r
3989     }\r
3990     \r
3991 \r
3992     // This is where rules clean up and exit\r
3993     //\r
3994     goto rulebooleanEx; /* Prevent compiler warnings */\r
3995     rulebooleanEx: ;\r
3996     retval.stop = LT(-1);\r
3997 \r
3998         retval.stop = LT(-1);\r
3999         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
4000         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
4001 \r
4002             if (HASEXCEPTION())\r
4003             {\r
4004                 PREPORTERROR();\r
4005                 PRECOVER();\r
4006                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
4007             }\r
4008 \r
4009 \r
4010     return retval;\r
4011 }\r
4012 /* $ANTLR end boolean */\r
4013 \r
4014 /** \r
4015  * $ANTLR start valueDefinitions\r
4016  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:1: valueDefinitions : ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) ;\r
4017  */\r
4018 static SimanticsDataParser_valueDefinitions_return\r
4019 valueDefinitions(pSimanticsDataParser ctx)\r
4020 {   \r
4021     SimanticsDataParser_valueDefinitions_return retval;\r
4022 \r
4023     pANTLR3_BASE_TREE root_0;\r
4024 \r
4025     SimanticsDataParser_valueDefinition_return valueDefinition66;\r
4026     #undef      RETURN_TYPE_valueDefinition66\r
4027     #define     RETURN_TYPE_valueDefinition66 SimanticsDataParser_valueDefinition_return\r
4028 \r
4029     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_valueDefinition;\r
4030     /* Initialize rule variables\r
4031      */\r
4032 \r
4033 \r
4034     root_0 = NULL;\r
4035 \r
4036     valueDefinition66.tree = NULL;\r
4037 \r
4038     retval.start = LT(1); retval.stop = retval.start;\r
4039 \r
4040 \r
4041     stream_valueDefinition   = NULL;\r
4042     #define CREATE_stream_valueDefinition  if (stream_valueDefinition == NULL) {stream_valueDefinition = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule valueDefinition"); }\r
4043 \r
4044     retval.tree  = NULL;\r
4045     {\r
4046         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:18: ( ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) )\r
4047         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:20: ( valueDefinition )*\r
4048         {\r
4049 \r
4050             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:20: ( valueDefinition )*\r
4051 \r
4052             for (;;)\r
4053             {\r
4054                 int alt18=2;\r
4055                 switch ( LA(1) ) \r
4056                 {\r
4057                 case ID:\r
4058                         {\r
4059                                 alt18=1;\r
4060                         }\r
4061                     break;\r
4062 \r
4063                 }\r
4064 \r
4065                 switch (alt18) \r
4066                 {\r
4067                 case 1:\r
4068                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:20: valueDefinition\r
4069                     {\r
4070                         FOLLOWPUSH(FOLLOW_valueDefinition_in_valueDefinitions1447);\r
4071                         valueDefinition66=valueDefinition(ctx);\r
4072 \r
4073                         FOLLOWPOP();\r
4074                         if  (HASEXCEPTION())\r
4075                         {\r
4076                             goto rulevalueDefinitionsEx;\r
4077                         }\r
4078 \r
4079                         CREATE_stream_valueDefinition; stream_valueDefinition->add(stream_valueDefinition, valueDefinition66.tree, NULL);\r
4080 \r
4081                     }\r
4082                     break;\r
4083 \r
4084                 default:\r
4085                     goto loop18;        /* break out of the loop */\r
4086                     break;\r
4087                 }\r
4088             }\r
4089             loop18: ; /* Jump out to here if this rule does not match */\r
4090 \r
4091 \r
4092              \r
4093             /* AST REWRITE\r
4094              * elements          : valueDefinition\r
4095              * token labels      : \r
4096              * rule labels       : retval\r
4097              * token list labels : \r
4098              * rule list labels  : \r
4099              */\r
4100             {\r
4101                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
4102 \r
4103                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
4104 \r
4105                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4106                 retval.tree    = root_0;\r
4107                 // 181:37: -> ^( VALUE_DEFINITIONS ( valueDefinition )* )\r
4108                 {\r
4109                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:40: ^( VALUE_DEFINITIONS ( valueDefinition )* )\r
4110                     {\r
4111                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4112                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, VALUE_DEFINITIONS, (pANTLR3_UINT8)"VALUE_DEFINITIONS"), root_1));\r
4113 \r
4114                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:60: ( valueDefinition )*\r
4115                         {\r
4116                                 while ( (stream_valueDefinition != NULL && stream_valueDefinition->hasNext(stream_valueDefinition))  )\r
4117                                 {\r
4118                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_valueDefinition == NULL ? NULL : stream_valueDefinition->nextTree(stream_valueDefinition));\r
4119 \r
4120                                 }\r
4121                                 if (stream_valueDefinition != NULL) stream_valueDefinition->reset(stream_valueDefinition);\r
4122 \r
4123                         }\r
4124 \r
4125                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
4126                     }\r
4127 \r
4128                 }\r
4129 \r
4130                 retval.tree = root_0; // set result root\r
4131                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
4132 \r
4133 \r
4134             }\r
4135         }\r
4136 \r
4137     }\r
4138     \r
4139 \r
4140     // This is where rules clean up and exit\r
4141     //\r
4142     goto rulevalueDefinitionsEx; /* Prevent compiler warnings */\r
4143     rulevalueDefinitionsEx: ;\r
4144     retval.stop = LT(-1);\r
4145 \r
4146         retval.stop = LT(-1);\r
4147         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
4148         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
4149         if (stream_valueDefinition != NULL) stream_valueDefinition->free(stream_valueDefinition);\r
4150 \r
4151             if (HASEXCEPTION())\r
4152             {\r
4153                 PREPORTERROR();\r
4154                 PRECOVER();\r
4155                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
4156             }\r
4157 \r
4158 \r
4159     return retval;\r
4160 }\r
4161 /* $ANTLR end valueDefinitions */\r
4162 \r
4163 /** \r
4164  * $ANTLR start valueDefinition\r
4165  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:183:1: valueDefinition : ID ':' unionType '=' value -> ^( VALUE_DEFINITION ID unionType value ) ;\r
4166  */\r
4167 static SimanticsDataParser_valueDefinition_return\r
4168 valueDefinition(pSimanticsDataParser ctx)\r
4169 {   \r
4170     SimanticsDataParser_valueDefinition_return retval;\r
4171 \r
4172     pANTLR3_BASE_TREE root_0;\r
4173 \r
4174     pANTLR3_COMMON_TOKEN    ID67;\r
4175     pANTLR3_COMMON_TOKEN    char_literal68;\r
4176     pANTLR3_COMMON_TOKEN    char_literal70;\r
4177     SimanticsDataParser_unionType_return unionType69;\r
4178     #undef      RETURN_TYPE_unionType69\r
4179     #define     RETURN_TYPE_unionType69 SimanticsDataParser_unionType_return\r
4180 \r
4181     SimanticsDataParser_value_return value71;\r
4182     #undef      RETURN_TYPE_value71\r
4183     #define     RETURN_TYPE_value71 SimanticsDataParser_value_return\r
4184 \r
4185     pANTLR3_BASE_TREE ID67_tree;\r
4186     pANTLR3_BASE_TREE char_literal68_tree;\r
4187     pANTLR3_BASE_TREE char_literal70_tree;\r
4188     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_45;\r
4189     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;\r
4190     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;\r
4191     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType;\r
4192     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;\r
4193     /* Initialize rule variables\r
4194      */\r
4195 \r
4196 \r
4197     root_0 = NULL;\r
4198 \r
4199     ID67       = NULL;\r
4200     char_literal68       = NULL;\r
4201     char_literal70       = NULL;\r
4202     unionType69.tree = NULL;\r
4203 \r
4204     value71.tree = NULL;\r
4205 \r
4206     retval.start = LT(1); retval.stop = retval.start;\r
4207 \r
4208     ID67_tree   = NULL;\r
4209     char_literal68_tree   = NULL;\r
4210     char_literal70_tree   = NULL;\r
4211 \r
4212     stream_45   = NULL;\r
4213     #define CREATE_stream_45  if (stream_45 == NULL) {stream_45 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 45"); } \r
4214     stream_ID   = NULL;\r
4215     #define CREATE_stream_ID  if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } \r
4216     stream_35   = NULL;\r
4217     #define CREATE_stream_35  if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } \r
4218     stream_unionType   = NULL;\r
4219     #define CREATE_stream_unionType  if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); }\r
4220     stream_value   = NULL;\r
4221     #define CREATE_stream_value  if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }\r
4222 \r
4223     retval.tree  = NULL;\r
4224     {\r
4225         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:184:5: ( ID ':' unionType '=' value -> ^( VALUE_DEFINITION ID unionType value ) )\r
4226         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:184:7: ID ':' unionType '=' value\r
4227         {\r
4228             ID67 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_valueDefinition1470); \r
4229             if  (HASEXCEPTION())\r
4230             {\r
4231                 goto rulevalueDefinitionEx;\r
4232             }\r
4233              \r
4234             CREATE_stream_ID; stream_ID->add(stream_ID, ID67, NULL);\r
4235 \r
4236             char_literal68 = (pANTLR3_COMMON_TOKEN) MATCHT(45, &FOLLOW_45_in_valueDefinition1472); \r
4237             if  (HASEXCEPTION())\r
4238             {\r
4239                 goto rulevalueDefinitionEx;\r
4240             }\r
4241              \r
4242             CREATE_stream_45; stream_45->add(stream_45, char_literal68, NULL);\r
4243 \r
4244             FOLLOWPUSH(FOLLOW_unionType_in_valueDefinition1474);\r
4245             unionType69=unionType(ctx);\r
4246 \r
4247             FOLLOWPOP();\r
4248             if  (HASEXCEPTION())\r
4249             {\r
4250                 goto rulevalueDefinitionEx;\r
4251             }\r
4252 \r
4253             CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType69.tree, NULL);\r
4254             char_literal70 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_valueDefinition1476); \r
4255             if  (HASEXCEPTION())\r
4256             {\r
4257                 goto rulevalueDefinitionEx;\r
4258             }\r
4259              \r
4260             CREATE_stream_35; stream_35->add(stream_35, char_literal70, NULL);\r
4261 \r
4262             FOLLOWPUSH(FOLLOW_value_in_valueDefinition1478);\r
4263             value71=value(ctx);\r
4264 \r
4265             FOLLOWPOP();\r
4266             if  (HASEXCEPTION())\r
4267             {\r
4268                 goto rulevalueDefinitionEx;\r
4269             }\r
4270 \r
4271             CREATE_stream_value; stream_value->add(stream_value, value71.tree, NULL);\r
4272 \r
4273              \r
4274             /* AST REWRITE\r
4275              * elements          : value, unionType, ID\r
4276              * token labels      : \r
4277              * rule labels       : retval\r
4278              * token list labels : \r
4279              * rule list labels  : \r
4280              */\r
4281             {\r
4282                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
4283 \r
4284                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
4285 \r
4286                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4287                 retval.tree    = root_0;\r
4288                 // 185:5: -> ^( VALUE_DEFINITION ID unionType value )\r
4289                 {\r
4290                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:185:8: ^( VALUE_DEFINITION ID unionType value )\r
4291                     {\r
4292                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4293                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, VALUE_DEFINITION, (pANTLR3_UINT8)"VALUE_DEFINITION"), root_1));\r
4294 \r
4295                         ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));\r
4296                         ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType));\r
4297                         ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));\r
4298 \r
4299                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
4300                     }\r
4301 \r
4302                 }\r
4303 \r
4304                 retval.tree = root_0; // set result root\r
4305                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
4306 \r
4307 \r
4308             }\r
4309         }\r
4310 \r
4311     }\r
4312     \r
4313 \r
4314     // This is where rules clean up and exit\r
4315     //\r
4316     goto rulevalueDefinitionEx; /* Prevent compiler warnings */\r
4317     rulevalueDefinitionEx: ;\r
4318     retval.stop = LT(-1);\r
4319 \r
4320         retval.stop = LT(-1);\r
4321         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
4322         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
4323         if (stream_45 != NULL) stream_45->free(stream_45);\r
4324         if (stream_ID != NULL) stream_ID->free(stream_ID);\r
4325         if (stream_35 != NULL) stream_35->free(stream_35);\r
4326         if (stream_unionType != NULL) stream_unionType->free(stream_unionType);\r
4327         if (stream_value != NULL) stream_value->free(stream_value);\r
4328 \r
4329             if (HASEXCEPTION())\r
4330             {\r
4331                 PREPORTERROR();\r
4332                 PRECOVER();\r
4333                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
4334             }\r
4335 \r
4336 \r
4337     return retval;\r
4338 }\r
4339 /* $ANTLR end valueDefinition */\r
4340 \r
4341 /** \r
4342  * $ANTLR start value\r
4343  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:188:1: value : ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* ;\r
4344  */\r
4345 static SimanticsDataParser_value_return\r
4346 value(pSimanticsDataParser ctx)\r
4347 {   \r
4348     SimanticsDataParser_value_return retval;\r
4349 \r
4350     pANTLR3_BASE_TREE root_0;\r
4351 \r
4352     pANTLR3_COMMON_TOKEN    char_literal73;\r
4353     SimanticsDataParser_basicValue_return basicValue72;\r
4354     #undef      RETURN_TYPE_basicValue72\r
4355     #define     RETURN_TYPE_basicValue72 SimanticsDataParser_basicValue_return\r
4356 \r
4357     SimanticsDataParser_type_return type74;\r
4358     #undef      RETURN_TYPE_type74\r
4359     #define     RETURN_TYPE_type74 SimanticsDataParser_type_return\r
4360 \r
4361     pANTLR3_BASE_TREE char_literal73_tree;\r
4362     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_45;\r
4363     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_basicValue;\r
4364     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_type;\r
4365     /* Initialize rule variables\r
4366      */\r
4367 \r
4368 \r
4369     root_0 = NULL;\r
4370 \r
4371     char_literal73       = NULL;\r
4372     basicValue72.tree = NULL;\r
4373 \r
4374     type74.tree = NULL;\r
4375 \r
4376     retval.start = LT(1); retval.stop = retval.start;\r
4377 \r
4378     char_literal73_tree   = NULL;\r
4379 \r
4380     stream_45   = NULL;\r
4381     #define CREATE_stream_45  if (stream_45 == NULL) {stream_45 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 45"); } \r
4382     stream_basicValue   = NULL;\r
4383     #define CREATE_stream_basicValue  if (stream_basicValue == NULL) {stream_basicValue = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule basicValue"); }\r
4384     stream_type   = NULL;\r
4385     #define CREATE_stream_type  if (stream_type == NULL) {stream_type = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule type"); }\r
4386 \r
4387     retval.tree  = NULL;\r
4388     {\r
4389         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:5: ( ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* )\r
4390         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:7: ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )*\r
4391         {\r
4392             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:7: ( basicValue -> basicValue )\r
4393             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:8: basicValue\r
4394             {\r
4395                 FOLLOWPUSH(FOLLOW_basicValue_in_value1514);\r
4396                 basicValue72=basicValue(ctx);\r
4397 \r
4398                 FOLLOWPOP();\r
4399                 if  (HASEXCEPTION())\r
4400                 {\r
4401                     goto rulevalueEx;\r
4402                 }\r
4403 \r
4404                 CREATE_stream_basicValue; stream_basicValue->add(stream_basicValue, basicValue72.tree, NULL);\r
4405 \r
4406                  \r
4407                 /* AST REWRITE\r
4408                  * elements          : basicValue\r
4409                  * token labels      : \r
4410                  * rule labels       : retval\r
4411                  * token list labels : \r
4412                  * rule list labels  : \r
4413                  */\r
4414                 {\r
4415                         pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
4416 \r
4417                         stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
4418 \r
4419                         root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4420                         retval.tree    = root_0;\r
4421                         // 189:19: -> basicValue\r
4422                         {\r
4423                             ADAPTOR->addChild(ADAPTOR, root_0, stream_basicValue == NULL ? NULL : stream_basicValue->nextTree(stream_basicValue));\r
4424 \r
4425                         }\r
4426 \r
4427                         retval.tree = root_0; // set result root\r
4428                         if (stream_retval != NULL) stream_retval->free(stream_retval);\r
4429 \r
4430 \r
4431                 }\r
4432             }\r
4433 \r
4434 \r
4435             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:190:7: ( ':' type -> ^( VARIANT type $value) )*\r
4436 \r
4437             for (;;)\r
4438             {\r
4439                 int alt19=2;\r
4440                 switch ( LA(1) ) \r
4441                 {\r
4442                 case 45:\r
4443                         {\r
4444                                 alt19=1;\r
4445                         }\r
4446                     break;\r
4447 \r
4448                 }\r
4449 \r
4450                 switch (alt19) \r
4451                 {\r
4452                 case 1:\r
4453                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:190:8: ':' type\r
4454                     {\r
4455                         char_literal73 = (pANTLR3_COMMON_TOKEN) MATCHT(45, &FOLLOW_45_in_value1528); \r
4456                         if  (HASEXCEPTION())\r
4457                         {\r
4458                             goto rulevalueEx;\r
4459                         }\r
4460                          \r
4461                         CREATE_stream_45; stream_45->add(stream_45, char_literal73, NULL);\r
4462 \r
4463                         FOLLOWPUSH(FOLLOW_type_in_value1530);\r
4464                         type74=type(ctx);\r
4465 \r
4466                         FOLLOWPOP();\r
4467                         if  (HASEXCEPTION())\r
4468                         {\r
4469                             goto rulevalueEx;\r
4470                         }\r
4471 \r
4472                         CREATE_stream_type; stream_type->add(stream_type, type74.tree, NULL);\r
4473 \r
4474                          \r
4475                         /* AST REWRITE\r
4476                          * elements          : value, type\r
4477                          * token labels      : \r
4478                          * rule labels       : retval\r
4479                          * token list labels : \r
4480                          * rule list labels  : \r
4481                          */\r
4482                         {\r
4483                                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
4484 \r
4485                                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
4486 \r
4487                                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4488                                 retval.tree    = root_0;\r
4489                                 // 190:17: -> ^( VARIANT type $value)\r
4490                                 {\r
4491                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:190:20: ^( VARIANT type $value)\r
4492                                     {\r
4493                                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4494                                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, VARIANT, (pANTLR3_UINT8)"VARIANT"), root_1));\r
4495 \r
4496                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_type == NULL ? NULL : stream_type->nextTree(stream_type));\r
4497                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_retval == NULL ? NULL : stream_retval->nextTree(stream_retval));\r
4498 \r
4499                                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
4500                                     }\r
4501 \r
4502                                 }\r
4503 \r
4504                                 retval.tree = root_0; // set result root\r
4505                                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
4506 \r
4507 \r
4508                         }\r
4509                     }\r
4510                     break;\r
4511 \r
4512                 default:\r
4513                     goto loop19;        /* break out of the loop */\r
4514                     break;\r
4515                 }\r
4516             }\r
4517             loop19: ; /* Jump out to here if this rule does not match */\r
4518 \r
4519 \r
4520         }\r
4521 \r
4522     }\r
4523     \r
4524 \r
4525     // This is where rules clean up and exit\r
4526     //\r
4527     goto rulevalueEx; /* Prevent compiler warnings */\r
4528     rulevalueEx: ;\r
4529     retval.stop = LT(-1);\r
4530 \r
4531         retval.stop = LT(-1);\r
4532         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
4533         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
4534         if (stream_45 != NULL) stream_45->free(stream_45);\r
4535         if (stream_basicValue != NULL) stream_basicValue->free(stream_basicValue);\r
4536         if (stream_type != NULL) stream_type->free(stream_type);\r
4537 \r
4538             if (HASEXCEPTION())\r
4539             {\r
4540                 PREPORTERROR();\r
4541                 PRECOVER();\r
4542                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
4543             }\r
4544 \r
4545 \r
4546     return retval;\r
4547 }\r
4548 /* $ANTLR end value */\r
4549 \r
4550 /** \r
4551  * $ANTLR start basicValue\r
4552  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:193:1: basicValue : ( 'null' -> NO_VALUE | string | number | boolean | array | tuple | taggedValue | map | record );\r
4553  */\r
4554 static SimanticsDataParser_basicValue_return\r
4555 basicValue(pSimanticsDataParser ctx)\r
4556 {   \r
4557     SimanticsDataParser_basicValue_return retval;\r
4558 \r
4559     pANTLR3_BASE_TREE root_0;\r
4560 \r
4561     pANTLR3_COMMON_TOKEN    string_literal75;\r
4562     SimanticsDataParser_string_return string76;\r
4563     #undef      RETURN_TYPE_string76\r
4564     #define     RETURN_TYPE_string76 SimanticsDataParser_string_return\r
4565 \r
4566     SimanticsDataParser_number_return number77;\r
4567     #undef      RETURN_TYPE_number77\r
4568     #define     RETURN_TYPE_number77 SimanticsDataParser_number_return\r
4569 \r
4570     SimanticsDataParser_boolean_return boolean78;\r
4571     #undef      RETURN_TYPE_boolean78\r
4572     #define     RETURN_TYPE_boolean78 SimanticsDataParser_boolean_return\r
4573 \r
4574     SimanticsDataParser_array_return array79;\r
4575     #undef      RETURN_TYPE_array79\r
4576     #define     RETURN_TYPE_array79 SimanticsDataParser_array_return\r
4577 \r
4578     SimanticsDataParser_tuple_return tuple80;\r
4579     #undef      RETURN_TYPE_tuple80\r
4580     #define     RETURN_TYPE_tuple80 SimanticsDataParser_tuple_return\r
4581 \r
4582     SimanticsDataParser_taggedValue_return taggedValue81;\r
4583     #undef      RETURN_TYPE_taggedValue81\r
4584     #define     RETURN_TYPE_taggedValue81 SimanticsDataParser_taggedValue_return\r
4585 \r
4586     SimanticsDataParser_map_return map82;\r
4587     #undef      RETURN_TYPE_map82\r
4588     #define     RETURN_TYPE_map82 SimanticsDataParser_map_return\r
4589 \r
4590     SimanticsDataParser_record_return record83;\r
4591     #undef      RETURN_TYPE_record83\r
4592     #define     RETURN_TYPE_record83 SimanticsDataParser_record_return\r
4593 \r
4594     pANTLR3_BASE_TREE string_literal75_tree;\r
4595     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_48;\r
4596 \r
4597     /* Initialize rule variables\r
4598      */\r
4599 \r
4600 \r
4601     root_0 = NULL;\r
4602 \r
4603     string_literal75       = NULL;\r
4604     string76.tree = NULL;\r
4605 \r
4606     number77.tree = NULL;\r
4607 \r
4608     boolean78.tree = NULL;\r
4609 \r
4610     array79.tree = NULL;\r
4611 \r
4612     tuple80.tree = NULL;\r
4613 \r
4614     taggedValue81.tree = NULL;\r
4615 \r
4616     map82.tree = NULL;\r
4617 \r
4618     record83.tree = NULL;\r
4619 \r
4620     retval.start = LT(1); retval.stop = retval.start;\r
4621 \r
4622     string_literal75_tree   = NULL;\r
4623 \r
4624     stream_48   = NULL;\r
4625     #define CREATE_stream_48  if (stream_48 == NULL) {stream_48 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 48"); } \r
4626 \r
4627     retval.tree  = NULL;\r
4628     {\r
4629         {\r
4630             //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:194:5: ( 'null' -> NO_VALUE | string | number | boolean | array | tuple | taggedValue | map | record )\r
4631             \r
4632             ANTLR3_UINT32 alt20;\r
4633 \r
4634             alt20=9;\r
4635 \r
4636             switch ( LA(1) ) \r
4637             {\r
4638             case 48:\r
4639                 {\r
4640                         alt20=1;\r
4641                 }\r
4642                 break;\r
4643             case STRING:\r
4644                 {\r
4645                         alt20=2;\r
4646                 }\r
4647                 break;\r
4648             case INT:\r
4649             case FLOAT:\r
4650                 {\r
4651                         alt20=3;\r
4652                 }\r
4653                 break;\r
4654             case 46:\r
4655             case 47:\r
4656                 {\r
4657                         alt20=4;\r
4658                 }\r
4659                 break;\r
4660             case 37:\r
4661                 {\r
4662                         alt20=5;\r
4663                 }\r
4664                 break;\r
4665             case 40:\r
4666                 {\r
4667                         alt20=6;\r
4668                 }\r
4669                 break;\r
4670             case ID:\r
4671                 {\r
4672                         alt20=7;\r
4673                 }\r
4674                 break;\r
4675             case 49:\r
4676                 {\r
4677                         alt20=8;\r
4678                 }\r
4679                 break;\r
4680             case 43:\r
4681                 {\r
4682                         alt20=9;\r
4683                 }\r
4684                 break;\r
4685 \r
4686             default:\r
4687                 CONSTRUCTEX();\r
4688                 EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
4689                 EXCEPTION->message      = (void *)"";\r
4690                 EXCEPTION->decisionNum  = 20;\r
4691                 EXCEPTION->state        = 0;\r
4692 \r
4693 \r
4694                 goto rulebasicValueEx;\r
4695             }\r
4696 \r
4697             switch (alt20) \r
4698             {\r
4699                 case 1:\r
4700                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:194:7: 'null'\r
4701                     {\r
4702                         string_literal75 = (pANTLR3_COMMON_TOKEN) MATCHT(48, &FOLLOW_48_in_basicValue1562); \r
4703                         if  (HASEXCEPTION())\r
4704                         {\r
4705                             goto rulebasicValueEx;\r
4706                         }\r
4707                          \r
4708                         CREATE_stream_48; stream_48->add(stream_48, string_literal75, NULL);\r
4709 \r
4710 \r
4711                          \r
4712                         /* AST REWRITE\r
4713                          * elements          : \r
4714                          * token labels      : \r
4715                          * rule labels       : retval\r
4716                          * token list labels : \r
4717                          * rule list labels  : \r
4718                          */\r
4719                         {\r
4720                                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
4721 \r
4722                                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
4723 \r
4724                                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4725                                 retval.tree    = root_0;\r
4726                                 // 194:14: -> NO_VALUE\r
4727                                 {\r
4728                                     ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, NO_VALUE, (pANTLR3_UINT8)"NO_VALUE"));\r
4729 \r
4730                                 }\r
4731 \r
4732                                 retval.tree = root_0; // set result root\r
4733                                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
4734 \r
4735 \r
4736                         }\r
4737                     }\r
4738                     break;\r
4739                 case 2:\r
4740                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:195:7: string\r
4741                     {\r
4742                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4743 \r
4744                         FOLLOWPUSH(FOLLOW_string_in_basicValue1574);\r
4745                         string76=string(ctx);\r
4746 \r
4747                         FOLLOWPOP();\r
4748                         if  (HASEXCEPTION())\r
4749                         {\r
4750                             goto rulebasicValueEx;\r
4751                         }\r
4752 \r
4753                         ADAPTOR->addChild(ADAPTOR, root_0, string76.tree);\r
4754 \r
4755                     }\r
4756                     break;\r
4757                 case 3:\r
4758                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:196:7: number\r
4759                     {\r
4760                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4761 \r
4762                         FOLLOWPUSH(FOLLOW_number_in_basicValue1582);\r
4763                         number77=number(ctx);\r
4764 \r
4765                         FOLLOWPOP();\r
4766                         if  (HASEXCEPTION())\r
4767                         {\r
4768                             goto rulebasicValueEx;\r
4769                         }\r
4770 \r
4771                         ADAPTOR->addChild(ADAPTOR, root_0, number77.tree);\r
4772 \r
4773                     }\r
4774                     break;\r
4775                 case 4:\r
4776                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:197:7: boolean\r
4777                     {\r
4778                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4779 \r
4780                         FOLLOWPUSH(FOLLOW_boolean_in_basicValue1590);\r
4781                         boolean78=boolean(ctx);\r
4782 \r
4783                         FOLLOWPOP();\r
4784                         if  (HASEXCEPTION())\r
4785                         {\r
4786                             goto rulebasicValueEx;\r
4787                         }\r
4788 \r
4789                         ADAPTOR->addChild(ADAPTOR, root_0, boolean78.tree);\r
4790 \r
4791                     }\r
4792                     break;\r
4793                 case 5:\r
4794                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:198:7: array\r
4795                     {\r
4796                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4797 \r
4798                         FOLLOWPUSH(FOLLOW_array_in_basicValue1598);\r
4799                         array79=array(ctx);\r
4800 \r
4801                         FOLLOWPOP();\r
4802                         if  (HASEXCEPTION())\r
4803                         {\r
4804                             goto rulebasicValueEx;\r
4805                         }\r
4806 \r
4807                         ADAPTOR->addChild(ADAPTOR, root_0, array79.tree);\r
4808 \r
4809                     }\r
4810                     break;\r
4811                 case 6:\r
4812                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:199:7: tuple\r
4813                     {\r
4814                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4815 \r
4816                         FOLLOWPUSH(FOLLOW_tuple_in_basicValue1606);\r
4817                         tuple80=tuple(ctx);\r
4818 \r
4819                         FOLLOWPOP();\r
4820                         if  (HASEXCEPTION())\r
4821                         {\r
4822                             goto rulebasicValueEx;\r
4823                         }\r
4824 \r
4825                         ADAPTOR->addChild(ADAPTOR, root_0, tuple80.tree);\r
4826 \r
4827                     }\r
4828                     break;\r
4829                 case 7:\r
4830                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:200:7: taggedValue\r
4831                     {\r
4832                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4833 \r
4834                         FOLLOWPUSH(FOLLOW_taggedValue_in_basicValue1614);\r
4835                         taggedValue81=taggedValue(ctx);\r
4836 \r
4837                         FOLLOWPOP();\r
4838                         if  (HASEXCEPTION())\r
4839                         {\r
4840                             goto rulebasicValueEx;\r
4841                         }\r
4842 \r
4843                         ADAPTOR->addChild(ADAPTOR, root_0, taggedValue81.tree);\r
4844 \r
4845                     }\r
4846                     break;\r
4847                 case 8:\r
4848                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:201:7: map\r
4849                     {\r
4850                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4851 \r
4852                         FOLLOWPUSH(FOLLOW_map_in_basicValue1622);\r
4853                         map82=map(ctx);\r
4854 \r
4855                         FOLLOWPOP();\r
4856                         if  (HASEXCEPTION())\r
4857                         {\r
4858                             goto rulebasicValueEx;\r
4859                         }\r
4860 \r
4861                         ADAPTOR->addChild(ADAPTOR, root_0, map82.tree);\r
4862 \r
4863                     }\r
4864                     break;\r
4865                 case 9:\r
4866                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:202:7: record\r
4867                     {\r
4868                         root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
4869 \r
4870                         FOLLOWPUSH(FOLLOW_record_in_basicValue1630);\r
4871                         record83=record(ctx);\r
4872 \r
4873                         FOLLOWPOP();\r
4874                         if  (HASEXCEPTION())\r
4875                         {\r
4876                             goto rulebasicValueEx;\r
4877                         }\r
4878 \r
4879                         ADAPTOR->addChild(ADAPTOR, root_0, record83.tree);\r
4880 \r
4881                     }\r
4882                     break;\r
4883 \r
4884             }\r
4885         }\r
4886     }\r
4887     \r
4888 \r
4889     // This is where rules clean up and exit\r
4890     //\r
4891     goto rulebasicValueEx; /* Prevent compiler warnings */\r
4892     rulebasicValueEx: ;\r
4893     retval.stop = LT(-1);\r
4894 \r
4895         retval.stop = LT(-1);\r
4896         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
4897         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
4898         if (stream_48 != NULL) stream_48->free(stream_48);\r
4899 \r
4900             if (HASEXCEPTION())\r
4901             {\r
4902                 PREPORTERROR();\r
4903                 PRECOVER();\r
4904                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
4905             }\r
4906 \r
4907 \r
4908     return retval;\r
4909 }\r
4910 /* $ANTLR end basicValue */\r
4911 \r
4912 /** \r
4913  * $ANTLR start array\r
4914  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:205:1: array : '[' ( value ( ',' value )* )? ']' -> ^( ARRAY ( value )* ) ;\r
4915  */\r
4916 static SimanticsDataParser_array_return\r
4917 array(pSimanticsDataParser ctx)\r
4918 {   \r
4919     SimanticsDataParser_array_return retval;\r
4920 \r
4921     pANTLR3_BASE_TREE root_0;\r
4922 \r
4923     pANTLR3_COMMON_TOKEN    char_literal84;\r
4924     pANTLR3_COMMON_TOKEN    char_literal86;\r
4925     pANTLR3_COMMON_TOKEN    char_literal88;\r
4926     SimanticsDataParser_value_return value85;\r
4927     #undef      RETURN_TYPE_value85\r
4928     #define     RETURN_TYPE_value85 SimanticsDataParser_value_return\r
4929 \r
4930     SimanticsDataParser_value_return value87;\r
4931     #undef      RETURN_TYPE_value87\r
4932     #define     RETURN_TYPE_value87 SimanticsDataParser_value_return\r
4933 \r
4934     pANTLR3_BASE_TREE char_literal84_tree;\r
4935     pANTLR3_BASE_TREE char_literal86_tree;\r
4936     pANTLR3_BASE_TREE char_literal88_tree;\r
4937     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;\r
4938     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_37;\r
4939     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_38;\r
4940     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;\r
4941     /* Initialize rule variables\r
4942      */\r
4943 \r
4944 \r
4945     root_0 = NULL;\r
4946 \r
4947     char_literal84       = NULL;\r
4948     char_literal86       = NULL;\r
4949     char_literal88       = NULL;\r
4950     value85.tree = NULL;\r
4951 \r
4952     value87.tree = NULL;\r
4953 \r
4954     retval.start = LT(1); retval.stop = retval.start;\r
4955 \r
4956     char_literal84_tree   = NULL;\r
4957     char_literal86_tree   = NULL;\r
4958     char_literal88_tree   = NULL;\r
4959 \r
4960     stream_41   = NULL;\r
4961     #define CREATE_stream_41  if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } \r
4962     stream_37   = NULL;\r
4963     #define CREATE_stream_37  if (stream_37 == NULL) {stream_37 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 37"); } \r
4964     stream_38   = NULL;\r
4965     #define CREATE_stream_38  if (stream_38 == NULL) {stream_38 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 38"); } \r
4966     stream_value   = NULL;\r
4967     #define CREATE_stream_value  if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }\r
4968 \r
4969     retval.tree  = NULL;\r
4970     {\r
4971         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:5: ( '[' ( value ( ',' value )* )? ']' -> ^( ARRAY ( value )* ) )\r
4972         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:7: '[' ( value ( ',' value )* )? ']'\r
4973         {\r
4974             char_literal84 = (pANTLR3_COMMON_TOKEN) MATCHT(37, &FOLLOW_37_in_array1648); \r
4975             if  (HASEXCEPTION())\r
4976             {\r
4977                 goto rulearrayEx;\r
4978             }\r
4979              \r
4980             CREATE_stream_37; stream_37->add(stream_37, char_literal84, NULL);\r
4981 \r
4982 \r
4983             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:11: ( value ( ',' value )* )?\r
4984             {\r
4985                 int alt22=2;\r
4986                 switch ( LA(1) ) \r
4987                 {\r
4988                     case ID:\r
4989                     case INT:\r
4990                     case FLOAT:\r
4991                     case STRING:\r
4992                     case 37:\r
4993                     case 40:\r
4994                     case 43:\r
4995                     case 46:\r
4996                     case 47:\r
4997                     case 48:\r
4998                     case 49:\r
4999                         {\r
5000                                 alt22=1;\r
5001                         }\r
5002                         break;\r
5003                 }\r
5004 \r
5005                 switch (alt22) \r
5006                 {\r
5007                 case 1:\r
5008                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:12: value ( ',' value )*\r
5009                     {\r
5010                         FOLLOWPUSH(FOLLOW_value_in_array1651);\r
5011                         value85=value(ctx);\r
5012 \r
5013                         FOLLOWPOP();\r
5014                         if  (HASEXCEPTION())\r
5015                         {\r
5016                             goto rulearrayEx;\r
5017                         }\r
5018 \r
5019                         CREATE_stream_value; stream_value->add(stream_value, value85.tree, NULL);\r
5020 \r
5021                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:18: ( ',' value )*\r
5022 \r
5023                         for (;;)\r
5024                         {\r
5025                             int alt21=2;\r
5026                             switch ( LA(1) ) \r
5027                             {\r
5028                             case 41:\r
5029                                 {\r
5030                                         alt21=1;\r
5031                                 }\r
5032                                 break;\r
5033 \r
5034                             }\r
5035 \r
5036                             switch (alt21) \r
5037                             {\r
5038                                 case 1:\r
5039                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:19: ',' value\r
5040                                     {\r
5041                                         char_literal86 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_array1654); \r
5042                                         if  (HASEXCEPTION())\r
5043                                         {\r
5044                                             goto rulearrayEx;\r
5045                                         }\r
5046                                          \r
5047                                         CREATE_stream_41; stream_41->add(stream_41, char_literal86, NULL);\r
5048 \r
5049                                         FOLLOWPUSH(FOLLOW_value_in_array1656);\r
5050                                         value87=value(ctx);\r
5051 \r
5052                                         FOLLOWPOP();\r
5053                                         if  (HASEXCEPTION())\r
5054                                         {\r
5055                                             goto rulearrayEx;\r
5056                                         }\r
5057 \r
5058                                         CREATE_stream_value; stream_value->add(stream_value, value87.tree, NULL);\r
5059 \r
5060                                     }\r
5061                                     break;\r
5062 \r
5063                                 default:\r
5064                                     goto loop21;        /* break out of the loop */\r
5065                                     break;\r
5066                             }\r
5067                         }\r
5068                         loop21: ; /* Jump out to here if this rule does not match */\r
5069 \r
5070 \r
5071                     }\r
5072                     break;\r
5073 \r
5074                 }\r
5075             }\r
5076             char_literal88 = (pANTLR3_COMMON_TOKEN) MATCHT(38, &FOLLOW_38_in_array1662); \r
5077             if  (HASEXCEPTION())\r
5078             {\r
5079                 goto rulearrayEx;\r
5080             }\r
5081              \r
5082             CREATE_stream_38; stream_38->add(stream_38, char_literal88, NULL);\r
5083 \r
5084 \r
5085              \r
5086             /* AST REWRITE\r
5087              * elements          : value\r
5088              * token labels      : \r
5089              * rule labels       : retval\r
5090              * token list labels : \r
5091              * rule list labels  : \r
5092              */\r
5093             {\r
5094                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
5095 \r
5096                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
5097 \r
5098                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5099                 retval.tree    = root_0;\r
5100                 // 207:5: -> ^( ARRAY ( value )* )\r
5101                 {\r
5102                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:207:8: ^( ARRAY ( value )* )\r
5103                     {\r
5104                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5105                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ARRAY, (pANTLR3_UINT8)"ARRAY"), root_1));\r
5106 \r
5107                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:207:16: ( value )*\r
5108                         {\r
5109                                 while ( (stream_value != NULL && stream_value->hasNext(stream_value))  )\r
5110                                 {\r
5111                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));\r
5112 \r
5113                                 }\r
5114                                 if (stream_value != NULL) stream_value->reset(stream_value);\r
5115 \r
5116                         }\r
5117 \r
5118                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
5119                     }\r
5120 \r
5121                 }\r
5122 \r
5123                 retval.tree = root_0; // set result root\r
5124                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
5125 \r
5126 \r
5127             }\r
5128         }\r
5129 \r
5130     }\r
5131     \r
5132 \r
5133     // This is where rules clean up and exit\r
5134     //\r
5135     goto rulearrayEx; /* Prevent compiler warnings */\r
5136     rulearrayEx: ;\r
5137     retval.stop = LT(-1);\r
5138 \r
5139         retval.stop = LT(-1);\r
5140         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
5141         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
5142         if (stream_41 != NULL) stream_41->free(stream_41);\r
5143         if (stream_37 != NULL) stream_37->free(stream_37);\r
5144         if (stream_38 != NULL) stream_38->free(stream_38);\r
5145         if (stream_value != NULL) stream_value->free(stream_value);\r
5146 \r
5147             if (HASEXCEPTION())\r
5148             {\r
5149                 PREPORTERROR();\r
5150                 PRECOVER();\r
5151                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
5152             }\r
5153 \r
5154 \r
5155     return retval;\r
5156 }\r
5157 /* $ANTLR end array */\r
5158 \r
5159 /** \r
5160  * $ANTLR start tuple\r
5161  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:210:1: tuple : '(' ( value ( ',' value )* )? ')' -> ^( TUPLE ( value )* ) ;\r
5162  */\r
5163 static SimanticsDataParser_tuple_return\r
5164 tuple(pSimanticsDataParser ctx)\r
5165 {   \r
5166     SimanticsDataParser_tuple_return retval;\r
5167 \r
5168     pANTLR3_BASE_TREE root_0;\r
5169 \r
5170     pANTLR3_COMMON_TOKEN    char_literal89;\r
5171     pANTLR3_COMMON_TOKEN    char_literal91;\r
5172     pANTLR3_COMMON_TOKEN    char_literal93;\r
5173     SimanticsDataParser_value_return value90;\r
5174     #undef      RETURN_TYPE_value90\r
5175     #define     RETURN_TYPE_value90 SimanticsDataParser_value_return\r
5176 \r
5177     SimanticsDataParser_value_return value92;\r
5178     #undef      RETURN_TYPE_value92\r
5179     #define     RETURN_TYPE_value92 SimanticsDataParser_value_return\r
5180 \r
5181     pANTLR3_BASE_TREE char_literal89_tree;\r
5182     pANTLR3_BASE_TREE char_literal91_tree;\r
5183     pANTLR3_BASE_TREE char_literal93_tree;\r
5184     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_42;\r
5185     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;\r
5186     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_40;\r
5187     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;\r
5188     /* Initialize rule variables\r
5189      */\r
5190 \r
5191 \r
5192     root_0 = NULL;\r
5193 \r
5194     char_literal89       = NULL;\r
5195     char_literal91       = NULL;\r
5196     char_literal93       = NULL;\r
5197     value90.tree = NULL;\r
5198 \r
5199     value92.tree = NULL;\r
5200 \r
5201     retval.start = LT(1); retval.stop = retval.start;\r
5202 \r
5203     char_literal89_tree   = NULL;\r
5204     char_literal91_tree   = NULL;\r
5205     char_literal93_tree   = NULL;\r
5206 \r
5207     stream_42   = NULL;\r
5208     #define CREATE_stream_42  if (stream_42 == NULL) {stream_42 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 42"); } \r
5209     stream_41   = NULL;\r
5210     #define CREATE_stream_41  if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } \r
5211     stream_40   = NULL;\r
5212     #define CREATE_stream_40  if (stream_40 == NULL) {stream_40 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 40"); } \r
5213     stream_value   = NULL;\r
5214     #define CREATE_stream_value  if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }\r
5215 \r
5216     retval.tree  = NULL;\r
5217     {\r
5218         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:5: ( '(' ( value ( ',' value )* )? ')' -> ^( TUPLE ( value )* ) )\r
5219         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:7: '(' ( value ( ',' value )* )? ')'\r
5220         {\r
5221             char_literal89 = (pANTLR3_COMMON_TOKEN) MATCHT(40, &FOLLOW_40_in_tuple1694); \r
5222             if  (HASEXCEPTION())\r
5223             {\r
5224                 goto ruletupleEx;\r
5225             }\r
5226              \r
5227             CREATE_stream_40; stream_40->add(stream_40, char_literal89, NULL);\r
5228 \r
5229 \r
5230             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:11: ( value ( ',' value )* )?\r
5231             {\r
5232                 int alt24=2;\r
5233                 switch ( LA(1) ) \r
5234                 {\r
5235                     case ID:\r
5236                     case INT:\r
5237                     case FLOAT:\r
5238                     case STRING:\r
5239                     case 37:\r
5240                     case 40:\r
5241                     case 43:\r
5242                     case 46:\r
5243                     case 47:\r
5244                     case 48:\r
5245                     case 49:\r
5246                         {\r
5247                                 alt24=1;\r
5248                         }\r
5249                         break;\r
5250                 }\r
5251 \r
5252                 switch (alt24) \r
5253                 {\r
5254                 case 1:\r
5255                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:12: value ( ',' value )*\r
5256                     {\r
5257                         FOLLOWPUSH(FOLLOW_value_in_tuple1697);\r
5258                         value90=value(ctx);\r
5259 \r
5260                         FOLLOWPOP();\r
5261                         if  (HASEXCEPTION())\r
5262                         {\r
5263                             goto ruletupleEx;\r
5264                         }\r
5265 \r
5266                         CREATE_stream_value; stream_value->add(stream_value, value90.tree, NULL);\r
5267 \r
5268                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:18: ( ',' value )*\r
5269 \r
5270                         for (;;)\r
5271                         {\r
5272                             int alt23=2;\r
5273                             switch ( LA(1) ) \r
5274                             {\r
5275                             case 41:\r
5276                                 {\r
5277                                         alt23=1;\r
5278                                 }\r
5279                                 break;\r
5280 \r
5281                             }\r
5282 \r
5283                             switch (alt23) \r
5284                             {\r
5285                                 case 1:\r
5286                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:19: ',' value\r
5287                                     {\r
5288                                         char_literal91 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_tuple1700); \r
5289                                         if  (HASEXCEPTION())\r
5290                                         {\r
5291                                             goto ruletupleEx;\r
5292                                         }\r
5293                                          \r
5294                                         CREATE_stream_41; stream_41->add(stream_41, char_literal91, NULL);\r
5295 \r
5296                                         FOLLOWPUSH(FOLLOW_value_in_tuple1702);\r
5297                                         value92=value(ctx);\r
5298 \r
5299                                         FOLLOWPOP();\r
5300                                         if  (HASEXCEPTION())\r
5301                                         {\r
5302                                             goto ruletupleEx;\r
5303                                         }\r
5304 \r
5305                                         CREATE_stream_value; stream_value->add(stream_value, value92.tree, NULL);\r
5306 \r
5307                                     }\r
5308                                     break;\r
5309 \r
5310                                 default:\r
5311                                     goto loop23;        /* break out of the loop */\r
5312                                     break;\r
5313                             }\r
5314                         }\r
5315                         loop23: ; /* Jump out to here if this rule does not match */\r
5316 \r
5317 \r
5318                     }\r
5319                     break;\r
5320 \r
5321                 }\r
5322             }\r
5323             char_literal93 = (pANTLR3_COMMON_TOKEN) MATCHT(42, &FOLLOW_42_in_tuple1708); \r
5324             if  (HASEXCEPTION())\r
5325             {\r
5326                 goto ruletupleEx;\r
5327             }\r
5328              \r
5329             CREATE_stream_42; stream_42->add(stream_42, char_literal93, NULL);\r
5330 \r
5331 \r
5332              \r
5333             /* AST REWRITE\r
5334              * elements          : value\r
5335              * token labels      : \r
5336              * rule labels       : retval\r
5337              * token list labels : \r
5338              * rule list labels  : \r
5339              */\r
5340             {\r
5341                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
5342 \r
5343                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
5344 \r
5345                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5346                 retval.tree    = root_0;\r
5347                 // 212:5: -> ^( TUPLE ( value )* )\r
5348                 {\r
5349                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:212:8: ^( TUPLE ( value )* )\r
5350                     {\r
5351                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5352                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TUPLE, (pANTLR3_UINT8)"TUPLE"), root_1));\r
5353 \r
5354                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:212:16: ( value )*\r
5355                         {\r
5356                                 while ( (stream_value != NULL && stream_value->hasNext(stream_value))  )\r
5357                                 {\r
5358                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));\r
5359 \r
5360                                 }\r
5361                                 if (stream_value != NULL) stream_value->reset(stream_value);\r
5362 \r
5363                         }\r
5364 \r
5365                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
5366                     }\r
5367 \r
5368                 }\r
5369 \r
5370                 retval.tree = root_0; // set result root\r
5371                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
5372 \r
5373 \r
5374             }\r
5375         }\r
5376 \r
5377     }\r
5378     \r
5379 \r
5380     // This is where rules clean up and exit\r
5381     //\r
5382     goto ruletupleEx; /* Prevent compiler warnings */\r
5383     ruletupleEx: ;\r
5384     retval.stop = LT(-1);\r
5385 \r
5386         retval.stop = LT(-1);\r
5387         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
5388         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
5389         if (stream_42 != NULL) stream_42->free(stream_42);\r
5390         if (stream_41 != NULL) stream_41->free(stream_41);\r
5391         if (stream_40 != NULL) stream_40->free(stream_40);\r
5392         if (stream_value != NULL) stream_value->free(stream_value);\r
5393 \r
5394             if (HASEXCEPTION())\r
5395             {\r
5396                 PREPORTERROR();\r
5397                 PRECOVER();\r
5398                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
5399             }\r
5400 \r
5401 \r
5402     return retval;\r
5403 }\r
5404 /* $ANTLR end tuple */\r
5405 \r
5406 /** \r
5407  * $ANTLR start taggedValue\r
5408  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:215:1: taggedValue : ID basicValue -> ^( TAGGED_VALUE ID basicValue ) ;\r
5409  */\r
5410 static SimanticsDataParser_taggedValue_return\r
5411 taggedValue(pSimanticsDataParser ctx)\r
5412 {   \r
5413     SimanticsDataParser_taggedValue_return retval;\r
5414 \r
5415     pANTLR3_BASE_TREE root_0;\r
5416 \r
5417     pANTLR3_COMMON_TOKEN    ID94;\r
5418     SimanticsDataParser_basicValue_return basicValue95;\r
5419     #undef      RETURN_TYPE_basicValue95\r
5420     #define     RETURN_TYPE_basicValue95 SimanticsDataParser_basicValue_return\r
5421 \r
5422     pANTLR3_BASE_TREE ID94_tree;\r
5423     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;\r
5424     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_basicValue;\r
5425     /* Initialize rule variables\r
5426      */\r
5427 \r
5428 \r
5429     root_0 = NULL;\r
5430 \r
5431     ID94       = NULL;\r
5432     basicValue95.tree = NULL;\r
5433 \r
5434     retval.start = LT(1); retval.stop = retval.start;\r
5435 \r
5436     ID94_tree   = NULL;\r
5437 \r
5438     stream_ID   = NULL;\r
5439     #define CREATE_stream_ID  if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } \r
5440     stream_basicValue   = NULL;\r
5441     #define CREATE_stream_basicValue  if (stream_basicValue == NULL) {stream_basicValue = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule basicValue"); }\r
5442 \r
5443     retval.tree  = NULL;\r
5444     {\r
5445         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:216:5: ( ID basicValue -> ^( TAGGED_VALUE ID basicValue ) )\r
5446         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:216:7: ID basicValue\r
5447         {\r
5448             ID94 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_taggedValue1740); \r
5449             if  (HASEXCEPTION())\r
5450             {\r
5451                 goto ruletaggedValueEx;\r
5452             }\r
5453              \r
5454             CREATE_stream_ID; stream_ID->add(stream_ID, ID94, NULL);\r
5455 \r
5456             FOLLOWPUSH(FOLLOW_basicValue_in_taggedValue1742);\r
5457             basicValue95=basicValue(ctx);\r
5458 \r
5459             FOLLOWPOP();\r
5460             if  (HASEXCEPTION())\r
5461             {\r
5462                 goto ruletaggedValueEx;\r
5463             }\r
5464 \r
5465             CREATE_stream_basicValue; stream_basicValue->add(stream_basicValue, basicValue95.tree, NULL);\r
5466 \r
5467              \r
5468             /* AST REWRITE\r
5469              * elements          : basicValue, ID\r
5470              * token labels      : \r
5471              * rule labels       : retval\r
5472              * token list labels : \r
5473              * rule list labels  : \r
5474              */\r
5475             {\r
5476                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
5477 \r
5478                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
5479 \r
5480                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5481                 retval.tree    = root_0;\r
5482                 // 217:5: -> ^( TAGGED_VALUE ID basicValue )\r
5483                 {\r
5484                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:217:8: ^( TAGGED_VALUE ID basicValue )\r
5485                     {\r
5486                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5487                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TAGGED_VALUE, (pANTLR3_UINT8)"TAGGED_VALUE"), root_1));\r
5488 \r
5489                         ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));\r
5490                         ADAPTOR->addChild(ADAPTOR, root_1, stream_basicValue == NULL ? NULL : stream_basicValue->nextTree(stream_basicValue));\r
5491 \r
5492                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
5493                     }\r
5494 \r
5495                 }\r
5496 \r
5497                 retval.tree = root_0; // set result root\r
5498                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
5499 \r
5500 \r
5501             }\r
5502         }\r
5503 \r
5504     }\r
5505     \r
5506 \r
5507     // This is where rules clean up and exit\r
5508     //\r
5509     goto ruletaggedValueEx; /* Prevent compiler warnings */\r
5510     ruletaggedValueEx: ;\r
5511     retval.stop = LT(-1);\r
5512 \r
5513         retval.stop = LT(-1);\r
5514         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
5515         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
5516         if (stream_ID != NULL) stream_ID->free(stream_ID);\r
5517         if (stream_basicValue != NULL) stream_basicValue->free(stream_basicValue);\r
5518 \r
5519             if (HASEXCEPTION())\r
5520             {\r
5521                 PREPORTERROR();\r
5522                 PRECOVER();\r
5523                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
5524             }\r
5525 \r
5526 \r
5527     return retval;\r
5528 }\r
5529 /* $ANTLR end taggedValue */\r
5530 \r
5531 /** \r
5532  * $ANTLR start record\r
5533  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:220:1: record : '{' ( recordAssignment ( ',' recordAssignment )* )? '}' -> ^( RECORD ( recordAssignment )* ) ;\r
5534  */\r
5535 static SimanticsDataParser_record_return\r
5536 record(pSimanticsDataParser ctx)\r
5537 {   \r
5538     SimanticsDataParser_record_return retval;\r
5539 \r
5540     pANTLR3_BASE_TREE root_0;\r
5541 \r
5542     pANTLR3_COMMON_TOKEN    char_literal96;\r
5543     pANTLR3_COMMON_TOKEN    char_literal98;\r
5544     pANTLR3_COMMON_TOKEN    char_literal100;\r
5545     SimanticsDataParser_recordAssignment_return recordAssignment97;\r
5546     #undef      RETURN_TYPE_recordAssignment97\r
5547     #define     RETURN_TYPE_recordAssignment97 SimanticsDataParser_recordAssignment_return\r
5548 \r
5549     SimanticsDataParser_recordAssignment_return recordAssignment99;\r
5550     #undef      RETURN_TYPE_recordAssignment99\r
5551     #define     RETURN_TYPE_recordAssignment99 SimanticsDataParser_recordAssignment_return\r
5552 \r
5553     pANTLR3_BASE_TREE char_literal96_tree;\r
5554     pANTLR3_BASE_TREE char_literal98_tree;\r
5555     pANTLR3_BASE_TREE char_literal100_tree;\r
5556     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_43;\r
5557     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_44;\r
5558     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;\r
5559     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_recordAssignment;\r
5560     /* Initialize rule variables\r
5561      */\r
5562 \r
5563 \r
5564     root_0 = NULL;\r
5565 \r
5566     char_literal96       = NULL;\r
5567     char_literal98       = NULL;\r
5568     char_literal100       = NULL;\r
5569     recordAssignment97.tree = NULL;\r
5570 \r
5571     recordAssignment99.tree = NULL;\r
5572 \r
5573     retval.start = LT(1); retval.stop = retval.start;\r
5574 \r
5575     char_literal96_tree   = NULL;\r
5576     char_literal98_tree   = NULL;\r
5577     char_literal100_tree   = NULL;\r
5578 \r
5579     stream_43   = NULL;\r
5580     #define CREATE_stream_43  if (stream_43 == NULL) {stream_43 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 43"); } \r
5581     stream_44   = NULL;\r
5582     #define CREATE_stream_44  if (stream_44 == NULL) {stream_44 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 44"); } \r
5583     stream_41   = NULL;\r
5584     #define CREATE_stream_41  if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } \r
5585     stream_recordAssignment   = NULL;\r
5586     #define CREATE_stream_recordAssignment  if (stream_recordAssignment == NULL) {stream_recordAssignment = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule recordAssignment"); }\r
5587 \r
5588     retval.tree  = NULL;\r
5589     {\r
5590         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:5: ( '{' ( recordAssignment ( ',' recordAssignment )* )? '}' -> ^( RECORD ( recordAssignment )* ) )\r
5591         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:7: '{' ( recordAssignment ( ',' recordAssignment )* )? '}'\r
5592         {\r
5593             char_literal96 = (pANTLR3_COMMON_TOKEN) MATCHT(43, &FOLLOW_43_in_record1775); \r
5594             if  (HASEXCEPTION())\r
5595             {\r
5596                 goto rulerecordEx;\r
5597             }\r
5598              \r
5599             CREATE_stream_43; stream_43->add(stream_43, char_literal96, NULL);\r
5600 \r
5601 \r
5602             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:11: ( recordAssignment ( ',' recordAssignment )* )?\r
5603             {\r
5604                 int alt26=2;\r
5605                 switch ( LA(1) ) \r
5606                 {\r
5607                     case ID:\r
5608                         {\r
5609                                 alt26=1;\r
5610                         }\r
5611                         break;\r
5612                 }\r
5613 \r
5614                 switch (alt26) \r
5615                 {\r
5616                 case 1:\r
5617                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:12: recordAssignment ( ',' recordAssignment )*\r
5618                     {\r
5619                         FOLLOWPUSH(FOLLOW_recordAssignment_in_record1778);\r
5620                         recordAssignment97=recordAssignment(ctx);\r
5621 \r
5622                         FOLLOWPOP();\r
5623                         if  (HASEXCEPTION())\r
5624                         {\r
5625                             goto rulerecordEx;\r
5626                         }\r
5627 \r
5628                         CREATE_stream_recordAssignment; stream_recordAssignment->add(stream_recordAssignment, recordAssignment97.tree, NULL);\r
5629 \r
5630                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:29: ( ',' recordAssignment )*\r
5631 \r
5632                         for (;;)\r
5633                         {\r
5634                             int alt25=2;\r
5635                             switch ( LA(1) ) \r
5636                             {\r
5637                             case 41:\r
5638                                 {\r
5639                                         alt25=1;\r
5640                                 }\r
5641                                 break;\r
5642 \r
5643                             }\r
5644 \r
5645                             switch (alt25) \r
5646                             {\r
5647                                 case 1:\r
5648                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:30: ',' recordAssignment\r
5649                                     {\r
5650                                         char_literal98 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_record1781); \r
5651                                         if  (HASEXCEPTION())\r
5652                                         {\r
5653                                             goto rulerecordEx;\r
5654                                         }\r
5655                                          \r
5656                                         CREATE_stream_41; stream_41->add(stream_41, char_literal98, NULL);\r
5657 \r
5658                                         FOLLOWPUSH(FOLLOW_recordAssignment_in_record1783);\r
5659                                         recordAssignment99=recordAssignment(ctx);\r
5660 \r
5661                                         FOLLOWPOP();\r
5662                                         if  (HASEXCEPTION())\r
5663                                         {\r
5664                                             goto rulerecordEx;\r
5665                                         }\r
5666 \r
5667                                         CREATE_stream_recordAssignment; stream_recordAssignment->add(stream_recordAssignment, recordAssignment99.tree, NULL);\r
5668 \r
5669                                     }\r
5670                                     break;\r
5671 \r
5672                                 default:\r
5673                                     goto loop25;        /* break out of the loop */\r
5674                                     break;\r
5675                             }\r
5676                         }\r
5677                         loop25: ; /* Jump out to here if this rule does not match */\r
5678 \r
5679 \r
5680                     }\r
5681                     break;\r
5682 \r
5683                 }\r
5684             }\r
5685             char_literal100 = (pANTLR3_COMMON_TOKEN) MATCHT(44, &FOLLOW_44_in_record1789); \r
5686             if  (HASEXCEPTION())\r
5687             {\r
5688                 goto rulerecordEx;\r
5689             }\r
5690              \r
5691             CREATE_stream_44; stream_44->add(stream_44, char_literal100, NULL);\r
5692 \r
5693 \r
5694              \r
5695             /* AST REWRITE\r
5696              * elements          : recordAssignment\r
5697              * token labels      : \r
5698              * rule labels       : retval\r
5699              * token list labels : \r
5700              * rule list labels  : \r
5701              */\r
5702             {\r
5703                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
5704 \r
5705                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
5706 \r
5707                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5708                 retval.tree    = root_0;\r
5709                 // 222:5: -> ^( RECORD ( recordAssignment )* )\r
5710                 {\r
5711                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:222:8: ^( RECORD ( recordAssignment )* )\r
5712                     {\r
5713                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5714                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, RECORD, (pANTLR3_UINT8)"RECORD"), root_1));\r
5715 \r
5716                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:222:17: ( recordAssignment )*\r
5717                         {\r
5718                                 while ( (stream_recordAssignment != NULL && stream_recordAssignment->hasNext(stream_recordAssignment))  )\r
5719                                 {\r
5720                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_recordAssignment == NULL ? NULL : stream_recordAssignment->nextTree(stream_recordAssignment));\r
5721 \r
5722                                 }\r
5723                                 if (stream_recordAssignment != NULL) stream_recordAssignment->reset(stream_recordAssignment);\r
5724 \r
5725                         }\r
5726 \r
5727                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
5728                     }\r
5729 \r
5730                 }\r
5731 \r
5732                 retval.tree = root_0; // set result root\r
5733                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
5734 \r
5735 \r
5736             }\r
5737         }\r
5738 \r
5739     }\r
5740     \r
5741 \r
5742     // This is where rules clean up and exit\r
5743     //\r
5744     goto rulerecordEx; /* Prevent compiler warnings */\r
5745     rulerecordEx: ;\r
5746     retval.stop = LT(-1);\r
5747 \r
5748         retval.stop = LT(-1);\r
5749         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
5750         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
5751         if (stream_43 != NULL) stream_43->free(stream_43);\r
5752         if (stream_44 != NULL) stream_44->free(stream_44);\r
5753         if (stream_41 != NULL) stream_41->free(stream_41);\r
5754         if (stream_recordAssignment != NULL) stream_recordAssignment->free(stream_recordAssignment);\r
5755 \r
5756             if (HASEXCEPTION())\r
5757             {\r
5758                 PREPORTERROR();\r
5759                 PRECOVER();\r
5760                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
5761             }\r
5762 \r
5763 \r
5764     return retval;\r
5765 }\r
5766 /* $ANTLR end record */\r
5767 \r
5768 /** \r
5769  * $ANTLR start recordAssignment\r
5770  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:225:1: recordAssignment : ID '=' value -> ^( ASSIGNMENT ID value ) ;\r
5771  */\r
5772 static SimanticsDataParser_recordAssignment_return\r
5773 recordAssignment(pSimanticsDataParser ctx)\r
5774 {   \r
5775     SimanticsDataParser_recordAssignment_return retval;\r
5776 \r
5777     pANTLR3_BASE_TREE root_0;\r
5778 \r
5779     pANTLR3_COMMON_TOKEN    ID101;\r
5780     pANTLR3_COMMON_TOKEN    char_literal102;\r
5781     SimanticsDataParser_value_return value103;\r
5782     #undef      RETURN_TYPE_value103\r
5783     #define     RETURN_TYPE_value103 SimanticsDataParser_value_return\r
5784 \r
5785     pANTLR3_BASE_TREE ID101_tree;\r
5786     pANTLR3_BASE_TREE char_literal102_tree;\r
5787     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;\r
5788     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;\r
5789     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;\r
5790     /* Initialize rule variables\r
5791      */\r
5792 \r
5793 \r
5794     root_0 = NULL;\r
5795 \r
5796     ID101       = NULL;\r
5797     char_literal102       = NULL;\r
5798     value103.tree = NULL;\r
5799 \r
5800     retval.start = LT(1); retval.stop = retval.start;\r
5801 \r
5802     ID101_tree   = NULL;\r
5803     char_literal102_tree   = NULL;\r
5804 \r
5805     stream_ID   = NULL;\r
5806     #define CREATE_stream_ID  if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } \r
5807     stream_35   = NULL;\r
5808     #define CREATE_stream_35  if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } \r
5809     stream_value   = NULL;\r
5810     #define CREATE_stream_value  if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }\r
5811 \r
5812     retval.tree  = NULL;\r
5813     {\r
5814         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:226:5: ( ID '=' value -> ^( ASSIGNMENT ID value ) )\r
5815         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:226:7: ID '=' value\r
5816         {\r
5817             ID101 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_recordAssignment1821); \r
5818             if  (HASEXCEPTION())\r
5819             {\r
5820                 goto rulerecordAssignmentEx;\r
5821             }\r
5822              \r
5823             CREATE_stream_ID; stream_ID->add(stream_ID, ID101, NULL);\r
5824 \r
5825             char_literal102 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_recordAssignment1823); \r
5826             if  (HASEXCEPTION())\r
5827             {\r
5828                 goto rulerecordAssignmentEx;\r
5829             }\r
5830              \r
5831             CREATE_stream_35; stream_35->add(stream_35, char_literal102, NULL);\r
5832 \r
5833             FOLLOWPUSH(FOLLOW_value_in_recordAssignment1825);\r
5834             value103=value(ctx);\r
5835 \r
5836             FOLLOWPOP();\r
5837             if  (HASEXCEPTION())\r
5838             {\r
5839                 goto rulerecordAssignmentEx;\r
5840             }\r
5841 \r
5842             CREATE_stream_value; stream_value->add(stream_value, value103.tree, NULL);\r
5843 \r
5844              \r
5845             /* AST REWRITE\r
5846              * elements          : value, ID\r
5847              * token labels      : \r
5848              * rule labels       : retval\r
5849              * token list labels : \r
5850              * rule list labels  : \r
5851              */\r
5852             {\r
5853                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
5854 \r
5855                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
5856 \r
5857                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5858                 retval.tree    = root_0;\r
5859                 // 227:5: -> ^( ASSIGNMENT ID value )\r
5860                 {\r
5861                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:227:8: ^( ASSIGNMENT ID value )\r
5862                     {\r
5863                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
5864                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ASSIGNMENT, (pANTLR3_UINT8)"ASSIGNMENT"), root_1));\r
5865 \r
5866                         ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));\r
5867                         ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));\r
5868 \r
5869                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
5870                     }\r
5871 \r
5872                 }\r
5873 \r
5874                 retval.tree = root_0; // set result root\r
5875                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
5876 \r
5877 \r
5878             }\r
5879         }\r
5880 \r
5881     }\r
5882     \r
5883 \r
5884     // This is where rules clean up and exit\r
5885     //\r
5886     goto rulerecordAssignmentEx; /* Prevent compiler warnings */\r
5887     rulerecordAssignmentEx: ;\r
5888     retval.stop = LT(-1);\r
5889 \r
5890         retval.stop = LT(-1);\r
5891         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
5892         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
5893         if (stream_ID != NULL) stream_ID->free(stream_ID);\r
5894         if (stream_35 != NULL) stream_35->free(stream_35);\r
5895         if (stream_value != NULL) stream_value->free(stream_value);\r
5896 \r
5897             if (HASEXCEPTION())\r
5898             {\r
5899                 PREPORTERROR();\r
5900                 PRECOVER();\r
5901                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
5902             }\r
5903 \r
5904 \r
5905     return retval;\r
5906 }\r
5907 /* $ANTLR end recordAssignment */\r
5908 \r
5909 /** \r
5910  * $ANTLR start map\r
5911  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:1: map : 'map' '{' ( mapAssignment ( ',' mapAssignment )* )? '}' -> ^( MAP ( mapAssignment )* ) ;\r
5912  */\r
5913 static SimanticsDataParser_map_return\r
5914 map(pSimanticsDataParser ctx)\r
5915 {   \r
5916     SimanticsDataParser_map_return retval;\r
5917 \r
5918     pANTLR3_BASE_TREE root_0;\r
5919 \r
5920     pANTLR3_COMMON_TOKEN    string_literal104;\r
5921     pANTLR3_COMMON_TOKEN    char_literal105;\r
5922     pANTLR3_COMMON_TOKEN    char_literal107;\r
5923     pANTLR3_COMMON_TOKEN    char_literal109;\r
5924     SimanticsDataParser_mapAssignment_return mapAssignment106;\r
5925     #undef      RETURN_TYPE_mapAssignment106\r
5926     #define     RETURN_TYPE_mapAssignment106 SimanticsDataParser_mapAssignment_return\r
5927 \r
5928     SimanticsDataParser_mapAssignment_return mapAssignment108;\r
5929     #undef      RETURN_TYPE_mapAssignment108\r
5930     #define     RETURN_TYPE_mapAssignment108 SimanticsDataParser_mapAssignment_return\r
5931 \r
5932     pANTLR3_BASE_TREE string_literal104_tree;\r
5933     pANTLR3_BASE_TREE char_literal105_tree;\r
5934     pANTLR3_BASE_TREE char_literal107_tree;\r
5935     pANTLR3_BASE_TREE char_literal109_tree;\r
5936     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_49;\r
5937     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_43;\r
5938     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_44;\r
5939     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;\r
5940     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_mapAssignment;\r
5941     /* Initialize rule variables\r
5942      */\r
5943 \r
5944 \r
5945     root_0 = NULL;\r
5946 \r
5947     string_literal104       = NULL;\r
5948     char_literal105       = NULL;\r
5949     char_literal107       = NULL;\r
5950     char_literal109       = NULL;\r
5951     mapAssignment106.tree = NULL;\r
5952 \r
5953     mapAssignment108.tree = NULL;\r
5954 \r
5955     retval.start = LT(1); retval.stop = retval.start;\r
5956 \r
5957     string_literal104_tree   = NULL;\r
5958     char_literal105_tree   = NULL;\r
5959     char_literal107_tree   = NULL;\r
5960     char_literal109_tree   = NULL;\r
5961 \r
5962     stream_49   = NULL;\r
5963     #define CREATE_stream_49  if (stream_49 == NULL) {stream_49 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 49"); } \r
5964     stream_43   = NULL;\r
5965     #define CREATE_stream_43  if (stream_43 == NULL) {stream_43 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 43"); } \r
5966     stream_44   = NULL;\r
5967     #define CREATE_stream_44  if (stream_44 == NULL) {stream_44 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 44"); } \r
5968     stream_41   = NULL;\r
5969     #define CREATE_stream_41  if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } \r
5970     stream_mapAssignment   = NULL;\r
5971     #define CREATE_stream_mapAssignment  if (stream_mapAssignment == NULL) {stream_mapAssignment = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule mapAssignment"); }\r
5972 \r
5973     retval.tree  = NULL;\r
5974     {\r
5975         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:5: ( 'map' '{' ( mapAssignment ( ',' mapAssignment )* )? '}' -> ^( MAP ( mapAssignment )* ) )\r
5976         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:7: 'map' '{' ( mapAssignment ( ',' mapAssignment )* )? '}'\r
5977         {\r
5978             string_literal104 = (pANTLR3_COMMON_TOKEN) MATCHT(49, &FOLLOW_49_in_map1852); \r
5979             if  (HASEXCEPTION())\r
5980             {\r
5981                 goto rulemapEx;\r
5982             }\r
5983              \r
5984             CREATE_stream_49; stream_49->add(stream_49, string_literal104, NULL);\r
5985 \r
5986             char_literal105 = (pANTLR3_COMMON_TOKEN) MATCHT(43, &FOLLOW_43_in_map1854); \r
5987             if  (HASEXCEPTION())\r
5988             {\r
5989                 goto rulemapEx;\r
5990             }\r
5991              \r
5992             CREATE_stream_43; stream_43->add(stream_43, char_literal105, NULL);\r
5993 \r
5994 \r
5995             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:17: ( mapAssignment ( ',' mapAssignment )* )?\r
5996             {\r
5997                 int alt28=2;\r
5998                 switch ( LA(1) ) \r
5999                 {\r
6000                     case ID:\r
6001                     case INT:\r
6002                     case FLOAT:\r
6003                     case STRING:\r
6004                     case 37:\r
6005                     case 40:\r
6006                     case 43:\r
6007                     case 46:\r
6008                     case 47:\r
6009                     case 48:\r
6010                     case 49:\r
6011                         {\r
6012                                 alt28=1;\r
6013                         }\r
6014                         break;\r
6015                 }\r
6016 \r
6017                 switch (alt28) \r
6018                 {\r
6019                 case 1:\r
6020                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:18: mapAssignment ( ',' mapAssignment )*\r
6021                     {\r
6022                         FOLLOWPUSH(FOLLOW_mapAssignment_in_map1857);\r
6023                         mapAssignment106=mapAssignment(ctx);\r
6024 \r
6025                         FOLLOWPOP();\r
6026                         if  (HASEXCEPTION())\r
6027                         {\r
6028                             goto rulemapEx;\r
6029                         }\r
6030 \r
6031                         CREATE_stream_mapAssignment; stream_mapAssignment->add(stream_mapAssignment, mapAssignment106.tree, NULL);\r
6032 \r
6033                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:32: ( ',' mapAssignment )*\r
6034 \r
6035                         for (;;)\r
6036                         {\r
6037                             int alt27=2;\r
6038                             switch ( LA(1) ) \r
6039                             {\r
6040                             case 41:\r
6041                                 {\r
6042                                         alt27=1;\r
6043                                 }\r
6044                                 break;\r
6045 \r
6046                             }\r
6047 \r
6048                             switch (alt27) \r
6049                             {\r
6050                                 case 1:\r
6051                                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:33: ',' mapAssignment\r
6052                                     {\r
6053                                         char_literal107 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_map1860); \r
6054                                         if  (HASEXCEPTION())\r
6055                                         {\r
6056                                             goto rulemapEx;\r
6057                                         }\r
6058                                          \r
6059                                         CREATE_stream_41; stream_41->add(stream_41, char_literal107, NULL);\r
6060 \r
6061                                         FOLLOWPUSH(FOLLOW_mapAssignment_in_map1862);\r
6062                                         mapAssignment108=mapAssignment(ctx);\r
6063 \r
6064                                         FOLLOWPOP();\r
6065                                         if  (HASEXCEPTION())\r
6066                                         {\r
6067                                             goto rulemapEx;\r
6068                                         }\r
6069 \r
6070                                         CREATE_stream_mapAssignment; stream_mapAssignment->add(stream_mapAssignment, mapAssignment108.tree, NULL);\r
6071 \r
6072                                     }\r
6073                                     break;\r
6074 \r
6075                                 default:\r
6076                                     goto loop27;        /* break out of the loop */\r
6077                                     break;\r
6078                             }\r
6079                         }\r
6080                         loop27: ; /* Jump out to here if this rule does not match */\r
6081 \r
6082 \r
6083                     }\r
6084                     break;\r
6085 \r
6086                 }\r
6087             }\r
6088             char_literal109 = (pANTLR3_COMMON_TOKEN) MATCHT(44, &FOLLOW_44_in_map1868); \r
6089             if  (HASEXCEPTION())\r
6090             {\r
6091                 goto rulemapEx;\r
6092             }\r
6093              \r
6094             CREATE_stream_44; stream_44->add(stream_44, char_literal109, NULL);\r
6095 \r
6096 \r
6097              \r
6098             /* AST REWRITE\r
6099              * elements          : mapAssignment\r
6100              * token labels      : \r
6101              * rule labels       : retval\r
6102              * token list labels : \r
6103              * rule list labels  : \r
6104              */\r
6105             {\r
6106                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
6107 \r
6108                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
6109 \r
6110                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
6111                 retval.tree    = root_0;\r
6112                 // 231:5: -> ^( MAP ( mapAssignment )* )\r
6113                 {\r
6114                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:231:8: ^( MAP ( mapAssignment )* )\r
6115                     {\r
6116                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
6117                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, MAP, (pANTLR3_UINT8)"MAP"), root_1));\r
6118 \r
6119                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:231:14: ( mapAssignment )*\r
6120                         {\r
6121                                 while ( (stream_mapAssignment != NULL && stream_mapAssignment->hasNext(stream_mapAssignment))  )\r
6122                                 {\r
6123                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_mapAssignment == NULL ? NULL : stream_mapAssignment->nextTree(stream_mapAssignment));\r
6124 \r
6125                                 }\r
6126                                 if (stream_mapAssignment != NULL) stream_mapAssignment->reset(stream_mapAssignment);\r
6127 \r
6128                         }\r
6129 \r
6130                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
6131                     }\r
6132 \r
6133                 }\r
6134 \r
6135                 retval.tree = root_0; // set result root\r
6136                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
6137 \r
6138 \r
6139             }\r
6140         }\r
6141 \r
6142     }\r
6143     \r
6144 \r
6145     // This is where rules clean up and exit\r
6146     //\r
6147     goto rulemapEx; /* Prevent compiler warnings */\r
6148     rulemapEx: ;\r
6149     retval.stop = LT(-1);\r
6150 \r
6151         retval.stop = LT(-1);\r
6152         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
6153         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
6154         if (stream_49 != NULL) stream_49->free(stream_49);\r
6155         if (stream_43 != NULL) stream_43->free(stream_43);\r
6156         if (stream_44 != NULL) stream_44->free(stream_44);\r
6157         if (stream_41 != NULL) stream_41->free(stream_41);\r
6158         if (stream_mapAssignment != NULL) stream_mapAssignment->free(stream_mapAssignment);\r
6159 \r
6160             if (HASEXCEPTION())\r
6161             {\r
6162                 PREPORTERROR();\r
6163                 PRECOVER();\r
6164                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
6165             }\r
6166 \r
6167 \r
6168     return retval;\r
6169 }\r
6170 /* $ANTLR end map */\r
6171 \r
6172 /** \r
6173  * $ANTLR start mapAssignment\r
6174  * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:234:1: mapAssignment : value '=' value -> ^( ASSIGNMENT ( value )* ) ;\r
6175  */\r
6176 static SimanticsDataParser_mapAssignment_return\r
6177 mapAssignment(pSimanticsDataParser ctx)\r
6178 {   \r
6179     SimanticsDataParser_mapAssignment_return retval;\r
6180 \r
6181     pANTLR3_BASE_TREE root_0;\r
6182 \r
6183     pANTLR3_COMMON_TOKEN    char_literal111;\r
6184     SimanticsDataParser_value_return value110;\r
6185     #undef      RETURN_TYPE_value110\r
6186     #define     RETURN_TYPE_value110 SimanticsDataParser_value_return\r
6187 \r
6188     SimanticsDataParser_value_return value112;\r
6189     #undef      RETURN_TYPE_value112\r
6190     #define     RETURN_TYPE_value112 SimanticsDataParser_value_return\r
6191 \r
6192     pANTLR3_BASE_TREE char_literal111_tree;\r
6193     pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;\r
6194     pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;\r
6195     /* Initialize rule variables\r
6196      */\r
6197 \r
6198 \r
6199     root_0 = NULL;\r
6200 \r
6201     char_literal111       = NULL;\r
6202     value110.tree = NULL;\r
6203 \r
6204     value112.tree = NULL;\r
6205 \r
6206     retval.start = LT(1); retval.stop = retval.start;\r
6207 \r
6208     char_literal111_tree   = NULL;\r
6209 \r
6210     stream_35   = NULL;\r
6211     #define CREATE_stream_35  if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } \r
6212     stream_value   = NULL;\r
6213     #define CREATE_stream_value  if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }\r
6214 \r
6215     retval.tree  = NULL;\r
6216     {\r
6217         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:235:5: ( value '=' value -> ^( ASSIGNMENT ( value )* ) )\r
6218         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:235:7: value '=' value\r
6219         {\r
6220             FOLLOWPUSH(FOLLOW_value_in_mapAssignment1900);\r
6221             value110=value(ctx);\r
6222 \r
6223             FOLLOWPOP();\r
6224             if  (HASEXCEPTION())\r
6225             {\r
6226                 goto rulemapAssignmentEx;\r
6227             }\r
6228 \r
6229             CREATE_stream_value; stream_value->add(stream_value, value110.tree, NULL);\r
6230             char_literal111 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_mapAssignment1902); \r
6231             if  (HASEXCEPTION())\r
6232             {\r
6233                 goto rulemapAssignmentEx;\r
6234             }\r
6235              \r
6236             CREATE_stream_35; stream_35->add(stream_35, char_literal111, NULL);\r
6237 \r
6238             FOLLOWPUSH(FOLLOW_value_in_mapAssignment1904);\r
6239             value112=value(ctx);\r
6240 \r
6241             FOLLOWPOP();\r
6242             if  (HASEXCEPTION())\r
6243             {\r
6244                 goto rulemapAssignmentEx;\r
6245             }\r
6246 \r
6247             CREATE_stream_value; stream_value->add(stream_value, value112.tree, NULL);\r
6248 \r
6249              \r
6250             /* AST REWRITE\r
6251              * elements          : value\r
6252              * token labels      : \r
6253              * rule labels       : retval\r
6254              * token list labels : \r
6255              * rule list labels  : \r
6256              */\r
6257             {\r
6258                 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
6259 \r
6260                 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR,  RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
6261 \r
6262                 root_0                      = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
6263                 retval.tree    = root_0;\r
6264                 // 236:5: -> ^( ASSIGNMENT ( value )* )\r
6265                 {\r
6266                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:236:8: ^( ASSIGNMENT ( value )* )\r
6267                     {\r
6268                         pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
6269                         root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ASSIGNMENT, (pANTLR3_UINT8)"ASSIGNMENT"), root_1));\r
6270 \r
6271                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:236:21: ( value )*\r
6272                         {\r
6273                                 while ( (stream_value != NULL && stream_value->hasNext(stream_value))  )\r
6274                                 {\r
6275                                         ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));\r
6276 \r
6277                                 }\r
6278                                 if (stream_value != NULL) stream_value->reset(stream_value);\r
6279 \r
6280                         }\r
6281 \r
6282                         ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
6283                     }\r
6284 \r
6285                 }\r
6286 \r
6287                 retval.tree = root_0; // set result root\r
6288                 if (stream_retval != NULL) stream_retval->free(stream_retval);\r
6289 \r
6290 \r
6291             }\r
6292         }\r
6293 \r
6294     }\r
6295     \r
6296 \r
6297     // This is where rules clean up and exit\r
6298     //\r
6299     goto rulemapAssignmentEx; /* Prevent compiler warnings */\r
6300     rulemapAssignmentEx: ;\r
6301     retval.stop = LT(-1);\r
6302 \r
6303         retval.stop = LT(-1);\r
6304         retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
6305         ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
6306         if (stream_35 != NULL) stream_35->free(stream_35);\r
6307         if (stream_value != NULL) stream_value->free(stream_value);\r
6308 \r
6309             if (HASEXCEPTION())\r
6310             {\r
6311                 PREPORTERROR();\r
6312                 PRECOVER();\r
6313                 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
6314             }\r
6315 \r
6316 \r
6317     return retval;\r
6318 }\r
6319 /* $ANTLR end mapAssignment */\r
6320 /* End of parsing rules\r
6321  * ==============================================\r
6322  */\r
6323 \r
6324 /* ==============================================\r
6325  * Syntactic predicates\r
6326  */\r
6327 /* End of syntactic predicates\r
6328  * ==============================================\r
6329  */\r
6330 \r
6331  \r
6332  \r
6333 \r
6334 \r
6335 \r
6336 /* End of code\r
6337  * =============================================================================\r
6338  */\r