/** \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 * ============================================================================= */