X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.databoard%2Fcpp%2FDataBoardTest%2FDataBoard%2FSimanticsDataParser.c;fp=bundles%2Forg.simantics.databoard%2Fcpp%2FDataBoardTest%2FDataBoard%2FSimanticsDataParser.c;h=80cc2eee8b157535bbcdb08a47bd873d9811f2af;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git diff --git a/bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/SimanticsDataParser.c b/bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/SimanticsDataParser.c new file mode 100644 index 000000000..80cc2eee8 --- /dev/null +++ b/bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/SimanticsDataParser.c @@ -0,0 +1,6338 @@ +/** \file + * This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23 + * + * - From the grammar source file : C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g + * - On : 2010-03-26 13:33:27 + * - for the parser : SimanticsDataParserParser * + * Editing it, at least manually, is not wise. + * + * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws. + * + * +*/ +// [The "BSD licence"] +// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC +// http://www.temporal-wave.com +// http://www.linkedin.com/in/jimidle +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. The name of the author may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* ----------------------------------------- + * Include the ANTLR3 generated header file. + */ +#include "SimanticsDataParser.h" +/* ----------------------------------------- */ + + + + + +/* MACROS that hide the C interface implementations from the + * generated code, which makes it a little more understandable to the human eye. + * I am very much against using C pre-processor macros for function calls and bits + * of code as you cannot see what is happening when single stepping in debuggers + * and so on. The exception (in my book at least) is for generated code, where you are + * not maintaining it, but may wish to read and understand it. If you single step it, you know that input() + * hides some indirect calls, but is always referring to the input stream. This is + * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig + * the runtime interfaces without changing the generated code too often, without + * confusing the reader of the generated output, who may not wish to know the gory + * details of the interface inheritance. + */ + +#define CTX ctx + +/* Aids in accessing scopes for grammar programmers + */ +#undef SCOPE_TYPE +#undef SCOPE_STACK +#undef SCOPE_TOP +#define SCOPE_TYPE(scope) pSimanticsDataParser_##scope##_SCOPE +#define SCOPE_STACK(scope) pSimanticsDataParser_##scope##Stack +#define SCOPE_TOP(scope) ctx->pSimanticsDataParser_##scope##Top +#define SCOPE_SIZE(scope) ctx->pSimanticsDataParser_##scope##Stack_limit +#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i)) + +/* Macros for accessing things in the parser + */ + +#undef PARSER +#undef RECOGNIZER +#undef HAVEPARSEDRULE +#undef MEMOIZE +#undef INPUT +#undef STRSTREAM +#undef HASEXCEPTION +#undef EXCEPTION +#undef MATCHT +#undef MATCHANYT +#undef FOLLOWSTACK +#undef FOLLOWPUSH +#undef FOLLOWPOP +#undef PRECOVER +#undef PREPORTERROR +#undef LA +#undef LT +#undef CONSTRUCTEX +#undef CONSUME +#undef MARK +#undef REWIND +#undef REWINDLAST +#undef PERRORRECOVERY +#undef HASFAILED +#undef FAILEDFLAG +#undef RECOVERFROMMISMATCHEDSET +#undef RECOVERFROMMISMATCHEDELEMENT +#undef INDEX +#undef ADAPTOR +#undef SEEK +#undef RULEMEMO +#undef DBG + +#define PARSER ctx->pParser +#define RECOGNIZER PARSER->rec +#define PSRSTATE RECOGNIZER->state +#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r) +#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si) +#define INPUT PARSER->tstream +#define STRSTREAM INPUT +#define ISTREAM INPUT->istream +#define INDEX() ISTREAM->index(INPUT->istream) +#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE) +#define EXCEPTION PSRSTATE->exception +#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs) +#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER) +#define FOLLOWSTACK PSRSTATE->following +#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL) +#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK) +#define PRECOVER() RECOGNIZER->recover(RECOGNIZER) +#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER) +#define LA(n) INPUT->istream->_LA(ISTREAM, n) +#define LT(n) INPUT->_LT(INPUT, n) +#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER) +#define CONSUME() ISTREAM->consume(ISTREAM) +#define MARK() ISTREAM->mark(ISTREAM) +#define REWIND(m) ISTREAM->rewind(ISTREAM, m) +#define REWINDLAST() ISTREAM->rewindLast(ISTREAM) +#define SEEK(n) ISTREAM->seek(ISTREAM, n) +#define PERRORRECOVERY PSRSTATE->errorRecovery +#define FAILEDFLAG PSRSTATE->failed +#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE) +#define BACKTRACKING PSRSTATE->backtracking +#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s) +#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s) +#define ADAPTOR ctx->adaptor +#define RULEMEMO PSRSTATE->ruleMemo +#define DBG RECOGNIZER->debugger + +#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt + +/* The 4 tokens defined below may well clash with your own #defines or token types. If so + * then for the present you must use different names for your defines as these are hard coded + * in the code generator. It would be better not to use such names internally, and maybe + * we can change this in a forthcoming release. I deliberately do not #undef these + * here as this will at least give you a redefined error somewhere if they clash. + */ +#define UP ANTLR3_TOKEN_UP +#define DOWN ANTLR3_TOKEN_DOWN +#define EOR ANTLR3_TOKEN_EOR +#define INVALID ANTLR3_TOKEN_INVALID + + +/* ============================================================================= + * Functions to create and destroy scopes. First come the rule scopes, followed + * by the global declared scopes. + */ + + + +/* ============================================================================= */ + +/* ============================================================================= + * Start of recognizer + */ + + + +/** \brief Table of all token names in symbolic order, mainly used for + * error reporting. + */ +pANTLR3_UINT8 SimanticsDataParserTokenNames[46+4] + = { + (pANTLR3_UINT8) "", /* String to print to indicate an invalid token */ + (pANTLR3_UINT8) "", + (pANTLR3_UINT8) "", + (pANTLR3_UINT8) "", + (pANTLR3_UINT8) "TYPE_DEFINITIONS", + (pANTLR3_UINT8) "TYPE_DEFINITION", + (pANTLR3_UINT8) "UNION_TYPE", + (pANTLR3_UINT8) "RECORD_TYPE", + (pANTLR3_UINT8) "TUPLE_TYPE", + (pANTLR3_UINT8) "ARRAY_TYPE", + (pANTLR3_UINT8) "TYPE_REFERENCE", + (pANTLR3_UINT8) "TYPE_ANNOTATION", + (pANTLR3_UINT8) "TYPE_COMPONENT", + (pANTLR3_UINT8) "VALUE_DEFINITIONS", + (pANTLR3_UINT8) "VALUE_DEFINITION", + (pANTLR3_UINT8) "NO_VALUE", + (pANTLR3_UINT8) "VARIANT", + (pANTLR3_UINT8) "ARRAY", + (pANTLR3_UINT8) "TUPLE", + (pANTLR3_UINT8) "TAGGED_VALUE", + (pANTLR3_UINT8) "RECORD", + (pANTLR3_UINT8) "MAP", + (pANTLR3_UINT8) "ASSIGNMENT", + (pANTLR3_UINT8) "ID", + (pANTLR3_UINT8) "INT", + (pANTLR3_UINT8) "EXPONENT", + (pANTLR3_UINT8) "FLOAT", + (pANTLR3_UINT8) "COMMENT", + (pANTLR3_UINT8) "WS", + (pANTLR3_UINT8) "ESC_SEQ", + (pANTLR3_UINT8) "STRING", + (pANTLR3_UINT8) "HEX_DIGIT", + (pANTLR3_UINT8) "UNICODE_ESC", + (pANTLR3_UINT8) "OCTAL_ESC", + (pANTLR3_UINT8) "'type'", + (pANTLR3_UINT8) "'='", + (pANTLR3_UINT8) "'|'", + (pANTLR3_UINT8) "'['", + (pANTLR3_UINT8) "']'", + (pANTLR3_UINT8) "'..'", + (pANTLR3_UINT8) "'('", + (pANTLR3_UINT8) "','", + (pANTLR3_UINT8) "')'", + (pANTLR3_UINT8) "'{'", + (pANTLR3_UINT8) "'}'", + (pANTLR3_UINT8) "':'", + (pANTLR3_UINT8) "'true'", + (pANTLR3_UINT8) "'false'", + (pANTLR3_UINT8) "'null'", + (pANTLR3_UINT8) "'map'" + }; + + + +// Forward declare the locally static matching functions we have generated. +// +static SimanticsDataParser_typeDefinitions_return typeDefinitions (pSimanticsDataParser ctx); +static SimanticsDataParser_typeDefinition_return typeDefinition (pSimanticsDataParser ctx); +static SimanticsDataParser_unionType_return unionType (pSimanticsDataParser ctx); +static SimanticsDataParser_unionComponent_return unionComponent (pSimanticsDataParser ctx); +static SimanticsDataParser_type_return type (pSimanticsDataParser ctx); +static SimanticsDataParser_arrayLength_return arrayLength (pSimanticsDataParser ctx); +static SimanticsDataParser_basicType_return basicType (pSimanticsDataParser ctx); +static SimanticsDataParser_tupleType_return tupleType (pSimanticsDataParser ctx); +static SimanticsDataParser_recordType_return recordType (pSimanticsDataParser ctx); +static SimanticsDataParser_component_return component (pSimanticsDataParser ctx); +static SimanticsDataParser_typeReference_return typeReference (pSimanticsDataParser ctx); +static SimanticsDataParser_parameter_return parameter (pSimanticsDataParser ctx); +static SimanticsDataParser_parameterValue_return parameterValue (pSimanticsDataParser ctx); +static SimanticsDataParser_range_return range (pSimanticsDataParser ctx); +static SimanticsDataParser_number_return number (pSimanticsDataParser ctx); +static SimanticsDataParser_string_return string (pSimanticsDataParser ctx); +static SimanticsDataParser_boolean_return boolean (pSimanticsDataParser ctx); +static SimanticsDataParser_valueDefinitions_return valueDefinitions (pSimanticsDataParser ctx); +static SimanticsDataParser_valueDefinition_return valueDefinition (pSimanticsDataParser ctx); +static SimanticsDataParser_value_return value (pSimanticsDataParser ctx); +static SimanticsDataParser_basicValue_return basicValue (pSimanticsDataParser ctx); +static SimanticsDataParser_array_return array (pSimanticsDataParser ctx); +static SimanticsDataParser_tuple_return tuple (pSimanticsDataParser ctx); +static SimanticsDataParser_taggedValue_return taggedValue (pSimanticsDataParser ctx); +static SimanticsDataParser_record_return record (pSimanticsDataParser ctx); +static SimanticsDataParser_recordAssignment_return recordAssignment (pSimanticsDataParser ctx); +static SimanticsDataParser_map_return map (pSimanticsDataParser ctx); +static SimanticsDataParser_mapAssignment_return mapAssignment (pSimanticsDataParser ctx); +static void SimanticsDataParserFree(pSimanticsDataParser ctx); +/* For use in tree output where we are accumulating rule labels via label += ruleRef + * we need a function that knows how to free a return scope when the list is destroyed. + * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro. + */ +static void ANTLR3_CDECL freeScope(void * scope) +{ + ANTLR3_FREE(scope); +} + +/** \brief Name of the grammar file that generated this code + */ +static const char fileName[] = "C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g"; + +/** \brief Return the name of the grammar file that generated this code. + */ +static const char * getGrammarFileName() +{ + return fileName; +} +/** \brief Create a new SimanticsDataParser parser and return a context for it. + * + * \param[in] instream Pointer to an input stream interface. + * + * \return Pointer to new parser context upon success. + */ +ANTLR3_API pSimanticsDataParser +SimanticsDataParserNew (pANTLR3_COMMON_TOKEN_STREAM instream) +{ + // See if we can create a new parser with the standard constructor + // + return SimanticsDataParserNewSSD(instream, NULL); +} + +/** \brief Create a new SimanticsDataParser parser and return a context for it. + * + * \param[in] instream Pointer to an input stream interface. + * + * \return Pointer to new parser context upon success. + */ +ANTLR3_API pSimanticsDataParser +SimanticsDataParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state) +{ + pSimanticsDataParser ctx; /* Context structure we will build and return */ + + ctx = (pSimanticsDataParser) ANTLR3_CALLOC(1, sizeof(SimanticsDataParser)); + + if (ctx == NULL) + { + // Failed to allocate memory for parser context + // + return NULL; + } + + /* ------------------------------------------------------------------- + * Memory for basic structure is allocated, now to fill in + * the base ANTLR3 structures. We initialize the function pointers + * for the standard ANTLR3 parser function set, but upon return + * from here, the programmer may set the pointers to provide custom + * implementations of each function. + * + * We don't use the macros defined in SimanticsDataParser.h here, in order that you can get a sense + * of what goes where. + */ + + /* Create a base parser/recognizer, using the supplied token stream + */ + ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state); + /* Install the implementation of our SimanticsDataParser interface + */ + ctx->typeDefinitions = typeDefinitions; + ctx->typeDefinition = typeDefinition; + ctx->unionType = unionType; + ctx->unionComponent = unionComponent; + ctx->type = type; + ctx->arrayLength = arrayLength; + ctx->basicType = basicType; + ctx->tupleType = tupleType; + ctx->recordType = recordType; + ctx->component = component; + ctx->typeReference = typeReference; + ctx->parameter = parameter; + ctx->parameterValue = parameterValue; + ctx->range = range; + ctx->number = number; + ctx->string = string; + ctx->boolean = boolean; + ctx->valueDefinitions = valueDefinitions; + ctx->valueDefinition = valueDefinition; + ctx->value = value; + ctx->basicValue = basicValue; + ctx->array = array; + ctx->tuple = tuple; + ctx->taggedValue = taggedValue; + ctx->record = record; + ctx->recordAssignment = recordAssignment; + ctx->map = map; + ctx->mapAssignment = mapAssignment; + ctx->free = SimanticsDataParserFree; + ctx->getGrammarFileName = getGrammarFileName; + + /* Install the scope pushing methods. + */ + ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory); + ctx->vectors = antlr3VectorFactoryNew(0); + + + + /* Install the token table + */ + PSRSTATE->tokenNames = SimanticsDataParserTokenNames; + + + /* Return the newly built parser to the caller + */ + return ctx; +} + +/** Free the parser resources + */ + static void + SimanticsDataParserFree(pSimanticsDataParser ctx) + { + /* Free any scope memory + */ + + ctx->vectors->close(ctx->vectors); + /* We created the adaptor so we must free it + */ + ADAPTOR->free(ADAPTOR); + // Free this parser + // + ctx->pParser->free(ctx->pParser); + ANTLR3_FREE(ctx); + + /* Everything is released, so we can return + */ + return; + } + +/** Return token names used by this parser + * + * The returned pointer is used as an index into the token names table (using the token + * number as the index). + * + * \return Pointer to first char * in the table. + */ +static pANTLR3_UINT8 *getTokenNames() +{ + return SimanticsDataParserTokenNames; +} + + +/* Declare the bitsets + */ + +/** Bitset defining follow set for error recovery in rule state: FOLLOW_typeDefinition_in_typeDefinitions768 */ +static ANTLR3_BITWORD FOLLOW_typeDefinition_in_typeDefinitions768_bits[] = { ANTLR3_UINT64_LIT(0x0000000400000002) }; +static ANTLR3_BITSET_LIST FOLLOW_typeDefinition_in_typeDefinitions768 = { FOLLOW_typeDefinition_in_typeDefinitions768_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_34_in_typeDefinition791 */ +static ANTLR3_BITWORD FOLLOW_34_in_typeDefinition791_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_34_in_typeDefinition791 = { FOLLOW_34_in_typeDefinition791_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_typeDefinition793 */ +static ANTLR3_BITWORD FOLLOW_ID_in_typeDefinition793_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) }; +static ANTLR3_BITSET_LIST FOLLOW_ID_in_typeDefinition793 = { FOLLOW_ID_in_typeDefinition793_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_typeDefinition795 */ +static ANTLR3_BITWORD FOLLOW_35_in_typeDefinition795_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_35_in_typeDefinition795 = { FOLLOW_35_in_typeDefinition795_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_typeDefinition797 */ +static ANTLR3_BITWORD FOLLOW_unionType_in_typeDefinition797_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_unionType_in_typeDefinition797 = { FOLLOW_unionType_in_typeDefinition797_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_unionType829 */ +static ANTLR3_BITWORD FOLLOW_type_in_unionType829_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_type_in_unionType829 = { FOLLOW_type_in_unionType829_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_36_in_unionType838 */ +static ANTLR3_BITWORD FOLLOW_36_in_unionType838_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_36_in_unionType838 = { FOLLOW_36_in_unionType838_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_unionComponent_in_unionType840 */ +static ANTLR3_BITWORD FOLLOW_unionComponent_in_unionType840_bits[] = { ANTLR3_UINT64_LIT(0x0000001000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_unionComponent_in_unionType840 = { FOLLOW_unionComponent_in_unionType840_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_unionComponent871 */ +static ANTLR3_BITWORD FOLLOW_ID_in_unionComponent871_bits[] = { ANTLR3_UINT64_LIT(0x0000090000800002) }; +static ANTLR3_BITSET_LIST FOLLOW_ID_in_unionComponent871 = { FOLLOW_ID_in_unionComponent871_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_unionComponent873 */ +static ANTLR3_BITWORD FOLLOW_type_in_unionComponent873_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_type_in_unionComponent873 = { FOLLOW_type_in_unionComponent873_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_basicType_in_type900 */ +static ANTLR3_BITWORD FOLLOW_basicType_in_type900_bits[] = { ANTLR3_UINT64_LIT(0x0000002000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_basicType_in_type900 = { FOLLOW_basicType_in_type900_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_37_in_type914 */ +static ANTLR3_BITWORD FOLLOW_37_in_type914_bits[] = { ANTLR3_UINT64_LIT(0x000000C001000000) }; +static ANTLR3_BITSET_LIST FOLLOW_37_in_type914 = { FOLLOW_37_in_type914_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_arrayLength_in_type916 */ +static ANTLR3_BITWORD FOLLOW_arrayLength_in_type916_bits[] = { ANTLR3_UINT64_LIT(0x0000004000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_arrayLength_in_type916 = { FOLLOW_arrayLength_in_type916_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_38_in_type919 */ +static ANTLR3_BITWORD FOLLOW_38_in_type919_bits[] = { ANTLR3_UINT64_LIT(0x0000002000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_38_in_type919 = { FOLLOW_38_in_type919_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength947 */ +static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength947_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength947 = { FOLLOW_INT_in_arrayLength947_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength955 */ +static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength955_bits[] = { ANTLR3_UINT64_LIT(0x0000008000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength955 = { FOLLOW_INT_in_arrayLength955_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_arrayLength957 */ +static ANTLR3_BITWORD FOLLOW_39_in_arrayLength957_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_39_in_arrayLength957 = { FOLLOW_39_in_arrayLength957_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_arrayLength965 */ +static ANTLR3_BITWORD FOLLOW_39_in_arrayLength965_bits[] = { ANTLR3_UINT64_LIT(0x0000000001000000) }; +static ANTLR3_BITSET_LIST FOLLOW_39_in_arrayLength965 = { FOLLOW_39_in_arrayLength965_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength967 */ +static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength967_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength967 = { FOLLOW_INT_in_arrayLength967_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength976 */ +static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength976_bits[] = { ANTLR3_UINT64_LIT(0x0000008000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength976 = { FOLLOW_INT_in_arrayLength976_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_arrayLength978 */ +static ANTLR3_BITWORD FOLLOW_39_in_arrayLength978_bits[] = { ANTLR3_UINT64_LIT(0x0000000001000000) }; +static ANTLR3_BITSET_LIST FOLLOW_39_in_arrayLength978 = { FOLLOW_39_in_arrayLength978_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_INT_in_arrayLength980 */ +static ANTLR3_BITWORD FOLLOW_INT_in_arrayLength980_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_INT_in_arrayLength980 = { FOLLOW_INT_in_arrayLength980_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_tupleType_in_basicType998 */ +static ANTLR3_BITWORD FOLLOW_tupleType_in_basicType998_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_tupleType_in_basicType998 = { FOLLOW_tupleType_in_basicType998_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_recordType_in_basicType1006 */ +static ANTLR3_BITWORD FOLLOW_recordType_in_basicType1006_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_recordType_in_basicType1006 = { FOLLOW_recordType_in_basicType1006_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_typeReference_in_basicType1014 */ +static ANTLR3_BITWORD FOLLOW_typeReference_in_basicType1014_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_typeReference_in_basicType1014 = { FOLLOW_typeReference_in_basicType1014_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_40_in_tupleType1036 */ +static ANTLR3_BITWORD FOLLOW_40_in_tupleType1036_bits[] = { ANTLR3_UINT64_LIT(0x00000D1000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_40_in_tupleType1036 = { FOLLOW_40_in_tupleType1036_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_tupleType1039 */ +static ANTLR3_BITWORD FOLLOW_unionType_in_tupleType1039_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_unionType_in_tupleType1039 = { FOLLOW_unionType_in_tupleType1039_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_tupleType1042 */ +static ANTLR3_BITWORD FOLLOW_41_in_tupleType1042_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_41_in_tupleType1042 = { FOLLOW_41_in_tupleType1042_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_tupleType1044 */ +static ANTLR3_BITWORD FOLLOW_unionType_in_tupleType1044_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_unionType_in_tupleType1044 = { FOLLOW_unionType_in_tupleType1044_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_42_in_tupleType1050 */ +static ANTLR3_BITWORD FOLLOW_42_in_tupleType1050_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_42_in_tupleType1050 = { FOLLOW_42_in_tupleType1050_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_43_in_recordType1083 */ +static ANTLR3_BITWORD FOLLOW_43_in_recordType1083_bits[] = { ANTLR3_UINT64_LIT(0x0000100000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_43_in_recordType1083 = { FOLLOW_43_in_recordType1083_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_component_in_recordType1086 */ +static ANTLR3_BITWORD FOLLOW_component_in_recordType1086_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_component_in_recordType1086 = { FOLLOW_component_in_recordType1086_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_recordType1089 */ +static ANTLR3_BITWORD FOLLOW_41_in_recordType1089_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_41_in_recordType1089 = { FOLLOW_41_in_recordType1089_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_component_in_recordType1091 */ +static ANTLR3_BITWORD FOLLOW_component_in_recordType1091_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_component_in_recordType1091 = { FOLLOW_component_in_recordType1091_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_44_in_recordType1097 */ +static ANTLR3_BITWORD FOLLOW_44_in_recordType1097_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_44_in_recordType1097 = { FOLLOW_44_in_recordType1097_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_component1129 */ +static ANTLR3_BITWORD FOLLOW_ID_in_component1129_bits[] = { ANTLR3_UINT64_LIT(0x0000200000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_ID_in_component1129 = { FOLLOW_ID_in_component1129_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_45_in_component1131 */ +static ANTLR3_BITWORD FOLLOW_45_in_component1131_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_45_in_component1131 = { FOLLOW_45_in_component1131_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_component1133 */ +static ANTLR3_BITWORD FOLLOW_unionType_in_component1133_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_unionType_in_component1133 = { FOLLOW_unionType_in_component1133_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_typeReference1167 */ +static ANTLR3_BITWORD FOLLOW_ID_in_typeReference1167_bits[] = { ANTLR3_UINT64_LIT(0x0000010000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_ID_in_typeReference1167 = { FOLLOW_ID_in_typeReference1167_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_40_in_typeReference1170 */ +static ANTLR3_BITWORD FOLLOW_40_in_typeReference1170_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_40_in_typeReference1170 = { FOLLOW_40_in_typeReference1170_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_parameter_in_typeReference1172 */ +static ANTLR3_BITWORD FOLLOW_parameter_in_typeReference1172_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_parameter_in_typeReference1172 = { FOLLOW_parameter_in_typeReference1172_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_typeReference1175 */ +static ANTLR3_BITWORD FOLLOW_41_in_typeReference1175_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_41_in_typeReference1175 = { FOLLOW_41_in_typeReference1175_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_parameter_in_typeReference1177 */ +static ANTLR3_BITWORD FOLLOW_parameter_in_typeReference1177_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_parameter_in_typeReference1177 = { FOLLOW_parameter_in_typeReference1177_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_42_in_typeReference1181 */ +static ANTLR3_BITWORD FOLLOW_42_in_typeReference1181_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_42_in_typeReference1181 = { FOLLOW_42_in_typeReference1181_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_parameter1217 */ +static ANTLR3_BITWORD FOLLOW_ID_in_parameter1217_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) }; +static ANTLR3_BITSET_LIST FOLLOW_ID_in_parameter1217 = { FOLLOW_ID_in_parameter1217_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_parameter1219 */ +static ANTLR3_BITWORD FOLLOW_35_in_parameter1219_bits[] = { ANTLR3_UINT64_LIT(0x0000C12045000000) }; +static ANTLR3_BITSET_LIST FOLLOW_35_in_parameter1219 = { FOLLOW_35_in_parameter1219_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_parameterValue_in_parameter1221 */ +static ANTLR3_BITWORD FOLLOW_parameterValue_in_parameter1221_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_parameterValue_in_parameter1221 = { FOLLOW_parameterValue_in_parameter1221_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_parameter1239 */ +static ANTLR3_BITWORD FOLLOW_unionType_in_parameter1239_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_unionType_in_parameter1239 = { FOLLOW_unionType_in_parameter1239_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_string_in_parameterValue1258 */ +static ANTLR3_BITWORD FOLLOW_string_in_parameterValue1258_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_string_in_parameterValue1258 = { FOLLOW_string_in_parameterValue1258_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_boolean_in_parameterValue1266 */ +static ANTLR3_BITWORD FOLLOW_boolean_in_parameterValue1266_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_boolean_in_parameterValue1266 = { FOLLOW_boolean_in_parameterValue1266_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_parameterValue1274 */ +static ANTLR3_BITWORD FOLLOW_number_in_parameterValue1274_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_number_in_parameterValue1274 = { FOLLOW_number_in_parameterValue1274_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_parameterValue1282 */ +static ANTLR3_BITWORD FOLLOW_set_in_parameterValue1282_bits[] = { ANTLR3_UINT64_LIT(0x0000008005000000) }; +static ANTLR3_BITSET_LIST FOLLOW_set_in_parameterValue1282 = { FOLLOW_set_in_parameterValue1282_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_range_in_parameterValue1290 */ +static ANTLR3_BITWORD FOLLOW_range_in_parameterValue1290_bits[] = { ANTLR3_UINT64_LIT(0x0000044000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_range_in_parameterValue1290 = { FOLLOW_range_in_parameterValue1290_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_parameterValue1292 */ +static ANTLR3_BITWORD FOLLOW_set_in_parameterValue1292_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_set_in_parameterValue1292 = { FOLLOW_set_in_parameterValue1292_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1319 */ +static ANTLR3_BITWORD FOLLOW_number_in_range1319_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_number_in_range1319 = { FOLLOW_number_in_range1319_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1327 */ +static ANTLR3_BITWORD FOLLOW_number_in_range1327_bits[] = { ANTLR3_UINT64_LIT(0x0000008000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_number_in_range1327 = { FOLLOW_number_in_range1327_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_range1329 */ +static ANTLR3_BITWORD FOLLOW_39_in_range1329_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_39_in_range1329 = { FOLLOW_39_in_range1329_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_range1337 */ +static ANTLR3_BITWORD FOLLOW_39_in_range1337_bits[] = { ANTLR3_UINT64_LIT(0x0000000005000000) }; +static ANTLR3_BITSET_LIST FOLLOW_39_in_range1337 = { FOLLOW_39_in_range1337_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1339 */ +static ANTLR3_BITWORD FOLLOW_number_in_range1339_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_number_in_range1339 = { FOLLOW_number_in_range1339_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1348 */ +static ANTLR3_BITWORD FOLLOW_number_in_range1348_bits[] = { ANTLR3_UINT64_LIT(0x0000008000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_number_in_range1348 = { FOLLOW_number_in_range1348_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_39_in_range1350 */ +static ANTLR3_BITWORD FOLLOW_39_in_range1350_bits[] = { ANTLR3_UINT64_LIT(0x0000000005000000) }; +static ANTLR3_BITSET_LIST FOLLOW_39_in_range1350 = { FOLLOW_39_in_range1350_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_range1352 */ +static ANTLR3_BITWORD FOLLOW_number_in_range1352_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_number_in_range1352 = { FOLLOW_number_in_range1352_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_number0 */ +static ANTLR3_BITWORD FOLLOW_set_in_number0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_set_in_number0 = { FOLLOW_set_in_number0_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_STRING_in_string1402 */ +static ANTLR3_BITWORD FOLLOW_STRING_in_string1402_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_STRING_in_string1402 = { FOLLOW_STRING_in_string1402_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_boolean0 */ +static ANTLR3_BITWORD FOLLOW_set_in_boolean0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_set_in_boolean0 = { FOLLOW_set_in_boolean0_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_valueDefinition_in_valueDefinitions1447 */ +static ANTLR3_BITWORD FOLLOW_valueDefinition_in_valueDefinitions1447_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800002) }; +static ANTLR3_BITSET_LIST FOLLOW_valueDefinition_in_valueDefinitions1447 = { FOLLOW_valueDefinition_in_valueDefinitions1447_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_valueDefinition1470 */ +static ANTLR3_BITWORD FOLLOW_ID_in_valueDefinition1470_bits[] = { ANTLR3_UINT64_LIT(0x0000200000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_ID_in_valueDefinition1470 = { FOLLOW_ID_in_valueDefinition1470_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_45_in_valueDefinition1472 */ +static ANTLR3_BITWORD FOLLOW_45_in_valueDefinition1472_bits[] = { ANTLR3_UINT64_LIT(0x0000091000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_45_in_valueDefinition1472 = { FOLLOW_45_in_valueDefinition1472_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_unionType_in_valueDefinition1474 */ +static ANTLR3_BITWORD FOLLOW_unionType_in_valueDefinition1474_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) }; +static ANTLR3_BITSET_LIST FOLLOW_unionType_in_valueDefinition1474 = { FOLLOW_unionType_in_valueDefinition1474_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_valueDefinition1476 */ +static ANTLR3_BITWORD FOLLOW_35_in_valueDefinition1476_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_35_in_valueDefinition1476 = { FOLLOW_35_in_valueDefinition1476_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_valueDefinition1478 */ +static ANTLR3_BITWORD FOLLOW_value_in_valueDefinition1478_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_value_in_valueDefinition1478 = { FOLLOW_value_in_valueDefinition1478_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_basicValue_in_value1514 */ +static ANTLR3_BITWORD FOLLOW_basicValue_in_value1514_bits[] = { ANTLR3_UINT64_LIT(0x0000200000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_basicValue_in_value1514 = { FOLLOW_basicValue_in_value1514_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_45_in_value1528 */ +static ANTLR3_BITWORD FOLLOW_45_in_value1528_bits[] = { ANTLR3_UINT64_LIT(0x0000090000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_45_in_value1528 = { FOLLOW_45_in_value1528_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_value1530 */ +static ANTLR3_BITWORD FOLLOW_type_in_value1530_bits[] = { ANTLR3_UINT64_LIT(0x0000200000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_type_in_value1530 = { FOLLOW_type_in_value1530_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_48_in_basicValue1562 */ +static ANTLR3_BITWORD FOLLOW_48_in_basicValue1562_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_48_in_basicValue1562 = { FOLLOW_48_in_basicValue1562_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_string_in_basicValue1574 */ +static ANTLR3_BITWORD FOLLOW_string_in_basicValue1574_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_string_in_basicValue1574 = { FOLLOW_string_in_basicValue1574_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_number_in_basicValue1582 */ +static ANTLR3_BITWORD FOLLOW_number_in_basicValue1582_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_number_in_basicValue1582 = { FOLLOW_number_in_basicValue1582_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_boolean_in_basicValue1590 */ +static ANTLR3_BITWORD FOLLOW_boolean_in_basicValue1590_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_boolean_in_basicValue1590 = { FOLLOW_boolean_in_basicValue1590_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_array_in_basicValue1598 */ +static ANTLR3_BITWORD FOLLOW_array_in_basicValue1598_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_array_in_basicValue1598 = { FOLLOW_array_in_basicValue1598_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_tuple_in_basicValue1606 */ +static ANTLR3_BITWORD FOLLOW_tuple_in_basicValue1606_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_tuple_in_basicValue1606 = { FOLLOW_tuple_in_basicValue1606_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_taggedValue_in_basicValue1614 */ +static ANTLR3_BITWORD FOLLOW_taggedValue_in_basicValue1614_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_taggedValue_in_basicValue1614 = { FOLLOW_taggedValue_in_basicValue1614_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_map_in_basicValue1622 */ +static ANTLR3_BITWORD FOLLOW_map_in_basicValue1622_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_map_in_basicValue1622 = { FOLLOW_map_in_basicValue1622_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_record_in_basicValue1630 */ +static ANTLR3_BITWORD FOLLOW_record_in_basicValue1630_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_record_in_basicValue1630 = { FOLLOW_record_in_basicValue1630_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_37_in_array1648 */ +static ANTLR3_BITWORD FOLLOW_37_in_array1648_bits[] = { ANTLR3_UINT64_LIT(0x0003C96045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_37_in_array1648 = { FOLLOW_37_in_array1648_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_array1651 */ +static ANTLR3_BITWORD FOLLOW_value_in_array1651_bits[] = { ANTLR3_UINT64_LIT(0x0000024000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_value_in_array1651 = { FOLLOW_value_in_array1651_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_array1654 */ +static ANTLR3_BITWORD FOLLOW_41_in_array1654_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_41_in_array1654 = { FOLLOW_41_in_array1654_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_array1656 */ +static ANTLR3_BITWORD FOLLOW_value_in_array1656_bits[] = { ANTLR3_UINT64_LIT(0x0000024000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_value_in_array1656 = { FOLLOW_value_in_array1656_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_38_in_array1662 */ +static ANTLR3_BITWORD FOLLOW_38_in_array1662_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_38_in_array1662 = { FOLLOW_38_in_array1662_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_40_in_tuple1694 */ +static ANTLR3_BITWORD FOLLOW_40_in_tuple1694_bits[] = { ANTLR3_UINT64_LIT(0x0003CD2045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_40_in_tuple1694 = { FOLLOW_40_in_tuple1694_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_tuple1697 */ +static ANTLR3_BITWORD FOLLOW_value_in_tuple1697_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_value_in_tuple1697 = { FOLLOW_value_in_tuple1697_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_tuple1700 */ +static ANTLR3_BITWORD FOLLOW_41_in_tuple1700_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_41_in_tuple1700 = { FOLLOW_41_in_tuple1700_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_tuple1702 */ +static ANTLR3_BITWORD FOLLOW_value_in_tuple1702_bits[] = { ANTLR3_UINT64_LIT(0x0000060000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_value_in_tuple1702 = { FOLLOW_value_in_tuple1702_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_42_in_tuple1708 */ +static ANTLR3_BITWORD FOLLOW_42_in_tuple1708_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_42_in_tuple1708 = { FOLLOW_42_in_tuple1708_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_taggedValue1740 */ +static ANTLR3_BITWORD FOLLOW_ID_in_taggedValue1740_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_ID_in_taggedValue1740 = { FOLLOW_ID_in_taggedValue1740_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_basicValue_in_taggedValue1742 */ +static ANTLR3_BITWORD FOLLOW_basicValue_in_taggedValue1742_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_basicValue_in_taggedValue1742 = { FOLLOW_basicValue_in_taggedValue1742_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_43_in_record1775 */ +static ANTLR3_BITWORD FOLLOW_43_in_record1775_bits[] = { ANTLR3_UINT64_LIT(0x0000100000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_43_in_record1775 = { FOLLOW_43_in_record1775_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_recordAssignment_in_record1778 */ +static ANTLR3_BITWORD FOLLOW_recordAssignment_in_record1778_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_recordAssignment_in_record1778 = { FOLLOW_recordAssignment_in_record1778_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_record1781 */ +static ANTLR3_BITWORD FOLLOW_41_in_record1781_bits[] = { ANTLR3_UINT64_LIT(0x0000000000800000) }; +static ANTLR3_BITSET_LIST FOLLOW_41_in_record1781 = { FOLLOW_41_in_record1781_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_recordAssignment_in_record1783 */ +static ANTLR3_BITWORD FOLLOW_recordAssignment_in_record1783_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_recordAssignment_in_record1783 = { FOLLOW_recordAssignment_in_record1783_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_44_in_record1789 */ +static ANTLR3_BITWORD FOLLOW_44_in_record1789_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_44_in_record1789 = { FOLLOW_44_in_record1789_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_recordAssignment1821 */ +static ANTLR3_BITWORD FOLLOW_ID_in_recordAssignment1821_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) }; +static ANTLR3_BITSET_LIST FOLLOW_ID_in_recordAssignment1821 = { FOLLOW_ID_in_recordAssignment1821_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_recordAssignment1823 */ +static ANTLR3_BITWORD FOLLOW_35_in_recordAssignment1823_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_35_in_recordAssignment1823 = { FOLLOW_35_in_recordAssignment1823_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_recordAssignment1825 */ +static ANTLR3_BITWORD FOLLOW_value_in_recordAssignment1825_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_value_in_recordAssignment1825 = { FOLLOW_value_in_recordAssignment1825_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_49_in_map1852 */ +static ANTLR3_BITWORD FOLLOW_49_in_map1852_bits[] = { ANTLR3_UINT64_LIT(0x0000080000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_49_in_map1852 = { FOLLOW_49_in_map1852_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_43_in_map1854 */ +static ANTLR3_BITWORD FOLLOW_43_in_map1854_bits[] = { ANTLR3_UINT64_LIT(0x0003D92045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_43_in_map1854 = { FOLLOW_43_in_map1854_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_mapAssignment_in_map1857 */ +static ANTLR3_BITWORD FOLLOW_mapAssignment_in_map1857_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_mapAssignment_in_map1857 = { FOLLOW_mapAssignment_in_map1857_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_41_in_map1860 */ +static ANTLR3_BITWORD FOLLOW_41_in_map1860_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_41_in_map1860 = { FOLLOW_41_in_map1860_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_mapAssignment_in_map1862 */ +static ANTLR3_BITWORD FOLLOW_mapAssignment_in_map1862_bits[] = { ANTLR3_UINT64_LIT(0x0000120000000000) }; +static ANTLR3_BITSET_LIST FOLLOW_mapAssignment_in_map1862 = { FOLLOW_mapAssignment_in_map1862_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_44_in_map1868 */ +static ANTLR3_BITWORD FOLLOW_44_in_map1868_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_44_in_map1868 = { FOLLOW_44_in_map1868_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_mapAssignment1900 */ +static ANTLR3_BITWORD FOLLOW_value_in_mapAssignment1900_bits[] = { ANTLR3_UINT64_LIT(0x0000000800000000) }; +static ANTLR3_BITSET_LIST FOLLOW_value_in_mapAssignment1900 = { FOLLOW_value_in_mapAssignment1900_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_35_in_mapAssignment1902 */ +static ANTLR3_BITWORD FOLLOW_35_in_mapAssignment1902_bits[] = { ANTLR3_UINT64_LIT(0x0003C92045800000) }; +static ANTLR3_BITSET_LIST FOLLOW_35_in_mapAssignment1902 = { FOLLOW_35_in_mapAssignment1902_bits, 1 }; +/** Bitset defining follow set for error recovery in rule state: FOLLOW_value_in_mapAssignment1904 */ +static ANTLR3_BITWORD FOLLOW_value_in_mapAssignment1904_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; +static ANTLR3_BITSET_LIST FOLLOW_value_in_mapAssignment1904 = { FOLLOW_value_in_mapAssignment1904_bits, 1 }; + + + + +/* ============================================== + * Parsing rules + */ +/** + * $ANTLR start typeDefinitions + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:1: typeDefinitions : ( typeDefinition )* -> ^( TYPE_DEFINITIONS ( typeDefinition )* ) ; + */ +static SimanticsDataParser_typeDefinitions_return +typeDefinitions(pSimanticsDataParser ctx) +{ + SimanticsDataParser_typeDefinitions_return retval; + + pANTLR3_BASE_TREE root_0; + + SimanticsDataParser_typeDefinition_return typeDefinition1; + #undef RETURN_TYPE_typeDefinition1 + #define RETURN_TYPE_typeDefinition1 SimanticsDataParser_typeDefinition_return + + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_typeDefinition; + /* Initialize rule variables + */ + + + root_0 = NULL; + + typeDefinition1.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + + stream_typeDefinition = NULL; + #define CREATE_stream_typeDefinition if (stream_typeDefinition == NULL) {stream_typeDefinition = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule typeDefinition"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:17: ( ( typeDefinition )* -> ^( TYPE_DEFINITIONS ( typeDefinition )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:19: ( typeDefinition )* + { + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:19: ( typeDefinition )* + + for (;;) + { + int alt1=2; + switch ( LA(1) ) + { + case 34: + { + alt1=1; + } + break; + + } + + switch (alt1) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:19: typeDefinition + { + FOLLOWPUSH(FOLLOW_typeDefinition_in_typeDefinitions768); + typeDefinition1=typeDefinition(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletypeDefinitionsEx; + } + + CREATE_stream_typeDefinition; stream_typeDefinition->add(stream_typeDefinition, typeDefinition1.tree, NULL); + + } + break; + + default: + goto loop1; /* break out of the loop */ + break; + } + } + loop1: ; /* Jump out to here if this rule does not match */ + + + + /* AST REWRITE + * elements : typeDefinition + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 93:35: -> ^( TYPE_DEFINITIONS ( typeDefinition )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:38: ^( TYPE_DEFINITIONS ( typeDefinition )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_DEFINITIONS, (pANTLR3_UINT8)"TYPE_DEFINITIONS"), root_1)); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:93:57: ( typeDefinition )* + { + while ( (stream_typeDefinition != NULL && stream_typeDefinition->hasNext(stream_typeDefinition)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_typeDefinition == NULL ? NULL : stream_typeDefinition->nextTree(stream_typeDefinition)); + + } + if (stream_typeDefinition != NULL) stream_typeDefinition->reset(stream_typeDefinition); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto ruletypeDefinitionsEx; /* Prevent compiler warnings */ + ruletypeDefinitionsEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_typeDefinition != NULL) stream_typeDefinition->free(stream_typeDefinition); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end typeDefinitions */ + +/** + * $ANTLR start typeDefinition + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:95:1: typeDefinition : 'type' ID '=' unionType -> ^( TYPE_DEFINITION ID unionType ) ; + */ +static SimanticsDataParser_typeDefinition_return +typeDefinition(pSimanticsDataParser ctx) +{ + SimanticsDataParser_typeDefinition_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN string_literal2; + pANTLR3_COMMON_TOKEN ID3; + pANTLR3_COMMON_TOKEN char_literal4; + SimanticsDataParser_unionType_return unionType5; + #undef RETURN_TYPE_unionType5 + #define RETURN_TYPE_unionType5 SimanticsDataParser_unionType_return + + pANTLR3_BASE_TREE string_literal2_tree; + pANTLR3_BASE_TREE ID3_tree; + pANTLR3_BASE_TREE char_literal4_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_34; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType; + /* Initialize rule variables + */ + + + root_0 = NULL; + + string_literal2 = NULL; + ID3 = NULL; + char_literal4 = NULL; + unionType5.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + string_literal2_tree = NULL; + ID3_tree = NULL; + char_literal4_tree = NULL; + + stream_ID = NULL; + #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } + stream_35 = NULL; + #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } + stream_34 = NULL; + #define CREATE_stream_34 if (stream_34 == NULL) {stream_34 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 34"); } + stream_unionType = NULL; + #define CREATE_stream_unionType if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:96:5: ( 'type' ID '=' unionType -> ^( TYPE_DEFINITION ID unionType ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:96:7: 'type' ID '=' unionType + { + string_literal2 = (pANTLR3_COMMON_TOKEN) MATCHT(34, &FOLLOW_34_in_typeDefinition791); + if (HASEXCEPTION()) + { + goto ruletypeDefinitionEx; + } + + CREATE_stream_34; stream_34->add(stream_34, string_literal2, NULL); + + ID3 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_typeDefinition793); + if (HASEXCEPTION()) + { + goto ruletypeDefinitionEx; + } + + CREATE_stream_ID; stream_ID->add(stream_ID, ID3, NULL); + + char_literal4 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_typeDefinition795); + if (HASEXCEPTION()) + { + goto ruletypeDefinitionEx; + } + + CREATE_stream_35; stream_35->add(stream_35, char_literal4, NULL); + + FOLLOWPUSH(FOLLOW_unionType_in_typeDefinition797); + unionType5=unionType(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletypeDefinitionEx; + } + + CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType5.tree, NULL); + + + /* AST REWRITE + * elements : unionType, ID + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 96:31: -> ^( TYPE_DEFINITION ID unionType ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:96:34: ^( TYPE_DEFINITION ID unionType ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_DEFINITION, (pANTLR3_UINT8)"TYPE_DEFINITION"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID)); + ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType)); + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto ruletypeDefinitionEx; /* Prevent compiler warnings */ + ruletypeDefinitionEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_ID != NULL) stream_ID->free(stream_ID); + if (stream_35 != NULL) stream_35->free(stream_35); + if (stream_34 != NULL) stream_34->free(stream_34); + if (stream_unionType != NULL) stream_unionType->free(stream_unionType); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end typeDefinition */ + +/** + * $ANTLR start unionType + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:99:1: unionType : ( type | ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) ); + */ +static SimanticsDataParser_unionType_return +unionType(pSimanticsDataParser ctx) +{ + SimanticsDataParser_unionType_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN char_literal7; + SimanticsDataParser_type_return type6; + #undef RETURN_TYPE_type6 + #define RETURN_TYPE_type6 SimanticsDataParser_type_return + + SimanticsDataParser_unionComponent_return unionComponent8; + #undef RETURN_TYPE_unionComponent8 + #define RETURN_TYPE_unionComponent8 SimanticsDataParser_unionComponent_return + + pANTLR3_BASE_TREE char_literal7_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_36; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionComponent; + /* Initialize rule variables + */ + + + root_0 = NULL; + + char_literal7 = NULL; + type6.tree = NULL; + + unionComponent8.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + char_literal7_tree = NULL; + + stream_36 = NULL; + #define CREATE_stream_36 if (stream_36 == NULL) {stream_36 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 36"); } + stream_unionComponent = NULL; + #define CREATE_stream_unionComponent if (stream_unionComponent == NULL) {stream_unionComponent = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionComponent"); } + + retval.tree = NULL; + { + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:100:5: ( type | ( '|' unionComponent )+ -> ^( UNION_TYPE ( unionComponent )+ ) ) + + ANTLR3_UINT32 alt3; + + alt3=2; + + switch ( LA(1) ) + { + case ID: + case 40: + case 43: + { + alt3=1; + } + break; + case 36: + { + alt3=2; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 3; + EXCEPTION->state = 0; + + + goto ruleunionTypeEx; + } + + switch (alt3) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:100:7: type + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_type_in_unionType829); + type6=type(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruleunionTypeEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, type6.tree); + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:101:7: ( '|' unionComponent )+ + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:101:7: ( '|' unionComponent )+ + { + int cnt2=0; + + for (;;) + { + int alt2=2; + switch ( LA(1) ) + { + case 36: + { + alt2=1; + } + break; + + } + + switch (alt2) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:101:8: '|' unionComponent + { + char_literal7 = (pANTLR3_COMMON_TOKEN) MATCHT(36, &FOLLOW_36_in_unionType838); + if (HASEXCEPTION()) + { + goto ruleunionTypeEx; + } + + CREATE_stream_36; stream_36->add(stream_36, char_literal7, NULL); + + FOLLOWPUSH(FOLLOW_unionComponent_in_unionType840); + unionComponent8=unionComponent(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruleunionTypeEx; + } + + CREATE_stream_unionComponent; stream_unionComponent->add(stream_unionComponent, unionComponent8.tree, NULL); + + } + break; + + default: + + if ( cnt2 >= 1 ) + { + goto loop2; + } + /* mismatchedSetEx() + */ + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; + + + goto ruleunionTypeEx; + } + cnt2++; + } + loop2: ; /* Jump to here if this rule does not match */ + } + + + /* AST REWRITE + * elements : unionComponent + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 102:5: -> ^( UNION_TYPE ( unionComponent )+ ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:102:8: ^( UNION_TYPE ( unionComponent )+ ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, UNION_TYPE, (pANTLR3_UINT8)"UNION_TYPE"), root_1)); + + if ((stream_unionComponent == NULL || !stream_unionComponent->hasNext(stream_unionComponent)) ) + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_REWRITE_EARLY_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_REWRITE_EARLY_EXCEPTION_NAME; + } + else + { + while ( (stream_unionComponent->hasNext(stream_unionComponent)) ) { + ADAPTOR->addChild(ADAPTOR, root_1, stream_unionComponent == NULL ? NULL : stream_unionComponent->nextTree(stream_unionComponent)); + + } + stream_unionComponent->reset(stream_unionComponent); + + } + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + break; + + } + } + } + + + // This is where rules clean up and exit + // + goto ruleunionTypeEx; /* Prevent compiler warnings */ + ruleunionTypeEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_36 != NULL) stream_36->free(stream_36); + if (stream_unionComponent != NULL) stream_unionComponent->free(stream_unionComponent); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end unionType */ + +/** + * $ANTLR start unionComponent + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:1: unionComponent : ID ( type )? -> ^( TYPE_COMPONENT ID ( type )? ) ; + */ +static SimanticsDataParser_unionComponent_return +unionComponent(pSimanticsDataParser ctx) +{ + SimanticsDataParser_unionComponent_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN ID9; + SimanticsDataParser_type_return type10; + #undef RETURN_TYPE_type10 + #define RETURN_TYPE_type10 SimanticsDataParser_type_return + + pANTLR3_BASE_TREE ID9_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_type; + /* Initialize rule variables + */ + + + root_0 = NULL; + + ID9 = NULL; + type10.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + ID9_tree = NULL; + + stream_ID = NULL; + #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } + stream_type = NULL; + #define CREATE_stream_type if (stream_type == NULL) {stream_type = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule type"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:16: ( ID ( type )? -> ^( TYPE_COMPONENT ID ( type )? ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:18: ID ( type )? + { + ID9 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_unionComponent871); + if (HASEXCEPTION()) + { + goto ruleunionComponentEx; + } + + CREATE_stream_ID; stream_ID->add(stream_ID, ID9, NULL); + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:21: ( type )? + { + int alt4=2; + switch ( LA(1) ) + { + case ID: + case 40: + case 43: + { + alt4=1; + } + break; + } + + switch (alt4) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:21: type + { + FOLLOWPUSH(FOLLOW_type_in_unionComponent873); + type10=type(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruleunionComponentEx; + } + + CREATE_stream_type; stream_type->add(stream_type, type10.tree, NULL); + + } + break; + + } + } + + + /* AST REWRITE + * elements : ID, type + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 105:27: -> ^( TYPE_COMPONENT ID ( type )? ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:30: ^( TYPE_COMPONENT ID ( type )? ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_COMPONENT, (pANTLR3_UINT8)"TYPE_COMPONENT"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID)); + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:105:50: ( type )? + { + if ( (stream_type != NULL && stream_type->hasNext(stream_type)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_type == NULL ? NULL : stream_type->nextTree(stream_type)); + + } + if ( stream_type != NULL) stream_type->reset(stream_type); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto ruleunionComponentEx; /* Prevent compiler warnings */ + ruleunionComponentEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_ID != NULL) stream_ID->free(stream_ID); + if (stream_type != NULL) stream_type->free(stream_type); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end unionComponent */ + +/** + * $ANTLR start type + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:107:1: type : ( basicType -> basicType ) ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )* ; + */ +static SimanticsDataParser_type_return +type(pSimanticsDataParser ctx) +{ + SimanticsDataParser_type_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN char_literal12; + pANTLR3_COMMON_TOKEN char_literal14; + SimanticsDataParser_basicType_return basicType11; + #undef RETURN_TYPE_basicType11 + #define RETURN_TYPE_basicType11 SimanticsDataParser_basicType_return + + SimanticsDataParser_arrayLength_return arrayLength13; + #undef RETURN_TYPE_arrayLength13 + #define RETURN_TYPE_arrayLength13 SimanticsDataParser_arrayLength_return + + pANTLR3_BASE_TREE char_literal12_tree; + pANTLR3_BASE_TREE char_literal14_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_37; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_38; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_arrayLength; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_basicType; + /* Initialize rule variables + */ + + + root_0 = NULL; + + char_literal12 = NULL; + char_literal14 = NULL; + basicType11.tree = NULL; + + arrayLength13.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + char_literal12_tree = NULL; + char_literal14_tree = NULL; + + stream_37 = NULL; + #define CREATE_stream_37 if (stream_37 == NULL) {stream_37 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 37"); } + stream_38 = NULL; + #define CREATE_stream_38 if (stream_38 == NULL) {stream_38 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 38"); } + stream_arrayLength = NULL; + #define CREATE_stream_arrayLength if (stream_arrayLength == NULL) {stream_arrayLength = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule arrayLength"); } + stream_basicType = NULL; + #define CREATE_stream_basicType if (stream_basicType == NULL) {stream_basicType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule basicType"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:5: ( ( basicType -> basicType ) ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )* ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:7: ( basicType -> basicType ) ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )* + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:7: ( basicType -> basicType ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:108:8: basicType + { + FOLLOWPUSH(FOLLOW_basicType_in_type900); + basicType11=basicType(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletypeEx; + } + + CREATE_stream_basicType; stream_basicType->add(stream_basicType, basicType11.tree, NULL); + + + /* AST REWRITE + * elements : basicType + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 108:18: -> basicType + { + ADAPTOR->addChild(ADAPTOR, root_0, stream_basicType == NULL ? NULL : stream_basicType->nextTree(stream_basicType)); + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:7: ( '[' ( arrayLength )? ']' -> ^( ARRAY_TYPE $type ( arrayLength )? ) )* + + for (;;) + { + int alt6=2; + switch ( LA(1) ) + { + case 37: + { + alt6=1; + } + break; + + } + + switch (alt6) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:8: '[' ( arrayLength )? ']' + { + char_literal12 = (pANTLR3_COMMON_TOKEN) MATCHT(37, &FOLLOW_37_in_type914); + if (HASEXCEPTION()) + { + goto ruletypeEx; + } + + CREATE_stream_37; stream_37->add(stream_37, char_literal12, NULL); + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:12: ( arrayLength )? + { + int alt5=2; + switch ( LA(1) ) + { + case INT: + case 39: + { + alt5=1; + } + break; + } + + switch (alt5) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:12: arrayLength + { + FOLLOWPUSH(FOLLOW_arrayLength_in_type916); + arrayLength13=arrayLength(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletypeEx; + } + + CREATE_stream_arrayLength; stream_arrayLength->add(stream_arrayLength, arrayLength13.tree, NULL); + + } + break; + + } + } + char_literal14 = (pANTLR3_COMMON_TOKEN) MATCHT(38, &FOLLOW_38_in_type919); + if (HASEXCEPTION()) + { + goto ruletypeEx; + } + + CREATE_stream_38; stream_38->add(stream_38, char_literal14, NULL); + + + + /* AST REWRITE + * elements : arrayLength, type + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 109:29: -> ^( ARRAY_TYPE $type ( arrayLength )? ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:32: ^( ARRAY_TYPE $type ( arrayLength )? ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ARRAY_TYPE, (pANTLR3_UINT8)"ARRAY_TYPE"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_retval == NULL ? NULL : stream_retval->nextTree(stream_retval)); + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:109:51: ( arrayLength )? + { + if ( (stream_arrayLength != NULL && stream_arrayLength->hasNext(stream_arrayLength)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_arrayLength == NULL ? NULL : stream_arrayLength->nextTree(stream_arrayLength)); + + } + if ( stream_arrayLength != NULL) stream_arrayLength->reset(stream_arrayLength); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + break; + + default: + goto loop6; /* break out of the loop */ + break; + } + } + loop6: ; /* Jump out to here if this rule does not match */ + + + } + + } + + + // This is where rules clean up and exit + // + goto ruletypeEx; /* Prevent compiler warnings */ + ruletypeEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_37 != NULL) stream_37->free(stream_37); + if (stream_38 != NULL) stream_38->free(stream_38); + if (stream_arrayLength != NULL) stream_arrayLength->free(stream_arrayLength); + if (stream_basicType != NULL) stream_basicType->free(stream_basicType); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end type */ + +/** + * $ANTLR start arrayLength + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:111:1: arrayLength : ( INT | INT '..' | '..' INT | INT '..' INT ); + */ +static SimanticsDataParser_arrayLength_return +arrayLength(pSimanticsDataParser ctx) +{ + SimanticsDataParser_arrayLength_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN INT15; + pANTLR3_COMMON_TOKEN INT16; + pANTLR3_COMMON_TOKEN string_literal17; + pANTLR3_COMMON_TOKEN string_literal18; + pANTLR3_COMMON_TOKEN INT19; + pANTLR3_COMMON_TOKEN INT20; + pANTLR3_COMMON_TOKEN string_literal21; + pANTLR3_COMMON_TOKEN INT22; + + pANTLR3_BASE_TREE INT15_tree; + pANTLR3_BASE_TREE INT16_tree; + pANTLR3_BASE_TREE string_literal17_tree; + pANTLR3_BASE_TREE string_literal18_tree; + pANTLR3_BASE_TREE INT19_tree; + pANTLR3_BASE_TREE INT20_tree; + pANTLR3_BASE_TREE string_literal21_tree; + pANTLR3_BASE_TREE INT22_tree; + + /* Initialize rule variables + */ + + + root_0 = NULL; + + INT15 = NULL; + INT16 = NULL; + string_literal17 = NULL; + string_literal18 = NULL; + INT19 = NULL; + INT20 = NULL; + string_literal21 = NULL; + INT22 = NULL; + retval.start = LT(1); retval.stop = retval.start; + + INT15_tree = NULL; + INT16_tree = NULL; + string_literal17_tree = NULL; + string_literal18_tree = NULL; + INT19_tree = NULL; + INT20_tree = NULL; + string_literal21_tree = NULL; + INT22_tree = NULL; + + + retval.tree = NULL; + { + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:112:5: ( INT | INT '..' | '..' INT | INT '..' INT ) + + ANTLR3_UINT32 alt7; + + alt7=4; + + switch ( LA(1) ) + { + case INT: + { + switch ( LA(2) ) + { + case 39: + { + switch ( LA(3) ) + { + case INT: + { + alt7=4; + } + break; + case 38: + { + alt7=2; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 7; + EXCEPTION->state = 3; + + + goto rulearrayLengthEx; + } + + } + break; + case 38: + { + alt7=1; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 7; + EXCEPTION->state = 1; + + + goto rulearrayLengthEx; + } + + } + break; + case 39: + { + alt7=3; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 7; + EXCEPTION->state = 0; + + + goto rulearrayLengthEx; + } + + switch (alt7) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:112:7: INT + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + INT15 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength947); + if (HASEXCEPTION()) + { + goto rulearrayLengthEx; + } + + INT15_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT15)); + ADAPTOR->addChild(ADAPTOR, root_0, INT15_tree); + + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:113:7: INT '..' + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + INT16 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength955); + if (HASEXCEPTION()) + { + goto rulearrayLengthEx; + } + + INT16_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT16)); + ADAPTOR->addChild(ADAPTOR, root_0, INT16_tree); + + string_literal17 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_arrayLength957); + if (HASEXCEPTION()) + { + goto rulearrayLengthEx; + } + + string_literal17_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal17)); + ADAPTOR->addChild(ADAPTOR, root_0, string_literal17_tree); + + + } + break; + case 3: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:114:7: '..' INT + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + string_literal18 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_arrayLength965); + if (HASEXCEPTION()) + { + goto rulearrayLengthEx; + } + + string_literal18_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal18)); + ADAPTOR->addChild(ADAPTOR, root_0, string_literal18_tree); + + INT19 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength967); + if (HASEXCEPTION()) + { + goto rulearrayLengthEx; + } + + INT19_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT19)); + ADAPTOR->addChild(ADAPTOR, root_0, INT19_tree); + + + } + break; + case 4: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:115:7: INT '..' INT + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + INT20 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength976); + if (HASEXCEPTION()) + { + goto rulearrayLengthEx; + } + + INT20_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT20)); + ADAPTOR->addChild(ADAPTOR, root_0, INT20_tree); + + string_literal21 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_arrayLength978); + if (HASEXCEPTION()) + { + goto rulearrayLengthEx; + } + + string_literal21_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal21)); + ADAPTOR->addChild(ADAPTOR, root_0, string_literal21_tree); + + INT22 = (pANTLR3_COMMON_TOKEN) MATCHT(INT, &FOLLOW_INT_in_arrayLength980); + if (HASEXCEPTION()) + { + goto rulearrayLengthEx; + } + + INT22_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, INT22)); + ADAPTOR->addChild(ADAPTOR, root_0, INT22_tree); + + + } + break; + + } + } + } + + + // This is where rules clean up and exit + // + goto rulearrayLengthEx; /* Prevent compiler warnings */ + rulearrayLengthEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end arrayLength */ + +/** + * $ANTLR start basicType + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:118:1: basicType : ( tupleType | recordType | typeReference ); + */ +static SimanticsDataParser_basicType_return +basicType(pSimanticsDataParser ctx) +{ + SimanticsDataParser_basicType_return retval; + + pANTLR3_BASE_TREE root_0; + + SimanticsDataParser_tupleType_return tupleType23; + #undef RETURN_TYPE_tupleType23 + #define RETURN_TYPE_tupleType23 SimanticsDataParser_tupleType_return + + SimanticsDataParser_recordType_return recordType24; + #undef RETURN_TYPE_recordType24 + #define RETURN_TYPE_recordType24 SimanticsDataParser_recordType_return + + SimanticsDataParser_typeReference_return typeReference25; + #undef RETURN_TYPE_typeReference25 + #define RETURN_TYPE_typeReference25 SimanticsDataParser_typeReference_return + + + /* Initialize rule variables + */ + + + root_0 = NULL; + + tupleType23.tree = NULL; + + recordType24.tree = NULL; + + typeReference25.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + + + retval.tree = NULL; + { + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:119:5: ( tupleType | recordType | typeReference ) + + ANTLR3_UINT32 alt8; + + alt8=3; + + switch ( LA(1) ) + { + case 40: + { + alt8=1; + } + break; + case 43: + { + alt8=2; + } + break; + case ID: + { + alt8=3; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 8; + EXCEPTION->state = 0; + + + goto rulebasicTypeEx; + } + + switch (alt8) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:119:7: tupleType + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_tupleType_in_basicType998); + tupleType23=tupleType(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicTypeEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, tupleType23.tree); + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:120:7: recordType + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_recordType_in_basicType1006); + recordType24=recordType(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicTypeEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, recordType24.tree); + + } + break; + case 3: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:121:7: typeReference + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_typeReference_in_basicType1014); + typeReference25=typeReference(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicTypeEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, typeReference25.tree); + + } + break; + + } + } + } + + + // This is where rules clean up and exit + // + goto rulebasicTypeEx; /* Prevent compiler warnings */ + rulebasicTypeEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end basicType */ + +/** + * $ANTLR start tupleType + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:124:1: tupleType : '(' ( unionType ( ',' unionType )* )? ')' -> ^( TUPLE_TYPE ( unionType )* ) ; + */ +static SimanticsDataParser_tupleType_return +tupleType(pSimanticsDataParser ctx) +{ + SimanticsDataParser_tupleType_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN char_literal26; + pANTLR3_COMMON_TOKEN char_literal28; + pANTLR3_COMMON_TOKEN char_literal30; + SimanticsDataParser_unionType_return unionType27; + #undef RETURN_TYPE_unionType27 + #define RETURN_TYPE_unionType27 SimanticsDataParser_unionType_return + + SimanticsDataParser_unionType_return unionType29; + #undef RETURN_TYPE_unionType29 + #define RETURN_TYPE_unionType29 SimanticsDataParser_unionType_return + + pANTLR3_BASE_TREE char_literal26_tree; + pANTLR3_BASE_TREE char_literal28_tree; + pANTLR3_BASE_TREE char_literal30_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_42; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_40; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType; + /* Initialize rule variables + */ + + + root_0 = NULL; + + char_literal26 = NULL; + char_literal28 = NULL; + char_literal30 = NULL; + unionType27.tree = NULL; + + unionType29.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + char_literal26_tree = NULL; + char_literal28_tree = NULL; + char_literal30_tree = NULL; + + stream_42 = NULL; + #define CREATE_stream_42 if (stream_42 == NULL) {stream_42 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 42"); } + stream_41 = NULL; + #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } + stream_40 = NULL; + #define CREATE_stream_40 if (stream_40 == NULL) {stream_40 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 40"); } + stream_unionType = NULL; + #define CREATE_stream_unionType if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:5: ( '(' ( unionType ( ',' unionType )* )? ')' -> ^( TUPLE_TYPE ( unionType )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:7: '(' ( unionType ( ',' unionType )* )? ')' + { + char_literal26 = (pANTLR3_COMMON_TOKEN) MATCHT(40, &FOLLOW_40_in_tupleType1036); + if (HASEXCEPTION()) + { + goto ruletupleTypeEx; + } + + CREATE_stream_40; stream_40->add(stream_40, char_literal26, NULL); + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:11: ( unionType ( ',' unionType )* )? + { + int alt10=2; + switch ( LA(1) ) + { + case ID: + case 36: + case 40: + case 43: + { + alt10=1; + } + break; + } + + switch (alt10) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:12: unionType ( ',' unionType )* + { + FOLLOWPUSH(FOLLOW_unionType_in_tupleType1039); + unionType27=unionType(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletupleTypeEx; + } + + CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType27.tree, NULL); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:22: ( ',' unionType )* + + for (;;) + { + int alt9=2; + switch ( LA(1) ) + { + case 41: + { + alt9=1; + } + break; + + } + + switch (alt9) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:125:23: ',' unionType + { + char_literal28 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_tupleType1042); + if (HASEXCEPTION()) + { + goto ruletupleTypeEx; + } + + CREATE_stream_41; stream_41->add(stream_41, char_literal28, NULL); + + FOLLOWPUSH(FOLLOW_unionType_in_tupleType1044); + unionType29=unionType(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletupleTypeEx; + } + + CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType29.tree, NULL); + + } + break; + + default: + goto loop9; /* break out of the loop */ + break; + } + } + loop9: ; /* Jump out to here if this rule does not match */ + + + } + break; + + } + } + char_literal30 = (pANTLR3_COMMON_TOKEN) MATCHT(42, &FOLLOW_42_in_tupleType1050); + if (HASEXCEPTION()) + { + goto ruletupleTypeEx; + } + + CREATE_stream_42; stream_42->add(stream_42, char_literal30, NULL); + + + + /* AST REWRITE + * elements : unionType + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 126:5: -> ^( TUPLE_TYPE ( unionType )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:126:8: ^( TUPLE_TYPE ( unionType )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TUPLE_TYPE, (pANTLR3_UINT8)"TUPLE_TYPE"), root_1)); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:126:21: ( unionType )* + { + while ( (stream_unionType != NULL && stream_unionType->hasNext(stream_unionType)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType)); + + } + if (stream_unionType != NULL) stream_unionType->reset(stream_unionType); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto ruletupleTypeEx; /* Prevent compiler warnings */ + ruletupleTypeEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_42 != NULL) stream_42->free(stream_42); + if (stream_41 != NULL) stream_41->free(stream_41); + if (stream_40 != NULL) stream_40->free(stream_40); + if (stream_unionType != NULL) stream_unionType->free(stream_unionType); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end tupleType */ + +/** + * $ANTLR start recordType + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:129:1: recordType : '{' ( component ( ',' component )* )? '}' -> ^( RECORD_TYPE ( component )* ) ; + */ +static SimanticsDataParser_recordType_return +recordType(pSimanticsDataParser ctx) +{ + SimanticsDataParser_recordType_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN char_literal31; + pANTLR3_COMMON_TOKEN char_literal33; + pANTLR3_COMMON_TOKEN char_literal35; + SimanticsDataParser_component_return component32; + #undef RETURN_TYPE_component32 + #define RETURN_TYPE_component32 SimanticsDataParser_component_return + + SimanticsDataParser_component_return component34; + #undef RETURN_TYPE_component34 + #define RETURN_TYPE_component34 SimanticsDataParser_component_return + + pANTLR3_BASE_TREE char_literal31_tree; + pANTLR3_BASE_TREE char_literal33_tree; + pANTLR3_BASE_TREE char_literal35_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_43; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_44; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_component; + /* Initialize rule variables + */ + + + root_0 = NULL; + + char_literal31 = NULL; + char_literal33 = NULL; + char_literal35 = NULL; + component32.tree = NULL; + + component34.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + char_literal31_tree = NULL; + char_literal33_tree = NULL; + char_literal35_tree = NULL; + + stream_43 = NULL; + #define CREATE_stream_43 if (stream_43 == NULL) {stream_43 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 43"); } + stream_44 = NULL; + #define CREATE_stream_44 if (stream_44 == NULL) {stream_44 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 44"); } + stream_41 = NULL; + #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } + stream_component = NULL; + #define CREATE_stream_component if (stream_component == NULL) {stream_component = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule component"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:5: ( '{' ( component ( ',' component )* )? '}' -> ^( RECORD_TYPE ( component )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:7: '{' ( component ( ',' component )* )? '}' + { + char_literal31 = (pANTLR3_COMMON_TOKEN) MATCHT(43, &FOLLOW_43_in_recordType1083); + if (HASEXCEPTION()) + { + goto rulerecordTypeEx; + } + + CREATE_stream_43; stream_43->add(stream_43, char_literal31, NULL); + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:11: ( component ( ',' component )* )? + { + int alt12=2; + switch ( LA(1) ) + { + case ID: + { + alt12=1; + } + break; + } + + switch (alt12) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:12: component ( ',' component )* + { + FOLLOWPUSH(FOLLOW_component_in_recordType1086); + component32=component(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerecordTypeEx; + } + + CREATE_stream_component; stream_component->add(stream_component, component32.tree, NULL); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:22: ( ',' component )* + + for (;;) + { + int alt11=2; + switch ( LA(1) ) + { + case 41: + { + alt11=1; + } + break; + + } + + switch (alt11) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:130:23: ',' component + { + char_literal33 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_recordType1089); + if (HASEXCEPTION()) + { + goto rulerecordTypeEx; + } + + CREATE_stream_41; stream_41->add(stream_41, char_literal33, NULL); + + FOLLOWPUSH(FOLLOW_component_in_recordType1091); + component34=component(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerecordTypeEx; + } + + CREATE_stream_component; stream_component->add(stream_component, component34.tree, NULL); + + } + break; + + default: + goto loop11; /* break out of the loop */ + break; + } + } + loop11: ; /* Jump out to here if this rule does not match */ + + + } + break; + + } + } + char_literal35 = (pANTLR3_COMMON_TOKEN) MATCHT(44, &FOLLOW_44_in_recordType1097); + if (HASEXCEPTION()) + { + goto rulerecordTypeEx; + } + + CREATE_stream_44; stream_44->add(stream_44, char_literal35, NULL); + + + + /* AST REWRITE + * elements : component + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 131:5: -> ^( RECORD_TYPE ( component )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:131:8: ^( RECORD_TYPE ( component )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, RECORD_TYPE, (pANTLR3_UINT8)"RECORD_TYPE"), root_1)); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:131:22: ( component )* + { + while ( (stream_component != NULL && stream_component->hasNext(stream_component)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_component == NULL ? NULL : stream_component->nextTree(stream_component)); + + } + if (stream_component != NULL) stream_component->reset(stream_component); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto rulerecordTypeEx; /* Prevent compiler warnings */ + rulerecordTypeEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_43 != NULL) stream_43->free(stream_43); + if (stream_44 != NULL) stream_44->free(stream_44); + if (stream_41 != NULL) stream_41->free(stream_41); + if (stream_component != NULL) stream_component->free(stream_component); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end recordType */ + +/** + * $ANTLR start component + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:134:1: component : ID ':' unionType -> ^( TYPE_COMPONENT ID unionType ) ; + */ +static SimanticsDataParser_component_return +component(pSimanticsDataParser ctx) +{ + SimanticsDataParser_component_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN ID36; + pANTLR3_COMMON_TOKEN char_literal37; + SimanticsDataParser_unionType_return unionType38; + #undef RETURN_TYPE_unionType38 + #define RETURN_TYPE_unionType38 SimanticsDataParser_unionType_return + + pANTLR3_BASE_TREE ID36_tree; + pANTLR3_BASE_TREE char_literal37_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_45; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType; + /* Initialize rule variables + */ + + + root_0 = NULL; + + ID36 = NULL; + char_literal37 = NULL; + unionType38.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + ID36_tree = NULL; + char_literal37_tree = NULL; + + stream_45 = NULL; + #define CREATE_stream_45 if (stream_45 == NULL) {stream_45 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 45"); } + stream_ID = NULL; + #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } + stream_unionType = NULL; + #define CREATE_stream_unionType if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:135:5: ( ID ':' unionType -> ^( TYPE_COMPONENT ID unionType ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:135:7: ID ':' unionType + { + ID36 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_component1129); + if (HASEXCEPTION()) + { + goto rulecomponentEx; + } + + CREATE_stream_ID; stream_ID->add(stream_ID, ID36, NULL); + + char_literal37 = (pANTLR3_COMMON_TOKEN) MATCHT(45, &FOLLOW_45_in_component1131); + if (HASEXCEPTION()) + { + goto rulecomponentEx; + } + + CREATE_stream_45; stream_45->add(stream_45, char_literal37, NULL); + + FOLLOWPUSH(FOLLOW_unionType_in_component1133); + unionType38=unionType(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulecomponentEx; + } + + CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType38.tree, NULL); + + + /* AST REWRITE + * elements : ID, unionType + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 136:5: -> ^( TYPE_COMPONENT ID unionType ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:136:8: ^( TYPE_COMPONENT ID unionType ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_COMPONENT, (pANTLR3_UINT8)"TYPE_COMPONENT"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID)); + ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType)); + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto rulecomponentEx; /* Prevent compiler warnings */ + rulecomponentEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_45 != NULL) stream_45->free(stream_45); + if (stream_ID != NULL) stream_ID->free(stream_ID); + if (stream_unionType != NULL) stream_unionType->free(stream_unionType); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end component */ + +/** + * $ANTLR start typeReference + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:139:1: typeReference : ID ( '(' parameter ( ',' parameter )* ')' )? -> ^( TYPE_REFERENCE ID ( parameter )* ) ; + */ +static SimanticsDataParser_typeReference_return +typeReference(pSimanticsDataParser ctx) +{ + SimanticsDataParser_typeReference_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN ID39; + pANTLR3_COMMON_TOKEN char_literal40; + pANTLR3_COMMON_TOKEN char_literal42; + pANTLR3_COMMON_TOKEN char_literal44; + SimanticsDataParser_parameter_return parameter41; + #undef RETURN_TYPE_parameter41 + #define RETURN_TYPE_parameter41 SimanticsDataParser_parameter_return + + SimanticsDataParser_parameter_return parameter43; + #undef RETURN_TYPE_parameter43 + #define RETURN_TYPE_parameter43 SimanticsDataParser_parameter_return + + pANTLR3_BASE_TREE ID39_tree; + pANTLR3_BASE_TREE char_literal40_tree; + pANTLR3_BASE_TREE char_literal42_tree; + pANTLR3_BASE_TREE char_literal44_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_42; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_40; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_parameter; + /* Initialize rule variables + */ + + + root_0 = NULL; + + ID39 = NULL; + char_literal40 = NULL; + char_literal42 = NULL; + char_literal44 = NULL; + parameter41.tree = NULL; + + parameter43.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + ID39_tree = NULL; + char_literal40_tree = NULL; + char_literal42_tree = NULL; + char_literal44_tree = NULL; + + stream_42 = NULL; + #define CREATE_stream_42 if (stream_42 == NULL) {stream_42 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 42"); } + stream_41 = NULL; + #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } + stream_40 = NULL; + #define CREATE_stream_40 if (stream_40 == NULL) {stream_40 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 40"); } + stream_ID = NULL; + #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } + stream_parameter = NULL; + #define CREATE_stream_parameter if (stream_parameter == NULL) {stream_parameter = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule parameter"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:5: ( ID ( '(' parameter ( ',' parameter )* ')' )? -> ^( TYPE_REFERENCE ID ( parameter )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:7: ID ( '(' parameter ( ',' parameter )* ')' )? + { + ID39 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_typeReference1167); + if (HASEXCEPTION()) + { + goto ruletypeReferenceEx; + } + + CREATE_stream_ID; stream_ID->add(stream_ID, ID39, NULL); + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:10: ( '(' parameter ( ',' parameter )* ')' )? + { + int alt14=2; + switch ( LA(1) ) + { + case 40: + { + alt14=1; + } + break; + } + + switch (alt14) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:11: '(' parameter ( ',' parameter )* ')' + { + char_literal40 = (pANTLR3_COMMON_TOKEN) MATCHT(40, &FOLLOW_40_in_typeReference1170); + if (HASEXCEPTION()) + { + goto ruletypeReferenceEx; + } + + CREATE_stream_40; stream_40->add(stream_40, char_literal40, NULL); + + FOLLOWPUSH(FOLLOW_parameter_in_typeReference1172); + parameter41=parameter(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletypeReferenceEx; + } + + CREATE_stream_parameter; stream_parameter->add(stream_parameter, parameter41.tree, NULL); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:25: ( ',' parameter )* + + for (;;) + { + int alt13=2; + switch ( LA(1) ) + { + case 41: + { + alt13=1; + } + break; + + } + + switch (alt13) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:140:26: ',' parameter + { + char_literal42 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_typeReference1175); + if (HASEXCEPTION()) + { + goto ruletypeReferenceEx; + } + + CREATE_stream_41; stream_41->add(stream_41, char_literal42, NULL); + + FOLLOWPUSH(FOLLOW_parameter_in_typeReference1177); + parameter43=parameter(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletypeReferenceEx; + } + + CREATE_stream_parameter; stream_parameter->add(stream_parameter, parameter43.tree, NULL); + + } + break; + + default: + goto loop13; /* break out of the loop */ + break; + } + } + loop13: ; /* Jump out to here if this rule does not match */ + + char_literal44 = (pANTLR3_COMMON_TOKEN) MATCHT(42, &FOLLOW_42_in_typeReference1181); + if (HASEXCEPTION()) + { + goto ruletypeReferenceEx; + } + + CREATE_stream_42; stream_42->add(stream_42, char_literal44, NULL); + + + } + break; + + } + } + + + /* AST REWRITE + * elements : ID, parameter + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 141:5: -> ^( TYPE_REFERENCE ID ( parameter )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:141:8: ^( TYPE_REFERENCE ID ( parameter )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_REFERENCE, (pANTLR3_UINT8)"TYPE_REFERENCE"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID)); + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:141:28: ( parameter )* + { + while ( (stream_parameter != NULL && stream_parameter->hasNext(stream_parameter)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_parameter == NULL ? NULL : stream_parameter->nextTree(stream_parameter)); + + } + if (stream_parameter != NULL) stream_parameter->reset(stream_parameter); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto ruletypeReferenceEx; /* Prevent compiler warnings */ + ruletypeReferenceEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_42 != NULL) stream_42->free(stream_42); + if (stream_41 != NULL) stream_41->free(stream_41); + if (stream_40 != NULL) stream_40->free(stream_40); + if (stream_ID != NULL) stream_ID->free(stream_ID); + if (stream_parameter != NULL) stream_parameter->free(stream_parameter); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end typeReference */ + +/** + * $ANTLR start parameter + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:144:1: parameter : ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | unionType ); + */ +static SimanticsDataParser_parameter_return +parameter(pSimanticsDataParser ctx) +{ + SimanticsDataParser_parameter_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN ID45; + pANTLR3_COMMON_TOKEN char_literal46; + SimanticsDataParser_parameterValue_return parameterValue47; + #undef RETURN_TYPE_parameterValue47 + #define RETURN_TYPE_parameterValue47 SimanticsDataParser_parameterValue_return + + SimanticsDataParser_unionType_return unionType48; + #undef RETURN_TYPE_unionType48 + #define RETURN_TYPE_unionType48 SimanticsDataParser_unionType_return + + pANTLR3_BASE_TREE ID45_tree; + pANTLR3_BASE_TREE char_literal46_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_parameterValue; + /* Initialize rule variables + */ + + + root_0 = NULL; + + ID45 = NULL; + char_literal46 = NULL; + parameterValue47.tree = NULL; + + unionType48.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + ID45_tree = NULL; + char_literal46_tree = NULL; + + stream_ID = NULL; + #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } + stream_35 = NULL; + #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } + stream_parameterValue = NULL; + #define CREATE_stream_parameterValue if (stream_parameterValue == NULL) {stream_parameterValue = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule parameterValue"); } + + retval.tree = NULL; + { + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:145:5: ( ID '=' parameterValue -> ^( TYPE_ANNOTATION ID parameterValue ) | unionType ) + + ANTLR3_UINT32 alt15; + + alt15=2; + + switch ( LA(1) ) + { + case ID: + { + switch ( LA(2) ) + { + case 35: + { + alt15=1; + } + break; + case 37: + case 40: + case 41: + case 42: + { + alt15=2; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 15; + EXCEPTION->state = 1; + + + goto ruleparameterEx; + } + + } + break; + case 36: + case 40: + case 43: + { + alt15=2; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 15; + EXCEPTION->state = 0; + + + goto ruleparameterEx; + } + + switch (alt15) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:145:7: ID '=' parameterValue + { + ID45 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_parameter1217); + if (HASEXCEPTION()) + { + goto ruleparameterEx; + } + + CREATE_stream_ID; stream_ID->add(stream_ID, ID45, NULL); + + char_literal46 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_parameter1219); + if (HASEXCEPTION()) + { + goto ruleparameterEx; + } + + CREATE_stream_35; stream_35->add(stream_35, char_literal46, NULL); + + FOLLOWPUSH(FOLLOW_parameterValue_in_parameter1221); + parameterValue47=parameterValue(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruleparameterEx; + } + + CREATE_stream_parameterValue; stream_parameterValue->add(stream_parameterValue, parameterValue47.tree, NULL); + + + /* AST REWRITE + * elements : ID, parameterValue + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 145:29: -> ^( TYPE_ANNOTATION ID parameterValue ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:145:32: ^( TYPE_ANNOTATION ID parameterValue ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TYPE_ANNOTATION, (pANTLR3_UINT8)"TYPE_ANNOTATION"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID)); + ADAPTOR->addChild(ADAPTOR, root_1, stream_parameterValue == NULL ? NULL : stream_parameterValue->nextTree(stream_parameterValue)); + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:146:7: unionType + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_unionType_in_parameter1239); + unionType48=unionType(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruleparameterEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, unionType48.tree); + + } + break; + + } + } + } + + + // This is where rules clean up and exit + // + goto ruleparameterEx; /* Prevent compiler warnings */ + ruleparameterEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_ID != NULL) stream_ID->free(stream_ID); + if (stream_35 != NULL) stream_35->free(stream_35); + if (stream_parameterValue != NULL) stream_parameterValue->free(stream_parameterValue); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end parameter */ + +/** + * $ANTLR start parameterValue + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:149:1: parameterValue : ( string | boolean | number | ( '[' | '(' ) range ( ']' | ')' ) ); + */ +static SimanticsDataParser_parameterValue_return +parameterValue(pSimanticsDataParser ctx) +{ + SimanticsDataParser_parameterValue_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN set52; + pANTLR3_COMMON_TOKEN set54; + SimanticsDataParser_string_return string49; + #undef RETURN_TYPE_string49 + #define RETURN_TYPE_string49 SimanticsDataParser_string_return + + SimanticsDataParser_boolean_return boolean50; + #undef RETURN_TYPE_boolean50 + #define RETURN_TYPE_boolean50 SimanticsDataParser_boolean_return + + SimanticsDataParser_number_return number51; + #undef RETURN_TYPE_number51 + #define RETURN_TYPE_number51 SimanticsDataParser_number_return + + SimanticsDataParser_range_return range53; + #undef RETURN_TYPE_range53 + #define RETURN_TYPE_range53 SimanticsDataParser_range_return + + pANTLR3_BASE_TREE set52_tree; + pANTLR3_BASE_TREE set54_tree; + + /* Initialize rule variables + */ + + + root_0 = NULL; + + set52 = NULL; + set54 = NULL; + string49.tree = NULL; + + boolean50.tree = NULL; + + number51.tree = NULL; + + range53.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + set52_tree = NULL; + set54_tree = NULL; + + + retval.tree = NULL; + { + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:150:5: ( string | boolean | number | ( '[' | '(' ) range ( ']' | ')' ) ) + + ANTLR3_UINT32 alt16; + + alt16=4; + + switch ( LA(1) ) + { + case STRING: + { + alt16=1; + } + break; + case 46: + case 47: + { + alt16=2; + } + break; + case INT: + case FLOAT: + { + alt16=3; + } + break; + case 37: + case 40: + { + alt16=4; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 16; + EXCEPTION->state = 0; + + + goto ruleparameterValueEx; + } + + switch (alt16) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:150:7: string + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_string_in_parameterValue1258); + string49=string(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruleparameterValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, string49.tree); + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:151:7: boolean + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_boolean_in_parameterValue1266); + boolean50=boolean(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruleparameterValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, boolean50.tree); + + } + break; + case 3: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:152:7: number + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_number_in_parameterValue1274); + number51=number(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruleparameterValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, number51.tree); + + } + break; + case 4: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:153:7: ( '[' | '(' ) range ( ']' | ')' ) + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + set52=(pANTLR3_COMMON_TOKEN)LT(1); + if ( LA(1) == 37 || LA(1) == 40 ) + { + CONSUME(); + ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set52))); + PERRORRECOVERY=ANTLR3_FALSE; + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + EXCEPTION->expectingSet = &FOLLOW_set_in_parameterValue1282; + RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_parameterValue1282); goto ruleparameterValueEx; + } + + FOLLOWPUSH(FOLLOW_range_in_parameterValue1290); + range53=range(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruleparameterValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, range53.tree); + set54=(pANTLR3_COMMON_TOKEN)LT(1); + if ( LA(1) == 38 || LA(1) == 42 ) + { + CONSUME(); + ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set54))); + PERRORRECOVERY=ANTLR3_FALSE; + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + EXCEPTION->expectingSet = &FOLLOW_set_in_parameterValue1292; + RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_parameterValue1292); goto ruleparameterValueEx; + } + + + } + break; + + } + } + } + + + // This is where rules clean up and exit + // + goto ruleparameterValueEx; /* Prevent compiler warnings */ + ruleparameterValueEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end parameterValue */ + +/** + * $ANTLR start range + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:156:1: range : ( number | number '..' | '..' number | number '..' number ); + */ +static SimanticsDataParser_range_return +range(pSimanticsDataParser ctx) +{ + SimanticsDataParser_range_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN string_literal57; + pANTLR3_COMMON_TOKEN string_literal58; + pANTLR3_COMMON_TOKEN string_literal61; + SimanticsDataParser_number_return number55; + #undef RETURN_TYPE_number55 + #define RETURN_TYPE_number55 SimanticsDataParser_number_return + + SimanticsDataParser_number_return number56; + #undef RETURN_TYPE_number56 + #define RETURN_TYPE_number56 SimanticsDataParser_number_return + + SimanticsDataParser_number_return number59; + #undef RETURN_TYPE_number59 + #define RETURN_TYPE_number59 SimanticsDataParser_number_return + + SimanticsDataParser_number_return number60; + #undef RETURN_TYPE_number60 + #define RETURN_TYPE_number60 SimanticsDataParser_number_return + + SimanticsDataParser_number_return number62; + #undef RETURN_TYPE_number62 + #define RETURN_TYPE_number62 SimanticsDataParser_number_return + + pANTLR3_BASE_TREE string_literal57_tree; + pANTLR3_BASE_TREE string_literal58_tree; + pANTLR3_BASE_TREE string_literal61_tree; + + /* Initialize rule variables + */ + + + root_0 = NULL; + + string_literal57 = NULL; + string_literal58 = NULL; + string_literal61 = NULL; + number55.tree = NULL; + + number56.tree = NULL; + + number59.tree = NULL; + + number60.tree = NULL; + + number62.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + string_literal57_tree = NULL; + string_literal58_tree = NULL; + string_literal61_tree = NULL; + + + retval.tree = NULL; + { + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:157:5: ( number | number '..' | '..' number | number '..' number ) + + ANTLR3_UINT32 alt17; + + alt17=4; + + switch ( LA(1) ) + { + case INT: + case FLOAT: + { + switch ( LA(2) ) + { + case 39: + { + switch ( LA(3) ) + { + case INT: + case FLOAT: + { + alt17=4; + } + break; + case 38: + case 42: + { + alt17=2; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 17; + EXCEPTION->state = 3; + + + goto rulerangeEx; + } + + } + break; + case 38: + case 42: + { + alt17=1; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 17; + EXCEPTION->state = 1; + + + goto rulerangeEx; + } + + } + break; + case 39: + { + alt17=3; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 17; + EXCEPTION->state = 0; + + + goto rulerangeEx; + } + + switch (alt17) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:157:7: number + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_number_in_range1319); + number55=number(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerangeEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, number55.tree); + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:158:7: number '..' + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_number_in_range1327); + number56=number(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerangeEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, number56.tree); + string_literal57 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_range1329); + if (HASEXCEPTION()) + { + goto rulerangeEx; + } + + string_literal57_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal57)); + ADAPTOR->addChild(ADAPTOR, root_0, string_literal57_tree); + + + } + break; + case 3: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:159:7: '..' number + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + string_literal58 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_range1337); + if (HASEXCEPTION()) + { + goto rulerangeEx; + } + + string_literal58_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal58)); + ADAPTOR->addChild(ADAPTOR, root_0, string_literal58_tree); + + FOLLOWPUSH(FOLLOW_number_in_range1339); + number59=number(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerangeEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, number59.tree); + + } + break; + case 4: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:160:7: number '..' number + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_number_in_range1348); + number60=number(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerangeEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, number60.tree); + string_literal61 = (pANTLR3_COMMON_TOKEN) MATCHT(39, &FOLLOW_39_in_range1350); + if (HASEXCEPTION()) + { + goto rulerangeEx; + } + + string_literal61_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, string_literal61)); + ADAPTOR->addChild(ADAPTOR, root_0, string_literal61_tree); + + FOLLOWPUSH(FOLLOW_number_in_range1352); + number62=number(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerangeEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, number62.tree); + + } + break; + + } + } + } + + + // This is where rules clean up and exit + // + goto rulerangeEx; /* Prevent compiler warnings */ + rulerangeEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end range */ + +/** + * $ANTLR start number + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:163:1: number : ( INT | FLOAT ); + */ +static SimanticsDataParser_number_return +number(pSimanticsDataParser ctx) +{ + SimanticsDataParser_number_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN set63; + + pANTLR3_BASE_TREE set63_tree; + + /* Initialize rule variables + */ + + + root_0 = NULL; + + set63 = NULL; + retval.start = LT(1); retval.stop = retval.start; + + set63_tree = NULL; + + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:164:5: ( INT | FLOAT ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g: + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + set63=(pANTLR3_COMMON_TOKEN)LT(1); + if ( LA(1) == INT || LA(1) == FLOAT ) + { + CONSUME(); + ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set63))); + PERRORRECOVERY=ANTLR3_FALSE; + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + EXCEPTION->expectingSet = &FOLLOW_set_in_number0; + RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_number0); goto rulenumberEx; + } + + + } + + } + + + // This is where rules clean up and exit + // + goto rulenumberEx; /* Prevent compiler warnings */ + rulenumberEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end number */ + +/** + * $ANTLR start string + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:168:1: string : STRING ; + */ +static SimanticsDataParser_string_return +string(pSimanticsDataParser ctx) +{ + SimanticsDataParser_string_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN STRING64; + + pANTLR3_BASE_TREE STRING64_tree; + + /* Initialize rule variables + */ + + + root_0 = NULL; + + STRING64 = NULL; + retval.start = LT(1); retval.stop = retval.start; + + STRING64_tree = NULL; + + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:169:5: ( STRING ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:169:7: STRING + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + STRING64 = (pANTLR3_COMMON_TOKEN) MATCHT(STRING, &FOLLOW_STRING_in_string1402); + if (HASEXCEPTION()) + { + goto rulestringEx; + } + + STRING64_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, STRING64)); + ADAPTOR->addChild(ADAPTOR, root_0, STRING64_tree); + + + } + + } + + + // This is where rules clean up and exit + // + goto rulestringEx; /* Prevent compiler warnings */ + rulestringEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end string */ + +/** + * $ANTLR start boolean + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:172:1: boolean : ( 'true' | 'false' ); + */ +static SimanticsDataParser_boolean_return +boolean(pSimanticsDataParser ctx) +{ + SimanticsDataParser_boolean_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN set65; + + pANTLR3_BASE_TREE set65_tree; + + /* Initialize rule variables + */ + + + root_0 = NULL; + + set65 = NULL; + retval.start = LT(1); retval.stop = retval.start; + + set65_tree = NULL; + + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:173:5: ( 'true' | 'false' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g: + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + set65=(pANTLR3_COMMON_TOKEN)LT(1); + if ( ((LA(1) >= 46) && (LA(1) <= 47)) ) + { + CONSUME(); + ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set65))); + PERRORRECOVERY=ANTLR3_FALSE; + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + EXCEPTION->expectingSet = &FOLLOW_set_in_boolean0; + RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_boolean0); goto rulebooleanEx; + } + + + } + + } + + + // This is where rules clean up and exit + // + goto rulebooleanEx; /* Prevent compiler warnings */ + rulebooleanEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end boolean */ + +/** + * $ANTLR start valueDefinitions + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:1: valueDefinitions : ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) ; + */ +static SimanticsDataParser_valueDefinitions_return +valueDefinitions(pSimanticsDataParser ctx) +{ + SimanticsDataParser_valueDefinitions_return retval; + + pANTLR3_BASE_TREE root_0; + + SimanticsDataParser_valueDefinition_return valueDefinition66; + #undef RETURN_TYPE_valueDefinition66 + #define RETURN_TYPE_valueDefinition66 SimanticsDataParser_valueDefinition_return + + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_valueDefinition; + /* Initialize rule variables + */ + + + root_0 = NULL; + + valueDefinition66.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + + stream_valueDefinition = NULL; + #define CREATE_stream_valueDefinition if (stream_valueDefinition == NULL) {stream_valueDefinition = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule valueDefinition"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:18: ( ( valueDefinition )* -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:20: ( valueDefinition )* + { + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:20: ( valueDefinition )* + + for (;;) + { + int alt18=2; + switch ( LA(1) ) + { + case ID: + { + alt18=1; + } + break; + + } + + switch (alt18) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:20: valueDefinition + { + FOLLOWPUSH(FOLLOW_valueDefinition_in_valueDefinitions1447); + valueDefinition66=valueDefinition(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulevalueDefinitionsEx; + } + + CREATE_stream_valueDefinition; stream_valueDefinition->add(stream_valueDefinition, valueDefinition66.tree, NULL); + + } + break; + + default: + goto loop18; /* break out of the loop */ + break; + } + } + loop18: ; /* Jump out to here if this rule does not match */ + + + + /* AST REWRITE + * elements : valueDefinition + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 181:37: -> ^( VALUE_DEFINITIONS ( valueDefinition )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:40: ^( VALUE_DEFINITIONS ( valueDefinition )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, VALUE_DEFINITIONS, (pANTLR3_UINT8)"VALUE_DEFINITIONS"), root_1)); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:181:60: ( valueDefinition )* + { + while ( (stream_valueDefinition != NULL && stream_valueDefinition->hasNext(stream_valueDefinition)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_valueDefinition == NULL ? NULL : stream_valueDefinition->nextTree(stream_valueDefinition)); + + } + if (stream_valueDefinition != NULL) stream_valueDefinition->reset(stream_valueDefinition); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto rulevalueDefinitionsEx; /* Prevent compiler warnings */ + rulevalueDefinitionsEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_valueDefinition != NULL) stream_valueDefinition->free(stream_valueDefinition); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end valueDefinitions */ + +/** + * $ANTLR start valueDefinition + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:183:1: valueDefinition : ID ':' unionType '=' value -> ^( VALUE_DEFINITION ID unionType value ) ; + */ +static SimanticsDataParser_valueDefinition_return +valueDefinition(pSimanticsDataParser ctx) +{ + SimanticsDataParser_valueDefinition_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN ID67; + pANTLR3_COMMON_TOKEN char_literal68; + pANTLR3_COMMON_TOKEN char_literal70; + SimanticsDataParser_unionType_return unionType69; + #undef RETURN_TYPE_unionType69 + #define RETURN_TYPE_unionType69 SimanticsDataParser_unionType_return + + SimanticsDataParser_value_return value71; + #undef RETURN_TYPE_value71 + #define RETURN_TYPE_value71 SimanticsDataParser_value_return + + pANTLR3_BASE_TREE ID67_tree; + pANTLR3_BASE_TREE char_literal68_tree; + pANTLR3_BASE_TREE char_literal70_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_45; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_unionType; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value; + /* Initialize rule variables + */ + + + root_0 = NULL; + + ID67 = NULL; + char_literal68 = NULL; + char_literal70 = NULL; + unionType69.tree = NULL; + + value71.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + ID67_tree = NULL; + char_literal68_tree = NULL; + char_literal70_tree = NULL; + + stream_45 = NULL; + #define CREATE_stream_45 if (stream_45 == NULL) {stream_45 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 45"); } + stream_ID = NULL; + #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } + stream_35 = NULL; + #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } + stream_unionType = NULL; + #define CREATE_stream_unionType if (stream_unionType == NULL) {stream_unionType = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule unionType"); } + stream_value = NULL; + #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:184:5: ( ID ':' unionType '=' value -> ^( VALUE_DEFINITION ID unionType value ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:184:7: ID ':' unionType '=' value + { + ID67 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_valueDefinition1470); + if (HASEXCEPTION()) + { + goto rulevalueDefinitionEx; + } + + CREATE_stream_ID; stream_ID->add(stream_ID, ID67, NULL); + + char_literal68 = (pANTLR3_COMMON_TOKEN) MATCHT(45, &FOLLOW_45_in_valueDefinition1472); + if (HASEXCEPTION()) + { + goto rulevalueDefinitionEx; + } + + CREATE_stream_45; stream_45->add(stream_45, char_literal68, NULL); + + FOLLOWPUSH(FOLLOW_unionType_in_valueDefinition1474); + unionType69=unionType(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulevalueDefinitionEx; + } + + CREATE_stream_unionType; stream_unionType->add(stream_unionType, unionType69.tree, NULL); + char_literal70 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_valueDefinition1476); + if (HASEXCEPTION()) + { + goto rulevalueDefinitionEx; + } + + CREATE_stream_35; stream_35->add(stream_35, char_literal70, NULL); + + FOLLOWPUSH(FOLLOW_value_in_valueDefinition1478); + value71=value(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulevalueDefinitionEx; + } + + CREATE_stream_value; stream_value->add(stream_value, value71.tree, NULL); + + + /* AST REWRITE + * elements : value, unionType, ID + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 185:5: -> ^( VALUE_DEFINITION ID unionType value ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:185:8: ^( VALUE_DEFINITION ID unionType value ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, VALUE_DEFINITION, (pANTLR3_UINT8)"VALUE_DEFINITION"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID)); + ADAPTOR->addChild(ADAPTOR, root_1, stream_unionType == NULL ? NULL : stream_unionType->nextTree(stream_unionType)); + ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value)); + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto rulevalueDefinitionEx; /* Prevent compiler warnings */ + rulevalueDefinitionEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_45 != NULL) stream_45->free(stream_45); + if (stream_ID != NULL) stream_ID->free(stream_ID); + if (stream_35 != NULL) stream_35->free(stream_35); + if (stream_unionType != NULL) stream_unionType->free(stream_unionType); + if (stream_value != NULL) stream_value->free(stream_value); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end valueDefinition */ + +/** + * $ANTLR start value + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:188:1: value : ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* ; + */ +static SimanticsDataParser_value_return +value(pSimanticsDataParser ctx) +{ + SimanticsDataParser_value_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN char_literal73; + SimanticsDataParser_basicValue_return basicValue72; + #undef RETURN_TYPE_basicValue72 + #define RETURN_TYPE_basicValue72 SimanticsDataParser_basicValue_return + + SimanticsDataParser_type_return type74; + #undef RETURN_TYPE_type74 + #define RETURN_TYPE_type74 SimanticsDataParser_type_return + + pANTLR3_BASE_TREE char_literal73_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_45; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_basicValue; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_type; + /* Initialize rule variables + */ + + + root_0 = NULL; + + char_literal73 = NULL; + basicValue72.tree = NULL; + + type74.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + char_literal73_tree = NULL; + + stream_45 = NULL; + #define CREATE_stream_45 if (stream_45 == NULL) {stream_45 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 45"); } + stream_basicValue = NULL; + #define CREATE_stream_basicValue if (stream_basicValue == NULL) {stream_basicValue = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule basicValue"); } + stream_type = NULL; + #define CREATE_stream_type if (stream_type == NULL) {stream_type = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule type"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:5: ( ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:7: ( basicValue -> basicValue ) ( ':' type -> ^( VARIANT type $value) )* + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:7: ( basicValue -> basicValue ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:189:8: basicValue + { + FOLLOWPUSH(FOLLOW_basicValue_in_value1514); + basicValue72=basicValue(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulevalueEx; + } + + CREATE_stream_basicValue; stream_basicValue->add(stream_basicValue, basicValue72.tree, NULL); + + + /* AST REWRITE + * elements : basicValue + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 189:19: -> basicValue + { + ADAPTOR->addChild(ADAPTOR, root_0, stream_basicValue == NULL ? NULL : stream_basicValue->nextTree(stream_basicValue)); + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:190:7: ( ':' type -> ^( VARIANT type $value) )* + + for (;;) + { + int alt19=2; + switch ( LA(1) ) + { + case 45: + { + alt19=1; + } + break; + + } + + switch (alt19) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:190:8: ':' type + { + char_literal73 = (pANTLR3_COMMON_TOKEN) MATCHT(45, &FOLLOW_45_in_value1528); + if (HASEXCEPTION()) + { + goto rulevalueEx; + } + + CREATE_stream_45; stream_45->add(stream_45, char_literal73, NULL); + + FOLLOWPUSH(FOLLOW_type_in_value1530); + type74=type(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulevalueEx; + } + + CREATE_stream_type; stream_type->add(stream_type, type74.tree, NULL); + + + /* AST REWRITE + * elements : value, type + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 190:17: -> ^( VARIANT type $value) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:190:20: ^( VARIANT type $value) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, VARIANT, (pANTLR3_UINT8)"VARIANT"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_type == NULL ? NULL : stream_type->nextTree(stream_type)); + ADAPTOR->addChild(ADAPTOR, root_1, stream_retval == NULL ? NULL : stream_retval->nextTree(stream_retval)); + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + break; + + default: + goto loop19; /* break out of the loop */ + break; + } + } + loop19: ; /* Jump out to here if this rule does not match */ + + + } + + } + + + // This is where rules clean up and exit + // + goto rulevalueEx; /* Prevent compiler warnings */ + rulevalueEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_45 != NULL) stream_45->free(stream_45); + if (stream_basicValue != NULL) stream_basicValue->free(stream_basicValue); + if (stream_type != NULL) stream_type->free(stream_type); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end value */ + +/** + * $ANTLR start basicValue + * 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 ); + */ +static SimanticsDataParser_basicValue_return +basicValue(pSimanticsDataParser ctx) +{ + SimanticsDataParser_basicValue_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN string_literal75; + SimanticsDataParser_string_return string76; + #undef RETURN_TYPE_string76 + #define RETURN_TYPE_string76 SimanticsDataParser_string_return + + SimanticsDataParser_number_return number77; + #undef RETURN_TYPE_number77 + #define RETURN_TYPE_number77 SimanticsDataParser_number_return + + SimanticsDataParser_boolean_return boolean78; + #undef RETURN_TYPE_boolean78 + #define RETURN_TYPE_boolean78 SimanticsDataParser_boolean_return + + SimanticsDataParser_array_return array79; + #undef RETURN_TYPE_array79 + #define RETURN_TYPE_array79 SimanticsDataParser_array_return + + SimanticsDataParser_tuple_return tuple80; + #undef RETURN_TYPE_tuple80 + #define RETURN_TYPE_tuple80 SimanticsDataParser_tuple_return + + SimanticsDataParser_taggedValue_return taggedValue81; + #undef RETURN_TYPE_taggedValue81 + #define RETURN_TYPE_taggedValue81 SimanticsDataParser_taggedValue_return + + SimanticsDataParser_map_return map82; + #undef RETURN_TYPE_map82 + #define RETURN_TYPE_map82 SimanticsDataParser_map_return + + SimanticsDataParser_record_return record83; + #undef RETURN_TYPE_record83 + #define RETURN_TYPE_record83 SimanticsDataParser_record_return + + pANTLR3_BASE_TREE string_literal75_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_48; + + /* Initialize rule variables + */ + + + root_0 = NULL; + + string_literal75 = NULL; + string76.tree = NULL; + + number77.tree = NULL; + + boolean78.tree = NULL; + + array79.tree = NULL; + + tuple80.tree = NULL; + + taggedValue81.tree = NULL; + + map82.tree = NULL; + + record83.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + string_literal75_tree = NULL; + + stream_48 = NULL; + #define CREATE_stream_48 if (stream_48 == NULL) {stream_48 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 48"); } + + retval.tree = NULL; + { + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:194:5: ( 'null' -> NO_VALUE | string | number | boolean | array | tuple | taggedValue | map | record ) + + ANTLR3_UINT32 alt20; + + alt20=9; + + switch ( LA(1) ) + { + case 48: + { + alt20=1; + } + break; + case STRING: + { + alt20=2; + } + break; + case INT: + case FLOAT: + { + alt20=3; + } + break; + case 46: + case 47: + { + alt20=4; + } + break; + case 37: + { + alt20=5; + } + break; + case 40: + { + alt20=6; + } + break; + case ID: + { + alt20=7; + } + break; + case 49: + { + alt20=8; + } + break; + case 43: + { + alt20=9; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 20; + EXCEPTION->state = 0; + + + goto rulebasicValueEx; + } + + switch (alt20) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:194:7: 'null' + { + string_literal75 = (pANTLR3_COMMON_TOKEN) MATCHT(48, &FOLLOW_48_in_basicValue1562); + if (HASEXCEPTION()) + { + goto rulebasicValueEx; + } + + CREATE_stream_48; stream_48->add(stream_48, string_literal75, NULL); + + + + /* AST REWRITE + * elements : + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 194:14: -> NO_VALUE + { + ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, NO_VALUE, (pANTLR3_UINT8)"NO_VALUE")); + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:195:7: string + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_string_in_basicValue1574); + string76=string(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, string76.tree); + + } + break; + case 3: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:196:7: number + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_number_in_basicValue1582); + number77=number(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, number77.tree); + + } + break; + case 4: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:197:7: boolean + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_boolean_in_basicValue1590); + boolean78=boolean(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, boolean78.tree); + + } + break; + case 5: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:198:7: array + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_array_in_basicValue1598); + array79=array(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, array79.tree); + + } + break; + case 6: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:199:7: tuple + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_tuple_in_basicValue1606); + tuple80=tuple(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, tuple80.tree); + + } + break; + case 7: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:200:7: taggedValue + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_taggedValue_in_basicValue1614); + taggedValue81=taggedValue(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, taggedValue81.tree); + + } + break; + case 8: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:201:7: map + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_map_in_basicValue1622); + map82=map(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, map82.tree); + + } + break; + case 9: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:202:7: record + { + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + + FOLLOWPUSH(FOLLOW_record_in_basicValue1630); + record83=record(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulebasicValueEx; + } + + ADAPTOR->addChild(ADAPTOR, root_0, record83.tree); + + } + break; + + } + } + } + + + // This is where rules clean up and exit + // + goto rulebasicValueEx; /* Prevent compiler warnings */ + rulebasicValueEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_48 != NULL) stream_48->free(stream_48); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end basicValue */ + +/** + * $ANTLR start array + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:205:1: array : '[' ( value ( ',' value )* )? ']' -> ^( ARRAY ( value )* ) ; + */ +static SimanticsDataParser_array_return +array(pSimanticsDataParser ctx) +{ + SimanticsDataParser_array_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN char_literal84; + pANTLR3_COMMON_TOKEN char_literal86; + pANTLR3_COMMON_TOKEN char_literal88; + SimanticsDataParser_value_return value85; + #undef RETURN_TYPE_value85 + #define RETURN_TYPE_value85 SimanticsDataParser_value_return + + SimanticsDataParser_value_return value87; + #undef RETURN_TYPE_value87 + #define RETURN_TYPE_value87 SimanticsDataParser_value_return + + pANTLR3_BASE_TREE char_literal84_tree; + pANTLR3_BASE_TREE char_literal86_tree; + pANTLR3_BASE_TREE char_literal88_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_37; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_38; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value; + /* Initialize rule variables + */ + + + root_0 = NULL; + + char_literal84 = NULL; + char_literal86 = NULL; + char_literal88 = NULL; + value85.tree = NULL; + + value87.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + char_literal84_tree = NULL; + char_literal86_tree = NULL; + char_literal88_tree = NULL; + + stream_41 = NULL; + #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } + stream_37 = NULL; + #define CREATE_stream_37 if (stream_37 == NULL) {stream_37 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 37"); } + stream_38 = NULL; + #define CREATE_stream_38 if (stream_38 == NULL) {stream_38 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 38"); } + stream_value = NULL; + #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:5: ( '[' ( value ( ',' value )* )? ']' -> ^( ARRAY ( value )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:7: '[' ( value ( ',' value )* )? ']' + { + char_literal84 = (pANTLR3_COMMON_TOKEN) MATCHT(37, &FOLLOW_37_in_array1648); + if (HASEXCEPTION()) + { + goto rulearrayEx; + } + + CREATE_stream_37; stream_37->add(stream_37, char_literal84, NULL); + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:11: ( value ( ',' value )* )? + { + int alt22=2; + switch ( LA(1) ) + { + case ID: + case INT: + case FLOAT: + case STRING: + case 37: + case 40: + case 43: + case 46: + case 47: + case 48: + case 49: + { + alt22=1; + } + break; + } + + switch (alt22) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:12: value ( ',' value )* + { + FOLLOWPUSH(FOLLOW_value_in_array1651); + value85=value(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulearrayEx; + } + + CREATE_stream_value; stream_value->add(stream_value, value85.tree, NULL); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:18: ( ',' value )* + + for (;;) + { + int alt21=2; + switch ( LA(1) ) + { + case 41: + { + alt21=1; + } + break; + + } + + switch (alt21) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:206:19: ',' value + { + char_literal86 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_array1654); + if (HASEXCEPTION()) + { + goto rulearrayEx; + } + + CREATE_stream_41; stream_41->add(stream_41, char_literal86, NULL); + + FOLLOWPUSH(FOLLOW_value_in_array1656); + value87=value(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulearrayEx; + } + + CREATE_stream_value; stream_value->add(stream_value, value87.tree, NULL); + + } + break; + + default: + goto loop21; /* break out of the loop */ + break; + } + } + loop21: ; /* Jump out to here if this rule does not match */ + + + } + break; + + } + } + char_literal88 = (pANTLR3_COMMON_TOKEN) MATCHT(38, &FOLLOW_38_in_array1662); + if (HASEXCEPTION()) + { + goto rulearrayEx; + } + + CREATE_stream_38; stream_38->add(stream_38, char_literal88, NULL); + + + + /* AST REWRITE + * elements : value + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 207:5: -> ^( ARRAY ( value )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:207:8: ^( ARRAY ( value )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ARRAY, (pANTLR3_UINT8)"ARRAY"), root_1)); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:207:16: ( value )* + { + while ( (stream_value != NULL && stream_value->hasNext(stream_value)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value)); + + } + if (stream_value != NULL) stream_value->reset(stream_value); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto rulearrayEx; /* Prevent compiler warnings */ + rulearrayEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_41 != NULL) stream_41->free(stream_41); + if (stream_37 != NULL) stream_37->free(stream_37); + if (stream_38 != NULL) stream_38->free(stream_38); + if (stream_value != NULL) stream_value->free(stream_value); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end array */ + +/** + * $ANTLR start tuple + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:210:1: tuple : '(' ( value ( ',' value )* )? ')' -> ^( TUPLE ( value )* ) ; + */ +static SimanticsDataParser_tuple_return +tuple(pSimanticsDataParser ctx) +{ + SimanticsDataParser_tuple_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN char_literal89; + pANTLR3_COMMON_TOKEN char_literal91; + pANTLR3_COMMON_TOKEN char_literal93; + SimanticsDataParser_value_return value90; + #undef RETURN_TYPE_value90 + #define RETURN_TYPE_value90 SimanticsDataParser_value_return + + SimanticsDataParser_value_return value92; + #undef RETURN_TYPE_value92 + #define RETURN_TYPE_value92 SimanticsDataParser_value_return + + pANTLR3_BASE_TREE char_literal89_tree; + pANTLR3_BASE_TREE char_literal91_tree; + pANTLR3_BASE_TREE char_literal93_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_42; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_40; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value; + /* Initialize rule variables + */ + + + root_0 = NULL; + + char_literal89 = NULL; + char_literal91 = NULL; + char_literal93 = NULL; + value90.tree = NULL; + + value92.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + char_literal89_tree = NULL; + char_literal91_tree = NULL; + char_literal93_tree = NULL; + + stream_42 = NULL; + #define CREATE_stream_42 if (stream_42 == NULL) {stream_42 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 42"); } + stream_41 = NULL; + #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } + stream_40 = NULL; + #define CREATE_stream_40 if (stream_40 == NULL) {stream_40 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 40"); } + stream_value = NULL; + #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:5: ( '(' ( value ( ',' value )* )? ')' -> ^( TUPLE ( value )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:7: '(' ( value ( ',' value )* )? ')' + { + char_literal89 = (pANTLR3_COMMON_TOKEN) MATCHT(40, &FOLLOW_40_in_tuple1694); + if (HASEXCEPTION()) + { + goto ruletupleEx; + } + + CREATE_stream_40; stream_40->add(stream_40, char_literal89, NULL); + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:11: ( value ( ',' value )* )? + { + int alt24=2; + switch ( LA(1) ) + { + case ID: + case INT: + case FLOAT: + case STRING: + case 37: + case 40: + case 43: + case 46: + case 47: + case 48: + case 49: + { + alt24=1; + } + break; + } + + switch (alt24) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:12: value ( ',' value )* + { + FOLLOWPUSH(FOLLOW_value_in_tuple1697); + value90=value(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletupleEx; + } + + CREATE_stream_value; stream_value->add(stream_value, value90.tree, NULL); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:18: ( ',' value )* + + for (;;) + { + int alt23=2; + switch ( LA(1) ) + { + case 41: + { + alt23=1; + } + break; + + } + + switch (alt23) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:211:19: ',' value + { + char_literal91 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_tuple1700); + if (HASEXCEPTION()) + { + goto ruletupleEx; + } + + CREATE_stream_41; stream_41->add(stream_41, char_literal91, NULL); + + FOLLOWPUSH(FOLLOW_value_in_tuple1702); + value92=value(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletupleEx; + } + + CREATE_stream_value; stream_value->add(stream_value, value92.tree, NULL); + + } + break; + + default: + goto loop23; /* break out of the loop */ + break; + } + } + loop23: ; /* Jump out to here if this rule does not match */ + + + } + break; + + } + } + char_literal93 = (pANTLR3_COMMON_TOKEN) MATCHT(42, &FOLLOW_42_in_tuple1708); + if (HASEXCEPTION()) + { + goto ruletupleEx; + } + + CREATE_stream_42; stream_42->add(stream_42, char_literal93, NULL); + + + + /* AST REWRITE + * elements : value + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 212:5: -> ^( TUPLE ( value )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:212:8: ^( TUPLE ( value )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TUPLE, (pANTLR3_UINT8)"TUPLE"), root_1)); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:212:16: ( value )* + { + while ( (stream_value != NULL && stream_value->hasNext(stream_value)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value)); + + } + if (stream_value != NULL) stream_value->reset(stream_value); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto ruletupleEx; /* Prevent compiler warnings */ + ruletupleEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_42 != NULL) stream_42->free(stream_42); + if (stream_41 != NULL) stream_41->free(stream_41); + if (stream_40 != NULL) stream_40->free(stream_40); + if (stream_value != NULL) stream_value->free(stream_value); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end tuple */ + +/** + * $ANTLR start taggedValue + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:215:1: taggedValue : ID basicValue -> ^( TAGGED_VALUE ID basicValue ) ; + */ +static SimanticsDataParser_taggedValue_return +taggedValue(pSimanticsDataParser ctx) +{ + SimanticsDataParser_taggedValue_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN ID94; + SimanticsDataParser_basicValue_return basicValue95; + #undef RETURN_TYPE_basicValue95 + #define RETURN_TYPE_basicValue95 SimanticsDataParser_basicValue_return + + pANTLR3_BASE_TREE ID94_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_basicValue; + /* Initialize rule variables + */ + + + root_0 = NULL; + + ID94 = NULL; + basicValue95.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + ID94_tree = NULL; + + stream_ID = NULL; + #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } + stream_basicValue = NULL; + #define CREATE_stream_basicValue if (stream_basicValue == NULL) {stream_basicValue = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule basicValue"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:216:5: ( ID basicValue -> ^( TAGGED_VALUE ID basicValue ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:216:7: ID basicValue + { + ID94 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_taggedValue1740); + if (HASEXCEPTION()) + { + goto ruletaggedValueEx; + } + + CREATE_stream_ID; stream_ID->add(stream_ID, ID94, NULL); + + FOLLOWPUSH(FOLLOW_basicValue_in_taggedValue1742); + basicValue95=basicValue(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto ruletaggedValueEx; + } + + CREATE_stream_basicValue; stream_basicValue->add(stream_basicValue, basicValue95.tree, NULL); + + + /* AST REWRITE + * elements : basicValue, ID + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 217:5: -> ^( TAGGED_VALUE ID basicValue ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:217:8: ^( TAGGED_VALUE ID basicValue ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, TAGGED_VALUE, (pANTLR3_UINT8)"TAGGED_VALUE"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID)); + ADAPTOR->addChild(ADAPTOR, root_1, stream_basicValue == NULL ? NULL : stream_basicValue->nextTree(stream_basicValue)); + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto ruletaggedValueEx; /* Prevent compiler warnings */ + ruletaggedValueEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_ID != NULL) stream_ID->free(stream_ID); + if (stream_basicValue != NULL) stream_basicValue->free(stream_basicValue); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end taggedValue */ + +/** + * $ANTLR start record + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:220:1: record : '{' ( recordAssignment ( ',' recordAssignment )* )? '}' -> ^( RECORD ( recordAssignment )* ) ; + */ +static SimanticsDataParser_record_return +record(pSimanticsDataParser ctx) +{ + SimanticsDataParser_record_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN char_literal96; + pANTLR3_COMMON_TOKEN char_literal98; + pANTLR3_COMMON_TOKEN char_literal100; + SimanticsDataParser_recordAssignment_return recordAssignment97; + #undef RETURN_TYPE_recordAssignment97 + #define RETURN_TYPE_recordAssignment97 SimanticsDataParser_recordAssignment_return + + SimanticsDataParser_recordAssignment_return recordAssignment99; + #undef RETURN_TYPE_recordAssignment99 + #define RETURN_TYPE_recordAssignment99 SimanticsDataParser_recordAssignment_return + + pANTLR3_BASE_TREE char_literal96_tree; + pANTLR3_BASE_TREE char_literal98_tree; + pANTLR3_BASE_TREE char_literal100_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_43; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_44; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_recordAssignment; + /* Initialize rule variables + */ + + + root_0 = NULL; + + char_literal96 = NULL; + char_literal98 = NULL; + char_literal100 = NULL; + recordAssignment97.tree = NULL; + + recordAssignment99.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + char_literal96_tree = NULL; + char_literal98_tree = NULL; + char_literal100_tree = NULL; + + stream_43 = NULL; + #define CREATE_stream_43 if (stream_43 == NULL) {stream_43 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 43"); } + stream_44 = NULL; + #define CREATE_stream_44 if (stream_44 == NULL) {stream_44 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 44"); } + stream_41 = NULL; + #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } + stream_recordAssignment = NULL; + #define CREATE_stream_recordAssignment if (stream_recordAssignment == NULL) {stream_recordAssignment = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule recordAssignment"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:5: ( '{' ( recordAssignment ( ',' recordAssignment )* )? '}' -> ^( RECORD ( recordAssignment )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:7: '{' ( recordAssignment ( ',' recordAssignment )* )? '}' + { + char_literal96 = (pANTLR3_COMMON_TOKEN) MATCHT(43, &FOLLOW_43_in_record1775); + if (HASEXCEPTION()) + { + goto rulerecordEx; + } + + CREATE_stream_43; stream_43->add(stream_43, char_literal96, NULL); + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:11: ( recordAssignment ( ',' recordAssignment )* )? + { + int alt26=2; + switch ( LA(1) ) + { + case ID: + { + alt26=1; + } + break; + } + + switch (alt26) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:12: recordAssignment ( ',' recordAssignment )* + { + FOLLOWPUSH(FOLLOW_recordAssignment_in_record1778); + recordAssignment97=recordAssignment(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerecordEx; + } + + CREATE_stream_recordAssignment; stream_recordAssignment->add(stream_recordAssignment, recordAssignment97.tree, NULL); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:29: ( ',' recordAssignment )* + + for (;;) + { + int alt25=2; + switch ( LA(1) ) + { + case 41: + { + alt25=1; + } + break; + + } + + switch (alt25) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:221:30: ',' recordAssignment + { + char_literal98 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_record1781); + if (HASEXCEPTION()) + { + goto rulerecordEx; + } + + CREATE_stream_41; stream_41->add(stream_41, char_literal98, NULL); + + FOLLOWPUSH(FOLLOW_recordAssignment_in_record1783); + recordAssignment99=recordAssignment(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerecordEx; + } + + CREATE_stream_recordAssignment; stream_recordAssignment->add(stream_recordAssignment, recordAssignment99.tree, NULL); + + } + break; + + default: + goto loop25; /* break out of the loop */ + break; + } + } + loop25: ; /* Jump out to here if this rule does not match */ + + + } + break; + + } + } + char_literal100 = (pANTLR3_COMMON_TOKEN) MATCHT(44, &FOLLOW_44_in_record1789); + if (HASEXCEPTION()) + { + goto rulerecordEx; + } + + CREATE_stream_44; stream_44->add(stream_44, char_literal100, NULL); + + + + /* AST REWRITE + * elements : recordAssignment + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 222:5: -> ^( RECORD ( recordAssignment )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:222:8: ^( RECORD ( recordAssignment )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, RECORD, (pANTLR3_UINT8)"RECORD"), root_1)); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:222:17: ( recordAssignment )* + { + while ( (stream_recordAssignment != NULL && stream_recordAssignment->hasNext(stream_recordAssignment)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_recordAssignment == NULL ? NULL : stream_recordAssignment->nextTree(stream_recordAssignment)); + + } + if (stream_recordAssignment != NULL) stream_recordAssignment->reset(stream_recordAssignment); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto rulerecordEx; /* Prevent compiler warnings */ + rulerecordEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_43 != NULL) stream_43->free(stream_43); + if (stream_44 != NULL) stream_44->free(stream_44); + if (stream_41 != NULL) stream_41->free(stream_41); + if (stream_recordAssignment != NULL) stream_recordAssignment->free(stream_recordAssignment); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end record */ + +/** + * $ANTLR start recordAssignment + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:225:1: recordAssignment : ID '=' value -> ^( ASSIGNMENT ID value ) ; + */ +static SimanticsDataParser_recordAssignment_return +recordAssignment(pSimanticsDataParser ctx) +{ + SimanticsDataParser_recordAssignment_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN ID101; + pANTLR3_COMMON_TOKEN char_literal102; + SimanticsDataParser_value_return value103; + #undef RETURN_TYPE_value103 + #define RETURN_TYPE_value103 SimanticsDataParser_value_return + + pANTLR3_BASE_TREE ID101_tree; + pANTLR3_BASE_TREE char_literal102_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value; + /* Initialize rule variables + */ + + + root_0 = NULL; + + ID101 = NULL; + char_literal102 = NULL; + value103.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + ID101_tree = NULL; + char_literal102_tree = NULL; + + stream_ID = NULL; + #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } + stream_35 = NULL; + #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } + stream_value = NULL; + #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:226:5: ( ID '=' value -> ^( ASSIGNMENT ID value ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:226:7: ID '=' value + { + ID101 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_recordAssignment1821); + if (HASEXCEPTION()) + { + goto rulerecordAssignmentEx; + } + + CREATE_stream_ID; stream_ID->add(stream_ID, ID101, NULL); + + char_literal102 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_recordAssignment1823); + if (HASEXCEPTION()) + { + goto rulerecordAssignmentEx; + } + + CREATE_stream_35; stream_35->add(stream_35, char_literal102, NULL); + + FOLLOWPUSH(FOLLOW_value_in_recordAssignment1825); + value103=value(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulerecordAssignmentEx; + } + + CREATE_stream_value; stream_value->add(stream_value, value103.tree, NULL); + + + /* AST REWRITE + * elements : value, ID + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 227:5: -> ^( ASSIGNMENT ID value ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:227:8: ^( ASSIGNMENT ID value ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ASSIGNMENT, (pANTLR3_UINT8)"ASSIGNMENT"), root_1)); + + ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID)); + ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value)); + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto rulerecordAssignmentEx; /* Prevent compiler warnings */ + rulerecordAssignmentEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_ID != NULL) stream_ID->free(stream_ID); + if (stream_35 != NULL) stream_35->free(stream_35); + if (stream_value != NULL) stream_value->free(stream_value); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end recordAssignment */ + +/** + * $ANTLR start map + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:1: map : 'map' '{' ( mapAssignment ( ',' mapAssignment )* )? '}' -> ^( MAP ( mapAssignment )* ) ; + */ +static SimanticsDataParser_map_return +map(pSimanticsDataParser ctx) +{ + SimanticsDataParser_map_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN string_literal104; + pANTLR3_COMMON_TOKEN char_literal105; + pANTLR3_COMMON_TOKEN char_literal107; + pANTLR3_COMMON_TOKEN char_literal109; + SimanticsDataParser_mapAssignment_return mapAssignment106; + #undef RETURN_TYPE_mapAssignment106 + #define RETURN_TYPE_mapAssignment106 SimanticsDataParser_mapAssignment_return + + SimanticsDataParser_mapAssignment_return mapAssignment108; + #undef RETURN_TYPE_mapAssignment108 + #define RETURN_TYPE_mapAssignment108 SimanticsDataParser_mapAssignment_return + + pANTLR3_BASE_TREE string_literal104_tree; + pANTLR3_BASE_TREE char_literal105_tree; + pANTLR3_BASE_TREE char_literal107_tree; + pANTLR3_BASE_TREE char_literal109_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_49; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_43; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_44; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_41; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_mapAssignment; + /* Initialize rule variables + */ + + + root_0 = NULL; + + string_literal104 = NULL; + char_literal105 = NULL; + char_literal107 = NULL; + char_literal109 = NULL; + mapAssignment106.tree = NULL; + + mapAssignment108.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + string_literal104_tree = NULL; + char_literal105_tree = NULL; + char_literal107_tree = NULL; + char_literal109_tree = NULL; + + stream_49 = NULL; + #define CREATE_stream_49 if (stream_49 == NULL) {stream_49 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 49"); } + stream_43 = NULL; + #define CREATE_stream_43 if (stream_43 == NULL) {stream_43 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 43"); } + stream_44 = NULL; + #define CREATE_stream_44 if (stream_44 == NULL) {stream_44 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 44"); } + stream_41 = NULL; + #define CREATE_stream_41 if (stream_41 == NULL) {stream_41 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 41"); } + stream_mapAssignment = NULL; + #define CREATE_stream_mapAssignment if (stream_mapAssignment == NULL) {stream_mapAssignment = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule mapAssignment"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:5: ( 'map' '{' ( mapAssignment ( ',' mapAssignment )* )? '}' -> ^( MAP ( mapAssignment )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:7: 'map' '{' ( mapAssignment ( ',' mapAssignment )* )? '}' + { + string_literal104 = (pANTLR3_COMMON_TOKEN) MATCHT(49, &FOLLOW_49_in_map1852); + if (HASEXCEPTION()) + { + goto rulemapEx; + } + + CREATE_stream_49; stream_49->add(stream_49, string_literal104, NULL); + + char_literal105 = (pANTLR3_COMMON_TOKEN) MATCHT(43, &FOLLOW_43_in_map1854); + if (HASEXCEPTION()) + { + goto rulemapEx; + } + + CREATE_stream_43; stream_43->add(stream_43, char_literal105, NULL); + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:17: ( mapAssignment ( ',' mapAssignment )* )? + { + int alt28=2; + switch ( LA(1) ) + { + case ID: + case INT: + case FLOAT: + case STRING: + case 37: + case 40: + case 43: + case 46: + case 47: + case 48: + case 49: + { + alt28=1; + } + break; + } + + switch (alt28) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:18: mapAssignment ( ',' mapAssignment )* + { + FOLLOWPUSH(FOLLOW_mapAssignment_in_map1857); + mapAssignment106=mapAssignment(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulemapEx; + } + + CREATE_stream_mapAssignment; stream_mapAssignment->add(stream_mapAssignment, mapAssignment106.tree, NULL); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:32: ( ',' mapAssignment )* + + for (;;) + { + int alt27=2; + switch ( LA(1) ) + { + case 41: + { + alt27=1; + } + break; + + } + + switch (alt27) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:230:33: ',' mapAssignment + { + char_literal107 = (pANTLR3_COMMON_TOKEN) MATCHT(41, &FOLLOW_41_in_map1860); + if (HASEXCEPTION()) + { + goto rulemapEx; + } + + CREATE_stream_41; stream_41->add(stream_41, char_literal107, NULL); + + FOLLOWPUSH(FOLLOW_mapAssignment_in_map1862); + mapAssignment108=mapAssignment(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulemapEx; + } + + CREATE_stream_mapAssignment; stream_mapAssignment->add(stream_mapAssignment, mapAssignment108.tree, NULL); + + } + break; + + default: + goto loop27; /* break out of the loop */ + break; + } + } + loop27: ; /* Jump out to here if this rule does not match */ + + + } + break; + + } + } + char_literal109 = (pANTLR3_COMMON_TOKEN) MATCHT(44, &FOLLOW_44_in_map1868); + if (HASEXCEPTION()) + { + goto rulemapEx; + } + + CREATE_stream_44; stream_44->add(stream_44, char_literal109, NULL); + + + + /* AST REWRITE + * elements : mapAssignment + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 231:5: -> ^( MAP ( mapAssignment )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:231:8: ^( MAP ( mapAssignment )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, MAP, (pANTLR3_UINT8)"MAP"), root_1)); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:231:14: ( mapAssignment )* + { + while ( (stream_mapAssignment != NULL && stream_mapAssignment->hasNext(stream_mapAssignment)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_mapAssignment == NULL ? NULL : stream_mapAssignment->nextTree(stream_mapAssignment)); + + } + if (stream_mapAssignment != NULL) stream_mapAssignment->reset(stream_mapAssignment); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto rulemapEx; /* Prevent compiler warnings */ + rulemapEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_49 != NULL) stream_49->free(stream_49); + if (stream_43 != NULL) stream_43->free(stream_43); + if (stream_44 != NULL) stream_44->free(stream_44); + if (stream_41 != NULL) stream_41->free(stream_41); + if (stream_mapAssignment != NULL) stream_mapAssignment->free(stream_mapAssignment); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end map */ + +/** + * $ANTLR start mapAssignment + * C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:234:1: mapAssignment : value '=' value -> ^( ASSIGNMENT ( value )* ) ; + */ +static SimanticsDataParser_mapAssignment_return +mapAssignment(pSimanticsDataParser ctx) +{ + SimanticsDataParser_mapAssignment_return retval; + + pANTLR3_BASE_TREE root_0; + + pANTLR3_COMMON_TOKEN char_literal111; + SimanticsDataParser_value_return value110; + #undef RETURN_TYPE_value110 + #define RETURN_TYPE_value110 SimanticsDataParser_value_return + + SimanticsDataParser_value_return value112; + #undef RETURN_TYPE_value112 + #define RETURN_TYPE_value112 SimanticsDataParser_value_return + + pANTLR3_BASE_TREE char_literal111_tree; + pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_35; + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_value; + /* Initialize rule variables + */ + + + root_0 = NULL; + + char_literal111 = NULL; + value110.tree = NULL; + + value112.tree = NULL; + + retval.start = LT(1); retval.stop = retval.start; + + char_literal111_tree = NULL; + + stream_35 = NULL; + #define CREATE_stream_35 if (stream_35 == NULL) {stream_35 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 35"); } + stream_value = NULL; + #define CREATE_stream_value if (stream_value == NULL) {stream_value = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule value"); } + + retval.tree = NULL; + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:235:5: ( value '=' value -> ^( ASSIGNMENT ( value )* ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:235:7: value '=' value + { + FOLLOWPUSH(FOLLOW_value_in_mapAssignment1900); + value110=value(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulemapAssignmentEx; + } + + CREATE_stream_value; stream_value->add(stream_value, value110.tree, NULL); + char_literal111 = (pANTLR3_COMMON_TOKEN) MATCHT(35, &FOLLOW_35_in_mapAssignment1902); + if (HASEXCEPTION()) + { + goto rulemapAssignmentEx; + } + + CREATE_stream_35; stream_35->add(stream_35, char_literal111, NULL); + + FOLLOWPUSH(FOLLOW_value_in_mapAssignment1904); + value112=value(ctx); + + FOLLOWPOP(); + if (HASEXCEPTION()) + { + goto rulemapAssignmentEx; + } + + CREATE_stream_value; stream_value->add(stream_value, value112.tree, NULL); + + + /* AST REWRITE + * elements : value + * token labels : + * rule labels : retval + * token list labels : + * rule list labels : + */ + { + pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval; + + stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL); + + root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + retval.tree = root_0; + // 236:5: -> ^( ASSIGNMENT ( value )* ) + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:236:8: ^( ASSIGNMENT ( value )* ) + { + pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); + root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, ASSIGNMENT, (pANTLR3_UINT8)"ASSIGNMENT"), root_1)); + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:236:21: ( value )* + { + while ( (stream_value != NULL && stream_value->hasNext(stream_value)) ) + { + ADAPTOR->addChild(ADAPTOR, root_1, stream_value == NULL ? NULL : stream_value->nextTree(stream_value)); + + } + if (stream_value != NULL) stream_value->reset(stream_value); + + } + + ADAPTOR->addChild(ADAPTOR, root_0, root_1); + } + + } + + retval.tree = root_0; // set result root + if (stream_retval != NULL) stream_retval->free(stream_retval); + + + } + } + + } + + + // This is where rules clean up and exit + // + goto rulemapAssignmentEx; /* Prevent compiler warnings */ + rulemapAssignmentEx: ; + retval.stop = LT(-1); + + retval.stop = LT(-1); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0)); + ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop); + if (stream_35 != NULL) stream_35->free(stream_35); + if (stream_value != NULL) stream_value->free(stream_value); + + if (HASEXCEPTION()) + { + PREPORTERROR(); + PRECOVER(); + retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); + } + + + return retval; +} +/* $ANTLR end mapAssignment */ +/* End of parsing rules + * ============================================== + */ + +/* ============================================== + * Syntactic predicates + */ +/* End of syntactic predicates + * ============================================== + */ + + + + + + +/* End of code + * ============================================================================= + */