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

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