--- /dev/null
+/** \file\r
+ * This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23\r
+ *\r
+ * - From the grammar source file : Lang.g\r
+ * - On : 2010-02-24 13:27:52\r
+ * - for the parser : LangParserParser *\r
+ * Editing it, at least manually, is not wise. \r
+ *\r
+ * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.\r
+ *\r
+ *\r
+*/\r
+// [The "BSD licence"]\r
+// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC\r
+// http://www.temporal-wave.com\r
+// http://www.linkedin.com/in/jimidle\r
+//\r
+// All rights reserved.\r
+//\r
+// Redistribution and use in source and binary forms, with or without\r
+// modification, are permitted provided that the following conditions\r
+// are met:\r
+// 1. Redistributions of source code must retain the above copyright\r
+// notice, this list of conditions and the following disclaimer.\r
+// 2. Redistributions in binary form must reproduce the above copyright\r
+// notice, this list of conditions and the following disclaimer in the\r
+// documentation and/or other materials provided with the distribution.\r
+// 3. The name of the author may not be used to endorse or promote products\r
+// derived from this software without specific prior written permission.\r
+//\r
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\r
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\r
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\r
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\r
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
+\r
+/* -----------------------------------------\r
+ * Include the ANTLR3 generated header file.\r
+ */\r
+#include "LangParser.h"\r
+/* ----------------------------------------- */\r
+\r
+\r
+\r
+\r
+\r
+/* MACROS that hide the C interface implementations from the\r
+ * generated code, which makes it a little more understandable to the human eye.\r
+ * I am very much against using C pre-processor macros for function calls and bits\r
+ * of code as you cannot see what is happening when single stepping in debuggers\r
+ * and so on. The exception (in my book at least) is for generated code, where you are\r
+ * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()\r
+ * hides some indirect calls, but is always referring to the input stream. This is\r
+ * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig\r
+ * the runtime interfaces without changing the generated code too often, without\r
+ * confusing the reader of the generated output, who may not wish to know the gory\r
+ * details of the interface inheritance.\r
+ */\r
+ \r
+#define CTX ctx\r
+\r
+/* Aids in accessing scopes for grammar programmers\r
+ */\r
+#undef SCOPE_TYPE\r
+#undef SCOPE_STACK\r
+#undef SCOPE_TOP\r
+#define SCOPE_TYPE(scope) pLangParser_##scope##_SCOPE\r
+#define SCOPE_STACK(scope) pLangParser_##scope##Stack\r
+#define SCOPE_TOP(scope) ctx->pLangParser_##scope##Top\r
+#define SCOPE_SIZE(scope) ctx->pLangParser_##scope##Stack_limit\r
+#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))\r
+\r
+/* Macros for accessing things in the parser\r
+ */\r
+ \r
+#undef PARSER \r
+#undef RECOGNIZER \r
+#undef HAVEPARSEDRULE\r
+#undef MEMOIZE\r
+#undef INPUT\r
+#undef STRSTREAM\r
+#undef HASEXCEPTION\r
+#undef EXCEPTION\r
+#undef MATCHT\r
+#undef MATCHANYT\r
+#undef FOLLOWSTACK\r
+#undef FOLLOWPUSH\r
+#undef FOLLOWPOP\r
+#undef PRECOVER\r
+#undef PREPORTERROR\r
+#undef LA\r
+#undef LT\r
+#undef CONSTRUCTEX\r
+#undef CONSUME\r
+#undef MARK\r
+#undef REWIND\r
+#undef REWINDLAST\r
+#undef PERRORRECOVERY\r
+#undef HASFAILED\r
+#undef FAILEDFLAG\r
+#undef RECOVERFROMMISMATCHEDSET\r
+#undef RECOVERFROMMISMATCHEDELEMENT\r
+#undef INDEX\r
+#undef ADAPTOR\r
+#undef SEEK\r
+#undef RULEMEMO \r
+#undef DBG\r
+\r
+#define PARSER ctx->pParser \r
+#define RECOGNIZER PARSER->rec\r
+#define PSRSTATE RECOGNIZER->state\r
+#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)\r
+#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si)\r
+#define INPUT PARSER->tstream\r
+#define STRSTREAM INPUT\r
+#define ISTREAM INPUT->istream\r
+#define INDEX() ISTREAM->index(INPUT->istream)\r
+#define HASEXCEPTION() (PSRSTATE->error == ANTLR3_TRUE)\r
+#define EXCEPTION PSRSTATE->exception\r
+#define MATCHT(t, fs) RECOGNIZER->match(RECOGNIZER, t, fs)\r
+#define MATCHANYT() RECOGNIZER->matchAny(RECOGNIZER)\r
+#define FOLLOWSTACK PSRSTATE->following\r
+#define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL)\r
+#define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK)\r
+#define PRECOVER() RECOGNIZER->recover(RECOGNIZER)\r
+#define PREPORTERROR() RECOGNIZER->reportError(RECOGNIZER)\r
+#define LA(n) INPUT->istream->_LA(ISTREAM, n)\r
+#define LT(n) INPUT->_LT(INPUT, n)\r
+#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER)\r
+#define CONSUME() ISTREAM->consume(ISTREAM)\r
+#define MARK() ISTREAM->mark(ISTREAM)\r
+#define REWIND(m) ISTREAM->rewind(ISTREAM, m)\r
+#define REWINDLAST() ISTREAM->rewindLast(ISTREAM)\r
+#define SEEK(n) ISTREAM->seek(ISTREAM, n)\r
+#define PERRORRECOVERY PSRSTATE->errorRecovery\r
+#define FAILEDFLAG PSRSTATE->failed\r
+#define HASFAILED() (FAILEDFLAG == ANTLR3_TRUE)\r
+#define BACKTRACKING PSRSTATE->backtracking\r
+#define RECOVERFROMMISMATCHEDSET(s) RECOGNIZER->recoverFromMismatchedSet(RECOGNIZER, s)\r
+#define RECOVERFROMMISMATCHEDELEMENT(e) RECOGNIZER->recoverFromMismatchedElement(RECOGNIZER, s)\r
+#define ADAPTOR ctx->adaptor\r
+#define RULEMEMO PSRSTATE->ruleMemo\r
+#define DBG RECOGNIZER->debugger\r
+\r
+#define TOKTEXT(tok, txt) tok, (pANTLR3_UINT8)txt\r
+\r
+/* The 4 tokens defined below may well clash with your own #defines or token types. If so\r
+ * then for the present you must use different names for your defines as these are hard coded\r
+ * in the code generator. It would be better not to use such names internally, and maybe\r
+ * we can change this in a forthcoming release. I deliberately do not #undef these\r
+ * here as this will at least give you a redefined error somewhere if they clash.\r
+ */\r
+#define UP ANTLR3_TOKEN_UP\r
+#define DOWN ANTLR3_TOKEN_DOWN\r
+#define EOR ANTLR3_TOKEN_EOR\r
+#define INVALID ANTLR3_TOKEN_INVALID\r
+\r
+\r
+/* =============================================================================\r
+ * Functions to create and destroy scopes. First come the rule scopes, followed\r
+ * by the global declared scopes.\r
+ */\r
+\r
+\r
+\r
+/* ============================================================================= */\r
+\r
+/* =============================================================================\r
+ * Start of recognizer\r
+ */\r
+\r
+\r
+\r
+/** \brief Table of all token names in symbolic order, mainly used for\r
+ * error reporting.\r
+ */\r
+pANTLR3_UINT8 LangParserTokenNames[7+4]\r
+ = {\r
+ (pANTLR3_UINT8) "<invalid>", /* String to print to indicate an invalid token */\r
+ (pANTLR3_UINT8) "<EOR>",\r
+ (pANTLR3_UINT8) "<DOWN>", \r
+ (pANTLR3_UINT8) "<UP>", \r
+ (pANTLR3_UINT8) "DECL",\r
+ (pANTLR3_UINT8) "ID",\r
+ (pANTLR3_UINT8) "INTTYPE",\r
+ (pANTLR3_UINT8) "FLOATTYPE",\r
+ (pANTLR3_UINT8) "INT",\r
+ (pANTLR3_UINT8) "WS",\r
+ (pANTLR3_UINT8) "';'"\r
+ };\r
+\r
+ \r
+\r
+// Forward declare the locally static matching functions we have generated.\r
+//\r
+static LangParser_start_return start (pLangParser ctx);\r
+static LangParser_decl_return decl (pLangParser ctx);\r
+static LangParser_type_return type (pLangParser ctx);\r
+static void LangParserFree(pLangParser ctx);\r
+/* For use in tree output where we are accumulating rule labels via label += ruleRef\r
+ * we need a function that knows how to free a return scope when the list is destroyed. \r
+ * We cannot just use ANTLR3_FREE because in debug tracking mode, this is a macro.\r
+ */\r
+static void ANTLR3_CDECL freeScope(void * scope)\r
+{\r
+ ANTLR3_FREE(scope);\r
+}\r
+\r
+/** \brief Name of the grammar file that generated this code\r
+ */\r
+static const char fileName[] = "Lang.g";\r
+\r
+/** \brief Return the name of the grammar file that generated this code.\r
+ */\r
+static const char * getGrammarFileName()\r
+{\r
+ return fileName;\r
+}\r
+/** \brief Create a new LangParser parser and return a context for it.\r
+ *\r
+ * \param[in] instream Pointer to an input stream interface.\r
+ *\r
+ * \return Pointer to new parser context upon success.\r
+ */\r
+ANTLR3_API pLangParser\r
+LangParserNew (pANTLR3_COMMON_TOKEN_STREAM instream)\r
+{\r
+ // See if we can create a new parser with the standard constructor\r
+ //\r
+ return LangParserNewSSD(instream, NULL);\r
+}\r
+\r
+/** \brief Create a new LangParser parser and return a context for it.\r
+ *\r
+ * \param[in] instream Pointer to an input stream interface.\r
+ *\r
+ * \return Pointer to new parser context upon success.\r
+ */\r
+ANTLR3_API pLangParser\r
+LangParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)\r
+{\r
+ pLangParser ctx; /* Context structure we will build and return */\r
+ \r
+ ctx = (pLangParser) ANTLR3_CALLOC(1, sizeof(LangParser));\r
+ \r
+ if (ctx == NULL)\r
+ {\r
+ // Failed to allocate memory for parser context\r
+ //\r
+ return NULL;\r
+ }\r
+ \r
+ /* -------------------------------------------------------------------\r
+ * Memory for basic structure is allocated, now to fill in\r
+ * the base ANTLR3 structures. We initialize the function pointers\r
+ * for the standard ANTLR3 parser function set, but upon return\r
+ * from here, the programmer may set the pointers to provide custom\r
+ * implementations of each function. \r
+ *\r
+ * We don't use the macros defined in LangParser.h here, in order that you can get a sense\r
+ * of what goes where.\r
+ */\r
+\r
+ /* Create a base parser/recognizer, using the supplied token stream\r
+ */\r
+ ctx->pParser = antlr3ParserNewStream(ANTLR3_SIZE_HINT, instream->tstream, state);\r
+ /* Install the implementation of our LangParser interface\r
+ */\r
+ ctx->start = start;\r
+ ctx->decl = decl;\r
+ ctx->type = type;\r
+ ctx->free = LangParserFree;\r
+ ctx->getGrammarFileName = getGrammarFileName;\r
+ \r
+ /* Install the scope pushing methods.\r
+ */\r
+ ADAPTOR = ANTLR3_TREE_ADAPTORNew(instream->tstream->tokenSource->strFactory);\r
+ ctx->vectors = antlr3VectorFactoryNew(0);\r
+ \r
+\r
+ \r
+ /* Install the token table\r
+ */\r
+ PSRSTATE->tokenNames = LangParserTokenNames;\r
+ \r
+ \r
+ /* Return the newly built parser to the caller\r
+ */\r
+ return ctx;\r
+}\r
+\r
+/** Free the parser resources\r
+ */\r
+ static void\r
+ LangParserFree(pLangParser ctx)\r
+ {\r
+ /* Free any scope memory\r
+ */\r
+ \r
+ ctx->vectors->close(ctx->vectors);\r
+ /* We created the adaptor so we must free it\r
+ */\r
+ ADAPTOR->free(ADAPTOR);\r
+ // Free this parser\r
+ //\r
+ ctx->pParser->free(ctx->pParser);\r
+ ANTLR3_FREE(ctx);\r
+\r
+ /* Everything is released, so we can return\r
+ */\r
+ return;\r
+ }\r
+ \r
+/** Return token names used by this parser\r
+ *\r
+ * The returned pointer is used as an index into the token names table (using the token \r
+ * number as the index).\r
+ * \r
+ * \return Pointer to first char * in the table.\r
+ */\r
+static pANTLR3_UINT8 *getTokenNames() \r
+{\r
+ return LangParserTokenNames; \r
+}\r
+\r
+ \r
+/* Declare the bitsets\r
+ */\r
+\r
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_decl_in_start91 */\r
+static ANTLR3_BITWORD FOLLOW_decl_in_start91_bits[] = { ANTLR3_UINT64_LIT(0x00000000000000C2) };\r
+static ANTLR3_BITSET_LIST FOLLOW_decl_in_start91 = { FOLLOW_decl_in_start91_bits, 1 };\r
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_type_in_decl103 */\r
+static ANTLR3_BITWORD FOLLOW_type_in_decl103_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000020) };\r
+static ANTLR3_BITSET_LIST FOLLOW_type_in_decl103 = { FOLLOW_type_in_decl103_bits, 1 };\r
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_ID_in_decl105 */\r
+static ANTLR3_BITWORD FOLLOW_ID_in_decl105_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000400) };\r
+static ANTLR3_BITSET_LIST FOLLOW_ID_in_decl105 = { FOLLOW_ID_in_decl105_bits, 1 };\r
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_10_in_decl107 */\r
+static ANTLR3_BITWORD FOLLOW_10_in_decl107_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
+static ANTLR3_BITSET_LIST FOLLOW_10_in_decl107 = { FOLLOW_10_in_decl107_bits, 1 };\r
+/** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_type0 */\r
+static ANTLR3_BITWORD FOLLOW_set_in_type0_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) };\r
+static ANTLR3_BITSET_LIST FOLLOW_set_in_type0 = { FOLLOW_set_in_type0_bits, 1 };\r
+ \r
+\r
+ \r
+ \r
+/* ==============================================\r
+ * Parsing rules\r
+ */\r
+/** \r
+ * $ANTLR start start\r
+ * Lang.g:20:1: start : ( decl )+ ;\r
+ */\r
+static LangParser_start_return\r
+start(pLangParser ctx)\r
+{ \r
+ LangParser_start_return retval;\r
+\r
+ pANTLR3_BASE_TREE root_0;\r
+\r
+ LangParser_decl_return decl1;\r
+ #undef RETURN_TYPE_decl1\r
+ #define RETURN_TYPE_decl1 LangParser_decl_return\r
+\r
+\r
+ /* Initialize rule variables\r
+ */\r
+\r
+\r
+ root_0 = NULL;\r
+\r
+ decl1.tree = NULL;\r
+\r
+ retval.start = LT(1); retval.stop = retval.start;\r
+\r
+\r
+\r
+ retval.tree = NULL;\r
+ {\r
+ // Lang.g:20:7: ( ( decl )+ )\r
+ // Lang.g:20:9: ( decl )+\r
+ {\r
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
+\r
+ // Lang.g:20:9: ( decl )+\r
+ {\r
+ int cnt1=0;\r
+\r
+ for (;;)\r
+ {\r
+ int alt1=2;\r
+ switch ( LA(1) ) \r
+ {\r
+ case INTTYPE:\r
+ case FLOATTYPE:\r
+ {\r
+ alt1=1;\r
+ }\r
+ break;\r
+\r
+ }\r
+\r
+ switch (alt1) \r
+ {\r
+ case 1:\r
+ // Lang.g:20:9: decl\r
+ {\r
+ FOLLOWPUSH(FOLLOW_decl_in_start91);\r
+ decl1=decl(ctx);\r
+\r
+ FOLLOWPOP();\r
+ if (HASEXCEPTION())\r
+ {\r
+ goto rulestartEx;\r
+ }\r
+\r
+ ADAPTOR->addChild(ADAPTOR, root_0, decl1.tree);\r
+\r
+ }\r
+ break;\r
+\r
+ default:\r
+ \r
+ if ( cnt1 >= 1 )\r
+ {\r
+ goto loop1;\r
+ }\r
+ /* mismatchedSetEx()\r
+ */\r
+ CONSTRUCTEX();\r
+ EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;\r
+ EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;\r
+\r
+\r
+ goto rulestartEx;\r
+ }\r
+ cnt1++;\r
+ }\r
+ loop1: ; /* Jump to here if this rule does not match */\r
+ }\r
+\r
+ }\r
+\r
+ }\r
+ \r
+\r
+ // This is where rules clean up and exit\r
+ //\r
+ goto rulestartEx; /* Prevent compiler warnings */\r
+ rulestartEx: ;\r
+ retval.stop = LT(-1);\r
+\r
+ retval.stop = LT(-1);\r
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
+\r
+ if (HASEXCEPTION())\r
+ {\r
+ PREPORTERROR();\r
+ PRECOVER();\r
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
+ }\r
+\r
+\r
+ return retval;\r
+}\r
+/* $ANTLR end start */\r
+\r
+/** \r
+ * $ANTLR start decl\r
+ * Lang.g:23:1: decl : type ID ';' -> ^( DECL type ID ) ;\r
+ */\r
+static LangParser_decl_return\r
+decl(pLangParser ctx)\r
+{ \r
+ LangParser_decl_return retval;\r
+\r
+ pANTLR3_BASE_TREE root_0;\r
+\r
+ pANTLR3_COMMON_TOKEN ID3;\r
+ pANTLR3_COMMON_TOKEN char_literal4;\r
+ LangParser_type_return type2;\r
+ #undef RETURN_TYPE_type2\r
+ #define RETURN_TYPE_type2 LangParser_type_return\r
+\r
+ pANTLR3_BASE_TREE ID3_tree;\r
+ pANTLR3_BASE_TREE char_literal4_tree;\r
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_10;\r
+ pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_ID;\r
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_type;\r
+ /* Initialize rule variables\r
+ */\r
+\r
+\r
+ root_0 = NULL;\r
+\r
+ ID3 = NULL;\r
+ char_literal4 = NULL;\r
+ type2.tree = NULL;\r
+\r
+ retval.start = LT(1); retval.stop = retval.start;\r
+\r
+ ID3_tree = NULL;\r
+ char_literal4_tree = NULL;\r
+\r
+ stream_10 = NULL;\r
+ #define CREATE_stream_10 if (stream_10 == NULL) {stream_10 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 10"); } \r
+ stream_ID = NULL;\r
+ #define CREATE_stream_ID if (stream_ID == NULL) {stream_ID = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token ID"); } \r
+ stream_type = NULL;\r
+ #define CREATE_stream_type if (stream_type == NULL) {stream_type = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule type"); }\r
+\r
+ retval.tree = NULL;\r
+ {\r
+ // Lang.g:23:6: ( type ID ';' -> ^( DECL type ID ) )\r
+ // Lang.g:23:8: type ID ';'\r
+ {\r
+ FOLLOWPUSH(FOLLOW_type_in_decl103);\r
+ type2=type(ctx);\r
+\r
+ FOLLOWPOP();\r
+ if (HASEXCEPTION())\r
+ {\r
+ goto ruledeclEx;\r
+ }\r
+\r
+ CREATE_stream_type; stream_type->add(stream_type, type2.tree, NULL);\r
+ ID3 = (pANTLR3_COMMON_TOKEN) MATCHT(ID, &FOLLOW_ID_in_decl105); \r
+ if (HASEXCEPTION())\r
+ {\r
+ goto ruledeclEx;\r
+ }\r
+ \r
+ CREATE_stream_ID; stream_ID->add(stream_ID, ID3, NULL);\r
+\r
+ char_literal4 = (pANTLR3_COMMON_TOKEN) MATCHT(10, &FOLLOW_10_in_decl107); \r
+ if (HASEXCEPTION())\r
+ {\r
+ goto ruledeclEx;\r
+ }\r
+ \r
+ CREATE_stream_10; stream_10->add(stream_10, char_literal4, NULL);\r
+\r
+\r
+ \r
+ /* AST REWRITE\r
+ * elements : ID, type\r
+ * token labels : \r
+ * rule labels : retval\r
+ * token list labels : \r
+ * rule list labels : \r
+ */\r
+ {\r
+ pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_retval;\r
+\r
+ stream_retval=antlr3RewriteRuleSubtreeStreamNewAEE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token retval", retval.tree != NULL ? retval.tree : NULL);\r
+\r
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
+ retval.tree = root_0;\r
+ // 23:20: -> ^( DECL type ID )\r
+ {\r
+ // Lang.g:23:23: ^( DECL type ID )\r
+ {\r
+ pANTLR3_BASE_TREE root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
+ root_1 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)ADAPTOR->createTypeText(ADAPTOR, DECL, (pANTLR3_UINT8)"DECL"), root_1));\r
+\r
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_type == NULL ? NULL : stream_type->nextTree(stream_type));\r
+ ADAPTOR->addChild(ADAPTOR, root_1, stream_ID == NULL ? NULL : stream_ID->nextNode(stream_ID));\r
+\r
+ ADAPTOR->addChild(ADAPTOR, root_0, root_1);\r
+ }\r
+\r
+ }\r
+\r
+ retval.tree = root_0; // set result root\r
+ if (stream_retval != NULL) stream_retval->free(stream_retval);\r
+\r
+\r
+ }\r
+ }\r
+\r
+ }\r
+ \r
+\r
+ // This is where rules clean up and exit\r
+ //\r
+ goto ruledeclEx; /* Prevent compiler warnings */\r
+ ruledeclEx: ;\r
+ retval.stop = LT(-1);\r
+\r
+ retval.stop = LT(-1);\r
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
+ if (stream_10 != NULL) stream_10->free(stream_10);\r
+ if (stream_ID != NULL) stream_ID->free(stream_ID);\r
+ if (stream_type != NULL) stream_type->free(stream_type);\r
+\r
+ if (HASEXCEPTION())\r
+ {\r
+ PREPORTERROR();\r
+ PRECOVER();\r
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
+ }\r
+\r
+\r
+ return retval;\r
+}\r
+/* $ANTLR end decl */\r
+\r
+/** \r
+ * $ANTLR start type\r
+ * Lang.g:26:1: type : ( INTTYPE | FLOATTYPE );\r
+ */\r
+static LangParser_type_return\r
+type(pLangParser ctx)\r
+{ \r
+ LangParser_type_return retval;\r
+\r
+ pANTLR3_BASE_TREE root_0;\r
+\r
+ pANTLR3_COMMON_TOKEN set5;\r
+\r
+ pANTLR3_BASE_TREE set5_tree;\r
+\r
+ /* Initialize rule variables\r
+ */\r
+\r
+\r
+ root_0 = NULL;\r
+\r
+ set5 = NULL;\r
+ retval.start = LT(1); retval.stop = retval.start;\r
+\r
+ set5_tree = NULL;\r
+\r
+\r
+ retval.tree = NULL;\r
+ {\r
+ // Lang.g:26:6: ( INTTYPE | FLOATTYPE )\r
+ // Lang.g:\r
+ {\r
+ root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR));\r
+\r
+ set5=(pANTLR3_COMMON_TOKEN)LT(1);\r
+ if ( ((LA(1) >= INTTYPE) && (LA(1) <= FLOATTYPE)) )\r
+ {\r
+ CONSUME();\r
+ ADAPTOR->addChild(ADAPTOR, root_0, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set5)));\r
+ PERRORRECOVERY=ANTLR3_FALSE;\r
+ }\r
+ else \r
+ {\r
+ CONSTRUCTEX();\r
+ EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
+ EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
+ EXCEPTION->expectingSet = &FOLLOW_set_in_type0;\r
+ RECOVERFROMMISMATCHEDSET(&FOLLOW_set_in_type0); goto ruletypeEx;\r
+ }\r
+\r
+\r
+ }\r
+\r
+ }\r
+ \r
+\r
+ // This is where rules clean up and exit\r
+ //\r
+ goto ruletypeEx; /* Prevent compiler warnings */\r
+ ruletypeEx: ;\r
+ retval.stop = LT(-1);\r
+\r
+ retval.stop = LT(-1);\r
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->rulePostProcessing(ADAPTOR, root_0));\r
+ ADAPTOR->setTokenBoundaries(ADAPTOR, retval.tree, retval.start, retval.stop);\r
+\r
+ if (HASEXCEPTION())\r
+ {\r
+ PREPORTERROR();\r
+ PRECOVER();\r
+ retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION));\r
+ }\r
+\r
+\r
+ return retval;\r
+}\r
+/* $ANTLR end type */\r
+/* End of parsing rules\r
+ * ==============================================\r
+ */\r
+\r
+/* ==============================================\r
+ * Syntactic predicates\r
+ */\r
+/* End of syntactic predicates\r
+ * ==============================================\r
+ */\r
+\r
+ \r
+ \r
+\r
+\r
+\r
+/* End of code\r
+ * =============================================================================\r
+ */\r
Code Review / simantics / platform.git / blobdiff