2 * This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23
\r
4 * - From the grammar source file : C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g
\r
5 * - On : 2010-03-26 13:33:27
\r
6 * - for the parser : SimanticsDataParserParser *
\r
7 * Editing it, at least manually, is not wise.
\r
9 * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.
\r
13 // [The "BSD licence"]
\r
14 // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
\r
15 // http://www.temporal-wave.com
\r
16 // http://www.linkedin.com/in/jimidle
\r
18 // All rights reserved.
\r
20 // Redistribution and use in source and binary forms, with or without
\r
21 // modification, are permitted provided that the following conditions
\r
23 // 1. Redistributions of source code must retain the above copyright
\r
24 // notice, this list of conditions and the following disclaimer.
\r
25 // 2. Redistributions in binary form must reproduce the above copyright
\r
26 // notice, this list of conditions and the following disclaimer in the
\r
27 // documentation and/or other materials provided with the distribution.
\r
28 // 3. The name of the author may not be used to endorse or promote products
\r
29 // derived from this software without specific prior written permission.
\r
31 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
\r
32 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
\r
33 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
\r
34 // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
\r
35 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
\r
36 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
\r
37 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
\r
38 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
\r
39 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
\r
40 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
42 /* -----------------------------------------
\r
43 * Include the ANTLR3 generated header file.
\r
45 #include "SimanticsDataParser.h"
\r
46 /* ----------------------------------------- */
\r
52 /* MACROS that hide the C interface implementations from the
\r
53 * generated code, which makes it a little more understandable to the human eye.
\r
54 * I am very much against using C pre-processor macros for function calls and bits
\r
55 * of code as you cannot see what is happening when single stepping in debuggers
\r
56 * and so on. The exception (in my book at least) is for generated code, where you are
\r
57 * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()
\r
58 * hides some indirect calls, but is always referring to the input stream. This is
\r
59 * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig
\r
60 * the runtime interfaces without changing the generated code too often, without
\r
61 * confusing the reader of the generated output, who may not wish to know the gory
\r
62 * details of the interface inheritance.
\r
67 /* Aids in accessing scopes for grammar programmers
\r
72 #define SCOPE_TYPE(scope) pSimanticsDataParser_##scope##_SCOPE
\r
73 #define SCOPE_STACK(scope) pSimanticsDataParser_##scope##Stack
\r
74 #define SCOPE_TOP(scope) ctx->pSimanticsDataParser_##scope##Top
\r
75 #define SCOPE_SIZE(scope) ctx->pSimanticsDataParser_##scope##Stack_limit
\r
76 #define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))
\r
78 /* Macros for accessing things in the parser
\r
83 #undef HAVEPARSEDRULE
\r
103 #undef PERRORRECOVERY
\r
106 #undef RECOVERFROMMISMATCHEDSET
\r
107 #undef RECOVERFROMMISMATCHEDELEMENT
\r
114 #define PARSER ctx->pParser
\r
115 #define RECOGNIZER PARSER->rec
\r
116 #define PSRSTATE RECOGNIZER->state
\r
117 #define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)
\r
118 #define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)
\r
119 #define INPUT PARSER->tstream
\r
120 #define STRSTREAM INPUT
\r
121 #define ISTREAM INPUT->istream
\r
122 #define INDEX() ISTREAM->index(INPUT->istream)
\r
123 #define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)
\r
124 #define EXCEPTION PSRSTATE->exception
\r
125 #define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)
\r
126 #define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)
\r
127 #define FOLLOWSTACK PSRSTATE->following
\r
128 #define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)
\r
129 #define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)
\r
130 #define PRECOVER() RECOGNIZER->recover(RECOGNIZER)
\r
131 #define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)
\r
132 #define LA(n) INPUT->istream->_LA(ISTREAM, n)
\r
133 #define LT(n) INPUT->_LT(INPUT, n)
\r
134 #define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)
\r
135 #define CONSUME() ISTREAM->consume(ISTREAM)
\r
136 #define MARK() ISTREAM->mark(ISTREAM)
\r
137 #define REWIND(m) ISTREAM->rewind(ISTREAM, m)
\r
138 #define REWINDLAST() ISTREAM->rewindLast(ISTREAM)
\r
139 #define SEEK(n) ISTREAM->seek(ISTREAM, n)
\r
140 #define PERRORRECOVERY PSRSTATE->errorRecovery
\r
141 #define FAILEDFLAG PSRSTATE->failed
\r
142 #define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)
\r
143 #define BACKTRACKING PSRSTATE->backtracking
\r
144 #define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)
\r
145 #define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)
\r
146 #define ADAPTOR ctx->adaptor
\r
147 #define RULEMEMO PSRSTATE->ruleMemo
\r
148 #define DBG RECOGNIZER->debugger
\r
150 #define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt
\r
152 /* The 4 tokens defined below may well clash with your own #defines or token types. If so
\r
153 * then for the present you must use different names for your defines as these are hard coded
\r
154 * in the code generator. It would be better not to use such names internally, and maybe
\r
155 * we can change this in a forthcoming release. I deliberately do not #undef these
\r
156 * here as this will at least give you a redefined error somewhere if they clash.
\r
158 #define UP ANTLR3_TOKEN_UP
\r
159 #define DOWN ANTLR3_TOKEN_DOWN
\r
160 #define EOR ANTLR3_TOKEN_EOR
\r
161 #define INVALID ANTLR3_TOKEN_INVALID
\r
164 /* =============================================================================
\r
165 * Functions to create and destroy scopes. First come the rule scopes, followed
\r
166 * by the global declared scopes.
\r
171 /* ============================================================================= */
\r
173 /* =============================================================================
\r
174 * Start of recognizer
\r
179 /** \brief Table of all token names in symbolic order, mainly used for
\r
182 pANTLR3_UINT8 SimanticsDataParserTokenNames[46+4]
\r
184 (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */
\r
185 (pANTLR3_UINT8) "<EOR>",
\r
186 (pANTLR3_UINT8) "<DOWN>",
\r
187 (pANTLR3_UINT8) "<UP>",
\r
188 (pANTLR3_UINT8) "TYPE_DEFINITIONS",
\r
189 (pANTLR3_UINT8) "TYPE_DEFINITION",
\r
190 (pANTLR3_UINT8) "UNION_TYPE",
\r
191 (pANTLR3_UINT8) "RECORD_TYPE",
\r
192 (pANTLR3_UINT8) "TUPLE_TYPE",
\r
193 (pANTLR3_UINT8) "ARRAY_TYPE",
\r
194 (pANTLR3_UINT8) "TYPE_REFERENCE",
\r
195 (pANTLR3_UINT8) "TYPE_ANNOTATION",
\r
196 (pANTLR3_UINT8) "TYPE_COMPONENT",
\r
197 (pANTLR3_UINT8) "VALUE_DEFINITIONS",
\r
198 (pANTLR3_UINT8) "VALUE_DEFINITION",
\r
199 (pANTLR3_UINT8) "NO_VALUE",
\r
200 (pANTLR3_UINT8) "VARIANT",
\r
201 (pANTLR3_UINT8) "ARRAY",
\r
202 (pANTLR3_UINT8) "TUPLE",
\r
203 (pANTLR3_UINT8) "TAGGED_VALUE",
\r
204 (pANTLR3_UINT8) "RECORD",
\r
205 (pANTLR3_UINT8) "MAP",
\r
206 (pANTLR3_UINT8) "ASSIGNMENT",
\r
207 (pANTLR3_UINT8) "ID",
\r
208 (pANTLR3_UINT8) "INT",
\r
209 (pANTLR3_UINT8) "EXPONENT",
\r
210 (pANTLR3_UINT8) "FLOAT",
\r
211 (pANTLR3_UINT8) "COMMENT",
\r
212 (pANTLR3_UINT8) "WS",
\r
213 (pANTLR3_UINT8) "ESC_SEQ",
\r
214 (pANTLR3_UINT8) "STRING",
\r
215 (pANTLR3_UINT8) "HEX_DIGIT",
\r
216 (pANTLR3_UINT8) "UNICODE_ESC",
\r
217 (pANTLR3_UINT8) "OCTAL_ESC",
\r
218 (pANTLR3_UINT8) "'type'",
\r
219 (pANTLR3_UINT8) "'='",
\r
220 (pANTLR3_UINT8) "'|'",
\r
221 (pANTLR3_UINT8) "'['",
\r
222 (pANTLR3_UINT8) "']'",
\r
223 (pANTLR3_UINT8) "'..'",
\r
224 (pANTLR3_UINT8) "'('",
\r
225 (pANTLR3_UINT8) "','",
\r
226 (pANTLR3_UINT8) "')'",
\r
227 (pANTLR3_UINT8) "'{'",
\r
228 (pANTLR3_UINT8) "'}'",
\r
229 (pANTLR3_UINT8) "':'",
\r
230 (pANTLR3_UINT8) "'true'",
\r
231 (pANTLR3_UINT8) "'false'",
\r
232 (pANTLR3_UINT8) "'null'",
\r
233 (pANTLR3_UINT8) "'map'"
\r
238 // Forward declare the locally static matching functions we have generated.
\r
240 static SimanticsDataParser_typeDefinitions_return typeDefinitions (pSimanticsDataParser ctx);
\r
241 static SimanticsDataParser_typeDefinition_return typeDefinition (pSimanticsDataParser ctx);
\r
242 static SimanticsDataParser_unionType_return unionType (pSimanticsDataParser ctx);
\r
243 static SimanticsDataParser_unionComponent_return unionComponent (pSimanticsDataParser ctx);
\r
244 static SimanticsDataParser_type_return type (pSimanticsDataParser ctx);
\r
245 static SimanticsDataParser_arrayLength_return arrayLength (pSimanticsDataParser ctx);
\r
246 static SimanticsDataParser_basicType_return basicType (pSimanticsDataParser ctx);
\r
247 static SimanticsDataParser_tupleType_return tupleType (pSimanticsDataParser ctx);
\r
248 static SimanticsDataParser_recordType_return recordType (pSimanticsDataParser ctx);
\r
249 static SimanticsDataParser_component_return component (pSimanticsDataParser ctx);
\r
250 static SimanticsDataParser_typeReference_return typeReference (pSimanticsDataParser ctx);
\r
251 static SimanticsDataParser_parameter_return parameter (pSimanticsDataParser ctx);
\r
252 static SimanticsDataParser_parameterValue_return parameterValue (pSimanticsDataParser ctx);
\r
253 static SimanticsDataParser_range_return range (pSimanticsDataParser ctx);
\r
254 static SimanticsDataParser_number_return number (pSimanticsDataParser ctx);
\r
255 static SimanticsDataParser_string_return string (pSimanticsDataParser ctx);
\r
256 static SimanticsDataParser_boolean_return boolean (pSimanticsDataParser ctx);
\r
257 static SimanticsDataParser_valueDefinitions_return valueDefinitions (pSimanticsDataParser ctx);
\r
258 static SimanticsDataParser_valueDefinition_return valueDefinition (pSimanticsDataParser ctx);
\r
259 static SimanticsDataParser_value_return value (pSimanticsDataParser ctx);
\r
260 static SimanticsDataParser_basicValue_return basicValue (pSimanticsDataParser ctx);
\r
261 static SimanticsDataParser_array_return array (pSimanticsDataParser ctx);
\r
262 static SimanticsDataParser_tuple_return tuple (pSimanticsDataParser ctx);
\r
263 static SimanticsDataParser_taggedValue_return taggedValue (pSimanticsDataParser ctx);
\r
264 static SimanticsDataParser_record_return record (pSimanticsDataParser ctx);
\r
265 static SimanticsDataParser_recordAssignment_return recordAssignment (pSimanticsDataParser ctx);
\r
266 static SimanticsDataParser_map_return map (pSimanticsDataParser ctx);
\r
267 static SimanticsDataParser_mapAssignment_return mapAssignment (pSimanticsDataParser ctx);
\r
268 static void SimanticsDataParserFree(pSimanticsDataParser ctx);
\r
269 /* For use in tree output where we are accumulating rule labels via label += ruleRef
\r
270 * we need a function that knows how to free a return scope when the list is destroyed.
\r
271 * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.
\r
273 static void ANTLR3_CDECL freeScope(void * scope)
\r
275 ANTLR3_FREE(scope);
\r
278 /** \brief Name of the grammar file that generated this code
\r
280 static const char fileName[] = "C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g";
\r
282 /** \brief Return the name of the grammar file that generated this code.
\r
284 static const char * getGrammarFileName()
\r
288 /** \brief Create a new SimanticsDataParser parser and return a context for it.
\r
290 * \param[in] instream Pointer to an input stream interface.
\r
292 * \return Pointer to new parser context upon success.
\r
294 ANTLR3_API pSimanticsDataParser
\r
295 SimanticsDataParserNew (pANTLR3_COMMON_TOKEN_STREAM instream)
\r
297 // See if we can create a new parser with the standard constructor
\r
299 return SimanticsDataParserNewSSD(instream, NULL);
\r
302 /** \brief Create a new SimanticsDataParser parser and return a context for it.
\r
304 * \param[in] instream Pointer to an input stream interface.
\r
306 * \return Pointer to new parser context upon success.
\r
308 ANTLR3_API pSimanticsDataParser
\r
309 SimanticsDataParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)
\r
311 pSimanticsDataParser ctx; /* Context structure we will build and return */
\r
313 ctx = (pSimanticsDataParser) ANTLR3_CALLOC(1, sizeof(SimanticsDataParser));
\r
317 // Failed to allocate memory for parser context
\r
322 /* -------------------------------------------------------------------
\r
323 * Memory for basic structure is allocated, now to fill in
\r
324 * the base ANTLR3 structures. We initialize the function pointers
\r
325 * for the standard ANTLR3 parser function set, but upon return
\r
326 * from here, the programmer may set the pointers to provide custom
\r
327 * implementations of each function.
\r
329 * We don't use the macros defined in SimanticsDataParser.h here, in order that you can get a sense
\r
330 * of what goes where.
\r
333 /* Create a base parser/recognizer, using the supplied token stream
\r
335 ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);
\r
336 /* Install the implementation of our SimanticsDataParser interface
\r
338 ctx->typeDefinitions = typeDefinitions;
\r
339 ctx->typeDefinition = typeDefinition;
\r
340 ctx->unionType = unionType;
\r
341 ctx->unionComponent = unionComponent;
\r
343 ctx->arrayLength = arrayLength;
\r
344 ctx->basicType = basicType;
\r
345 ctx->tupleType = tupleType;
\r
346 ctx->recordType = recordType;
\r
347 ctx->component = component;
\r
348 ctx->typeReference = typeReference;
\r
349 ctx->parameter = parameter;
\r
350 ctx->parameterValue = parameterValue;
\r
351 ctx->range = range;
\r
352 ctx->number = number;
\r
353 ctx->string = string;
\r
354 ctx->boolean = boolean;
\r
355 ctx->valueDefinitions = valueDefinitions;
\r
356 ctx->valueDefinition = valueDefinition;
\r
357 ctx->value = value;
\r
358 ctx->basicValue = basicValue;
\r
359 ctx->array = array;
\r
360 ctx->tuple = tuple;
\r
361 ctx->taggedValue = taggedValue;
\r
362 ctx->record = record;
\r
363 ctx->recordAssignment = recordAssignment;
\r
365 ctx->mapAssignment = mapAssignment;
\r
366 ctx->free = SimanticsDataParserFree;
\r
367 ctx->getGrammarFileName = getGrammarFileName;
\r
369 /* Install the scope pushing methods.
\r
371 ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);
\r
372 ctx->vectors = antlr3VectorFactoryNew(0);
\r
376 /* Install the token table
\r
378 PSRSTATE->tokenNames = SimanticsDataParserTokenNames;
\r
381 /* Return the newly built parser to the caller
\r
386 /** Free the parser resources
\r
389 SimanticsDataParserFree(pSimanticsDataParser ctx)
\r
391 /* Free any scope memory
\r
394 ctx->vectors->close(ctx->vectors);
\r
395 /* We created the adaptor so we must free it
\r
397 ADAPTOR->free(ADAPTOR);
\r
398 // Free this parser
\r
400 ctx->pParser->free(ctx->pParser);
\r
403 /* Everything is released, so we can return
\r
408 /** Return token names used by this parser
\r
410 * The returned pointer is used as an index into the token names table (using the token
\r
411 * number as the index).
\r
413 * \return Pointer to first char * in the table.
\r
415 static pANTLR3_UINT8 *getTokenNames()
\r
417 return SimanticsDataParserTokenNames;
\r
421 /* Declare the bitsets
\r
424 /** Bitset defining follow set for error recovery in rule state: FOLLOW_typeDefinition_in_typeDefinitions768 */
\r
425 static ANTLR3_BITWORD FOLLOW_typeDefinition_in_typeDefinitions768_bits[] = { ANTLR3_UINT64_LIT(0x0000000400000002) };
\r
426 static ANTLR3_BITSET_LIST FOLLOW_typeDefinition_in_typeDefinitions768 = { FOLLOW_typeDefinition_in_typeDefinitions768_bits, 1 };
\r
427 /** Bitset defining follow set for error recovery in rule state: FOLLOW_34_in_typeDefinition791 */
\r
428 static ANTLR3_BITWORD FOLLOW_34_in_typeDefinition791_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) };
\r
429 static ANTLR3_BITSET_LIST FOLLOW_34_in_typeDefinition791 = { FOLLOW_34_in_typeDefinition791_bits, 1 };
\r
430 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_typeDefinition793 */
\r
431 static ANTLR3_BITWORD FOLLOW_ID_in_typeDefinition793_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) };
\r
432 static ANTLR3_BITSET_LIST FOLLOW_ID_in_typeDefinition793 = { FOLLOW_ID_in_typeDefinition793_bits, 1 };
\r
433 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_typeDefinition795 */
\r
434 static ANTLR3_BITWORD FOLLOW_35_in_typeDefinition795_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) };
\r
435 static ANTLR3_BITSET_LIST FOLLOW_35_in_typeDefinition795 = { FOLLOW_35_in_typeDefinition795_bits, 1 };
\r
436 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_typeDefinition797 */
\r
437 static ANTLR3_BITWORD FOLLOW_unionType_in_typeDefinition797_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
438 static ANTLR3_BITSET_LIST FOLLOW_unionType_in_typeDefinition797 = { FOLLOW_unionType_in_typeDefinition797_bits, 1 };
\r
439 /** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_unionType829 */
\r
440 static ANTLR3_BITWORD FOLLOW_type_in_unionType829_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
441 static ANTLR3_BITSET_LIST FOLLOW_type_in_unionType829 = { FOLLOW_type_in_unionType829_bits, 1 };
\r
442 /** Bitset defining follow set for error recovery in rule state: FOLLOW_36_in_unionType838 */
\r
443 static ANTLR3_BITWORD FOLLOW_36_in_unionType838_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) };
\r
444 static ANTLR3_BITSET_LIST FOLLOW_36_in_unionType838 = { FOLLOW_36_in_unionType838_bits, 1 };
\r
445 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionComponent_in_unionType840 */
\r
446 static ANTLR3_BITWORD FOLLOW_unionComponent_in_unionType840_bits[] = { ANTLR3_UINT64_LIT(0x0000001000000002) };
\r
447 static ANTLR3_BITSET_LIST FOLLOW_unionComponent_in_unionType840 = { FOLLOW_unionComponent_in_unionType840_bits, 1 };
\r
448 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_unionComponent871 */
\r
449 static ANTLR3_BITWORD FOLLOW_ID_in_unionComponent871_bits[] = { ANTLR3_UINT64_LIT(0x0000090000800002) };
\r
450 static ANTLR3_BITSET_LIST FOLLOW_ID_in_unionComponent871 = { FOLLOW_ID_in_unionComponent871_bits, 1 };
\r
451 /** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_unionComponent873 */
\r
452 static ANTLR3_BITWORD FOLLOW_type_in_unionComponent873_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
453 static ANTLR3_BITSET_LIST FOLLOW_type_in_unionComponent873 = { FOLLOW_type_in_unionComponent873_bits, 1 };
\r
454 /** Bitset defining follow set for error recovery in rule state: FOLLOW_basicType_in_type900 */
\r
455 static ANTLR3_BITWORD FOLLOW_basicType_in_type900_bits[] = { ANTLR3_UINT64_LIT(0x0000002000000002) };
\r
456 static ANTLR3_BITSET_LIST FOLLOW_basicType_in_type900 = { FOLLOW_basicType_in_type900_bits, 1 };
\r
457 /** Bitset defining follow set for error recovery in rule state: FOLLOW_37_in_type914 */
\r
458 static ANTLR3_BITWORD FOLLOW_37_in_type914_bits[] = { ANTLR3_UINT64_LIT(0x000000C001000000) };
\r
459 static ANTLR3_BITSET_LIST FOLLOW_37_in_type914 = { FOLLOW_37_in_type914_bits, 1 };
\r
460 /** Bitset defining follow set for error recovery in rule state: FOLLOW_arrayLength_in_type916 */
\r
461 static ANTLR3_BITWORD FOLLOW_arrayLength_in_type916_bits[] = { ANTLR3_UINT64_LIT(0x0000004000000000) };
\r
462 static ANTLR3_BITSET_LIST FOLLOW_arrayLength_in_type916 = { FOLLOW_arrayLength_in_type916_bits, 1 };
\r
463 /** Bitset defining follow set for error recovery in rule state: FOLLOW_38_in_type919 */
\r
464 static ANTLR3_BITWORD FOLLOW_38_in_type919_bits[] = { ANTLR3_UINT64_LIT(0x0000002000000002) };
\r
465 static ANTLR3_BITSET_LIST FOLLOW_38_in_type919 = { FOLLOW_38_in_type919_bits, 1 };
\r
466 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength947 */
\r
467 static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength947_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
468 static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength947 = { FOLLOW_INT_in_arrayLength947_bits, 1 };
\r
469 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength955 */
\r
470 static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength955_bits[] = { ANTLR3_UINT64_LIT(0x0000008000000000) };
\r
471 static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength955 = { FOLLOW_INT_in_arrayLength955_bits, 1 };
\r
472 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_arrayLength957 */
\r
473 static ANTLR3_BITWORD FOLLOW_39_in_arrayLength957_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
474 static ANTLR3_BITSET_LIST FOLLOW_39_in_arrayLength957 = { FOLLOW_39_in_arrayLength957_bits, 1 };
\r
475 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_arrayLength965 */
\r
476 static ANTLR3_BITWORD FOLLOW_39_in_arrayLength965_bits[] = { ANTLR3_UINT64_LIT(0x0000000001000000) };
\r
477 static ANTLR3_BITSET_LIST FOLLOW_39_in_arrayLength965 = { FOLLOW_39_in_arrayLength965_bits, 1 };
\r
478 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength967 */
\r
479 static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength967_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
480 static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength967 = { FOLLOW_INT_in_arrayLength967_bits, 1 };
\r
481 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength976 */
\r
482 static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength976_bits[] = { ANTLR3_UINT64_LIT(0x0000008000000000) };
\r
483 static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength976 = { FOLLOW_INT_in_arrayLength976_bits, 1 };
\r
484 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_arrayLength978 */
\r
485 static ANTLR3_BITWORD FOLLOW_39_in_arrayLength978_bits[] = { ANTLR3_UINT64_LIT(0x0000000001000000) };
\r
486 static ANTLR3_BITSET_LIST FOLLOW_39_in_arrayLength978 = { FOLLOW_39_in_arrayLength978_bits, 1 };
\r
487 /** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength980 */
\r
488 static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength980_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
489 static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength980 = { FOLLOW_INT_in_arrayLength980_bits, 1 };
\r
490 /** Bitset defining follow set for error recovery in rule state: FOLLOW_tupleType_in_basicType998 */
\r
491 static ANTLR3_BITWORD FOLLOW_tupleType_in_basicType998_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
492 static ANTLR3_BITSET_LIST FOLLOW_tupleType_in_basicType998 = { FOLLOW_tupleType_in_basicType998_bits, 1 };
\r
493 /** Bitset defining follow set for error recovery in rule state: FOLLOW_recordType_in_basicType1006 */
\r
494 static ANTLR3_BITWORD FOLLOW_recordType_in_basicType1006_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
495 static ANTLR3_BITSET_LIST FOLLOW_recordType_in_basicType1006 = { FOLLOW_recordType_in_basicType1006_bits, 1 };
\r
496 /** Bitset defining follow set for error recovery in rule state: FOLLOW_typeReference_in_basicType1014 */
\r
497 static ANTLR3_BITWORD FOLLOW_typeReference_in_basicType1014_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
498 static ANTLR3_BITSET_LIST FOLLOW_typeReference_in_basicType1014 = { FOLLOW_typeReference_in_basicType1014_bits, 1 };
\r
499 /** Bitset defining follow set for error recovery in rule state: FOLLOW_40_in_tupleType1036 */
\r
500 static ANTLR3_BITWORD FOLLOW_40_in_tupleType1036_bits[] = { ANTLR3_UINT64_LIT(0x00000D1000800000) };
\r
501 static ANTLR3_BITSET_LIST FOLLOW_40_in_tupleType1036 = { FOLLOW_40_in_tupleType1036_bits, 1 };
\r
502 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_tupleType1039 */
\r
503 static ANTLR3_BITWORD FOLLOW_unionType_in_tupleType1039_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };
\r
504 static ANTLR3_BITSET_LIST FOLLOW_unionType_in_tupleType1039 = { FOLLOW_unionType_in_tupleType1039_bits, 1 };
\r
505 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_tupleType1042 */
\r
506 static ANTLR3_BITWORD FOLLOW_41_in_tupleType1042_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) };
\r
507 static ANTLR3_BITSET_LIST FOLLOW_41_in_tupleType1042 = { FOLLOW_41_in_tupleType1042_bits, 1 };
\r
508 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_tupleType1044 */
\r
509 static ANTLR3_BITWORD FOLLOW_unionType_in_tupleType1044_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };
\r
510 static ANTLR3_BITSET_LIST FOLLOW_unionType_in_tupleType1044 = { FOLLOW_unionType_in_tupleType1044_bits, 1 };
\r
511 /** Bitset defining follow set for error recovery in rule state: FOLLOW_42_in_tupleType1050 */
\r
512 static ANTLR3_BITWORD FOLLOW_42_in_tupleType1050_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
513 static ANTLR3_BITSET_LIST FOLLOW_42_in_tupleType1050 = { FOLLOW_42_in_tupleType1050_bits, 1 };
\r
514 /** Bitset defining follow set for error recovery in rule state: FOLLOW_43_in_recordType1083 */
\r
515 static ANTLR3_BITWORD FOLLOW_43_in_recordType1083_bits[] = { ANTLR3_UINT64_LIT(0x0000100000800000) };
\r
516 static ANTLR3_BITSET_LIST FOLLOW_43_in_recordType1083 = { FOLLOW_43_in_recordType1083_bits, 1 };
\r
517 /** Bitset defining follow set for error recovery in rule state: FOLLOW_component_in_recordType1086 */
\r
518 static ANTLR3_BITWORD FOLLOW_component_in_recordType1086_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) };
\r
519 static ANTLR3_BITSET_LIST FOLLOW_component_in_recordType1086 = { FOLLOW_component_in_recordType1086_bits, 1 };
\r
520 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_recordType1089 */
\r
521 static ANTLR3_BITWORD FOLLOW_41_in_recordType1089_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) };
\r
522 static ANTLR3_BITSET_LIST FOLLOW_41_in_recordType1089 = { FOLLOW_41_in_recordType1089_bits, 1 };
\r
523 /** Bitset defining follow set for error recovery in rule state: FOLLOW_component_in_recordType1091 */
\r
524 static ANTLR3_BITWORD FOLLOW_component_in_recordType1091_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) };
\r
525 static ANTLR3_BITSET_LIST FOLLOW_component_in_recordType1091 = { FOLLOW_component_in_recordType1091_bits, 1 };
\r
526 /** Bitset defining follow set for error recovery in rule state: FOLLOW_44_in_recordType1097 */
\r
527 static ANTLR3_BITWORD FOLLOW_44_in_recordType1097_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
528 static ANTLR3_BITSET_LIST FOLLOW_44_in_recordType1097 = { FOLLOW_44_in_recordType1097_bits, 1 };
\r
529 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_component1129 */
\r
530 static ANTLR3_BITWORD FOLLOW_ID_in_component1129_bits[] = { ANTLR3_UINT64_LIT(0x0000200000000000) };
\r
531 static ANTLR3_BITSET_LIST FOLLOW_ID_in_component1129 = { FOLLOW_ID_in_component1129_bits, 1 };
\r
532 /** Bitset defining follow set for error recovery in rule state: FOLLOW_45_in_component1131 */
\r
533 static ANTLR3_BITWORD FOLLOW_45_in_component1131_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) };
\r
534 static ANTLR3_BITSET_LIST FOLLOW_45_in_component1131 = { FOLLOW_45_in_component1131_bits, 1 };
\r
535 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_component1133 */
\r
536 static ANTLR3_BITWORD FOLLOW_unionType_in_component1133_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
537 static ANTLR3_BITSET_LIST FOLLOW_unionType_in_component1133 = { FOLLOW_unionType_in_component1133_bits, 1 };
\r
538 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_typeReference1167 */
\r
539 static ANTLR3_BITWORD FOLLOW_ID_in_typeReference1167_bits[] = { ANTLR3_UINT64_LIT(0x0000010000000002) };
\r
540 static ANTLR3_BITSET_LIST FOLLOW_ID_in_typeReference1167 = { FOLLOW_ID_in_typeReference1167_bits, 1 };
\r
541 /** Bitset defining follow set for error recovery in rule state: FOLLOW_40_in_typeReference1170 */
\r
542 static ANTLR3_BITWORD FOLLOW_40_in_typeReference1170_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) };
\r
543 static ANTLR3_BITSET_LIST FOLLOW_40_in_typeReference1170 = { FOLLOW_40_in_typeReference1170_bits, 1 };
\r
544 /** Bitset defining follow set for error recovery in rule state: FOLLOW_parameter_in_typeReference1172 */
\r
545 static ANTLR3_BITWORD FOLLOW_parameter_in_typeReference1172_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };
\r
546 static ANTLR3_BITSET_LIST FOLLOW_parameter_in_typeReference1172 = { FOLLOW_parameter_in_typeReference1172_bits, 1 };
\r
547 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_typeReference1175 */
\r
548 static ANTLR3_BITWORD FOLLOW_41_in_typeReference1175_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) };
\r
549 static ANTLR3_BITSET_LIST FOLLOW_41_in_typeReference1175 = { FOLLOW_41_in_typeReference1175_bits, 1 };
\r
550 /** Bitset defining follow set for error recovery in rule state: FOLLOW_parameter_in_typeReference1177 */
\r
551 static ANTLR3_BITWORD FOLLOW_parameter_in_typeReference1177_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };
\r
552 static ANTLR3_BITSET_LIST FOLLOW_parameter_in_typeReference1177 = { FOLLOW_parameter_in_typeReference1177_bits, 1 };
\r
553 /** Bitset defining follow set for error recovery in rule state: FOLLOW_42_in_typeReference1181 */
\r
554 static ANTLR3_BITWORD FOLLOW_42_in_typeReference1181_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
555 static ANTLR3_BITSET_LIST FOLLOW_42_in_typeReference1181 = { FOLLOW_42_in_typeReference1181_bits, 1 };
\r
556 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_parameter1217 */
\r
557 static ANTLR3_BITWORD FOLLOW_ID_in_parameter1217_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) };
\r
558 static ANTLR3_BITSET_LIST FOLLOW_ID_in_parameter1217 = { FOLLOW_ID_in_parameter1217_bits, 1 };
\r
559 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_parameter1219 */
\r
560 static ANTLR3_BITWORD FOLLOW_35_in_parameter1219_bits[] = { ANTLR3_UINT64_LIT(0x0000C12045000000) };
\r
561 static ANTLR3_BITSET_LIST FOLLOW_35_in_parameter1219 = { FOLLOW_35_in_parameter1219_bits, 1 };
\r
562 /** Bitset defining follow set for error recovery in rule state: FOLLOW_parameterValue_in_parameter1221 */
\r
563 static ANTLR3_BITWORD FOLLOW_parameterValue_in_parameter1221_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
564 static ANTLR3_BITSET_LIST FOLLOW_parameterValue_in_parameter1221 = { FOLLOW_parameterValue_in_parameter1221_bits, 1 };
\r
565 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_parameter1239 */
\r
566 static ANTLR3_BITWORD FOLLOW_unionType_in_parameter1239_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
567 static ANTLR3_BITSET_LIST FOLLOW_unionType_in_parameter1239 = { FOLLOW_unionType_in_parameter1239_bits, 1 };
\r
568 /** Bitset defining follow set for error recovery in rule state: FOLLOW_string_in_parameterValue1258 */
\r
569 static ANTLR3_BITWORD FOLLOW_string_in_parameterValue1258_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
570 static ANTLR3_BITSET_LIST FOLLOW_string_in_parameterValue1258 = { FOLLOW_string_in_parameterValue1258_bits, 1 };
\r
571 /** Bitset defining follow set for error recovery in rule state: FOLLOW_boolean_in_parameterValue1266 */
\r
572 static ANTLR3_BITWORD FOLLOW_boolean_in_parameterValue1266_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
573 static ANTLR3_BITSET_LIST FOLLOW_boolean_in_parameterValue1266 = { FOLLOW_boolean_in_parameterValue1266_bits, 1 };
\r
574 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_parameterValue1274 */
\r
575 static ANTLR3_BITWORD FOLLOW_number_in_parameterValue1274_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
576 static ANTLR3_BITSET_LIST FOLLOW_number_in_parameterValue1274 = { FOLLOW_number_in_parameterValue1274_bits, 1 };
\r
577 /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_parameterValue1282 */
\r
578 static ANTLR3_BITWORD FOLLOW_set_in_parameterValue1282_bits[] = { ANTLR3_UINT64_LIT(0x0000008005000000) };
\r
579 static ANTLR3_BITSET_LIST FOLLOW_set_in_parameterValue1282 = { FOLLOW_set_in_parameterValue1282_bits, 1 };
\r
580 /** Bitset defining follow set for error recovery in rule state: FOLLOW_range_in_parameterValue1290 */
\r
581 static ANTLR3_BITWORD FOLLOW_range_in_parameterValue1290_bits[] = { ANTLR3_UINT64_LIT(0x0000044000000000) };
\r
582 static ANTLR3_BITSET_LIST FOLLOW_range_in_parameterValue1290 = { FOLLOW_range_in_parameterValue1290_bits, 1 };
\r
583 /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_parameterValue1292 */
\r
584 static ANTLR3_BITWORD FOLLOW_set_in_parameterValue1292_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
585 static ANTLR3_BITSET_LIST FOLLOW_set_in_parameterValue1292 = { FOLLOW_set_in_parameterValue1292_bits, 1 };
\r
586 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1319 */
\r
587 static ANTLR3_BITWORD FOLLOW_number_in_range1319_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
588 static ANTLR3_BITSET_LIST FOLLOW_number_in_range1319 = { FOLLOW_number_in_range1319_bits, 1 };
\r
589 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1327 */
\r
590 static ANTLR3_BITWORD FOLLOW_number_in_range1327_bits[] = { ANTLR3_UINT64_LIT(0x0000008000000000) };
\r
591 static ANTLR3_BITSET_LIST FOLLOW_number_in_range1327 = { FOLLOW_number_in_range1327_bits, 1 };
\r
592 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_range1329 */
\r
593 static ANTLR3_BITWORD FOLLOW_39_in_range1329_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
594 static ANTLR3_BITSET_LIST FOLLOW_39_in_range1329 = { FOLLOW_39_in_range1329_bits, 1 };
\r
595 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_range1337 */
\r
596 static ANTLR3_BITWORD FOLLOW_39_in_range1337_bits[] = { ANTLR3_UINT64_LIT(0x0000000005000000) };
\r
597 static ANTLR3_BITSET_LIST FOLLOW_39_in_range1337 = { FOLLOW_39_in_range1337_bits, 1 };
\r
598 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1339 */
\r
599 static ANTLR3_BITWORD FOLLOW_number_in_range1339_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
600 static ANTLR3_BITSET_LIST FOLLOW_number_in_range1339 = { FOLLOW_number_in_range1339_bits, 1 };
\r
601 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1348 */
\r
602 static ANTLR3_BITWORD FOLLOW_number_in_range1348_bits[] = { ANTLR3_UINT64_LIT(0x0000008000000000) };
\r
603 static ANTLR3_BITSET_LIST FOLLOW_number_in_range1348 = { FOLLOW_number_in_range1348_bits, 1 };
\r
604 /** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_range1350 */
\r
605 static ANTLR3_BITWORD FOLLOW_39_in_range1350_bits[] = { ANTLR3_UINT64_LIT(0x0000000005000000) };
\r
606 static ANTLR3_BITSET_LIST FOLLOW_39_in_range1350 = { FOLLOW_39_in_range1350_bits, 1 };
\r
607 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1352 */
\r
608 static ANTLR3_BITWORD FOLLOW_number_in_range1352_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
609 static ANTLR3_BITSET_LIST FOLLOW_number_in_range1352 = { FOLLOW_number_in_range1352_bits, 1 };
\r
610 /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_number0 */
\r
611 static ANTLR3_BITWORD FOLLOW_set_in_number0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
612 static ANTLR3_BITSET_LIST FOLLOW_set_in_number0 = { FOLLOW_set_in_number0_bits, 1 };
\r
613 /** Bitset defining follow set for error recovery in rule state: FOLLOW_STRING_in_string1402 */
\r
614 static ANTLR3_BITWORD FOLLOW_STRING_in_string1402_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
615 static ANTLR3_BITSET_LIST FOLLOW_STRING_in_string1402 = { FOLLOW_STRING_in_string1402_bits, 1 };
\r
616 /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_boolean0 */
\r
617 static ANTLR3_BITWORD FOLLOW_set_in_boolean0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
618 static ANTLR3_BITSET_LIST FOLLOW_set_in_boolean0 = { FOLLOW_set_in_boolean0_bits, 1 };
\r
619 /** Bitset defining follow set for error recovery in rule state: FOLLOW_valueDefinition_in_valueDefinitions1447 */
\r
620 static ANTLR3_BITWORD FOLLOW_valueDefinition_in_valueDefinitions1447_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800002) };
\r
621 static ANTLR3_BITSET_LIST FOLLOW_valueDefinition_in_valueDefinitions1447 = { FOLLOW_valueDefinition_in_valueDefinitions1447_bits, 1 };
\r
622 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_valueDefinition1470 */
\r
623 static ANTLR3_BITWORD FOLLOW_ID_in_valueDefinition1470_bits[] = { ANTLR3_UINT64_LIT(0x0000200000000000) };
\r
624 static ANTLR3_BITSET_LIST FOLLOW_ID_in_valueDefinition1470 = { FOLLOW_ID_in_valueDefinition1470_bits, 1 };
\r
625 /** Bitset defining follow set for error recovery in rule state: FOLLOW_45_in_valueDefinition1472 */
\r
626 static ANTLR3_BITWORD FOLLOW_45_in_valueDefinition1472_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) };
\r
627 static ANTLR3_BITSET_LIST FOLLOW_45_in_valueDefinition1472 = { FOLLOW_45_in_valueDefinition1472_bits, 1 };
\r
628 /** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_valueDefinition1474 */
\r
629 static ANTLR3_BITWORD FOLLOW_unionType_in_valueDefinition1474_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) };
\r
630 static ANTLR3_BITSET_LIST FOLLOW_unionType_in_valueDefinition1474 = { FOLLOW_unionType_in_valueDefinition1474_bits, 1 };
\r
631 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_valueDefinition1476 */
\r
632 static ANTLR3_BITWORD FOLLOW_35_in_valueDefinition1476_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) };
\r
633 static ANTLR3_BITSET_LIST FOLLOW_35_in_valueDefinition1476 = { FOLLOW_35_in_valueDefinition1476_bits, 1 };
\r
634 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_valueDefinition1478 */
\r
635 static ANTLR3_BITWORD FOLLOW_value_in_valueDefinition1478_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
636 static ANTLR3_BITSET_LIST FOLLOW_value_in_valueDefinition1478 = { FOLLOW_value_in_valueDefinition1478_bits, 1 };
\r
637 /** Bitset defining follow set for error recovery in rule state: FOLLOW_basicValue_in_value1514 */
\r
638 static ANTLR3_BITWORD FOLLOW_basicValue_in_value1514_bits[] = { ANTLR3_UINT64_LIT(0x0000200000000002) };
\r
639 static ANTLR3_BITSET_LIST FOLLOW_basicValue_in_value1514 = { FOLLOW_basicValue_in_value1514_bits, 1 };
\r
640 /** Bitset defining follow set for error recovery in rule state: FOLLOW_45_in_value1528 */
\r
641 static ANTLR3_BITWORD FOLLOW_45_in_value1528_bits[] = { ANTLR3_UINT64_LIT(0x0000090000800000) };
\r
642 static ANTLR3_BITSET_LIST FOLLOW_45_in_value1528 = { FOLLOW_45_in_value1528_bits, 1 };
\r
643 /** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_value1530 */
\r
644 static ANTLR3_BITWORD FOLLOW_type_in_value1530_bits[] = { ANTLR3_UINT64_LIT(0x0000200000000002) };
\r
645 static ANTLR3_BITSET_LIST FOLLOW_type_in_value1530 = { FOLLOW_type_in_value1530_bits, 1 };
\r
646 /** Bitset defining follow set for error recovery in rule state: FOLLOW_48_in_basicValue1562 */
\r
647 static ANTLR3_BITWORD FOLLOW_48_in_basicValue1562_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
648 static ANTLR3_BITSET_LIST FOLLOW_48_in_basicValue1562 = { FOLLOW_48_in_basicValue1562_bits, 1 };
\r
649 /** Bitset defining follow set for error recovery in rule state: FOLLOW_string_in_basicValue1574 */
\r
650 static ANTLR3_BITWORD FOLLOW_string_in_basicValue1574_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
651 static ANTLR3_BITSET_LIST FOLLOW_string_in_basicValue1574 = { FOLLOW_string_in_basicValue1574_bits, 1 };
\r
652 /** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_basicValue1582 */
\r
653 static ANTLR3_BITWORD FOLLOW_number_in_basicValue1582_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
654 static ANTLR3_BITSET_LIST FOLLOW_number_in_basicValue1582 = { FOLLOW_number_in_basicValue1582_bits, 1 };
\r
655 /** Bitset defining follow set for error recovery in rule state: FOLLOW_boolean_in_basicValue1590 */
\r
656 static ANTLR3_BITWORD FOLLOW_boolean_in_basicValue1590_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
657 static ANTLR3_BITSET_LIST FOLLOW_boolean_in_basicValue1590 = { FOLLOW_boolean_in_basicValue1590_bits, 1 };
\r
658 /** Bitset defining follow set for error recovery in rule state: FOLLOW_array_in_basicValue1598 */
\r
659 static ANTLR3_BITWORD FOLLOW_array_in_basicValue1598_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
660 static ANTLR3_BITSET_LIST FOLLOW_array_in_basicValue1598 = { FOLLOW_array_in_basicValue1598_bits, 1 };
\r
661 /** Bitset defining follow set for error recovery in rule state: FOLLOW_tuple_in_basicValue1606 */
\r
662 static ANTLR3_BITWORD FOLLOW_tuple_in_basicValue1606_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
663 static ANTLR3_BITSET_LIST FOLLOW_tuple_in_basicValue1606 = { FOLLOW_tuple_in_basicValue1606_bits, 1 };
\r
664 /** Bitset defining follow set for error recovery in rule state: FOLLOW_taggedValue_in_basicValue1614 */
\r
665 static ANTLR3_BITWORD FOLLOW_taggedValue_in_basicValue1614_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
666 static ANTLR3_BITSET_LIST FOLLOW_taggedValue_in_basicValue1614 = { FOLLOW_taggedValue_in_basicValue1614_bits, 1 };
\r
667 /** Bitset defining follow set for error recovery in rule state: FOLLOW_map_in_basicValue1622 */
\r
668 static ANTLR3_BITWORD FOLLOW_map_in_basicValue1622_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
669 static ANTLR3_BITSET_LIST FOLLOW_map_in_basicValue1622 = { FOLLOW_map_in_basicValue1622_bits, 1 };
\r
670 /** Bitset defining follow set for error recovery in rule state: FOLLOW_record_in_basicValue1630 */
\r
671 static ANTLR3_BITWORD FOLLOW_record_in_basicValue1630_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
672 static ANTLR3_BITSET_LIST FOLLOW_record_in_basicValue1630 = { FOLLOW_record_in_basicValue1630_bits, 1 };
\r
673 /** Bitset defining follow set for error recovery in rule state: FOLLOW_37_in_array1648 */
\r
674 static ANTLR3_BITWORD FOLLOW_37_in_array1648_bits[] = { ANTLR3_UINT64_LIT(0x0003C96045800000) };
\r
675 static ANTLR3_BITSET_LIST FOLLOW_37_in_array1648 = { FOLLOW_37_in_array1648_bits, 1 };
\r
676 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_array1651 */
\r
677 static ANTLR3_BITWORD FOLLOW_value_in_array1651_bits[] = { ANTLR3_UINT64_LIT(0x0000024000000000) };
\r
678 static ANTLR3_BITSET_LIST FOLLOW_value_in_array1651 = { FOLLOW_value_in_array1651_bits, 1 };
\r
679 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_array1654 */
\r
680 static ANTLR3_BITWORD FOLLOW_41_in_array1654_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) };
\r
681 static ANTLR3_BITSET_LIST FOLLOW_41_in_array1654 = { FOLLOW_41_in_array1654_bits, 1 };
\r
682 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_array1656 */
\r
683 static ANTLR3_BITWORD FOLLOW_value_in_array1656_bits[] = { ANTLR3_UINT64_LIT(0x0000024000000000) };
\r
684 static ANTLR3_BITSET_LIST FOLLOW_value_in_array1656 = { FOLLOW_value_in_array1656_bits, 1 };
\r
685 /** Bitset defining follow set for error recovery in rule state: FOLLOW_38_in_array1662 */
\r
686 static ANTLR3_BITWORD FOLLOW_38_in_array1662_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
687 static ANTLR3_BITSET_LIST FOLLOW_38_in_array1662 = { FOLLOW_38_in_array1662_bits, 1 };
\r
688 /** Bitset defining follow set for error recovery in rule state: FOLLOW_40_in_tuple1694 */
\r
689 static ANTLR3_BITWORD FOLLOW_40_in_tuple1694_bits[] = { ANTLR3_UINT64_LIT(0x0003CD2045800000) };
\r
690 static ANTLR3_BITSET_LIST FOLLOW_40_in_tuple1694 = { FOLLOW_40_in_tuple1694_bits, 1 };
\r
691 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_tuple1697 */
\r
692 static ANTLR3_BITWORD FOLLOW_value_in_tuple1697_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };
\r
693 static ANTLR3_BITSET_LIST FOLLOW_value_in_tuple1697 = { FOLLOW_value_in_tuple1697_bits, 1 };
\r
694 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_tuple1700 */
\r
695 static ANTLR3_BITWORD FOLLOW_41_in_tuple1700_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) };
\r
696 static ANTLR3_BITSET_LIST FOLLOW_41_in_tuple1700 = { FOLLOW_41_in_tuple1700_bits, 1 };
\r
697 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_tuple1702 */
\r
698 static ANTLR3_BITWORD FOLLOW_value_in_tuple1702_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) };
\r
699 static ANTLR3_BITSET_LIST FOLLOW_value_in_tuple1702 = { FOLLOW_value_in_tuple1702_bits, 1 };
\r
700 /** Bitset defining follow set for error recovery in rule state: FOLLOW_42_in_tuple1708 */
\r
701 static ANTLR3_BITWORD FOLLOW_42_in_tuple1708_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
702 static ANTLR3_BITSET_LIST FOLLOW_42_in_tuple1708 = { FOLLOW_42_in_tuple1708_bits, 1 };
\r
703 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_taggedValue1740 */
\r
704 static ANTLR3_BITWORD FOLLOW_ID_in_taggedValue1740_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) };
\r
705 static ANTLR3_BITSET_LIST FOLLOW_ID_in_taggedValue1740 = { FOLLOW_ID_in_taggedValue1740_bits, 1 };
\r
706 /** Bitset defining follow set for error recovery in rule state: FOLLOW_basicValue_in_taggedValue1742 */
\r
707 static ANTLR3_BITWORD FOLLOW_basicValue_in_taggedValue1742_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
708 static ANTLR3_BITSET_LIST FOLLOW_basicValue_in_taggedValue1742 = { FOLLOW_basicValue_in_taggedValue1742_bits, 1 };
\r
709 /** Bitset defining follow set for error recovery in rule state: FOLLOW_43_in_record1775 */
\r
710 static ANTLR3_BITWORD FOLLOW_43_in_record1775_bits[] = { ANTLR3_UINT64_LIT(0x0000100000800000) };
\r
711 static ANTLR3_BITSET_LIST FOLLOW_43_in_record1775 = { FOLLOW_43_in_record1775_bits, 1 };
\r
712 /** Bitset defining follow set for error recovery in rule state: FOLLOW_recordAssignment_in_record1778 */
\r
713 static ANTLR3_BITWORD FOLLOW_recordAssignment_in_record1778_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) };
\r
714 static ANTLR3_BITSET_LIST FOLLOW_recordAssignment_in_record1778 = { FOLLOW_recordAssignment_in_record1778_bits, 1 };
\r
715 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_record1781 */
\r
716 static ANTLR3_BITWORD FOLLOW_41_in_record1781_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) };
\r
717 static ANTLR3_BITSET_LIST FOLLOW_41_in_record1781 = { FOLLOW_41_in_record1781_bits, 1 };
\r
718 /** Bitset defining follow set for error recovery in rule state: FOLLOW_recordAssignment_in_record1783 */
\r
719 static ANTLR3_BITWORD FOLLOW_recordAssignment_in_record1783_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) };
\r
720 static ANTLR3_BITSET_LIST FOLLOW_recordAssignment_in_record1783 = { FOLLOW_recordAssignment_in_record1783_bits, 1 };
\r
721 /** Bitset defining follow set for error recovery in rule state: FOLLOW_44_in_record1789 */
\r
722 static ANTLR3_BITWORD FOLLOW_44_in_record1789_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
723 static ANTLR3_BITSET_LIST FOLLOW_44_in_record1789 = { FOLLOW_44_in_record1789_bits, 1 };
\r
724 /** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_recordAssignment1821 */
\r
725 static ANTLR3_BITWORD FOLLOW_ID_in_recordAssignment1821_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) };
\r
726 static ANTLR3_BITSET_LIST FOLLOW_ID_in_recordAssignment1821 = { FOLLOW_ID_in_recordAssignment1821_bits, 1 };
\r
727 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_recordAssignment1823 */
\r
728 static ANTLR3_BITWORD FOLLOW_35_in_recordAssignment1823_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) };
\r
729 static ANTLR3_BITSET_LIST FOLLOW_35_in_recordAssignment1823 = { FOLLOW_35_in_recordAssignment1823_bits, 1 };
\r
730 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_recordAssignment1825 */
\r
731 static ANTLR3_BITWORD FOLLOW_value_in_recordAssignment1825_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
732 static ANTLR3_BITSET_LIST FOLLOW_value_in_recordAssignment1825 = { FOLLOW_value_in_recordAssignment1825_bits, 1 };
\r
733 /** Bitset defining follow set for error recovery in rule state: FOLLOW_49_in_map1852 */
\r
734 static ANTLR3_BITWORD FOLLOW_49_in_map1852_bits[] = { ANTLR3_UINT64_LIT(0x0000080000000000) };
\r
735 static ANTLR3_BITSET_LIST FOLLOW_49_in_map1852 = { FOLLOW_49_in_map1852_bits, 1 };
\r
736 /** Bitset defining follow set for error recovery in rule state: FOLLOW_43_in_map1854 */
\r
737 static ANTLR3_BITWORD FOLLOW_43_in_map1854_bits[] = { ANTLR3_UINT64_LIT(0x0003D92045800000) };
\r
738 static ANTLR3_BITSET_LIST FOLLOW_43_in_map1854 = { FOLLOW_43_in_map1854_bits, 1 };
\r
739 /** Bitset defining follow set for error recovery in rule state: FOLLOW_mapAssignment_in_map1857 */
\r
740 static ANTLR3_BITWORD FOLLOW_mapAssignment_in_map1857_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) };
\r
741 static ANTLR3_BITSET_LIST FOLLOW_mapAssignment_in_map1857 = { FOLLOW_mapAssignment_in_map1857_bits, 1 };
\r
742 /** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_map1860 */
\r
743 static ANTLR3_BITWORD FOLLOW_41_in_map1860_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) };
\r
744 static ANTLR3_BITSET_LIST FOLLOW_41_in_map1860 = { FOLLOW_41_in_map1860_bits, 1 };
\r
745 /** Bitset defining follow set for error recovery in rule state: FOLLOW_mapAssignment_in_map1862 */
\r
746 static ANTLR3_BITWORD FOLLOW_mapAssignment_in_map1862_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) };
\r
747 static ANTLR3_BITSET_LIST FOLLOW_mapAssignment_in_map1862 = { FOLLOW_mapAssignment_in_map1862_bits, 1 };
\r
748 /** Bitset defining follow set for error recovery in rule state: FOLLOW_44_in_map1868 */
\r
749 static ANTLR3_BITWORD FOLLOW_44_in_map1868_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
750 static ANTLR3_BITSET_LIST FOLLOW_44_in_map1868 = { FOLLOW_44_in_map1868_bits, 1 };
\r
751 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_mapAssignment1900 */
\r
752 static ANTLR3_BITWORD FOLLOW_value_in_mapAssignment1900_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) };
\r
753 static ANTLR3_BITSET_LIST FOLLOW_value_in_mapAssignment1900 = { FOLLOW_value_in_mapAssignment1900_bits, 1 };
\r
754 /** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_mapAssignment1902 */
\r
755 static ANTLR3_BITWORD FOLLOW_35_in_mapAssignment1902_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) };
\r
756 static ANTLR3_BITSET_LIST FOLLOW_35_in_mapAssignment1902 = { FOLLOW_35_in_mapAssignment1902_bits, 1 };
\r
757 /** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_mapAssignment1904 */
\r
758 static ANTLR3_BITWORD FOLLOW_value_in_mapAssignment1904_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };
\r
759 static ANTLR3_BITSET_LIST FOLLOW_value_in_mapAssignment1904 = { FOLLOW_value_in_mapAssignment1904_bits, 1 };
\r
764 /* ==============================================
\r
768 * $ANTLR start typeDefinitions
\r
769 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:1: typeDefinitions : ( typeDefinition )* -> ^( TYPE_DEFINITIONS ( typeDefinition )* ) ;
\r
771 static SimanticsDataParser_typeDefinitions_return
\r
772 typeDefinitions(pSimanticsDataParser ctx)
\r
774 SimanticsDataParser_typeDefinitions_return retval;
\r
776 pANTLR3_BASE_TREE root_0;
\r
778 SimanticsDataParser_typeDefinition_return typeDefinition1;
\r
779 #undef RETURN_TYPE_typeDefinition1
\r
780 #define RETURN_TYPE_typeDefinition1 SimanticsDataParser_typeDefinition_return
\r
782 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_typeDefinition;
\r
783 /* Initialize rule variables
\r
789 typeDefinition1.tree = NULL;
\r
791 retval.start = LT(1); retval.stop = retval.start;
\r
794 stream_typeDefinition = NULL;
\r
795 #define CREATE_stream_typeDefinition if (stream_typeDefinition == NULL) {stream_typeDefinition = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule typeDefinition"); }
\r
797 retval.tree = NULL;
\r
799 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:17: ( ( typeDefinition )* -> ^( TYPE_DEFINITIONS ( typeDefinition )* ) )
\r
800 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:19: ( typeDefinition )*
\r
803 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:19: ( typeDefinition )*
\r
821 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:19: typeDefinition
\r
823 FOLLOWPUSH(FOLLOW_typeDefinition_in_typeDefinitions768);
\r
824 typeDefinition1=typeDefinition(ctx);
\r
827 if (HASEXCEPTION())
\r
829 goto ruletypeDefinitionsEx;
\r
832 CREATE_stream_typeDefinition; stream_typeDefinition->add(stream_typeDefinition, typeDefinition1.tree, NULL);
\r
838 goto loop1; /* break out of the loop */
\r
842 loop1: ; /* Jump out to here if this rule does not match */
\r
847 * elements : typeDefinition
\r
849 * rule labels : retval
\r
850 * token list labels :
\r
851 * rule list labels :
\r
854 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
856 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
858 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
859 retval.tree = root_0;
\r
860 // 93:35: -> ^( TYPE_DEFINITIONS ( typeDefinition )* )
\r
862 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:38: ^( TYPE_DEFINITIONS ( typeDefinition )* )
\r
864 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
865 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_DEFINITIONS, (pANTLR3_UINT8)"TYPE_DEFINITIONS"), root_1));
\r
867 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:57: ( typeDefinition )*
\r
869 while ( (stream_typeDefinition != NULL && stream_typeDefinition->hasNext(stream_typeDefinition)) )
\r
871 ADAPTOR->addChild(ADAPTOR, root_1, stream_typeDefinition == NULL ? NULL : stream_typeDefinition->nextTree(stream_typeDefinition));
\r
874 if (stream_typeDefinition != NULL) stream_typeDefinition->reset(stream_typeDefinition);
\r
878 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
883 retval.tree = root_0; // set result root
\r
884 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
893 // This is where rules clean up and exit
\r
895 goto ruletypeDefinitionsEx; /* Prevent compiler warnings */
\r
896 ruletypeDefinitionsEx: ;
\r
897 retval.stop = LT(-1);
\r
899 retval.stop = LT(-1);
\r
900 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
901 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
902 if (stream_typeDefinition != NULL) stream_typeDefinition->free(stream_typeDefinition);
\r
904 if (HASEXCEPTION())
\r
908 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
914 /* $ANTLR end typeDefinitions */
\r
917 * $ANTLR start typeDefinition
\r
918 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:95:1: typeDefinition : 'type' ID '=' unionType -> ^( TYPE_DEFINITION ID unionType ) ;
\r
920 static SimanticsDataParser_typeDefinition_return
\r
921 typeDefinition(pSimanticsDataParser ctx)
\r
923 SimanticsDataParser_typeDefinition_return retval;
\r
925 pANTLR3_BASE_TREE root_0;
\r
927 pANTLR3_COMMON_TOKEN string_literal2;
\r
928 pANTLR3_COMMON_TOKEN ID3;
\r
929 pANTLR3_COMMON_TOKEN char_literal4;
\r
930 SimanticsDataParser_unionType_return unionType5;
\r
931 #undef RETURN_TYPE_unionType5
\r
932 #define RETURN_TYPE_unionType5 SimanticsDataParser_unionType_return
\r
934 pANTLR3_BASE_TREE string_literal2_tree;
\r
935 pANTLR3_BASE_TREE ID3_tree;
\r
936 pANTLR3_BASE_TREE char_literal4_tree;
\r
937 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;
\r
938 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;
\r
939 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_34;
\r
940 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType;
\r
941 /* Initialize rule variables
\r
947 string_literal2 = NULL;
\r
949 char_literal4 = NULL;
\r
950 unionType5.tree = NULL;
\r
952 retval.start = LT(1); retval.stop = retval.start;
\r
954 string_literal2_tree = NULL;
\r
956 char_literal4_tree = NULL;
\r
959 #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); }
\r
961 #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); }
\r
963 #define CREATE_stream_34 if (stream_34 == NULL) {stream_34 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 34"); }
\r
964 stream_unionType = NULL;
\r
965 #define CREATE_stream_unionType if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); }
\r
967 retval.tree = NULL;
\r
969 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:96:5: ( 'type' ID '=' unionType -> ^( TYPE_DEFINITION ID unionType ) )
\r
970 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:96:7: 'type' ID '=' unionType
\r
972 string_literal2 = (pANTLR3_COMMON_TOKEN) MATCHT(34, &FOLLOW_34_in_typeDefinition791);
\r
973 if (HASEXCEPTION())
\r
975 goto ruletypeDefinitionEx;
\r
978 CREATE_stream_34; stream_34->add(stream_34, string_literal2, NULL);
\r
980 ID3 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_typeDefinition793);
\r
981 if (HASEXCEPTION())
\r
983 goto ruletypeDefinitionEx;
\r
986 CREATE_stream_ID; stream_ID->add(stream_ID, ID3, NULL);
\r
988 char_literal4 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_typeDefinition795);
\r
989 if (HASEXCEPTION())
\r
991 goto ruletypeDefinitionEx;
\r
994 CREATE_stream_35; stream_35->add(stream_35, char_literal4, NULL);
\r
996 FOLLOWPUSH(FOLLOW_unionType_in_typeDefinition797);
\r
997 unionType5=unionType(ctx);
\r
1000 if (HASEXCEPTION())
\r
1002 goto ruletypeDefinitionEx;
\r
1005 CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType5.tree, NULL);
\r
1009 * elements : unionType, ID
\r
1011 * rule labels : retval
\r
1012 * token list labels :
\r
1013 * rule list labels :
\r
1016 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
1018 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
1020 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1021 retval.tree = root_0;
\r
1022 // 96:31: -> ^( TYPE_DEFINITION ID unionType )
\r
1024 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:96:34: ^( TYPE_DEFINITION ID unionType )
\r
1026 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1027 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_DEFINITION, (pANTLR3_UINT8)"TYPE_DEFINITION"), root_1));
\r
1029 ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));
\r
1030 ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType));
\r
1032 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
1037 retval.tree = root_0; // set result root
\r
1038 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
1047 // This is where rules clean up and exit
\r
1049 goto ruletypeDefinitionEx; /* Prevent compiler warnings */
\r
1050 ruletypeDefinitionEx: ;
\r
1051 retval.stop = LT(-1);
\r
1053 retval.stop = LT(-1);
\r
1054 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
1055 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
1056 if (stream_ID != NULL) stream_ID->free(stream_ID);
\r
1057 if (stream_35 != NULL) stream_35->free(stream_35);
\r
1058 if (stream_34 != NULL) stream_34->free(stream_34);
\r
1059 if (stream_unionType != NULL) stream_unionType->free(stream_unionType);
\r
1061 if (HASEXCEPTION())
\r
1065 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
1071 /* $ANTLR end typeDefinition */
\r
1074 * $ANTLR start unionType
\r
1075 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:99:1: unionType : ( type | ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) );
\r
1077 static SimanticsDataParser_unionType_return
\r
1078 unionType(pSimanticsDataParser ctx)
\r
1080 SimanticsDataParser_unionType_return retval;
\r
1082 pANTLR3_BASE_TREE root_0;
\r
1084 pANTLR3_COMMON_TOKEN char_literal7;
\r
1085 SimanticsDataParser_type_return type6;
\r
1086 #undef RETURN_TYPE_type6
\r
1087 #define RETURN_TYPE_type6 SimanticsDataParser_type_return
\r
1089 SimanticsDataParser_unionComponent_return unionComponent8;
\r
1090 #undef RETURN_TYPE_unionComponent8
\r
1091 #define RETURN_TYPE_unionComponent8 SimanticsDataParser_unionComponent_return
\r
1093 pANTLR3_BASE_TREE char_literal7_tree;
\r
1094 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_36;
\r
1095 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionComponent;
\r
1096 /* Initialize rule variables
\r
1102 char_literal7 = NULL;
\r
1103 type6.tree = NULL;
\r
1105 unionComponent8.tree = NULL;
\r
1107 retval.start = LT(1); retval.stop = retval.start;
\r
1109 char_literal7_tree = NULL;
\r
1112 #define CREATE_stream_36 if (stream_36 == NULL) {stream_36 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 36"); }
\r
1113 stream_unionComponent = NULL;
\r
1114 #define CREATE_stream_unionComponent if (stream_unionComponent == NULL) {stream_unionComponent = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionComponent"); }
\r
1116 retval.tree = NULL;
\r
1119 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:100:5: ( type | ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) )
\r
1121 ANTLR3_UINT32 alt3;
\r
1142 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
1143 EXCEPTION->message = (void *)"";
\r
1144 EXCEPTION->decisionNum = 3;
\r
1145 EXCEPTION->state = 0;
\r
1148 goto ruleunionTypeEx;
\r
1154 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:100:7: type
\r
1156 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1158 FOLLOWPUSH(FOLLOW_type_in_unionType829);
\r
1162 if (HASEXCEPTION())
\r
1164 goto ruleunionTypeEx;
\r
1167 ADAPTOR->addChild(ADAPTOR, root_0, type6.tree);
\r
1172 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:101:7: ( '|' unionComponent )+
\r
1174 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:101:7: ( '|' unionComponent )+
\r
1194 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:101:8: '|' unionComponent
\r
1196 char_literal7 = (pANTLR3_COMMON_TOKEN) MATCHT(36, &FOLLOW_36_in_unionType838);
\r
1197 if (HASEXCEPTION())
\r
1199 goto ruleunionTypeEx;
\r
1202 CREATE_stream_36; stream_36->add(stream_36, char_literal7, NULL);
\r
1204 FOLLOWPUSH(FOLLOW_unionComponent_in_unionType840);
\r
1205 unionComponent8=unionComponent(ctx);
\r
1208 if (HASEXCEPTION())
\r
1210 goto ruleunionTypeEx;
\r
1213 CREATE_stream_unionComponent; stream_unionComponent->add(stream_unionComponent, unionComponent8.tree, NULL);
\r
1224 /* mismatchedSetEx()
\r
1227 EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;
\r
1228 EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;
\r
1231 goto ruleunionTypeEx;
\r
1235 loop2: ; /* Jump to here if this rule does not match */
\r
1240 * elements : unionComponent
\r
1242 * rule labels : retval
\r
1243 * token list labels :
\r
1244 * rule list labels :
\r
1247 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
1249 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
1251 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1252 retval.tree = root_0;
\r
1253 // 102:5: -> ^( UNION_TYPE ( unionComponent )+ )
\r
1255 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:102:8: ^( UNION_TYPE ( unionComponent )+ )
\r
1257 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1258 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, UNION_TYPE, (pANTLR3_UINT8)"UNION_TYPE"), root_1));
\r
1260 if ((stream_unionComponent == NULL || !stream_unionComponent->hasNext(stream_unionComponent)) )
\r
1263 EXCEPTION->type = ANTLR3_REWRITE_EARLY_EXCEPTION;
\r
1264 EXCEPTION->name = (void *)ANTLR3_REWRITE_EARLY_EXCEPTION_NAME;
\r
1268 while ( (stream_unionComponent->hasNext(stream_unionComponent)) ) {
\r
1269 ADAPTOR->addChild(ADAPTOR, root_1, stream_unionComponent == NULL ? NULL : stream_unionComponent->nextTree(stream_unionComponent));
\r
1272 stream_unionComponent->reset(stream_unionComponent);
\r
1275 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
1280 retval.tree = root_0; // set result root
\r
1281 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
1293 // This is where rules clean up and exit
\r
1295 goto ruleunionTypeEx; /* Prevent compiler warnings */
\r
1296 ruleunionTypeEx: ;
\r
1297 retval.stop = LT(-1);
\r
1299 retval.stop = LT(-1);
\r
1300 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
1301 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
1302 if (stream_36 != NULL) stream_36->free(stream_36);
\r
1303 if (stream_unionComponent != NULL) stream_unionComponent->free(stream_unionComponent);
\r
1305 if (HASEXCEPTION())
\r
1309 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
1315 /* $ANTLR end unionType */
\r
1318 * $ANTLR start unionComponent
\r
1319 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:1: unionComponent : ID ( type )? -> ^( TYPE_COMPONENT ID ( type )? ) ;
\r
1321 static SimanticsDataParser_unionComponent_return
\r
1322 unionComponent(pSimanticsDataParser ctx)
\r
1324 SimanticsDataParser_unionComponent_return retval;
\r
1326 pANTLR3_BASE_TREE root_0;
\r
1328 pANTLR3_COMMON_TOKEN ID9;
\r
1329 SimanticsDataParser_type_return type10;
\r
1330 #undef RETURN_TYPE_type10
\r
1331 #define RETURN_TYPE_type10 SimanticsDataParser_type_return
\r
1333 pANTLR3_BASE_TREE ID9_tree;
\r
1334 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;
\r
1335 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_type;
\r
1336 /* Initialize rule variables
\r
1343 type10.tree = NULL;
\r
1345 retval.start = LT(1); retval.stop = retval.start;
\r
1350 #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); }
\r
1351 stream_type = NULL;
\r
1352 #define CREATE_stream_type if (stream_type == NULL) {stream_type = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule type"); }
\r
1354 retval.tree = NULL;
\r
1356 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:16: ( ID ( type )? -> ^( TYPE_COMPONENT ID ( type )? ) )
\r
1357 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:18: ID ( type )?
\r
1359 ID9 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_unionComponent871);
\r
1360 if (HASEXCEPTION())
\r
1362 goto ruleunionComponentEx;
\r
1365 CREATE_stream_ID; stream_ID->add(stream_ID, ID9, NULL);
\r
1368 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:21: ( type )?
\r
1385 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:21: type
\r
1387 FOLLOWPUSH(FOLLOW_type_in_unionComponent873);
\r
1391 if (HASEXCEPTION())
\r
1393 goto ruleunionComponentEx;
\r
1396 CREATE_stream_type; stream_type->add(stream_type, type10.tree, NULL);
\r
1406 * elements : ID, type
\r
1408 * rule labels : retval
\r
1409 * token list labels :
\r
1410 * rule list labels :
\r
1413 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
1415 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
1417 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1418 retval.tree = root_0;
\r
1419 // 105:27: -> ^( TYPE_COMPONENT ID ( type )? )
\r
1421 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:30: ^( TYPE_COMPONENT ID ( type )? )
\r
1423 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1424 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_COMPONENT, (pANTLR3_UINT8)"TYPE_COMPONENT"), root_1));
\r
1426 ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));
\r
1427 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:50: ( type )?
\r
1429 if ( (stream_type != NULL && stream_type->hasNext(stream_type)) )
\r
1431 ADAPTOR->addChild(ADAPTOR, root_1, stream_type == NULL ? NULL : stream_type->nextTree(stream_type));
\r
1434 if ( stream_type != NULL) stream_type->reset(stream_type);
\r
1438 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
1443 retval.tree = root_0; // set result root
\r
1444 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
1453 // This is where rules clean up and exit
\r
1455 goto ruleunionComponentEx; /* Prevent compiler warnings */
\r
1456 ruleunionComponentEx: ;
\r
1457 retval.stop = LT(-1);
\r
1459 retval.stop = LT(-1);
\r
1460 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
1461 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
1462 if (stream_ID != NULL) stream_ID->free(stream_ID);
\r
1463 if (stream_type != NULL) stream_type->free(stream_type);
\r
1465 if (HASEXCEPTION())
\r
1469 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
1475 /* $ANTLR end unionComponent */
\r
1478 * $ANTLR start type
\r
1479 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:107:1: type : ( basicType -> basicType ) ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )* ;
\r
1481 static SimanticsDataParser_type_return
\r
1482 type(pSimanticsDataParser ctx)
\r
1484 SimanticsDataParser_type_return retval;
\r
1486 pANTLR3_BASE_TREE root_0;
\r
1488 pANTLR3_COMMON_TOKEN char_literal12;
\r
1489 pANTLR3_COMMON_TOKEN char_literal14;
\r
1490 SimanticsDataParser_basicType_return basicType11;
\r
1491 #undef RETURN_TYPE_basicType11
\r
1492 #define RETURN_TYPE_basicType11 SimanticsDataParser_basicType_return
\r
1494 SimanticsDataParser_arrayLength_return arrayLength13;
\r
1495 #undef RETURN_TYPE_arrayLength13
\r
1496 #define RETURN_TYPE_arrayLength13 SimanticsDataParser_arrayLength_return
\r
1498 pANTLR3_BASE_TREE char_literal12_tree;
\r
1499 pANTLR3_BASE_TREE char_literal14_tree;
\r
1500 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_37;
\r
1501 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_38;
\r
1502 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_arrayLength;
\r
1503 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_basicType;
\r
1504 /* Initialize rule variables
\r
1510 char_literal12 = NULL;
\r
1511 char_literal14 = NULL;
\r
1512 basicType11.tree = NULL;
\r
1514 arrayLength13.tree = NULL;
\r
1516 retval.start = LT(1); retval.stop = retval.start;
\r
1518 char_literal12_tree = NULL;
\r
1519 char_literal14_tree = NULL;
\r
1522 #define CREATE_stream_37 if (stream_37 == NULL) {stream_37 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 37"); }
\r
1524 #define CREATE_stream_38 if (stream_38 == NULL) {stream_38 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 38"); }
\r
1525 stream_arrayLength = NULL;
\r
1526 #define CREATE_stream_arrayLength if (stream_arrayLength == NULL) {stream_arrayLength = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule arrayLength"); }
\r
1527 stream_basicType = NULL;
\r
1528 #define CREATE_stream_basicType if (stream_basicType == NULL) {stream_basicType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule basicType"); }
\r
1530 retval.tree = NULL;
\r
1532 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:5: ( ( basicType -> basicType ) ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )* )
\r
1533 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:7: ( basicType -> basicType ) ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )*
\r
1535 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:7: ( basicType -> basicType )
\r
1536 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:8: basicType
\r
1538 FOLLOWPUSH(FOLLOW_basicType_in_type900);
\r
1539 basicType11=basicType(ctx);
\r
1542 if (HASEXCEPTION())
\r
1547 CREATE_stream_basicType; stream_basicType->add(stream_basicType, basicType11.tree, NULL);
\r
1551 * elements : basicType
\r
1553 * rule labels : retval
\r
1554 * token list labels :
\r
1555 * rule list labels :
\r
1558 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
1560 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
1562 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1563 retval.tree = root_0;
\r
1564 // 108:18: -> basicType
\r
1566 ADAPTOR->addChild(ADAPTOR, root_0, stream_basicType == NULL ? NULL : stream_basicType->nextTree(stream_basicType));
\r
1570 retval.tree = root_0; // set result root
\r
1571 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
1578 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:7: ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )*
\r
1596 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:8: '[' ( arrayLength )? ']'
\r
1598 char_literal12 = (pANTLR3_COMMON_TOKEN) MATCHT(37, &FOLLOW_37_in_type914);
\r
1599 if (HASEXCEPTION())
\r
1604 CREATE_stream_37; stream_37->add(stream_37, char_literal12, NULL);
\r
1607 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:12: ( arrayLength )?
\r
1623 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:12: arrayLength
\r
1625 FOLLOWPUSH(FOLLOW_arrayLength_in_type916);
\r
1626 arrayLength13=arrayLength(ctx);
\r
1629 if (HASEXCEPTION())
\r
1634 CREATE_stream_arrayLength; stream_arrayLength->add(stream_arrayLength, arrayLength13.tree, NULL);
\r
1641 char_literal14 = (pANTLR3_COMMON_TOKEN) MATCHT(38, &FOLLOW_38_in_type919);
\r
1642 if (HASEXCEPTION())
\r
1647 CREATE_stream_38; stream_38->add(stream_38, char_literal14, NULL);
\r
1652 * elements : arrayLength, type
\r
1654 * rule labels : retval
\r
1655 * token list labels :
\r
1656 * rule list labels :
\r
1659 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
1661 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
1663 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1664 retval.tree = root_0;
\r
1665 // 109:29: -> ^( ARRAY_TYPE $type ( arrayLength )? )
\r
1667 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:32: ^( ARRAY_TYPE $type ( arrayLength )? )
\r
1669 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1670 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ARRAY_TYPE, (pANTLR3_UINT8)"ARRAY_TYPE"), root_1));
\r
1672 ADAPTOR->addChild(ADAPTOR, root_1, stream_retval == NULL ? NULL : stream_retval->nextTree(stream_retval));
\r
1673 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:51: ( arrayLength )?
\r
1675 if ( (stream_arrayLength != NULL && stream_arrayLength->hasNext(stream_arrayLength)) )
\r
1677 ADAPTOR->addChild(ADAPTOR, root_1, stream_arrayLength == NULL ? NULL : stream_arrayLength->nextTree(stream_arrayLength));
\r
1680 if ( stream_arrayLength != NULL) stream_arrayLength->reset(stream_arrayLength);
\r
1684 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
1689 retval.tree = root_0; // set result root
\r
1690 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
1698 goto loop6; /* break out of the loop */
\r
1702 loop6: ; /* Jump out to here if this rule does not match */
\r
1710 // This is where rules clean up and exit
\r
1712 goto ruletypeEx; /* Prevent compiler warnings */
\r
1714 retval.stop = LT(-1);
\r
1716 retval.stop = LT(-1);
\r
1717 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
1718 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
1719 if (stream_37 != NULL) stream_37->free(stream_37);
\r
1720 if (stream_38 != NULL) stream_38->free(stream_38);
\r
1721 if (stream_arrayLength != NULL) stream_arrayLength->free(stream_arrayLength);
\r
1722 if (stream_basicType != NULL) stream_basicType->free(stream_basicType);
\r
1724 if (HASEXCEPTION())
\r
1728 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
1734 /* $ANTLR end type */
\r
1737 * $ANTLR start arrayLength
\r
1738 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:111:1: arrayLength : ( INT | INT '..' | '..' INT | INT '..' INT );
\r
1740 static SimanticsDataParser_arrayLength_return
\r
1741 arrayLength(pSimanticsDataParser ctx)
\r
1743 SimanticsDataParser_arrayLength_return retval;
\r
1745 pANTLR3_BASE_TREE root_0;
\r
1747 pANTLR3_COMMON_TOKEN INT15;
\r
1748 pANTLR3_COMMON_TOKEN INT16;
\r
1749 pANTLR3_COMMON_TOKEN string_literal17;
\r
1750 pANTLR3_COMMON_TOKEN string_literal18;
\r
1751 pANTLR3_COMMON_TOKEN INT19;
\r
1752 pANTLR3_COMMON_TOKEN INT20;
\r
1753 pANTLR3_COMMON_TOKEN string_literal21;
\r
1754 pANTLR3_COMMON_TOKEN INT22;
\r
1756 pANTLR3_BASE_TREE INT15_tree;
\r
1757 pANTLR3_BASE_TREE INT16_tree;
\r
1758 pANTLR3_BASE_TREE string_literal17_tree;
\r
1759 pANTLR3_BASE_TREE string_literal18_tree;
\r
1760 pANTLR3_BASE_TREE INT19_tree;
\r
1761 pANTLR3_BASE_TREE INT20_tree;
\r
1762 pANTLR3_BASE_TREE string_literal21_tree;
\r
1763 pANTLR3_BASE_TREE INT22_tree;
\r
1765 /* Initialize rule variables
\r
1773 string_literal17 = NULL;
\r
1774 string_literal18 = NULL;
\r
1777 string_literal21 = NULL;
\r
1779 retval.start = LT(1); retval.stop = retval.start;
\r
1781 INT15_tree = NULL;
\r
1782 INT16_tree = NULL;
\r
1783 string_literal17_tree = NULL;
\r
1784 string_literal18_tree = NULL;
\r
1785 INT19_tree = NULL;
\r
1786 INT20_tree = NULL;
\r
1787 string_literal21_tree = NULL;
\r
1788 INT22_tree = NULL;
\r
1791 retval.tree = NULL;
\r
1794 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:112:5: ( INT | INT '..' | '..' INT | INT '..' INT )
\r
1796 ANTLR3_UINT32 alt7;
\r
1823 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
1824 EXCEPTION->message = (void *)"";
\r
1825 EXCEPTION->decisionNum = 7;
\r
1826 EXCEPTION->state = 3;
\r
1829 goto rulearrayLengthEx;
\r
1842 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
1843 EXCEPTION->message = (void *)"";
\r
1844 EXCEPTION->decisionNum = 7;
\r
1845 EXCEPTION->state = 1;
\r
1848 goto rulearrayLengthEx;
\r
1861 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
1862 EXCEPTION->message = (void *)"";
\r
1863 EXCEPTION->decisionNum = 7;
\r
1864 EXCEPTION->state = 0;
\r
1867 goto rulearrayLengthEx;
\r
1873 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:112:7: INT
\r
1875 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1877 INT15 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength947);
\r
1878 if (HASEXCEPTION())
\r
1880 goto rulearrayLengthEx;
\r
1883 INT15_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT15));
\r
1884 ADAPTOR->addChild(ADAPTOR, root_0, INT15_tree);
\r
1890 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:113:7: INT '..'
\r
1892 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1894 INT16 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength955);
\r
1895 if (HASEXCEPTION())
\r
1897 goto rulearrayLengthEx;
\r
1900 INT16_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT16));
\r
1901 ADAPTOR->addChild(ADAPTOR, root_0, INT16_tree);
\r
1903 string_literal17 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_arrayLength957);
\r
1904 if (HASEXCEPTION())
\r
1906 goto rulearrayLengthEx;
\r
1909 string_literal17_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal17));
\r
1910 ADAPTOR->addChild(ADAPTOR, root_0, string_literal17_tree);
\r
1916 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:114:7: '..' INT
\r
1918 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1920 string_literal18 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_arrayLength965);
\r
1921 if (HASEXCEPTION())
\r
1923 goto rulearrayLengthEx;
\r
1926 string_literal18_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal18));
\r
1927 ADAPTOR->addChild(ADAPTOR, root_0, string_literal18_tree);
\r
1929 INT19 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength967);
\r
1930 if (HASEXCEPTION())
\r
1932 goto rulearrayLengthEx;
\r
1935 INT19_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT19));
\r
1936 ADAPTOR->addChild(ADAPTOR, root_0, INT19_tree);
\r
1942 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:115:7: INT '..' INT
\r
1944 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
1946 INT20 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength976);
\r
1947 if (HASEXCEPTION())
\r
1949 goto rulearrayLengthEx;
\r
1952 INT20_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT20));
\r
1953 ADAPTOR->addChild(ADAPTOR, root_0, INT20_tree);
\r
1955 string_literal21 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_arrayLength978);
\r
1956 if (HASEXCEPTION())
\r
1958 goto rulearrayLengthEx;
\r
1961 string_literal21_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal21));
\r
1962 ADAPTOR->addChild(ADAPTOR, root_0, string_literal21_tree);
\r
1964 INT22 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength980);
\r
1965 if (HASEXCEPTION())
\r
1967 goto rulearrayLengthEx;
\r
1970 INT22_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT22));
\r
1971 ADAPTOR->addChild(ADAPTOR, root_0, INT22_tree);
\r
1982 // This is where rules clean up and exit
\r
1984 goto rulearrayLengthEx; /* Prevent compiler warnings */
\r
1985 rulearrayLengthEx: ;
\r
1986 retval.stop = LT(-1);
\r
1988 retval.stop = LT(-1);
\r
1989 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
1990 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
1992 if (HASEXCEPTION())
\r
1996 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
2002 /* $ANTLR end arrayLength */
\r
2005 * $ANTLR start basicType
\r
2006 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:118:1: basicType : ( tupleType | recordType | typeReference );
\r
2008 static SimanticsDataParser_basicType_return
\r
2009 basicType(pSimanticsDataParser ctx)
\r
2011 SimanticsDataParser_basicType_return retval;
\r
2013 pANTLR3_BASE_TREE root_0;
\r
2015 SimanticsDataParser_tupleType_return tupleType23;
\r
2016 #undef RETURN_TYPE_tupleType23
\r
2017 #define RETURN_TYPE_tupleType23 SimanticsDataParser_tupleType_return
\r
2019 SimanticsDataParser_recordType_return recordType24;
\r
2020 #undef RETURN_TYPE_recordType24
\r
2021 #define RETURN_TYPE_recordType24 SimanticsDataParser_recordType_return
\r
2023 SimanticsDataParser_typeReference_return typeReference25;
\r
2024 #undef RETURN_TYPE_typeReference25
\r
2025 #define RETURN_TYPE_typeReference25 SimanticsDataParser_typeReference_return
\r
2028 /* Initialize rule variables
\r
2034 tupleType23.tree = NULL;
\r
2036 recordType24.tree = NULL;
\r
2038 typeReference25.tree = NULL;
\r
2040 retval.start = LT(1); retval.stop = retval.start;
\r
2044 retval.tree = NULL;
\r
2047 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:119:5: ( tupleType | recordType | typeReference )
\r
2049 ANTLR3_UINT32 alt8;
\r
2073 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
2074 EXCEPTION->message = (void *)"";
\r
2075 EXCEPTION->decisionNum = 8;
\r
2076 EXCEPTION->state = 0;
\r
2079 goto rulebasicTypeEx;
\r
2085 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:119:7: tupleType
\r
2087 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2089 FOLLOWPUSH(FOLLOW_tupleType_in_basicType998);
\r
2090 tupleType23=tupleType(ctx);
\r
2093 if (HASEXCEPTION())
\r
2095 goto rulebasicTypeEx;
\r
2098 ADAPTOR->addChild(ADAPTOR, root_0, tupleType23.tree);
\r
2103 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:120:7: recordType
\r
2105 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2107 FOLLOWPUSH(FOLLOW_recordType_in_basicType1006);
\r
2108 recordType24=recordType(ctx);
\r
2111 if (HASEXCEPTION())
\r
2113 goto rulebasicTypeEx;
\r
2116 ADAPTOR->addChild(ADAPTOR, root_0, recordType24.tree);
\r
2121 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:121:7: typeReference
\r
2123 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2125 FOLLOWPUSH(FOLLOW_typeReference_in_basicType1014);
\r
2126 typeReference25=typeReference(ctx);
\r
2129 if (HASEXCEPTION())
\r
2131 goto rulebasicTypeEx;
\r
2134 ADAPTOR->addChild(ADAPTOR, root_0, typeReference25.tree);
\r
2144 // This is where rules clean up and exit
\r
2146 goto rulebasicTypeEx; /* Prevent compiler warnings */
\r
2147 rulebasicTypeEx: ;
\r
2148 retval.stop = LT(-1);
\r
2150 retval.stop = LT(-1);
\r
2151 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
2152 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
2154 if (HASEXCEPTION())
\r
2158 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
2164 /* $ANTLR end basicType */
\r
2167 * $ANTLR start tupleType
\r
2168 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:124:1: tupleType : '(' ( unionType ( ',' unionType )* )? ')' -> ^( TUPLE_TYPE ( unionType )* ) ;
\r
2170 static SimanticsDataParser_tupleType_return
\r
2171 tupleType(pSimanticsDataParser ctx)
\r
2173 SimanticsDataParser_tupleType_return retval;
\r
2175 pANTLR3_BASE_TREE root_0;
\r
2177 pANTLR3_COMMON_TOKEN char_literal26;
\r
2178 pANTLR3_COMMON_TOKEN char_literal28;
\r
2179 pANTLR3_COMMON_TOKEN char_literal30;
\r
2180 SimanticsDataParser_unionType_return unionType27;
\r
2181 #undef RETURN_TYPE_unionType27
\r
2182 #define RETURN_TYPE_unionType27 SimanticsDataParser_unionType_return
\r
2184 SimanticsDataParser_unionType_return unionType29;
\r
2185 #undef RETURN_TYPE_unionType29
\r
2186 #define RETURN_TYPE_unionType29 SimanticsDataParser_unionType_return
\r
2188 pANTLR3_BASE_TREE char_literal26_tree;
\r
2189 pANTLR3_BASE_TREE char_literal28_tree;
\r
2190 pANTLR3_BASE_TREE char_literal30_tree;
\r
2191 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_42;
\r
2192 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;
\r
2193 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_40;
\r
2194 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType;
\r
2195 /* Initialize rule variables
\r
2201 char_literal26 = NULL;
\r
2202 char_literal28 = NULL;
\r
2203 char_literal30 = NULL;
\r
2204 unionType27.tree = NULL;
\r
2206 unionType29.tree = NULL;
\r
2208 retval.start = LT(1); retval.stop = retval.start;
\r
2210 char_literal26_tree = NULL;
\r
2211 char_literal28_tree = NULL;
\r
2212 char_literal30_tree = NULL;
\r
2215 #define CREATE_stream_42 if (stream_42 == NULL) {stream_42 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 42"); }
\r
2217 #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); }
\r
2219 #define CREATE_stream_40 if (stream_40 == NULL) {stream_40 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 40"); }
\r
2220 stream_unionType = NULL;
\r
2221 #define CREATE_stream_unionType if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); }
\r
2223 retval.tree = NULL;
\r
2225 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:5: ( '(' ( unionType ( ',' unionType )* )? ')' -> ^( TUPLE_TYPE ( unionType )* ) )
\r
2226 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:7: '(' ( unionType ( ',' unionType )* )? ')'
\r
2228 char_literal26 = (pANTLR3_COMMON_TOKEN) MATCHT(40, &FOLLOW_40_in_tupleType1036);
\r
2229 if (HASEXCEPTION())
\r
2231 goto ruletupleTypeEx;
\r
2234 CREATE_stream_40; stream_40->add(stream_40, char_literal26, NULL);
\r
2237 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:11: ( unionType ( ',' unionType )* )?
\r
2255 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:12: unionType ( ',' unionType )*
\r
2257 FOLLOWPUSH(FOLLOW_unionType_in_tupleType1039);
\r
2258 unionType27=unionType(ctx);
\r
2261 if (HASEXCEPTION())
\r
2263 goto ruletupleTypeEx;
\r
2266 CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType27.tree, NULL);
\r
2268 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:22: ( ',' unionType )*
\r
2286 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:23: ',' unionType
\r
2288 char_literal28 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_tupleType1042);
\r
2289 if (HASEXCEPTION())
\r
2291 goto ruletupleTypeEx;
\r
2294 CREATE_stream_41; stream_41->add(stream_41, char_literal28, NULL);
\r
2296 FOLLOWPUSH(FOLLOW_unionType_in_tupleType1044);
\r
2297 unionType29=unionType(ctx);
\r
2300 if (HASEXCEPTION())
\r
2302 goto ruletupleTypeEx;
\r
2305 CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType29.tree, NULL);
\r
2311 goto loop9; /* break out of the loop */
\r
2315 loop9: ; /* Jump out to here if this rule does not match */
\r
2323 char_literal30 = (pANTLR3_COMMON_TOKEN) MATCHT(42, &FOLLOW_42_in_tupleType1050);
\r
2324 if (HASEXCEPTION())
\r
2326 goto ruletupleTypeEx;
\r
2329 CREATE_stream_42; stream_42->add(stream_42, char_literal30, NULL);
\r
2334 * elements : unionType
\r
2336 * rule labels : retval
\r
2337 * token list labels :
\r
2338 * rule list labels :
\r
2341 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
2343 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
2345 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2346 retval.tree = root_0;
\r
2347 // 126:5: -> ^( TUPLE_TYPE ( unionType )* )
\r
2349 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:126:8: ^( TUPLE_TYPE ( unionType )* )
\r
2351 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2352 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TUPLE_TYPE, (pANTLR3_UINT8)"TUPLE_TYPE"), root_1));
\r
2354 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:126:21: ( unionType )*
\r
2356 while ( (stream_unionType != NULL && stream_unionType->hasNext(stream_unionType)) )
\r
2358 ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType));
\r
2361 if (stream_unionType != NULL) stream_unionType->reset(stream_unionType);
\r
2365 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
2370 retval.tree = root_0; // set result root
\r
2371 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
2380 // This is where rules clean up and exit
\r
2382 goto ruletupleTypeEx; /* Prevent compiler warnings */
\r
2383 ruletupleTypeEx: ;
\r
2384 retval.stop = LT(-1);
\r
2386 retval.stop = LT(-1);
\r
2387 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
2388 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
2389 if (stream_42 != NULL) stream_42->free(stream_42);
\r
2390 if (stream_41 != NULL) stream_41->free(stream_41);
\r
2391 if (stream_40 != NULL) stream_40->free(stream_40);
\r
2392 if (stream_unionType != NULL) stream_unionType->free(stream_unionType);
\r
2394 if (HASEXCEPTION())
\r
2398 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
2404 /* $ANTLR end tupleType */
\r
2407 * $ANTLR start recordType
\r
2408 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:129:1: recordType : '{' ( component ( ',' component )* )? '}' -> ^( RECORD_TYPE ( component )* ) ;
\r
2410 static SimanticsDataParser_recordType_return
\r
2411 recordType(pSimanticsDataParser ctx)
\r
2413 SimanticsDataParser_recordType_return retval;
\r
2415 pANTLR3_BASE_TREE root_0;
\r
2417 pANTLR3_COMMON_TOKEN char_literal31;
\r
2418 pANTLR3_COMMON_TOKEN char_literal33;
\r
2419 pANTLR3_COMMON_TOKEN char_literal35;
\r
2420 SimanticsDataParser_component_return component32;
\r
2421 #undef RETURN_TYPE_component32
\r
2422 #define RETURN_TYPE_component32 SimanticsDataParser_component_return
\r
2424 SimanticsDataParser_component_return component34;
\r
2425 #undef RETURN_TYPE_component34
\r
2426 #define RETURN_TYPE_component34 SimanticsDataParser_component_return
\r
2428 pANTLR3_BASE_TREE char_literal31_tree;
\r
2429 pANTLR3_BASE_TREE char_literal33_tree;
\r
2430 pANTLR3_BASE_TREE char_literal35_tree;
\r
2431 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_43;
\r
2432 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_44;
\r
2433 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;
\r
2434 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_component;
\r
2435 /* Initialize rule variables
\r
2441 char_literal31 = NULL;
\r
2442 char_literal33 = NULL;
\r
2443 char_literal35 = NULL;
\r
2444 component32.tree = NULL;
\r
2446 component34.tree = NULL;
\r
2448 retval.start = LT(1); retval.stop = retval.start;
\r
2450 char_literal31_tree = NULL;
\r
2451 char_literal33_tree = NULL;
\r
2452 char_literal35_tree = NULL;
\r
2455 #define CREATE_stream_43 if (stream_43 == NULL) {stream_43 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 43"); }
\r
2457 #define CREATE_stream_44 if (stream_44 == NULL) {stream_44 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 44"); }
\r
2459 #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); }
\r
2460 stream_component = NULL;
\r
2461 #define CREATE_stream_component if (stream_component == NULL) {stream_component = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule component"); }
\r
2463 retval.tree = NULL;
\r
2465 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:5: ( '{' ( component ( ',' component )* )? '}' -> ^( RECORD_TYPE ( component )* ) )
\r
2466 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:7: '{' ( component ( ',' component )* )? '}'
\r
2468 char_literal31 = (pANTLR3_COMMON_TOKEN) MATCHT(43, &FOLLOW_43_in_recordType1083);
\r
2469 if (HASEXCEPTION())
\r
2471 goto rulerecordTypeEx;
\r
2474 CREATE_stream_43; stream_43->add(stream_43, char_literal31, NULL);
\r
2477 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:11: ( component ( ',' component )* )?
\r
2492 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:12: component ( ',' component )*
\r
2494 FOLLOWPUSH(FOLLOW_component_in_recordType1086);
\r
2495 component32=component(ctx);
\r
2498 if (HASEXCEPTION())
\r
2500 goto rulerecordTypeEx;
\r
2503 CREATE_stream_component; stream_component->add(stream_component, component32.tree, NULL);
\r
2505 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:22: ( ',' component )*
\r
2523 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:23: ',' component
\r
2525 char_literal33 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_recordType1089);
\r
2526 if (HASEXCEPTION())
\r
2528 goto rulerecordTypeEx;
\r
2531 CREATE_stream_41; stream_41->add(stream_41, char_literal33, NULL);
\r
2533 FOLLOWPUSH(FOLLOW_component_in_recordType1091);
\r
2534 component34=component(ctx);
\r
2537 if (HASEXCEPTION())
\r
2539 goto rulerecordTypeEx;
\r
2542 CREATE_stream_component; stream_component->add(stream_component, component34.tree, NULL);
\r
2548 goto loop11; /* break out of the loop */
\r
2552 loop11: ; /* Jump out to here if this rule does not match */
\r
2560 char_literal35 = (pANTLR3_COMMON_TOKEN) MATCHT(44, &FOLLOW_44_in_recordType1097);
\r
2561 if (HASEXCEPTION())
\r
2563 goto rulerecordTypeEx;
\r
2566 CREATE_stream_44; stream_44->add(stream_44, char_literal35, NULL);
\r
2571 * elements : component
\r
2573 * rule labels : retval
\r
2574 * token list labels :
\r
2575 * rule list labels :
\r
2578 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
2580 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
2582 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2583 retval.tree = root_0;
\r
2584 // 131:5: -> ^( RECORD_TYPE ( component )* )
\r
2586 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:131:8: ^( RECORD_TYPE ( component )* )
\r
2588 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2589 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, RECORD_TYPE, (pANTLR3_UINT8)"RECORD_TYPE"), root_1));
\r
2591 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:131:22: ( component )*
\r
2593 while ( (stream_component != NULL && stream_component->hasNext(stream_component)) )
\r
2595 ADAPTOR->addChild(ADAPTOR, root_1, stream_component == NULL ? NULL : stream_component->nextTree(stream_component));
\r
2598 if (stream_component != NULL) stream_component->reset(stream_component);
\r
2602 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
2607 retval.tree = root_0; // set result root
\r
2608 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
2617 // This is where rules clean up and exit
\r
2619 goto rulerecordTypeEx; /* Prevent compiler warnings */
\r
2620 rulerecordTypeEx: ;
\r
2621 retval.stop = LT(-1);
\r
2623 retval.stop = LT(-1);
\r
2624 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
2625 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
2626 if (stream_43 != NULL) stream_43->free(stream_43);
\r
2627 if (stream_44 != NULL) stream_44->free(stream_44);
\r
2628 if (stream_41 != NULL) stream_41->free(stream_41);
\r
2629 if (stream_component != NULL) stream_component->free(stream_component);
\r
2631 if (HASEXCEPTION())
\r
2635 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
2641 /* $ANTLR end recordType */
\r
2644 * $ANTLR start component
\r
2645 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:134:1: component : ID ':' unionType -> ^( TYPE_COMPONENT ID unionType ) ;
\r
2647 static SimanticsDataParser_component_return
\r
2648 component(pSimanticsDataParser ctx)
\r
2650 SimanticsDataParser_component_return retval;
\r
2652 pANTLR3_BASE_TREE root_0;
\r
2654 pANTLR3_COMMON_TOKEN ID36;
\r
2655 pANTLR3_COMMON_TOKEN char_literal37;
\r
2656 SimanticsDataParser_unionType_return unionType38;
\r
2657 #undef RETURN_TYPE_unionType38
\r
2658 #define RETURN_TYPE_unionType38 SimanticsDataParser_unionType_return
\r
2660 pANTLR3_BASE_TREE ID36_tree;
\r
2661 pANTLR3_BASE_TREE char_literal37_tree;
\r
2662 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_45;
\r
2663 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;
\r
2664 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType;
\r
2665 /* Initialize rule variables
\r
2672 char_literal37 = NULL;
\r
2673 unionType38.tree = NULL;
\r
2675 retval.start = LT(1); retval.stop = retval.start;
\r
2678 char_literal37_tree = NULL;
\r
2681 #define CREATE_stream_45 if (stream_45 == NULL) {stream_45 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 45"); }
\r
2683 #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); }
\r
2684 stream_unionType = NULL;
\r
2685 #define CREATE_stream_unionType if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); }
\r
2687 retval.tree = NULL;
\r
2689 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:135:5: ( ID ':' unionType -> ^( TYPE_COMPONENT ID unionType ) )
\r
2690 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:135:7: ID ':' unionType
\r
2692 ID36 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_component1129);
\r
2693 if (HASEXCEPTION())
\r
2695 goto rulecomponentEx;
\r
2698 CREATE_stream_ID; stream_ID->add(stream_ID, ID36, NULL);
\r
2700 char_literal37 = (pANTLR3_COMMON_TOKEN) MATCHT(45, &FOLLOW_45_in_component1131);
\r
2701 if (HASEXCEPTION())
\r
2703 goto rulecomponentEx;
\r
2706 CREATE_stream_45; stream_45->add(stream_45, char_literal37, NULL);
\r
2708 FOLLOWPUSH(FOLLOW_unionType_in_component1133);
\r
2709 unionType38=unionType(ctx);
\r
2712 if (HASEXCEPTION())
\r
2714 goto rulecomponentEx;
\r
2717 CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType38.tree, NULL);
\r
2721 * elements : ID, unionType
\r
2723 * rule labels : retval
\r
2724 * token list labels :
\r
2725 * rule list labels :
\r
2728 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
2730 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
2732 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2733 retval.tree = root_0;
\r
2734 // 136:5: -> ^( TYPE_COMPONENT ID unionType )
\r
2736 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:136:8: ^( TYPE_COMPONENT ID unionType )
\r
2738 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2739 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_COMPONENT, (pANTLR3_UINT8)"TYPE_COMPONENT"), root_1));
\r
2741 ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));
\r
2742 ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType));
\r
2744 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
2749 retval.tree = root_0; // set result root
\r
2750 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
2759 // This is where rules clean up and exit
\r
2761 goto rulecomponentEx; /* Prevent compiler warnings */
\r
2762 rulecomponentEx: ;
\r
2763 retval.stop = LT(-1);
\r
2765 retval.stop = LT(-1);
\r
2766 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
2767 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
2768 if (stream_45 != NULL) stream_45->free(stream_45);
\r
2769 if (stream_ID != NULL) stream_ID->free(stream_ID);
\r
2770 if (stream_unionType != NULL) stream_unionType->free(stream_unionType);
\r
2772 if (HASEXCEPTION())
\r
2776 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
2782 /* $ANTLR end component */
\r
2785 * $ANTLR start typeReference
\r
2786 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:139:1: typeReference : ID ( '(' parameter ( ',' parameter )* ')' )? -> ^( TYPE_REFERENCE ID ( parameter )* ) ;
\r
2788 static SimanticsDataParser_typeReference_return
\r
2789 typeReference(pSimanticsDataParser ctx)
\r
2791 SimanticsDataParser_typeReference_return retval;
\r
2793 pANTLR3_BASE_TREE root_0;
\r
2795 pANTLR3_COMMON_TOKEN ID39;
\r
2796 pANTLR3_COMMON_TOKEN char_literal40;
\r
2797 pANTLR3_COMMON_TOKEN char_literal42;
\r
2798 pANTLR3_COMMON_TOKEN char_literal44;
\r
2799 SimanticsDataParser_parameter_return parameter41;
\r
2800 #undef RETURN_TYPE_parameter41
\r
2801 #define RETURN_TYPE_parameter41 SimanticsDataParser_parameter_return
\r
2803 SimanticsDataParser_parameter_return parameter43;
\r
2804 #undef RETURN_TYPE_parameter43
\r
2805 #define RETURN_TYPE_parameter43 SimanticsDataParser_parameter_return
\r
2807 pANTLR3_BASE_TREE ID39_tree;
\r
2808 pANTLR3_BASE_TREE char_literal40_tree;
\r
2809 pANTLR3_BASE_TREE char_literal42_tree;
\r
2810 pANTLR3_BASE_TREE char_literal44_tree;
\r
2811 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_42;
\r
2812 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;
\r
2813 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_40;
\r
2814 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;
\r
2815 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_parameter;
\r
2816 /* Initialize rule variables
\r
2823 char_literal40 = NULL;
\r
2824 char_literal42 = NULL;
\r
2825 char_literal44 = NULL;
\r
2826 parameter41.tree = NULL;
\r
2828 parameter43.tree = NULL;
\r
2830 retval.start = LT(1); retval.stop = retval.start;
\r
2833 char_literal40_tree = NULL;
\r
2834 char_literal42_tree = NULL;
\r
2835 char_literal44_tree = NULL;
\r
2838 #define CREATE_stream_42 if (stream_42 == NULL) {stream_42 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 42"); }
\r
2840 #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); }
\r
2842 #define CREATE_stream_40 if (stream_40 == NULL) {stream_40 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 40"); }
\r
2844 #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); }
\r
2845 stream_parameter = NULL;
\r
2846 #define CREATE_stream_parameter if (stream_parameter == NULL) {stream_parameter = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule parameter"); }
\r
2848 retval.tree = NULL;
\r
2850 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:5: ( ID ( '(' parameter ( ',' parameter )* ')' )? -> ^( TYPE_REFERENCE ID ( parameter )* ) )
\r
2851 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:7: ID ( '(' parameter ( ',' parameter )* ')' )?
\r
2853 ID39 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_typeReference1167);
\r
2854 if (HASEXCEPTION())
\r
2856 goto ruletypeReferenceEx;
\r
2859 CREATE_stream_ID; stream_ID->add(stream_ID, ID39, NULL);
\r
2862 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:10: ( '(' parameter ( ',' parameter )* ')' )?
\r
2877 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:11: '(' parameter ( ',' parameter )* ')'
\r
2879 char_literal40 = (pANTLR3_COMMON_TOKEN) MATCHT(40, &FOLLOW_40_in_typeReference1170);
\r
2880 if (HASEXCEPTION())
\r
2882 goto ruletypeReferenceEx;
\r
2885 CREATE_stream_40; stream_40->add(stream_40, char_literal40, NULL);
\r
2887 FOLLOWPUSH(FOLLOW_parameter_in_typeReference1172);
\r
2888 parameter41=parameter(ctx);
\r
2891 if (HASEXCEPTION())
\r
2893 goto ruletypeReferenceEx;
\r
2896 CREATE_stream_parameter; stream_parameter->add(stream_parameter, parameter41.tree, NULL);
\r
2898 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:25: ( ',' parameter )*
\r
2916 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:26: ',' parameter
\r
2918 char_literal42 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_typeReference1175);
\r
2919 if (HASEXCEPTION())
\r
2921 goto ruletypeReferenceEx;
\r
2924 CREATE_stream_41; stream_41->add(stream_41, char_literal42, NULL);
\r
2926 FOLLOWPUSH(FOLLOW_parameter_in_typeReference1177);
\r
2927 parameter43=parameter(ctx);
\r
2930 if (HASEXCEPTION())
\r
2932 goto ruletypeReferenceEx;
\r
2935 CREATE_stream_parameter; stream_parameter->add(stream_parameter, parameter43.tree, NULL);
\r
2941 goto loop13; /* break out of the loop */
\r
2945 loop13: ; /* Jump out to here if this rule does not match */
\r
2947 char_literal44 = (pANTLR3_COMMON_TOKEN) MATCHT(42, &FOLLOW_42_in_typeReference1181);
\r
2948 if (HASEXCEPTION())
\r
2950 goto ruletypeReferenceEx;
\r
2953 CREATE_stream_42; stream_42->add(stream_42, char_literal44, NULL);
\r
2964 * elements : ID, parameter
\r
2966 * rule labels : retval
\r
2967 * token list labels :
\r
2968 * rule list labels :
\r
2971 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
2973 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
2975 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2976 retval.tree = root_0;
\r
2977 // 141:5: -> ^( TYPE_REFERENCE ID ( parameter )* )
\r
2979 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:141:8: ^( TYPE_REFERENCE ID ( parameter )* )
\r
2981 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
2982 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_REFERENCE, (pANTLR3_UINT8)"TYPE_REFERENCE"), root_1));
\r
2984 ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));
\r
2985 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:141:28: ( parameter )*
\r
2987 while ( (stream_parameter != NULL && stream_parameter->hasNext(stream_parameter)) )
\r
2989 ADAPTOR->addChild(ADAPTOR, root_1, stream_parameter == NULL ? NULL : stream_parameter->nextTree(stream_parameter));
\r
2992 if (stream_parameter != NULL) stream_parameter->reset(stream_parameter);
\r
2996 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
3001 retval.tree = root_0; // set result root
\r
3002 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
3011 // This is where rules clean up and exit
\r
3013 goto ruletypeReferenceEx; /* Prevent compiler warnings */
\r
3014 ruletypeReferenceEx: ;
\r
3015 retval.stop = LT(-1);
\r
3017 retval.stop = LT(-1);
\r
3018 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
3019 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
3020 if (stream_42 != NULL) stream_42->free(stream_42);
\r
3021 if (stream_41 != NULL) stream_41->free(stream_41);
\r
3022 if (stream_40 != NULL) stream_40->free(stream_40);
\r
3023 if (stream_ID != NULL) stream_ID->free(stream_ID);
\r
3024 if (stream_parameter != NULL) stream_parameter->free(stream_parameter);
\r
3026 if (HASEXCEPTION())
\r
3030 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
3036 /* $ANTLR end typeReference */
\r
3039 * $ANTLR start parameter
\r
3040 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:144:1: parameter : ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | unionType );
\r
3042 static SimanticsDataParser_parameter_return
\r
3043 parameter(pSimanticsDataParser ctx)
\r
3045 SimanticsDataParser_parameter_return retval;
\r
3047 pANTLR3_BASE_TREE root_0;
\r
3049 pANTLR3_COMMON_TOKEN ID45;
\r
3050 pANTLR3_COMMON_TOKEN char_literal46;
\r
3051 SimanticsDataParser_parameterValue_return parameterValue47;
\r
3052 #undef RETURN_TYPE_parameterValue47
\r
3053 #define RETURN_TYPE_parameterValue47 SimanticsDataParser_parameterValue_return
\r
3055 SimanticsDataParser_unionType_return unionType48;
\r
3056 #undef RETURN_TYPE_unionType48
\r
3057 #define RETURN_TYPE_unionType48 SimanticsDataParser_unionType_return
\r
3059 pANTLR3_BASE_TREE ID45_tree;
\r
3060 pANTLR3_BASE_TREE char_literal46_tree;
\r
3061 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;
\r
3062 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;
\r
3063 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_parameterValue;
\r
3064 /* Initialize rule variables
\r
3071 char_literal46 = NULL;
\r
3072 parameterValue47.tree = NULL;
\r
3074 unionType48.tree = NULL;
\r
3076 retval.start = LT(1); retval.stop = retval.start;
\r
3079 char_literal46_tree = NULL;
\r
3082 #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); }
\r
3084 #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); }
\r
3085 stream_parameterValue = NULL;
\r
3086 #define CREATE_stream_parameterValue if (stream_parameterValue == NULL) {stream_parameterValue = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule parameterValue"); }
\r
3088 retval.tree = NULL;
\r
3091 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:145:5: ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | unionType )
\r
3093 ANTLR3_UINT32 alt15;
\r
3119 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
3120 EXCEPTION->message = (void *)"";
\r
3121 EXCEPTION->decisionNum = 15;
\r
3122 EXCEPTION->state = 1;
\r
3125 goto ruleparameterEx;
\r
3140 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
3141 EXCEPTION->message = (void *)"";
\r
3142 EXCEPTION->decisionNum = 15;
\r
3143 EXCEPTION->state = 0;
\r
3146 goto ruleparameterEx;
\r
3152 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:145:7: ID '=' parameterValue
\r
3154 ID45 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_parameter1217);
\r
3155 if (HASEXCEPTION())
\r
3157 goto ruleparameterEx;
\r
3160 CREATE_stream_ID; stream_ID->add(stream_ID, ID45, NULL);
\r
3162 char_literal46 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_parameter1219);
\r
3163 if (HASEXCEPTION())
\r
3165 goto ruleparameterEx;
\r
3168 CREATE_stream_35; stream_35->add(stream_35, char_literal46, NULL);
\r
3170 FOLLOWPUSH(FOLLOW_parameterValue_in_parameter1221);
\r
3171 parameterValue47=parameterValue(ctx);
\r
3174 if (HASEXCEPTION())
\r
3176 goto ruleparameterEx;
\r
3179 CREATE_stream_parameterValue; stream_parameterValue->add(stream_parameterValue, parameterValue47.tree, NULL);
\r
3183 * elements : ID, parameterValue
\r
3185 * rule labels : retval
\r
3186 * token list labels :
\r
3187 * rule list labels :
\r
3190 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
3192 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
3194 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3195 retval.tree = root_0;
\r
3196 // 145:29: -> ^( TYPE_ANNOTATION ID parameterValue )
\r
3198 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:145:32: ^( TYPE_ANNOTATION ID parameterValue )
\r
3200 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3201 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_ANNOTATION, (pANTLR3_UINT8)"TYPE_ANNOTATION"), root_1));
\r
3203 ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));
\r
3204 ADAPTOR->addChild(ADAPTOR, root_1, stream_parameterValue == NULL ? NULL : stream_parameterValue->nextTree(stream_parameterValue));
\r
3206 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
3211 retval.tree = root_0; // set result root
\r
3212 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
3219 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:146:7: unionType
\r
3221 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3223 FOLLOWPUSH(FOLLOW_unionType_in_parameter1239);
\r
3224 unionType48=unionType(ctx);
\r
3227 if (HASEXCEPTION())
\r
3229 goto ruleparameterEx;
\r
3232 ADAPTOR->addChild(ADAPTOR, root_0, unionType48.tree);
\r
3242 // This is where rules clean up and exit
\r
3244 goto ruleparameterEx; /* Prevent compiler warnings */
\r
3245 ruleparameterEx: ;
\r
3246 retval.stop = LT(-1);
\r
3248 retval.stop = LT(-1);
\r
3249 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
3250 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
3251 if (stream_ID != NULL) stream_ID->free(stream_ID);
\r
3252 if (stream_35 != NULL) stream_35->free(stream_35);
\r
3253 if (stream_parameterValue != NULL) stream_parameterValue->free(stream_parameterValue);
\r
3255 if (HASEXCEPTION())
\r
3259 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
3265 /* $ANTLR end parameter */
\r
3268 * $ANTLR start parameterValue
\r
3269 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:149:1: parameterValue : ( string | boolean | number | ( '[' | '(' ) range ( ']' | ')' ) );
\r
3271 static SimanticsDataParser_parameterValue_return
\r
3272 parameterValue(pSimanticsDataParser ctx)
\r
3274 SimanticsDataParser_parameterValue_return retval;
\r
3276 pANTLR3_BASE_TREE root_0;
\r
3278 pANTLR3_COMMON_TOKEN set52;
\r
3279 pANTLR3_COMMON_TOKEN set54;
\r
3280 SimanticsDataParser_string_return string49;
\r
3281 #undef RETURN_TYPE_string49
\r
3282 #define RETURN_TYPE_string49 SimanticsDataParser_string_return
\r
3284 SimanticsDataParser_boolean_return boolean50;
\r
3285 #undef RETURN_TYPE_boolean50
\r
3286 #define RETURN_TYPE_boolean50 SimanticsDataParser_boolean_return
\r
3288 SimanticsDataParser_number_return number51;
\r
3289 #undef RETURN_TYPE_number51
\r
3290 #define RETURN_TYPE_number51 SimanticsDataParser_number_return
\r
3292 SimanticsDataParser_range_return range53;
\r
3293 #undef RETURN_TYPE_range53
\r
3294 #define RETURN_TYPE_range53 SimanticsDataParser_range_return
\r
3296 pANTLR3_BASE_TREE set52_tree;
\r
3297 pANTLR3_BASE_TREE set54_tree;
\r
3299 /* Initialize rule variables
\r
3307 string49.tree = NULL;
\r
3309 boolean50.tree = NULL;
\r
3311 number51.tree = NULL;
\r
3313 range53.tree = NULL;
\r
3315 retval.start = LT(1); retval.stop = retval.start;
\r
3317 set52_tree = NULL;
\r
3318 set54_tree = NULL;
\r
3321 retval.tree = NULL;
\r
3324 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:150:5: ( string | boolean | number | ( '[' | '(' ) range ( ']' | ')' ) )
\r
3326 ANTLR3_UINT32 alt16;
\r
3358 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
3359 EXCEPTION->message = (void *)"";
\r
3360 EXCEPTION->decisionNum = 16;
\r
3361 EXCEPTION->state = 0;
\r
3364 goto ruleparameterValueEx;
\r
3370 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:150:7: string
\r
3372 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3374 FOLLOWPUSH(FOLLOW_string_in_parameterValue1258);
\r
3375 string49=string(ctx);
\r
3378 if (HASEXCEPTION())
\r
3380 goto ruleparameterValueEx;
\r
3383 ADAPTOR->addChild(ADAPTOR, root_0, string49.tree);
\r
3388 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:151:7: boolean
\r
3390 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3392 FOLLOWPUSH(FOLLOW_boolean_in_parameterValue1266);
\r
3393 boolean50=boolean(ctx);
\r
3396 if (HASEXCEPTION())
\r
3398 goto ruleparameterValueEx;
\r
3401 ADAPTOR->addChild(ADAPTOR, root_0, boolean50.tree);
\r
3406 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:152:7: number
\r
3408 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3410 FOLLOWPUSH(FOLLOW_number_in_parameterValue1274);
\r
3411 number51=number(ctx);
\r
3414 if (HASEXCEPTION())
\r
3416 goto ruleparameterValueEx;
\r
3419 ADAPTOR->addChild(ADAPTOR, root_0, number51.tree);
\r
3424 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:153:7: ( '[' | '(' ) range ( ']' | ')' )
\r
3426 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3428 set52=(pANTLR3_COMMON_TOKEN)LT(1);
\r
3429 if ( LA(1) == 37 || LA(1) == 40 )
\r
3432 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set52)));
\r
3433 PERRORRECOVERY=ANTLR3_FALSE;
\r
3438 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
\r
3439 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
\r
3440 EXCEPTION->expectingSet = &FOLLOW_set_in_parameterValue1282;
\r
3441 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_parameterValue1282); goto ruleparameterValueEx;
\r
3444 FOLLOWPUSH(FOLLOW_range_in_parameterValue1290);
\r
3445 range53=range(ctx);
\r
3448 if (HASEXCEPTION())
\r
3450 goto ruleparameterValueEx;
\r
3453 ADAPTOR->addChild(ADAPTOR, root_0, range53.tree);
\r
3454 set54=(pANTLR3_COMMON_TOKEN)LT(1);
\r
3455 if ( LA(1) == 38 || LA(1) == 42 )
\r
3458 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set54)));
\r
3459 PERRORRECOVERY=ANTLR3_FALSE;
\r
3464 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
\r
3465 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
\r
3466 EXCEPTION->expectingSet = &FOLLOW_set_in_parameterValue1292;
\r
3467 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_parameterValue1292); goto ruleparameterValueEx;
\r
3479 // This is where rules clean up and exit
\r
3481 goto ruleparameterValueEx; /* Prevent compiler warnings */
\r
3482 ruleparameterValueEx: ;
\r
3483 retval.stop = LT(-1);
\r
3485 retval.stop = LT(-1);
\r
3486 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
3487 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
3489 if (HASEXCEPTION())
\r
3493 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
3499 /* $ANTLR end parameterValue */
\r
3502 * $ANTLR start range
\r
3503 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:156:1: range : ( number | number '..' | '..' number | number '..' number );
\r
3505 static SimanticsDataParser_range_return
\r
3506 range(pSimanticsDataParser ctx)
\r
3508 SimanticsDataParser_range_return retval;
\r
3510 pANTLR3_BASE_TREE root_0;
\r
3512 pANTLR3_COMMON_TOKEN string_literal57;
\r
3513 pANTLR3_COMMON_TOKEN string_literal58;
\r
3514 pANTLR3_COMMON_TOKEN string_literal61;
\r
3515 SimanticsDataParser_number_return number55;
\r
3516 #undef RETURN_TYPE_number55
\r
3517 #define RETURN_TYPE_number55 SimanticsDataParser_number_return
\r
3519 SimanticsDataParser_number_return number56;
\r
3520 #undef RETURN_TYPE_number56
\r
3521 #define RETURN_TYPE_number56 SimanticsDataParser_number_return
\r
3523 SimanticsDataParser_number_return number59;
\r
3524 #undef RETURN_TYPE_number59
\r
3525 #define RETURN_TYPE_number59 SimanticsDataParser_number_return
\r
3527 SimanticsDataParser_number_return number60;
\r
3528 #undef RETURN_TYPE_number60
\r
3529 #define RETURN_TYPE_number60 SimanticsDataParser_number_return
\r
3531 SimanticsDataParser_number_return number62;
\r
3532 #undef RETURN_TYPE_number62
\r
3533 #define RETURN_TYPE_number62 SimanticsDataParser_number_return
\r
3535 pANTLR3_BASE_TREE string_literal57_tree;
\r
3536 pANTLR3_BASE_TREE string_literal58_tree;
\r
3537 pANTLR3_BASE_TREE string_literal61_tree;
\r
3539 /* Initialize rule variables
\r
3545 string_literal57 = NULL;
\r
3546 string_literal58 = NULL;
\r
3547 string_literal61 = NULL;
\r
3548 number55.tree = NULL;
\r
3550 number56.tree = NULL;
\r
3552 number59.tree = NULL;
\r
3554 number60.tree = NULL;
\r
3556 number62.tree = NULL;
\r
3558 retval.start = LT(1); retval.stop = retval.start;
\r
3560 string_literal57_tree = NULL;
\r
3561 string_literal58_tree = NULL;
\r
3562 string_literal61_tree = NULL;
\r
3565 retval.tree = NULL;
\r
3568 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:157:5: ( number | number '..' | '..' number | number '..' number )
\r
3570 ANTLR3_UINT32 alt17;
\r
3600 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
3601 EXCEPTION->message = (void *)"";
\r
3602 EXCEPTION->decisionNum = 17;
\r
3603 EXCEPTION->state = 3;
\r
3620 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
3621 EXCEPTION->message = (void *)"";
\r
3622 EXCEPTION->decisionNum = 17;
\r
3623 EXCEPTION->state = 1;
\r
3639 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
3640 EXCEPTION->message = (void *)"";
\r
3641 EXCEPTION->decisionNum = 17;
\r
3642 EXCEPTION->state = 0;
\r
3651 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:157:7: number
\r
3653 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3655 FOLLOWPUSH(FOLLOW_number_in_range1319);
\r
3656 number55=number(ctx);
\r
3659 if (HASEXCEPTION())
\r
3664 ADAPTOR->addChild(ADAPTOR, root_0, number55.tree);
\r
3669 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:158:7: number '..'
\r
3671 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3673 FOLLOWPUSH(FOLLOW_number_in_range1327);
\r
3674 number56=number(ctx);
\r
3677 if (HASEXCEPTION())
\r
3682 ADAPTOR->addChild(ADAPTOR, root_0, number56.tree);
\r
3683 string_literal57 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_range1329);
\r
3684 if (HASEXCEPTION())
\r
3689 string_literal57_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal57));
\r
3690 ADAPTOR->addChild(ADAPTOR, root_0, string_literal57_tree);
\r
3696 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:159:7: '..' number
\r
3698 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3700 string_literal58 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_range1337);
\r
3701 if (HASEXCEPTION())
\r
3706 string_literal58_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal58));
\r
3707 ADAPTOR->addChild(ADAPTOR, root_0, string_literal58_tree);
\r
3709 FOLLOWPUSH(FOLLOW_number_in_range1339);
\r
3710 number59=number(ctx);
\r
3713 if (HASEXCEPTION())
\r
3718 ADAPTOR->addChild(ADAPTOR, root_0, number59.tree);
\r
3723 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:160:7: number '..' number
\r
3725 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3727 FOLLOWPUSH(FOLLOW_number_in_range1348);
\r
3728 number60=number(ctx);
\r
3731 if (HASEXCEPTION())
\r
3736 ADAPTOR->addChild(ADAPTOR, root_0, number60.tree);
\r
3737 string_literal61 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_range1350);
\r
3738 if (HASEXCEPTION())
\r
3743 string_literal61_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal61));
\r
3744 ADAPTOR->addChild(ADAPTOR, root_0, string_literal61_tree);
\r
3746 FOLLOWPUSH(FOLLOW_number_in_range1352);
\r
3747 number62=number(ctx);
\r
3750 if (HASEXCEPTION())
\r
3755 ADAPTOR->addChild(ADAPTOR, root_0, number62.tree);
\r
3765 // This is where rules clean up and exit
\r
3767 goto rulerangeEx; /* Prevent compiler warnings */
\r
3769 retval.stop = LT(-1);
\r
3771 retval.stop = LT(-1);
\r
3772 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
3773 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
3775 if (HASEXCEPTION())
\r
3779 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
3785 /* $ANTLR end range */
\r
3788 * $ANTLR start number
\r
3789 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:163:1: number : ( INT | FLOAT );
\r
3791 static SimanticsDataParser_number_return
\r
3792 number(pSimanticsDataParser ctx)
\r
3794 SimanticsDataParser_number_return retval;
\r
3796 pANTLR3_BASE_TREE root_0;
\r
3798 pANTLR3_COMMON_TOKEN set63;
\r
3800 pANTLR3_BASE_TREE set63_tree;
\r
3802 /* Initialize rule variables
\r
3809 retval.start = LT(1); retval.stop = retval.start;
\r
3811 set63_tree = NULL;
\r
3814 retval.tree = NULL;
\r
3816 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:164:5: ( INT | FLOAT )
\r
3817 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:
\r
3819 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3821 set63=(pANTLR3_COMMON_TOKEN)LT(1);
\r
3822 if ( LA(1) == INT || LA(1) == FLOAT )
\r
3825 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set63)));
\r
3826 PERRORRECOVERY=ANTLR3_FALSE;
\r
3831 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
\r
3832 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
\r
3833 EXCEPTION->expectingSet = &FOLLOW_set_in_number0;
\r
3834 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_number0); goto rulenumberEx;
\r
3843 // This is where rules clean up and exit
\r
3845 goto rulenumberEx; /* Prevent compiler warnings */
\r
3847 retval.stop = LT(-1);
\r
3849 retval.stop = LT(-1);
\r
3850 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
3851 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
3853 if (HASEXCEPTION())
\r
3857 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
3863 /* $ANTLR end number */
\r
3866 * $ANTLR start string
\r
3867 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:168:1: string : STRING ;
\r
3869 static SimanticsDataParser_string_return
\r
3870 string(pSimanticsDataParser ctx)
\r
3872 SimanticsDataParser_string_return retval;
\r
3874 pANTLR3_BASE_TREE root_0;
\r
3876 pANTLR3_COMMON_TOKEN STRING64;
\r
3878 pANTLR3_BASE_TREE STRING64_tree;
\r
3880 /* Initialize rule variables
\r
3887 retval.start = LT(1); retval.stop = retval.start;
\r
3889 STRING64_tree = NULL;
\r
3892 retval.tree = NULL;
\r
3894 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:169:5: ( STRING )
\r
3895 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:169:7: STRING
\r
3897 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3899 STRING64 = (pANTLR3_COMMON_TOKEN) MATCHT(STRING, &FOLLOW_STRING_in_string1402);
\r
3900 if (HASEXCEPTION())
\r
3902 goto rulestringEx;
\r
3905 STRING64_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STRING64));
\r
3906 ADAPTOR->addChild(ADAPTOR, root_0, STRING64_tree);
\r
3914 // This is where rules clean up and exit
\r
3916 goto rulestringEx; /* Prevent compiler warnings */
\r
3918 retval.stop = LT(-1);
\r
3920 retval.stop = LT(-1);
\r
3921 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
3922 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
3924 if (HASEXCEPTION())
\r
3928 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
3934 /* $ANTLR end string */
\r
3937 * $ANTLR start boolean
\r
3938 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:172:1: boolean : ( 'true' | 'false' );
\r
3940 static SimanticsDataParser_boolean_return
\r
3941 boolean(pSimanticsDataParser ctx)
\r
3943 SimanticsDataParser_boolean_return retval;
\r
3945 pANTLR3_BASE_TREE root_0;
\r
3947 pANTLR3_COMMON_TOKEN set65;
\r
3949 pANTLR3_BASE_TREE set65_tree;
\r
3951 /* Initialize rule variables
\r
3958 retval.start = LT(1); retval.stop = retval.start;
\r
3960 set65_tree = NULL;
\r
3963 retval.tree = NULL;
\r
3965 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:173:5: ( 'true' | 'false' )
\r
3966 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:
\r
3968 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
3970 set65=(pANTLR3_COMMON_TOKEN)LT(1);
\r
3971 if ( ((LA(1) >= 46) && (LA(1) <= 47)) )
\r
3974 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set65)));
\r
3975 PERRORRECOVERY=ANTLR3_FALSE;
\r
3980 EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;
\r
3981 EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;
\r
3982 EXCEPTION->expectingSet = &FOLLOW_set_in_boolean0;
\r
3983 RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_boolean0); goto rulebooleanEx;
\r
3992 // This is where rules clean up and exit
\r
3994 goto rulebooleanEx; /* Prevent compiler warnings */
\r
3996 retval.stop = LT(-1);
\r
3998 retval.stop = LT(-1);
\r
3999 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
4000 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
4002 if (HASEXCEPTION())
\r
4006 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
4012 /* $ANTLR end boolean */
\r
4015 * $ANTLR start valueDefinitions
\r
4016 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:1: valueDefinitions : ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) ;
\r
4018 static SimanticsDataParser_valueDefinitions_return
\r
4019 valueDefinitions(pSimanticsDataParser ctx)
\r
4021 SimanticsDataParser_valueDefinitions_return retval;
\r
4023 pANTLR3_BASE_TREE root_0;
\r
4025 SimanticsDataParser_valueDefinition_return valueDefinition66;
\r
4026 #undef RETURN_TYPE_valueDefinition66
\r
4027 #define RETURN_TYPE_valueDefinition66 SimanticsDataParser_valueDefinition_return
\r
4029 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_valueDefinition;
\r
4030 /* Initialize rule variables
\r
4036 valueDefinition66.tree = NULL;
\r
4038 retval.start = LT(1); retval.stop = retval.start;
\r
4041 stream_valueDefinition = NULL;
\r
4042 #define CREATE_stream_valueDefinition if (stream_valueDefinition == NULL) {stream_valueDefinition = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule valueDefinition"); }
\r
4044 retval.tree = NULL;
\r
4046 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:18: ( ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) )
\r
4047 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:20: ( valueDefinition )*
\r
4050 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:20: ( valueDefinition )*
\r
4068 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:20: valueDefinition
\r
4070 FOLLOWPUSH(FOLLOW_valueDefinition_in_valueDefinitions1447);
\r
4071 valueDefinition66=valueDefinition(ctx);
\r
4074 if (HASEXCEPTION())
\r
4076 goto rulevalueDefinitionsEx;
\r
4079 CREATE_stream_valueDefinition; stream_valueDefinition->add(stream_valueDefinition, valueDefinition66.tree, NULL);
\r
4085 goto loop18; /* break out of the loop */
\r
4089 loop18: ; /* Jump out to here if this rule does not match */
\r
4094 * elements : valueDefinition
\r
4096 * rule labels : retval
\r
4097 * token list labels :
\r
4098 * rule list labels :
\r
4101 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
4103 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
4105 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4106 retval.tree = root_0;
\r
4107 // 181:37: -> ^( VALUE_DEFINITIONS ( valueDefinition )* )
\r
4109 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:40: ^( VALUE_DEFINITIONS ( valueDefinition )* )
\r
4111 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4112 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, VALUE_DEFINITIONS, (pANTLR3_UINT8)"VALUE_DEFINITIONS"), root_1));
\r
4114 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:60: ( valueDefinition )*
\r
4116 while ( (stream_valueDefinition != NULL && stream_valueDefinition->hasNext(stream_valueDefinition)) )
\r
4118 ADAPTOR->addChild(ADAPTOR, root_1, stream_valueDefinition == NULL ? NULL : stream_valueDefinition->nextTree(stream_valueDefinition));
\r
4121 if (stream_valueDefinition != NULL) stream_valueDefinition->reset(stream_valueDefinition);
\r
4125 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
4130 retval.tree = root_0; // set result root
\r
4131 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
4140 // This is where rules clean up and exit
\r
4142 goto rulevalueDefinitionsEx; /* Prevent compiler warnings */
\r
4143 rulevalueDefinitionsEx: ;
\r
4144 retval.stop = LT(-1);
\r
4146 retval.stop = LT(-1);
\r
4147 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
4148 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
4149 if (stream_valueDefinition != NULL) stream_valueDefinition->free(stream_valueDefinition);
\r
4151 if (HASEXCEPTION())
\r
4155 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
4161 /* $ANTLR end valueDefinitions */
\r
4164 * $ANTLR start valueDefinition
\r
4165 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:183:1: valueDefinition : ID ':' unionType '=' value -> ^( VALUE_DEFINITION ID unionType value ) ;
\r
4167 static SimanticsDataParser_valueDefinition_return
\r
4168 valueDefinition(pSimanticsDataParser ctx)
\r
4170 SimanticsDataParser_valueDefinition_return retval;
\r
4172 pANTLR3_BASE_TREE root_0;
\r
4174 pANTLR3_COMMON_TOKEN ID67;
\r
4175 pANTLR3_COMMON_TOKEN char_literal68;
\r
4176 pANTLR3_COMMON_TOKEN char_literal70;
\r
4177 SimanticsDataParser_unionType_return unionType69;
\r
4178 #undef RETURN_TYPE_unionType69
\r
4179 #define RETURN_TYPE_unionType69 SimanticsDataParser_unionType_return
\r
4181 SimanticsDataParser_value_return value71;
\r
4182 #undef RETURN_TYPE_value71
\r
4183 #define RETURN_TYPE_value71 SimanticsDataParser_value_return
\r
4185 pANTLR3_BASE_TREE ID67_tree;
\r
4186 pANTLR3_BASE_TREE char_literal68_tree;
\r
4187 pANTLR3_BASE_TREE char_literal70_tree;
\r
4188 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_45;
\r
4189 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;
\r
4190 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;
\r
4191 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType;
\r
4192 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;
\r
4193 /* Initialize rule variables
\r
4200 char_literal68 = NULL;
\r
4201 char_literal70 = NULL;
\r
4202 unionType69.tree = NULL;
\r
4204 value71.tree = NULL;
\r
4206 retval.start = LT(1); retval.stop = retval.start;
\r
4209 char_literal68_tree = NULL;
\r
4210 char_literal70_tree = NULL;
\r
4213 #define CREATE_stream_45 if (stream_45 == NULL) {stream_45 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 45"); }
\r
4215 #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); }
\r
4217 #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); }
\r
4218 stream_unionType = NULL;
\r
4219 #define CREATE_stream_unionType if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); }
\r
4220 stream_value = NULL;
\r
4221 #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }
\r
4223 retval.tree = NULL;
\r
4225 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:184:5: ( ID ':' unionType '=' value -> ^( VALUE_DEFINITION ID unionType value ) )
\r
4226 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:184:7: ID ':' unionType '=' value
\r
4228 ID67 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_valueDefinition1470);
\r
4229 if (HASEXCEPTION())
\r
4231 goto rulevalueDefinitionEx;
\r
4234 CREATE_stream_ID; stream_ID->add(stream_ID, ID67, NULL);
\r
4236 char_literal68 = (pANTLR3_COMMON_TOKEN) MATCHT(45, &FOLLOW_45_in_valueDefinition1472);
\r
4237 if (HASEXCEPTION())
\r
4239 goto rulevalueDefinitionEx;
\r
4242 CREATE_stream_45; stream_45->add(stream_45, char_literal68, NULL);
\r
4244 FOLLOWPUSH(FOLLOW_unionType_in_valueDefinition1474);
\r
4245 unionType69=unionType(ctx);
\r
4248 if (HASEXCEPTION())
\r
4250 goto rulevalueDefinitionEx;
\r
4253 CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType69.tree, NULL);
\r
4254 char_literal70 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_valueDefinition1476);
\r
4255 if (HASEXCEPTION())
\r
4257 goto rulevalueDefinitionEx;
\r
4260 CREATE_stream_35; stream_35->add(stream_35, char_literal70, NULL);
\r
4262 FOLLOWPUSH(FOLLOW_value_in_valueDefinition1478);
\r
4263 value71=value(ctx);
\r
4266 if (HASEXCEPTION())
\r
4268 goto rulevalueDefinitionEx;
\r
4271 CREATE_stream_value; stream_value->add(stream_value, value71.tree, NULL);
\r
4275 * elements : value, unionType, ID
\r
4277 * rule labels : retval
\r
4278 * token list labels :
\r
4279 * rule list labels :
\r
4282 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
4284 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
4286 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4287 retval.tree = root_0;
\r
4288 // 185:5: -> ^( VALUE_DEFINITION ID unionType value )
\r
4290 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:185:8: ^( VALUE_DEFINITION ID unionType value )
\r
4292 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4293 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, VALUE_DEFINITION, (pANTLR3_UINT8)"VALUE_DEFINITION"), root_1));
\r
4295 ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));
\r
4296 ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType));
\r
4297 ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));
\r
4299 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
4304 retval.tree = root_0; // set result root
\r
4305 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
4314 // This is where rules clean up and exit
\r
4316 goto rulevalueDefinitionEx; /* Prevent compiler warnings */
\r
4317 rulevalueDefinitionEx: ;
\r
4318 retval.stop = LT(-1);
\r
4320 retval.stop = LT(-1);
\r
4321 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
4322 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
4323 if (stream_45 != NULL) stream_45->free(stream_45);
\r
4324 if (stream_ID != NULL) stream_ID->free(stream_ID);
\r
4325 if (stream_35 != NULL) stream_35->free(stream_35);
\r
4326 if (stream_unionType != NULL) stream_unionType->free(stream_unionType);
\r
4327 if (stream_value != NULL) stream_value->free(stream_value);
\r
4329 if (HASEXCEPTION())
\r
4333 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
4339 /* $ANTLR end valueDefinition */
\r
4342 * $ANTLR start value
\r
4343 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:188:1: value : ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* ;
\r
4345 static SimanticsDataParser_value_return
\r
4346 value(pSimanticsDataParser ctx)
\r
4348 SimanticsDataParser_value_return retval;
\r
4350 pANTLR3_BASE_TREE root_0;
\r
4352 pANTLR3_COMMON_TOKEN char_literal73;
\r
4353 SimanticsDataParser_basicValue_return basicValue72;
\r
4354 #undef RETURN_TYPE_basicValue72
\r
4355 #define RETURN_TYPE_basicValue72 SimanticsDataParser_basicValue_return
\r
4357 SimanticsDataParser_type_return type74;
\r
4358 #undef RETURN_TYPE_type74
\r
4359 #define RETURN_TYPE_type74 SimanticsDataParser_type_return
\r
4361 pANTLR3_BASE_TREE char_literal73_tree;
\r
4362 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_45;
\r
4363 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_basicValue;
\r
4364 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_type;
\r
4365 /* Initialize rule variables
\r
4371 char_literal73 = NULL;
\r
4372 basicValue72.tree = NULL;
\r
4374 type74.tree = NULL;
\r
4376 retval.start = LT(1); retval.stop = retval.start;
\r
4378 char_literal73_tree = NULL;
\r
4381 #define CREATE_stream_45 if (stream_45 == NULL) {stream_45 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 45"); }
\r
4382 stream_basicValue = NULL;
\r
4383 #define CREATE_stream_basicValue if (stream_basicValue == NULL) {stream_basicValue = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule basicValue"); }
\r
4384 stream_type = NULL;
\r
4385 #define CREATE_stream_type if (stream_type == NULL) {stream_type = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule type"); }
\r
4387 retval.tree = NULL;
\r
4389 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:5: ( ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* )
\r
4390 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:7: ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )*
\r
4392 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:7: ( basicValue -> basicValue )
\r
4393 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:8: basicValue
\r
4395 FOLLOWPUSH(FOLLOW_basicValue_in_value1514);
\r
4396 basicValue72=basicValue(ctx);
\r
4399 if (HASEXCEPTION())
\r
4404 CREATE_stream_basicValue; stream_basicValue->add(stream_basicValue, basicValue72.tree, NULL);
\r
4408 * elements : basicValue
\r
4410 * rule labels : retval
\r
4411 * token list labels :
\r
4412 * rule list labels :
\r
4415 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
4417 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
4419 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4420 retval.tree = root_0;
\r
4421 // 189:19: -> basicValue
\r
4423 ADAPTOR->addChild(ADAPTOR, root_0, stream_basicValue == NULL ? NULL : stream_basicValue->nextTree(stream_basicValue));
\r
4427 retval.tree = root_0; // set result root
\r
4428 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
4435 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:190:7: ( ':' type -> ^( VARIANT type $value) )*
\r
4453 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:190:8: ':' type
\r
4455 char_literal73 = (pANTLR3_COMMON_TOKEN) MATCHT(45, &FOLLOW_45_in_value1528);
\r
4456 if (HASEXCEPTION())
\r
4461 CREATE_stream_45; stream_45->add(stream_45, char_literal73, NULL);
\r
4463 FOLLOWPUSH(FOLLOW_type_in_value1530);
\r
4467 if (HASEXCEPTION())
\r
4472 CREATE_stream_type; stream_type->add(stream_type, type74.tree, NULL);
\r
4476 * elements : value, type
\r
4478 * rule labels : retval
\r
4479 * token list labels :
\r
4480 * rule list labels :
\r
4483 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
4485 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
4487 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4488 retval.tree = root_0;
\r
4489 // 190:17: -> ^( VARIANT type $value)
\r
4491 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:190:20: ^( VARIANT type $value)
\r
4493 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4494 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, VARIANT, (pANTLR3_UINT8)"VARIANT"), root_1));
\r
4496 ADAPTOR->addChild(ADAPTOR, root_1, stream_type == NULL ? NULL : stream_type->nextTree(stream_type));
\r
4497 ADAPTOR->addChild(ADAPTOR, root_1, stream_retval == NULL ? NULL : stream_retval->nextTree(stream_retval));
\r
4499 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
4504 retval.tree = root_0; // set result root
\r
4505 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
4513 goto loop19; /* break out of the loop */
\r
4517 loop19: ; /* Jump out to here if this rule does not match */
\r
4525 // This is where rules clean up and exit
\r
4527 goto rulevalueEx; /* Prevent compiler warnings */
\r
4529 retval.stop = LT(-1);
\r
4531 retval.stop = LT(-1);
\r
4532 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
4533 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
4534 if (stream_45 != NULL) stream_45->free(stream_45);
\r
4535 if (stream_basicValue != NULL) stream_basicValue->free(stream_basicValue);
\r
4536 if (stream_type != NULL) stream_type->free(stream_type);
\r
4538 if (HASEXCEPTION())
\r
4542 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
4548 /* $ANTLR end value */
\r
4551 * $ANTLR start basicValue
\r
4552 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:193:1: basicValue : ( 'null' -> NO_VALUE | string | number | boolean | array | tuple | taggedValue | map | record );
\r
4554 static SimanticsDataParser_basicValue_return
\r
4555 basicValue(pSimanticsDataParser ctx)
\r
4557 SimanticsDataParser_basicValue_return retval;
\r
4559 pANTLR3_BASE_TREE root_0;
\r
4561 pANTLR3_COMMON_TOKEN string_literal75;
\r
4562 SimanticsDataParser_string_return string76;
\r
4563 #undef RETURN_TYPE_string76
\r
4564 #define RETURN_TYPE_string76 SimanticsDataParser_string_return
\r
4566 SimanticsDataParser_number_return number77;
\r
4567 #undef RETURN_TYPE_number77
\r
4568 #define RETURN_TYPE_number77 SimanticsDataParser_number_return
\r
4570 SimanticsDataParser_boolean_return boolean78;
\r
4571 #undef RETURN_TYPE_boolean78
\r
4572 #define RETURN_TYPE_boolean78 SimanticsDataParser_boolean_return
\r
4574 SimanticsDataParser_array_return array79;
\r
4575 #undef RETURN_TYPE_array79
\r
4576 #define RETURN_TYPE_array79 SimanticsDataParser_array_return
\r
4578 SimanticsDataParser_tuple_return tuple80;
\r
4579 #undef RETURN_TYPE_tuple80
\r
4580 #define RETURN_TYPE_tuple80 SimanticsDataParser_tuple_return
\r
4582 SimanticsDataParser_taggedValue_return taggedValue81;
\r
4583 #undef RETURN_TYPE_taggedValue81
\r
4584 #define RETURN_TYPE_taggedValue81 SimanticsDataParser_taggedValue_return
\r
4586 SimanticsDataParser_map_return map82;
\r
4587 #undef RETURN_TYPE_map82
\r
4588 #define RETURN_TYPE_map82 SimanticsDataParser_map_return
\r
4590 SimanticsDataParser_record_return record83;
\r
4591 #undef RETURN_TYPE_record83
\r
4592 #define RETURN_TYPE_record83 SimanticsDataParser_record_return
\r
4594 pANTLR3_BASE_TREE string_literal75_tree;
\r
4595 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_48;
\r
4597 /* Initialize rule variables
\r
4603 string_literal75 = NULL;
\r
4604 string76.tree = NULL;
\r
4606 number77.tree = NULL;
\r
4608 boolean78.tree = NULL;
\r
4610 array79.tree = NULL;
\r
4612 tuple80.tree = NULL;
\r
4614 taggedValue81.tree = NULL;
\r
4616 map82.tree = NULL;
\r
4618 record83.tree = NULL;
\r
4620 retval.start = LT(1); retval.stop = retval.start;
\r
4622 string_literal75_tree = NULL;
\r
4625 #define CREATE_stream_48 if (stream_48 == NULL) {stream_48 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 48"); }
\r
4627 retval.tree = NULL;
\r
4630 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:194:5: ( 'null' -> NO_VALUE | string | number | boolean | array | tuple | taggedValue | map | record )
\r
4632 ANTLR3_UINT32 alt20;
\r
4688 EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION;
\r
4689 EXCEPTION->message = (void *)"";
\r
4690 EXCEPTION->decisionNum = 20;
\r
4691 EXCEPTION->state = 0;
\r
4694 goto rulebasicValueEx;
\r
4700 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:194:7: 'null'
\r
4702 string_literal75 = (pANTLR3_COMMON_TOKEN) MATCHT(48, &FOLLOW_48_in_basicValue1562);
\r
4703 if (HASEXCEPTION())
\r
4705 goto rulebasicValueEx;
\r
4708 CREATE_stream_48; stream_48->add(stream_48, string_literal75, NULL);
\r
4715 * rule labels : retval
\r
4716 * token list labels :
\r
4717 * rule list labels :
\r
4720 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
4722 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
4724 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4725 retval.tree = root_0;
\r
4726 // 194:14: -> NO_VALUE
\r
4728 ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, NO_VALUE, (pANTLR3_UINT8)"NO_VALUE"));
\r
4732 retval.tree = root_0; // set result root
\r
4733 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
4740 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:195:7: string
\r
4742 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4744 FOLLOWPUSH(FOLLOW_string_in_basicValue1574);
\r
4745 string76=string(ctx);
\r
4748 if (HASEXCEPTION())
\r
4750 goto rulebasicValueEx;
\r
4753 ADAPTOR->addChild(ADAPTOR, root_0, string76.tree);
\r
4758 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:196:7: number
\r
4760 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4762 FOLLOWPUSH(FOLLOW_number_in_basicValue1582);
\r
4763 number77=number(ctx);
\r
4766 if (HASEXCEPTION())
\r
4768 goto rulebasicValueEx;
\r
4771 ADAPTOR->addChild(ADAPTOR, root_0, number77.tree);
\r
4776 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:197:7: boolean
\r
4778 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4780 FOLLOWPUSH(FOLLOW_boolean_in_basicValue1590);
\r
4781 boolean78=boolean(ctx);
\r
4784 if (HASEXCEPTION())
\r
4786 goto rulebasicValueEx;
\r
4789 ADAPTOR->addChild(ADAPTOR, root_0, boolean78.tree);
\r
4794 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:198:7: array
\r
4796 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4798 FOLLOWPUSH(FOLLOW_array_in_basicValue1598);
\r
4799 array79=array(ctx);
\r
4802 if (HASEXCEPTION())
\r
4804 goto rulebasicValueEx;
\r
4807 ADAPTOR->addChild(ADAPTOR, root_0, array79.tree);
\r
4812 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:199:7: tuple
\r
4814 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4816 FOLLOWPUSH(FOLLOW_tuple_in_basicValue1606);
\r
4817 tuple80=tuple(ctx);
\r
4820 if (HASEXCEPTION())
\r
4822 goto rulebasicValueEx;
\r
4825 ADAPTOR->addChild(ADAPTOR, root_0, tuple80.tree);
\r
4830 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:200:7: taggedValue
\r
4832 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4834 FOLLOWPUSH(FOLLOW_taggedValue_in_basicValue1614);
\r
4835 taggedValue81=taggedValue(ctx);
\r
4838 if (HASEXCEPTION())
\r
4840 goto rulebasicValueEx;
\r
4843 ADAPTOR->addChild(ADAPTOR, root_0, taggedValue81.tree);
\r
4848 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:201:7: map
\r
4850 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4852 FOLLOWPUSH(FOLLOW_map_in_basicValue1622);
\r
4856 if (HASEXCEPTION())
\r
4858 goto rulebasicValueEx;
\r
4861 ADAPTOR->addChild(ADAPTOR, root_0, map82.tree);
\r
4866 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:202:7: record
\r
4868 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
4870 FOLLOWPUSH(FOLLOW_record_in_basicValue1630);
\r
4871 record83=record(ctx);
\r
4874 if (HASEXCEPTION())
\r
4876 goto rulebasicValueEx;
\r
4879 ADAPTOR->addChild(ADAPTOR, root_0, record83.tree);
\r
4889 // This is where rules clean up and exit
\r
4891 goto rulebasicValueEx; /* Prevent compiler warnings */
\r
4892 rulebasicValueEx: ;
\r
4893 retval.stop = LT(-1);
\r
4895 retval.stop = LT(-1);
\r
4896 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
4897 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
4898 if (stream_48 != NULL) stream_48->free(stream_48);
\r
4900 if (HASEXCEPTION())
\r
4904 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
4910 /* $ANTLR end basicValue */
\r
4913 * $ANTLR start array
\r
4914 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:205:1: array : '[' ( value ( ',' value )* )? ']' -> ^( ARRAY ( value )* ) ;
\r
4916 static SimanticsDataParser_array_return
\r
4917 array(pSimanticsDataParser ctx)
\r
4919 SimanticsDataParser_array_return retval;
\r
4921 pANTLR3_BASE_TREE root_0;
\r
4923 pANTLR3_COMMON_TOKEN char_literal84;
\r
4924 pANTLR3_COMMON_TOKEN char_literal86;
\r
4925 pANTLR3_COMMON_TOKEN char_literal88;
\r
4926 SimanticsDataParser_value_return value85;
\r
4927 #undef RETURN_TYPE_value85
\r
4928 #define RETURN_TYPE_value85 SimanticsDataParser_value_return
\r
4930 SimanticsDataParser_value_return value87;
\r
4931 #undef RETURN_TYPE_value87
\r
4932 #define RETURN_TYPE_value87 SimanticsDataParser_value_return
\r
4934 pANTLR3_BASE_TREE char_literal84_tree;
\r
4935 pANTLR3_BASE_TREE char_literal86_tree;
\r
4936 pANTLR3_BASE_TREE char_literal88_tree;
\r
4937 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;
\r
4938 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_37;
\r
4939 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_38;
\r
4940 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;
\r
4941 /* Initialize rule variables
\r
4947 char_literal84 = NULL;
\r
4948 char_literal86 = NULL;
\r
4949 char_literal88 = NULL;
\r
4950 value85.tree = NULL;
\r
4952 value87.tree = NULL;
\r
4954 retval.start = LT(1); retval.stop = retval.start;
\r
4956 char_literal84_tree = NULL;
\r
4957 char_literal86_tree = NULL;
\r
4958 char_literal88_tree = NULL;
\r
4961 #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); }
\r
4963 #define CREATE_stream_37 if (stream_37 == NULL) {stream_37 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 37"); }
\r
4965 #define CREATE_stream_38 if (stream_38 == NULL) {stream_38 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 38"); }
\r
4966 stream_value = NULL;
\r
4967 #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }
\r
4969 retval.tree = NULL;
\r
4971 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:5: ( '[' ( value ( ',' value )* )? ']' -> ^( ARRAY ( value )* ) )
\r
4972 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:7: '[' ( value ( ',' value )* )? ']'
\r
4974 char_literal84 = (pANTLR3_COMMON_TOKEN) MATCHT(37, &FOLLOW_37_in_array1648);
\r
4975 if (HASEXCEPTION())
\r
4980 CREATE_stream_37; stream_37->add(stream_37, char_literal84, NULL);
\r
4983 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:11: ( value ( ',' value )* )?
\r
5008 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:12: value ( ',' value )*
\r
5010 FOLLOWPUSH(FOLLOW_value_in_array1651);
\r
5011 value85=value(ctx);
\r
5014 if (HASEXCEPTION())
\r
5019 CREATE_stream_value; stream_value->add(stream_value, value85.tree, NULL);
\r
5021 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:18: ( ',' value )*
\r
5039 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:19: ',' value
\r
5041 char_literal86 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_array1654);
\r
5042 if (HASEXCEPTION())
\r
5047 CREATE_stream_41; stream_41->add(stream_41, char_literal86, NULL);
\r
5049 FOLLOWPUSH(FOLLOW_value_in_array1656);
\r
5050 value87=value(ctx);
\r
5053 if (HASEXCEPTION())
\r
5058 CREATE_stream_value; stream_value->add(stream_value, value87.tree, NULL);
\r
5064 goto loop21; /* break out of the loop */
\r
5068 loop21: ; /* Jump out to here if this rule does not match */
\r
5076 char_literal88 = (pANTLR3_COMMON_TOKEN) MATCHT(38, &FOLLOW_38_in_array1662);
\r
5077 if (HASEXCEPTION())
\r
5082 CREATE_stream_38; stream_38->add(stream_38, char_literal88, NULL);
\r
5087 * elements : value
\r
5089 * rule labels : retval
\r
5090 * token list labels :
\r
5091 * rule list labels :
\r
5094 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
5096 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
5098 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5099 retval.tree = root_0;
\r
5100 // 207:5: -> ^( ARRAY ( value )* )
\r
5102 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:207:8: ^( ARRAY ( value )* )
\r
5104 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5105 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ARRAY, (pANTLR3_UINT8)"ARRAY"), root_1));
\r
5107 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:207:16: ( value )*
\r
5109 while ( (stream_value != NULL && stream_value->hasNext(stream_value)) )
\r
5111 ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));
\r
5114 if (stream_value != NULL) stream_value->reset(stream_value);
\r
5118 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
5123 retval.tree = root_0; // set result root
\r
5124 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
5133 // This is where rules clean up and exit
\r
5135 goto rulearrayEx; /* Prevent compiler warnings */
\r
5137 retval.stop = LT(-1);
\r
5139 retval.stop = LT(-1);
\r
5140 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
5141 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
5142 if (stream_41 != NULL) stream_41->free(stream_41);
\r
5143 if (stream_37 != NULL) stream_37->free(stream_37);
\r
5144 if (stream_38 != NULL) stream_38->free(stream_38);
\r
5145 if (stream_value != NULL) stream_value->free(stream_value);
\r
5147 if (HASEXCEPTION())
\r
5151 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
5157 /* $ANTLR end array */
\r
5160 * $ANTLR start tuple
\r
5161 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:210:1: tuple : '(' ( value ( ',' value )* )? ')' -> ^( TUPLE ( value )* ) ;
\r
5163 static SimanticsDataParser_tuple_return
\r
5164 tuple(pSimanticsDataParser ctx)
\r
5166 SimanticsDataParser_tuple_return retval;
\r
5168 pANTLR3_BASE_TREE root_0;
\r
5170 pANTLR3_COMMON_TOKEN char_literal89;
\r
5171 pANTLR3_COMMON_TOKEN char_literal91;
\r
5172 pANTLR3_COMMON_TOKEN char_literal93;
\r
5173 SimanticsDataParser_value_return value90;
\r
5174 #undef RETURN_TYPE_value90
\r
5175 #define RETURN_TYPE_value90 SimanticsDataParser_value_return
\r
5177 SimanticsDataParser_value_return value92;
\r
5178 #undef RETURN_TYPE_value92
\r
5179 #define RETURN_TYPE_value92 SimanticsDataParser_value_return
\r
5181 pANTLR3_BASE_TREE char_literal89_tree;
\r
5182 pANTLR3_BASE_TREE char_literal91_tree;
\r
5183 pANTLR3_BASE_TREE char_literal93_tree;
\r
5184 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_42;
\r
5185 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;
\r
5186 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_40;
\r
5187 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;
\r
5188 /* Initialize rule variables
\r
5194 char_literal89 = NULL;
\r
5195 char_literal91 = NULL;
\r
5196 char_literal93 = NULL;
\r
5197 value90.tree = NULL;
\r
5199 value92.tree = NULL;
\r
5201 retval.start = LT(1); retval.stop = retval.start;
\r
5203 char_literal89_tree = NULL;
\r
5204 char_literal91_tree = NULL;
\r
5205 char_literal93_tree = NULL;
\r
5208 #define CREATE_stream_42 if (stream_42 == NULL) {stream_42 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 42"); }
\r
5210 #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); }
\r
5212 #define CREATE_stream_40 if (stream_40 == NULL) {stream_40 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 40"); }
\r
5213 stream_value = NULL;
\r
5214 #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }
\r
5216 retval.tree = NULL;
\r
5218 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:5: ( '(' ( value ( ',' value )* )? ')' -> ^( TUPLE ( value )* ) )
\r
5219 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:7: '(' ( value ( ',' value )* )? ')'
\r
5221 char_literal89 = (pANTLR3_COMMON_TOKEN) MATCHT(40, &FOLLOW_40_in_tuple1694);
\r
5222 if (HASEXCEPTION())
\r
5227 CREATE_stream_40; stream_40->add(stream_40, char_literal89, NULL);
\r
5230 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:11: ( value ( ',' value )* )?
\r
5255 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:12: value ( ',' value )*
\r
5257 FOLLOWPUSH(FOLLOW_value_in_tuple1697);
\r
5258 value90=value(ctx);
\r
5261 if (HASEXCEPTION())
\r
5266 CREATE_stream_value; stream_value->add(stream_value, value90.tree, NULL);
\r
5268 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:18: ( ',' value )*
\r
5286 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:19: ',' value
\r
5288 char_literal91 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_tuple1700);
\r
5289 if (HASEXCEPTION())
\r
5294 CREATE_stream_41; stream_41->add(stream_41, char_literal91, NULL);
\r
5296 FOLLOWPUSH(FOLLOW_value_in_tuple1702);
\r
5297 value92=value(ctx);
\r
5300 if (HASEXCEPTION())
\r
5305 CREATE_stream_value; stream_value->add(stream_value, value92.tree, NULL);
\r
5311 goto loop23; /* break out of the loop */
\r
5315 loop23: ; /* Jump out to here if this rule does not match */
\r
5323 char_literal93 = (pANTLR3_COMMON_TOKEN) MATCHT(42, &FOLLOW_42_in_tuple1708);
\r
5324 if (HASEXCEPTION())
\r
5329 CREATE_stream_42; stream_42->add(stream_42, char_literal93, NULL);
\r
5334 * elements : value
\r
5336 * rule labels : retval
\r
5337 * token list labels :
\r
5338 * rule list labels :
\r
5341 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
5343 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
5345 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5346 retval.tree = root_0;
\r
5347 // 212:5: -> ^( TUPLE ( value )* )
\r
5349 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:212:8: ^( TUPLE ( value )* )
\r
5351 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5352 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TUPLE, (pANTLR3_UINT8)"TUPLE"), root_1));
\r
5354 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:212:16: ( value )*
\r
5356 while ( (stream_value != NULL && stream_value->hasNext(stream_value)) )
\r
5358 ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));
\r
5361 if (stream_value != NULL) stream_value->reset(stream_value);
\r
5365 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
5370 retval.tree = root_0; // set result root
\r
5371 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
5380 // This is where rules clean up and exit
\r
5382 goto ruletupleEx; /* Prevent compiler warnings */
\r
5384 retval.stop = LT(-1);
\r
5386 retval.stop = LT(-1);
\r
5387 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
5388 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
5389 if (stream_42 != NULL) stream_42->free(stream_42);
\r
5390 if (stream_41 != NULL) stream_41->free(stream_41);
\r
5391 if (stream_40 != NULL) stream_40->free(stream_40);
\r
5392 if (stream_value != NULL) stream_value->free(stream_value);
\r
5394 if (HASEXCEPTION())
\r
5398 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
5404 /* $ANTLR end tuple */
\r
5407 * $ANTLR start taggedValue
\r
5408 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:215:1: taggedValue : ID basicValue -> ^( TAGGED_VALUE ID basicValue ) ;
\r
5410 static SimanticsDataParser_taggedValue_return
\r
5411 taggedValue(pSimanticsDataParser ctx)
\r
5413 SimanticsDataParser_taggedValue_return retval;
\r
5415 pANTLR3_BASE_TREE root_0;
\r
5417 pANTLR3_COMMON_TOKEN ID94;
\r
5418 SimanticsDataParser_basicValue_return basicValue95;
\r
5419 #undef RETURN_TYPE_basicValue95
\r
5420 #define RETURN_TYPE_basicValue95 SimanticsDataParser_basicValue_return
\r
5422 pANTLR3_BASE_TREE ID94_tree;
\r
5423 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;
\r
5424 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_basicValue;
\r
5425 /* Initialize rule variables
\r
5432 basicValue95.tree = NULL;
\r
5434 retval.start = LT(1); retval.stop = retval.start;
\r
5439 #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); }
\r
5440 stream_basicValue = NULL;
\r
5441 #define CREATE_stream_basicValue if (stream_basicValue == NULL) {stream_basicValue = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule basicValue"); }
\r
5443 retval.tree = NULL;
\r
5445 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:216:5: ( ID basicValue -> ^( TAGGED_VALUE ID basicValue ) )
\r
5446 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:216:7: ID basicValue
\r
5448 ID94 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_taggedValue1740);
\r
5449 if (HASEXCEPTION())
\r
5451 goto ruletaggedValueEx;
\r
5454 CREATE_stream_ID; stream_ID->add(stream_ID, ID94, NULL);
\r
5456 FOLLOWPUSH(FOLLOW_basicValue_in_taggedValue1742);
\r
5457 basicValue95=basicValue(ctx);
\r
5460 if (HASEXCEPTION())
\r
5462 goto ruletaggedValueEx;
\r
5465 CREATE_stream_basicValue; stream_basicValue->add(stream_basicValue, basicValue95.tree, NULL);
\r
5469 * elements : basicValue, ID
\r
5471 * rule labels : retval
\r
5472 * token list labels :
\r
5473 * rule list labels :
\r
5476 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
5478 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
5480 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5481 retval.tree = root_0;
\r
5482 // 217:5: -> ^( TAGGED_VALUE ID basicValue )
\r
5484 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:217:8: ^( TAGGED_VALUE ID basicValue )
\r
5486 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5487 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TAGGED_VALUE, (pANTLR3_UINT8)"TAGGED_VALUE"), root_1));
\r
5489 ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));
\r
5490 ADAPTOR->addChild(ADAPTOR, root_1, stream_basicValue == NULL ? NULL : stream_basicValue->nextTree(stream_basicValue));
\r
5492 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
5497 retval.tree = root_0; // set result root
\r
5498 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
5507 // This is where rules clean up and exit
\r
5509 goto ruletaggedValueEx; /* Prevent compiler warnings */
\r
5510 ruletaggedValueEx: ;
\r
5511 retval.stop = LT(-1);
\r
5513 retval.stop = LT(-1);
\r
5514 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
5515 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
5516 if (stream_ID != NULL) stream_ID->free(stream_ID);
\r
5517 if (stream_basicValue != NULL) stream_basicValue->free(stream_basicValue);
\r
5519 if (HASEXCEPTION())
\r
5523 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
5529 /* $ANTLR end taggedValue */
\r
5532 * $ANTLR start record
\r
5533 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:220:1: record : '{' ( recordAssignment ( ',' recordAssignment )* )? '}' -> ^( RECORD ( recordAssignment )* ) ;
\r
5535 static SimanticsDataParser_record_return
\r
5536 record(pSimanticsDataParser ctx)
\r
5538 SimanticsDataParser_record_return retval;
\r
5540 pANTLR3_BASE_TREE root_0;
\r
5542 pANTLR3_COMMON_TOKEN char_literal96;
\r
5543 pANTLR3_COMMON_TOKEN char_literal98;
\r
5544 pANTLR3_COMMON_TOKEN char_literal100;
\r
5545 SimanticsDataParser_recordAssignment_return recordAssignment97;
\r
5546 #undef RETURN_TYPE_recordAssignment97
\r
5547 #define RETURN_TYPE_recordAssignment97 SimanticsDataParser_recordAssignment_return
\r
5549 SimanticsDataParser_recordAssignment_return recordAssignment99;
\r
5550 #undef RETURN_TYPE_recordAssignment99
\r
5551 #define RETURN_TYPE_recordAssignment99 SimanticsDataParser_recordAssignment_return
\r
5553 pANTLR3_BASE_TREE char_literal96_tree;
\r
5554 pANTLR3_BASE_TREE char_literal98_tree;
\r
5555 pANTLR3_BASE_TREE char_literal100_tree;
\r
5556 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_43;
\r
5557 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_44;
\r
5558 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;
\r
5559 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_recordAssignment;
\r
5560 /* Initialize rule variables
\r
5566 char_literal96 = NULL;
\r
5567 char_literal98 = NULL;
\r
5568 char_literal100 = NULL;
\r
5569 recordAssignment97.tree = NULL;
\r
5571 recordAssignment99.tree = NULL;
\r
5573 retval.start = LT(1); retval.stop = retval.start;
\r
5575 char_literal96_tree = NULL;
\r
5576 char_literal98_tree = NULL;
\r
5577 char_literal100_tree = NULL;
\r
5580 #define CREATE_stream_43 if (stream_43 == NULL) {stream_43 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 43"); }
\r
5582 #define CREATE_stream_44 if (stream_44 == NULL) {stream_44 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 44"); }
\r
5584 #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); }
\r
5585 stream_recordAssignment = NULL;
\r
5586 #define CREATE_stream_recordAssignment if (stream_recordAssignment == NULL) {stream_recordAssignment = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule recordAssignment"); }
\r
5588 retval.tree = NULL;
\r
5590 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:5: ( '{' ( recordAssignment ( ',' recordAssignment )* )? '}' -> ^( RECORD ( recordAssignment )* ) )
\r
5591 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:7: '{' ( recordAssignment ( ',' recordAssignment )* )? '}'
\r
5593 char_literal96 = (pANTLR3_COMMON_TOKEN) MATCHT(43, &FOLLOW_43_in_record1775);
\r
5594 if (HASEXCEPTION())
\r
5596 goto rulerecordEx;
\r
5599 CREATE_stream_43; stream_43->add(stream_43, char_literal96, NULL);
\r
5602 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:11: ( recordAssignment ( ',' recordAssignment )* )?
\r
5617 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:12: recordAssignment ( ',' recordAssignment )*
\r
5619 FOLLOWPUSH(FOLLOW_recordAssignment_in_record1778);
\r
5620 recordAssignment97=recordAssignment(ctx);
\r
5623 if (HASEXCEPTION())
\r
5625 goto rulerecordEx;
\r
5628 CREATE_stream_recordAssignment; stream_recordAssignment->add(stream_recordAssignment, recordAssignment97.tree, NULL);
\r
5630 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:29: ( ',' recordAssignment )*
\r
5648 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:30: ',' recordAssignment
\r
5650 char_literal98 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_record1781);
\r
5651 if (HASEXCEPTION())
\r
5653 goto rulerecordEx;
\r
5656 CREATE_stream_41; stream_41->add(stream_41, char_literal98, NULL);
\r
5658 FOLLOWPUSH(FOLLOW_recordAssignment_in_record1783);
\r
5659 recordAssignment99=recordAssignment(ctx);
\r
5662 if (HASEXCEPTION())
\r
5664 goto rulerecordEx;
\r
5667 CREATE_stream_recordAssignment; stream_recordAssignment->add(stream_recordAssignment, recordAssignment99.tree, NULL);
\r
5673 goto loop25; /* break out of the loop */
\r
5677 loop25: ; /* Jump out to here if this rule does not match */
\r
5685 char_literal100 = (pANTLR3_COMMON_TOKEN) MATCHT(44, &FOLLOW_44_in_record1789);
\r
5686 if (HASEXCEPTION())
\r
5688 goto rulerecordEx;
\r
5691 CREATE_stream_44; stream_44->add(stream_44, char_literal100, NULL);
\r
5696 * elements : recordAssignment
\r
5698 * rule labels : retval
\r
5699 * token list labels :
\r
5700 * rule list labels :
\r
5703 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
5705 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
5707 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5708 retval.tree = root_0;
\r
5709 // 222:5: -> ^( RECORD ( recordAssignment )* )
\r
5711 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:222:8: ^( RECORD ( recordAssignment )* )
\r
5713 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5714 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, RECORD, (pANTLR3_UINT8)"RECORD"), root_1));
\r
5716 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:222:17: ( recordAssignment )*
\r
5718 while ( (stream_recordAssignment != NULL && stream_recordAssignment->hasNext(stream_recordAssignment)) )
\r
5720 ADAPTOR->addChild(ADAPTOR, root_1, stream_recordAssignment == NULL ? NULL : stream_recordAssignment->nextTree(stream_recordAssignment));
\r
5723 if (stream_recordAssignment != NULL) stream_recordAssignment->reset(stream_recordAssignment);
\r
5727 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
5732 retval.tree = root_0; // set result root
\r
5733 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
5742 // This is where rules clean up and exit
\r
5744 goto rulerecordEx; /* Prevent compiler warnings */
\r
5746 retval.stop = LT(-1);
\r
5748 retval.stop = LT(-1);
\r
5749 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
5750 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
5751 if (stream_43 != NULL) stream_43->free(stream_43);
\r
5752 if (stream_44 != NULL) stream_44->free(stream_44);
\r
5753 if (stream_41 != NULL) stream_41->free(stream_41);
\r
5754 if (stream_recordAssignment != NULL) stream_recordAssignment->free(stream_recordAssignment);
\r
5756 if (HASEXCEPTION())
\r
5760 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
5766 /* $ANTLR end record */
\r
5769 * $ANTLR start recordAssignment
\r
5770 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:225:1: recordAssignment : ID '=' value -> ^( ASSIGNMENT ID value ) ;
\r
5772 static SimanticsDataParser_recordAssignment_return
\r
5773 recordAssignment(pSimanticsDataParser ctx)
\r
5775 SimanticsDataParser_recordAssignment_return retval;
\r
5777 pANTLR3_BASE_TREE root_0;
\r
5779 pANTLR3_COMMON_TOKEN ID101;
\r
5780 pANTLR3_COMMON_TOKEN char_literal102;
\r
5781 SimanticsDataParser_value_return value103;
\r
5782 #undef RETURN_TYPE_value103
\r
5783 #define RETURN_TYPE_value103 SimanticsDataParser_value_return
\r
5785 pANTLR3_BASE_TREE ID101_tree;
\r
5786 pANTLR3_BASE_TREE char_literal102_tree;
\r
5787 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;
\r
5788 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;
\r
5789 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;
\r
5790 /* Initialize rule variables
\r
5797 char_literal102 = NULL;
\r
5798 value103.tree = NULL;
\r
5800 retval.start = LT(1); retval.stop = retval.start;
\r
5802 ID101_tree = NULL;
\r
5803 char_literal102_tree = NULL;
\r
5806 #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); }
\r
5808 #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); }
\r
5809 stream_value = NULL;
\r
5810 #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }
\r
5812 retval.tree = NULL;
\r
5814 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:226:5: ( ID '=' value -> ^( ASSIGNMENT ID value ) )
\r
5815 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:226:7: ID '=' value
\r
5817 ID101 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_recordAssignment1821);
\r
5818 if (HASEXCEPTION())
\r
5820 goto rulerecordAssignmentEx;
\r
5823 CREATE_stream_ID; stream_ID->add(stream_ID, ID101, NULL);
\r
5825 char_literal102 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_recordAssignment1823);
\r
5826 if (HASEXCEPTION())
\r
5828 goto rulerecordAssignmentEx;
\r
5831 CREATE_stream_35; stream_35->add(stream_35, char_literal102, NULL);
\r
5833 FOLLOWPUSH(FOLLOW_value_in_recordAssignment1825);
\r
5834 value103=value(ctx);
\r
5837 if (HASEXCEPTION())
\r
5839 goto rulerecordAssignmentEx;
\r
5842 CREATE_stream_value; stream_value->add(stream_value, value103.tree, NULL);
\r
5846 * elements : value, ID
\r
5848 * rule labels : retval
\r
5849 * token list labels :
\r
5850 * rule list labels :
\r
5853 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
5855 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
5857 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5858 retval.tree = root_0;
\r
5859 // 227:5: -> ^( ASSIGNMENT ID value )
\r
5861 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:227:8: ^( ASSIGNMENT ID value )
\r
5863 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
5864 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ASSIGNMENT, (pANTLR3_UINT8)"ASSIGNMENT"), root_1));
\r
5866 ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));
\r
5867 ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));
\r
5869 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
5874 retval.tree = root_0; // set result root
\r
5875 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
5884 // This is where rules clean up and exit
\r
5886 goto rulerecordAssignmentEx; /* Prevent compiler warnings */
\r
5887 rulerecordAssignmentEx: ;
\r
5888 retval.stop = LT(-1);
\r
5890 retval.stop = LT(-1);
\r
5891 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
5892 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
5893 if (stream_ID != NULL) stream_ID->free(stream_ID);
\r
5894 if (stream_35 != NULL) stream_35->free(stream_35);
\r
5895 if (stream_value != NULL) stream_value->free(stream_value);
\r
5897 if (HASEXCEPTION())
\r
5901 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
5907 /* $ANTLR end recordAssignment */
\r
5910 * $ANTLR start map
\r
5911 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:1: map : 'map' '{' ( mapAssignment ( ',' mapAssignment )* )? '}' -> ^( MAP ( mapAssignment )* ) ;
\r
5913 static SimanticsDataParser_map_return
\r
5914 map(pSimanticsDataParser ctx)
\r
5916 SimanticsDataParser_map_return retval;
\r
5918 pANTLR3_BASE_TREE root_0;
\r
5920 pANTLR3_COMMON_TOKEN string_literal104;
\r
5921 pANTLR3_COMMON_TOKEN char_literal105;
\r
5922 pANTLR3_COMMON_TOKEN char_literal107;
\r
5923 pANTLR3_COMMON_TOKEN char_literal109;
\r
5924 SimanticsDataParser_mapAssignment_return mapAssignment106;
\r
5925 #undef RETURN_TYPE_mapAssignment106
\r
5926 #define RETURN_TYPE_mapAssignment106 SimanticsDataParser_mapAssignment_return
\r
5928 SimanticsDataParser_mapAssignment_return mapAssignment108;
\r
5929 #undef RETURN_TYPE_mapAssignment108
\r
5930 #define RETURN_TYPE_mapAssignment108 SimanticsDataParser_mapAssignment_return
\r
5932 pANTLR3_BASE_TREE string_literal104_tree;
\r
5933 pANTLR3_BASE_TREE char_literal105_tree;
\r
5934 pANTLR3_BASE_TREE char_literal107_tree;
\r
5935 pANTLR3_BASE_TREE char_literal109_tree;
\r
5936 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_49;
\r
5937 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_43;
\r
5938 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_44;
\r
5939 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41;
\r
5940 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_mapAssignment;
\r
5941 /* Initialize rule variables
\r
5947 string_literal104 = NULL;
\r
5948 char_literal105 = NULL;
\r
5949 char_literal107 = NULL;
\r
5950 char_literal109 = NULL;
\r
5951 mapAssignment106.tree = NULL;
\r
5953 mapAssignment108.tree = NULL;
\r
5955 retval.start = LT(1); retval.stop = retval.start;
\r
5957 string_literal104_tree = NULL;
\r
5958 char_literal105_tree = NULL;
\r
5959 char_literal107_tree = NULL;
\r
5960 char_literal109_tree = NULL;
\r
5963 #define CREATE_stream_49 if (stream_49 == NULL) {stream_49 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 49"); }
\r
5965 #define CREATE_stream_43 if (stream_43 == NULL) {stream_43 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 43"); }
\r
5967 #define CREATE_stream_44 if (stream_44 == NULL) {stream_44 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 44"); }
\r
5969 #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); }
\r
5970 stream_mapAssignment = NULL;
\r
5971 #define CREATE_stream_mapAssignment if (stream_mapAssignment == NULL) {stream_mapAssignment = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule mapAssignment"); }
\r
5973 retval.tree = NULL;
\r
5975 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:5: ( 'map' '{' ( mapAssignment ( ',' mapAssignment )* )? '}' -> ^( MAP ( mapAssignment )* ) )
\r
5976 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:7: 'map' '{' ( mapAssignment ( ',' mapAssignment )* )? '}'
\r
5978 string_literal104 = (pANTLR3_COMMON_TOKEN) MATCHT(49, &FOLLOW_49_in_map1852);
\r
5979 if (HASEXCEPTION())
\r
5984 CREATE_stream_49; stream_49->add(stream_49, string_literal104, NULL);
\r
5986 char_literal105 = (pANTLR3_COMMON_TOKEN) MATCHT(43, &FOLLOW_43_in_map1854);
\r
5987 if (HASEXCEPTION())
\r
5992 CREATE_stream_43; stream_43->add(stream_43, char_literal105, NULL);
\r
5995 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:17: ( mapAssignment ( ',' mapAssignment )* )?
\r
6020 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:18: mapAssignment ( ',' mapAssignment )*
\r
6022 FOLLOWPUSH(FOLLOW_mapAssignment_in_map1857);
\r
6023 mapAssignment106=mapAssignment(ctx);
\r
6026 if (HASEXCEPTION())
\r
6031 CREATE_stream_mapAssignment; stream_mapAssignment->add(stream_mapAssignment, mapAssignment106.tree, NULL);
\r
6033 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:32: ( ',' mapAssignment )*
\r
6051 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:33: ',' mapAssignment
\r
6053 char_literal107 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_map1860);
\r
6054 if (HASEXCEPTION())
\r
6059 CREATE_stream_41; stream_41->add(stream_41, char_literal107, NULL);
\r
6061 FOLLOWPUSH(FOLLOW_mapAssignment_in_map1862);
\r
6062 mapAssignment108=mapAssignment(ctx);
\r
6065 if (HASEXCEPTION())
\r
6070 CREATE_stream_mapAssignment; stream_mapAssignment->add(stream_mapAssignment, mapAssignment108.tree, NULL);
\r
6076 goto loop27; /* break out of the loop */
\r
6080 loop27: ; /* Jump out to here if this rule does not match */
\r
6088 char_literal109 = (pANTLR3_COMMON_TOKEN) MATCHT(44, &FOLLOW_44_in_map1868);
\r
6089 if (HASEXCEPTION())
\r
6094 CREATE_stream_44; stream_44->add(stream_44, char_literal109, NULL);
\r
6099 * elements : mapAssignment
\r
6101 * rule labels : retval
\r
6102 * token list labels :
\r
6103 * rule list labels :
\r
6106 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
6108 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
6110 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
6111 retval.tree = root_0;
\r
6112 // 231:5: -> ^( MAP ( mapAssignment )* )
\r
6114 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:231:8: ^( MAP ( mapAssignment )* )
\r
6116 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
6117 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, MAP, (pANTLR3_UINT8)"MAP"), root_1));
\r
6119 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:231:14: ( mapAssignment )*
\r
6121 while ( (stream_mapAssignment != NULL && stream_mapAssignment->hasNext(stream_mapAssignment)) )
\r
6123 ADAPTOR->addChild(ADAPTOR, root_1, stream_mapAssignment == NULL ? NULL : stream_mapAssignment->nextTree(stream_mapAssignment));
\r
6126 if (stream_mapAssignment != NULL) stream_mapAssignment->reset(stream_mapAssignment);
\r
6130 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
6135 retval.tree = root_0; // set result root
\r
6136 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
6145 // This is where rules clean up and exit
\r
6147 goto rulemapEx; /* Prevent compiler warnings */
\r
6149 retval.stop = LT(-1);
\r
6151 retval.stop = LT(-1);
\r
6152 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
6153 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
6154 if (stream_49 != NULL) stream_49->free(stream_49);
\r
6155 if (stream_43 != NULL) stream_43->free(stream_43);
\r
6156 if (stream_44 != NULL) stream_44->free(stream_44);
\r
6157 if (stream_41 != NULL) stream_41->free(stream_41);
\r
6158 if (stream_mapAssignment != NULL) stream_mapAssignment->free(stream_mapAssignment);
\r
6160 if (HASEXCEPTION())
\r
6164 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
6170 /* $ANTLR end map */
\r
6173 * $ANTLR start mapAssignment
\r
6174 * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:234:1: mapAssignment : value '=' value -> ^( ASSIGNMENT ( value )* ) ;
\r
6176 static SimanticsDataParser_mapAssignment_return
\r
6177 mapAssignment(pSimanticsDataParser ctx)
\r
6179 SimanticsDataParser_mapAssignment_return retval;
\r
6181 pANTLR3_BASE_TREE root_0;
\r
6183 pANTLR3_COMMON_TOKEN char_literal111;
\r
6184 SimanticsDataParser_value_return value110;
\r
6185 #undef RETURN_TYPE_value110
\r
6186 #define RETURN_TYPE_value110 SimanticsDataParser_value_return
\r
6188 SimanticsDataParser_value_return value112;
\r
6189 #undef RETURN_TYPE_value112
\r
6190 #define RETURN_TYPE_value112 SimanticsDataParser_value_return
\r
6192 pANTLR3_BASE_TREE char_literal111_tree;
\r
6193 pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35;
\r
6194 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value;
\r
6195 /* Initialize rule variables
\r
6201 char_literal111 = NULL;
\r
6202 value110.tree = NULL;
\r
6204 value112.tree = NULL;
\r
6206 retval.start = LT(1); retval.stop = retval.start;
\r
6208 char_literal111_tree = NULL;
\r
6211 #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); }
\r
6212 stream_value = NULL;
\r
6213 #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); }
\r
6215 retval.tree = NULL;
\r
6217 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:235:5: ( value '=' value -> ^( ASSIGNMENT ( value )* ) )
\r
6218 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:235:7: value '=' value
\r
6220 FOLLOWPUSH(FOLLOW_value_in_mapAssignment1900);
\r
6221 value110=value(ctx);
\r
6224 if (HASEXCEPTION())
\r
6226 goto rulemapAssignmentEx;
\r
6229 CREATE_stream_value; stream_value->add(stream_value, value110.tree, NULL);
\r
6230 char_literal111 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_mapAssignment1902);
\r
6231 if (HASEXCEPTION())
\r
6233 goto rulemapAssignmentEx;
\r
6236 CREATE_stream_35; stream_35->add(stream_35, char_literal111, NULL);
\r
6238 FOLLOWPUSH(FOLLOW_value_in_mapAssignment1904);
\r
6239 value112=value(ctx);
\r
6242 if (HASEXCEPTION())
\r
6244 goto rulemapAssignmentEx;
\r
6247 CREATE_stream_value; stream_value->add(stream_value, value112.tree, NULL);
\r
6251 * elements : value
\r
6253 * rule labels : retval
\r
6254 * token list labels :
\r
6255 * rule list labels :
\r
6258 pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;
\r
6260 stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);
\r
6262 root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
6263 retval.tree = root_0;
\r
6264 // 236:5: -> ^( ASSIGNMENT ( value )* )
\r
6266 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:236:8: ^( ASSIGNMENT ( value )* )
\r
6268 pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));
\r
6269 root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ASSIGNMENT, (pANTLR3_UINT8)"ASSIGNMENT"), root_1));
\r
6271 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:236:21: ( value )*
\r
6273 while ( (stream_value != NULL && stream_value->hasNext(stream_value)) )
\r
6275 ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value));
\r
6278 if (stream_value != NULL) stream_value->reset(stream_value);
\r
6282 ADAPTOR->addChild(ADAPTOR, root_0, root_1);
\r
6287 retval.tree = root_0; // set result root
\r
6288 if (stream_retval != NULL) stream_retval->free(stream_retval);
\r
6297 // This is where rules clean up and exit
\r
6299 goto rulemapAssignmentEx; /* Prevent compiler warnings */
\r
6300 rulemapAssignmentEx: ;
\r
6301 retval.stop = LT(-1);
\r
6303 retval.stop = LT(-1);
\r
6304 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));
\r
6305 ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);
\r
6306 if (stream_35 != NULL) stream_35->free(stream_35);
\r
6307 if (stream_value != NULL) stream_value->free(stream_value);
\r
6309 if (HASEXCEPTION())
\r
6313 retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));
\r
6319 /* $ANTLR end mapAssignment */
\r
6320 /* End of parsing rules
\r
6321 * ==============================================
\r
6324 /* ==============================================
\r
6325 * Syntactic predicates
\r
6327 /* End of syntactic predicates
\r
6328 * ==============================================
\r
6337 * =============================================================================
\r