/** \file * This C source file was generated by $ANTLR version 3.4 * * - From the grammar source file : EquationSystem.g * - On : 2012-07-12 15:47:50 * - for the parser : EquationSystemParserParser * * Editing it, at least manually, is not wise. * * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws. * * */ // [The "BSD license"] // 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 "EquationSystemParser.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) pEquationSystemParser_##scope##_SCOPE #define SCOPE_STACK(scope) pEquationSystemParser_##scope##Stack #define SCOPE_TOP(scope) ctx->pEquationSystemParser_##scope##Top #define SCOPE_SIZE(scope) ctx->pEquationSystemParser_##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 #ifdef SKIP_FOLLOW_SETS #define FOLLOWPUSH(x) #define FOLLOWPOP() #else #define FOLLOWPUSH(x) FOLLOWSTACK->push(FOLLOWSTACK, ((void *)(&(x))), NULL) #define FOLLOWPOP() FOLLOWSTACK->pop(FOLLOWSTACK) #endif #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 EquationSystemParserTokenNames[19+4] = { (pANTLR3_UINT8) "", /* String to print to indicate an invalid token */ (pANTLR3_UINT8) "", (pANTLR3_UINT8) "", (pANTLR3_UINT8) "", (pANTLR3_UINT8) "COMMA", (pANTLR3_UINT8) "DIGIT", (pANTLR3_UINT8) "GREATER_EQUAL", (pANTLR3_UINT8) "GUARD", (pANTLR3_UINT8) "LETTER", (pANTLR3_UINT8) "MAXIMUM", (pANTLR3_UINT8) "MINIMUM", (pANTLR3_UINT8) "MULT", (pANTLR3_UINT8) "NEWLINE", (pANTLR3_UINT8) "NUMBER", (pANTLR3_UINT8) "PLUS", (pANTLR3_UINT8) "QUESTION_MARK", (pANTLR3_UINT8) "SUB", (pANTLR3_UINT8) "VARIABLE", (pANTLR3_UINT8) "WHITESPACE", (pANTLR3_UINT8) "'('", (pANTLR3_UINT8) "')'", (pANTLR3_UINT8) "','", (pANTLR3_UINT8) "'='" }; // Forward declare the locally static matching functions we have generated. // static EquationSystemParser_equation_system_return equation_system (pEquationSystemParser ctx); static EquationSystemParser_equation_return equation (pEquationSystemParser ctx); static EquationSystemParser_maxExpr_return maxExpr (pEquationSystemParser ctx); static EquationSystemParser_minExpr_return minExpr (pEquationSystemParser ctx); static EquationSystemParser_expr_return expr (pEquationSystemParser ctx); static EquationSystemParser_term_return term (pEquationSystemParser ctx); static ANTLR3_BOOLEAN synpred8_EquationSystem (pEquationSystemParser ctx); static ANTLR3_BOOLEAN synpred12_EquationSystem (pEquationSystemParser ctx); static void EquationSystemParserFree(pEquationSystemParser ctx); static void EquationSystemParserReset (pEquationSystemParser 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[] = "EquationSystem.g"; /** \brief Return the name of the grammar file that generated this code. */ static const char * getGrammarFileName() { return fileName; } /** \brief Create a new EquationSystemParser 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 pEquationSystemParser EquationSystemParserNew (pANTLR3_COMMON_TOKEN_STREAM instream) { // See if we can create a new parser with the standard constructor // return EquationSystemParserNewSSD(instream, NULL); } /** \brief Create a new EquationSystemParser 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 pEquationSystemParser EquationSystemParserNewSSD (pANTLR3_COMMON_TOKEN_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state) { pEquationSystemParser ctx; /* Context structure we will build and return */ ctx = (pEquationSystemParser) ANTLR3_CALLOC(1, sizeof(EquationSystemParser)); 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 EquationSystemParser.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 EquationSystemParser interface */ ctx->equation_system = equation_system; ctx->equation = equation; ctx->maxExpr = maxExpr; ctx->minExpr = minExpr; ctx->expr = expr; ctx->term = term; ctx->synpred8_EquationSystem = synpred8_EquationSystem; ctx->synpred12_EquationSystem = synpred12_EquationSystem; ctx->free = EquationSystemParserFree; ctx->reset = EquationSystemParserReset; 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 = EquationSystemParserTokenNames; /* Return the newly built parser to the caller */ return ctx; } static void EquationSystemParserReset (pEquationSystemParser ctx) { RECOGNIZER->reset(RECOGNIZER); } /** Free the parser resources */ static void EquationSystemParserFree(pEquationSystemParser 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 EquationSystemParserTokenNames; } /* Declare the bitsets */ /** Bitset defining follow set for error recovery in rule state: FOLLOW_equation_in_equation_system141 */ static ANTLR3_BITWORD FOLLOW_equation_in_equation_system141_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001002) }; static ANTLR3_BITSET_LIST FOLLOW_equation_in_equation_system141 = { FOLLOW_equation_in_equation_system141_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_NEWLINE_in_equation_system145 */ static ANTLR3_BITWORD FOLLOW_NEWLINE_in_equation_system145_bits[] = { ANTLR3_UINT64_LIT(0x0000000000021000) }; static ANTLR3_BITSET_LIST FOLLOW_NEWLINE_in_equation_system145 = { FOLLOW_NEWLINE_in_equation_system145_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_equation_in_equation_system150 */ static ANTLR3_BITWORD FOLLOW_equation_in_equation_system150_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001002) }; static ANTLR3_BITSET_LIST FOLLOW_equation_in_equation_system150 = { FOLLOW_equation_in_equation_system150_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_NEWLINE_in_equation_system157 */ static ANTLR3_BITWORD FOLLOW_NEWLINE_in_equation_system157_bits[] = { ANTLR3_UINT64_LIT(0x0000000000001002) }; static ANTLR3_BITSET_LIST FOLLOW_NEWLINE_in_equation_system157 = { FOLLOW_NEWLINE_in_equation_system157_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_VARIABLE_in_equation168 */ static ANTLR3_BITWORD FOLLOW_VARIABLE_in_equation168_bits[] = { ANTLR3_UINT64_LIT(0x0000000000400000) }; static ANTLR3_BITSET_LIST FOLLOW_VARIABLE_in_equation168 = { FOLLOW_VARIABLE_in_equation168_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_22_in_equation170 */ static ANTLR3_BITWORD FOLLOW_22_in_equation170_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2600) }; static ANTLR3_BITSET_LIST FOLLOW_22_in_equation170 = { FOLLOW_22_in_equation170_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_maxExpr_in_equation173 */ static ANTLR3_BITWORD FOLLOW_maxExpr_in_equation173_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_maxExpr_in_equation173 = { FOLLOW_maxExpr_in_equation173_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_MAXIMUM_in_maxExpr182 */ static ANTLR3_BITWORD FOLLOW_MAXIMUM_in_maxExpr182_bits[] = { ANTLR3_UINT64_LIT(0x0000000000080000) }; static ANTLR3_BITSET_LIST FOLLOW_MAXIMUM_in_maxExpr182 = { FOLLOW_MAXIMUM_in_maxExpr182_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_19_in_maxExpr185 */ static ANTLR3_BITWORD FOLLOW_19_in_maxExpr185_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2400) }; static ANTLR3_BITSET_LIST FOLLOW_19_in_maxExpr185 = { FOLLOW_19_in_maxExpr185_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_minExpr_in_maxExpr188 */ static ANTLR3_BITWORD FOLLOW_minExpr_in_maxExpr188_bits[] = { ANTLR3_UINT64_LIT(0x0000000000300000) }; static ANTLR3_BITSET_LIST FOLLOW_minExpr_in_maxExpr188 = { FOLLOW_minExpr_in_maxExpr188_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_21_in_maxExpr192 */ static ANTLR3_BITWORD FOLLOW_21_in_maxExpr192_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2400) }; static ANTLR3_BITSET_LIST FOLLOW_21_in_maxExpr192 = { FOLLOW_21_in_maxExpr192_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_minExpr_in_maxExpr195 */ static ANTLR3_BITWORD FOLLOW_minExpr_in_maxExpr195_bits[] = { ANTLR3_UINT64_LIT(0x0000000000300000) }; static ANTLR3_BITSET_LIST FOLLOW_minExpr_in_maxExpr195 = { FOLLOW_minExpr_in_maxExpr195_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_20_in_maxExpr200 */ static ANTLR3_BITWORD FOLLOW_20_in_maxExpr200_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_20_in_maxExpr200 = { FOLLOW_20_in_maxExpr200_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_minExpr_in_maxExpr205 */ static ANTLR3_BITWORD FOLLOW_minExpr_in_maxExpr205_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_minExpr_in_maxExpr205 = { FOLLOW_minExpr_in_maxExpr205_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_MINIMUM_in_minExpr213 */ static ANTLR3_BITWORD FOLLOW_MINIMUM_in_minExpr213_bits[] = { ANTLR3_UINT64_LIT(0x0000000000080000) }; static ANTLR3_BITSET_LIST FOLLOW_MINIMUM_in_minExpr213 = { FOLLOW_MINIMUM_in_minExpr213_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_19_in_minExpr216 */ static ANTLR3_BITWORD FOLLOW_19_in_minExpr216_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2600) }; static ANTLR3_BITSET_LIST FOLLOW_19_in_minExpr216 = { FOLLOW_19_in_minExpr216_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_maxExpr_in_minExpr219 */ static ANTLR3_BITWORD FOLLOW_maxExpr_in_minExpr219_bits[] = { ANTLR3_UINT64_LIT(0x0000000000300000) }; static ANTLR3_BITSET_LIST FOLLOW_maxExpr_in_minExpr219 = { FOLLOW_maxExpr_in_minExpr219_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_21_in_minExpr223 */ static ANTLR3_BITWORD FOLLOW_21_in_minExpr223_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2600) }; static ANTLR3_BITSET_LIST FOLLOW_21_in_minExpr223 = { FOLLOW_21_in_minExpr223_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_maxExpr_in_minExpr226 */ static ANTLR3_BITWORD FOLLOW_maxExpr_in_minExpr226_bits[] = { ANTLR3_UINT64_LIT(0x0000000000300000) }; static ANTLR3_BITSET_LIST FOLLOW_maxExpr_in_minExpr226 = { FOLLOW_maxExpr_in_minExpr226_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_20_in_minExpr231 */ static ANTLR3_BITWORD FOLLOW_20_in_minExpr231_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_20_in_minExpr231 = { FOLLOW_20_in_minExpr231_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_minExpr236 */ static ANTLR3_BITWORD FOLLOW_expr_in_minExpr236_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_minExpr236 = { FOLLOW_expr_in_minExpr236_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_19_in_expr245 */ static ANTLR3_BITWORD FOLLOW_19_in_expr245_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_19_in_expr245 = { FOLLOW_19_in_expr245_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr247 */ static ANTLR3_BITWORD FOLLOW_expr_in_expr247_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000040) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr247 = { FOLLOW_expr_in_expr247_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_GREATER_EQUAL_in_expr249 */ static ANTLR3_BITWORD FOLLOW_GREATER_EQUAL_in_expr249_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_GREATER_EQUAL_in_expr249 = { FOLLOW_GREATER_EQUAL_in_expr249_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr251 */ static ANTLR3_BITWORD FOLLOW_expr_in_expr251_bits[] = { ANTLR3_UINT64_LIT(0x0000000000008000) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr251 = { FOLLOW_expr_in_expr251_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_QUESTION_MARK_in_expr253 */ static ANTLR3_BITWORD FOLLOW_QUESTION_MARK_in_expr253_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_QUESTION_MARK_in_expr253 = { FOLLOW_QUESTION_MARK_in_expr253_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr255 */ static ANTLR3_BITWORD FOLLOW_expr_in_expr255_bits[] = { ANTLR3_UINT64_LIT(0x0000000000100000) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr255 = { FOLLOW_expr_in_expr255_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_20_in_expr257 */ static ANTLR3_BITWORD FOLLOW_20_in_expr257_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_20_in_expr257 = { FOLLOW_20_in_expr257_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_term_in_expr278 */ static ANTLR3_BITWORD FOLLOW_term_in_expr278_bits[] = { ANTLR3_UINT64_LIT(0x0000000000014812) }; static ANTLR3_BITSET_LIST FOLLOW_term_in_expr278 = { FOLLOW_term_in_expr278_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_expr282 */ static ANTLR3_BITWORD FOLLOW_set_in_expr282_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_set_in_expr282 = { FOLLOW_set_in_expr282_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_expr299 */ static ANTLR3_BITWORD FOLLOW_expr_in_expr299_bits[] = { ANTLR3_UINT64_LIT(0x0000000000014812) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_expr299 = { FOLLOW_expr_in_expr299_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_NUMBER_in_term311 */ static ANTLR3_BITWORD FOLLOW_NUMBER_in_term311_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_NUMBER_in_term311 = { FOLLOW_NUMBER_in_term311_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_VARIABLE_in_term320 */ static ANTLR3_BITWORD FOLLOW_VARIABLE_in_term320_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_VARIABLE_in_term320 = { FOLLOW_VARIABLE_in_term320_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_SUB_in_term329 */ static ANTLR3_BITWORD FOLLOW_SUB_in_term329_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_SUB_in_term329 = { FOLLOW_SUB_in_term329_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_term_in_term332 */ static ANTLR3_BITWORD FOLLOW_term_in_term332_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_term_in_term332 = { FOLLOW_term_in_term332_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_19_in_term341 */ static ANTLR3_BITWORD FOLLOW_19_in_term341_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_19_in_term341 = { FOLLOW_19_in_term341_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_term344 */ static ANTLR3_BITWORD FOLLOW_expr_in_term344_bits[] = { ANTLR3_UINT64_LIT(0x0000000000100000) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_term344 = { FOLLOW_expr_in_term344_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_20_in_term346 */ static ANTLR3_BITWORD FOLLOW_20_in_term346_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_20_in_term346 = { FOLLOW_20_in_term346_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_19_in_synpred8_EquationSystem245 */ static ANTLR3_BITWORD FOLLOW_19_in_synpred8_EquationSystem245_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_19_in_synpred8_EquationSystem245 = { FOLLOW_19_in_synpred8_EquationSystem245_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_synpred8_EquationSystem247 */ static ANTLR3_BITWORD FOLLOW_expr_in_synpred8_EquationSystem247_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000040) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_synpred8_EquationSystem247 = { FOLLOW_expr_in_synpred8_EquationSystem247_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_GREATER_EQUAL_in_synpred8_EquationSystem249 */ static ANTLR3_BITWORD FOLLOW_GREATER_EQUAL_in_synpred8_EquationSystem249_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_GREATER_EQUAL_in_synpred8_EquationSystem249 = { FOLLOW_GREATER_EQUAL_in_synpred8_EquationSystem249_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_synpred8_EquationSystem251 */ static ANTLR3_BITWORD FOLLOW_expr_in_synpred8_EquationSystem251_bits[] = { ANTLR3_UINT64_LIT(0x0000000000008000) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_synpred8_EquationSystem251 = { FOLLOW_expr_in_synpred8_EquationSystem251_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_QUESTION_MARK_in_synpred8_EquationSystem253 */ static ANTLR3_BITWORD FOLLOW_QUESTION_MARK_in_synpred8_EquationSystem253_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_QUESTION_MARK_in_synpred8_EquationSystem253 = { FOLLOW_QUESTION_MARK_in_synpred8_EquationSystem253_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_synpred8_EquationSystem255 */ static ANTLR3_BITWORD FOLLOW_expr_in_synpred8_EquationSystem255_bits[] = { ANTLR3_UINT64_LIT(0x0000000000100000) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_synpred8_EquationSystem255 = { FOLLOW_expr_in_synpred8_EquationSystem255_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_20_in_synpred8_EquationSystem257 */ static ANTLR3_BITWORD FOLLOW_20_in_synpred8_EquationSystem257_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_20_in_synpred8_EquationSystem257 = { FOLLOW_20_in_synpred8_EquationSystem257_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_set_in_synpred12_EquationSystem282 */ static ANTLR3_BITWORD FOLLOW_set_in_synpred12_EquationSystem282_bits[] = { ANTLR3_UINT64_LIT(0x00000000000B2000) }; static ANTLR3_BITSET_LIST FOLLOW_set_in_synpred12_EquationSystem282 = { FOLLOW_set_in_synpred12_EquationSystem282_bits, 1 }; /** Bitset defining follow set for error recovery in rule state: FOLLOW_expr_in_synpred12_EquationSystem299 */ static ANTLR3_BITWORD FOLLOW_expr_in_synpred12_EquationSystem299_bits[] = { ANTLR3_UINT64_LIT(0x0000000000000002) }; static ANTLR3_BITSET_LIST FOLLOW_expr_in_synpred12_EquationSystem299 = { FOLLOW_expr_in_synpred12_EquationSystem299_bits, 1 }; /* ========================================================================= * DFA tables for the parser */ /** Static dfa state tables for Cyclic dfa: * ()* loopback of 22:28: ( ( NEWLINE !)+ equation )* */ static const ANTLR3_INT32 dfa2_eot[4] = { -1, -1, -1, -1 }; static const ANTLR3_INT32 dfa2_eof[4] = { 2, 2, -1, -1 }; static const ANTLR3_INT32 dfa2_min[4] = { 12, 12, -1, -1 }; static const ANTLR3_INT32 dfa2_max[4] = { 12, 17, -1, -1 }; static const ANTLR3_INT32 dfa2_accept[4] = { -1, -1, 2, 1 }; static const ANTLR3_INT32 dfa2_special[4] = { -1, -1, -1, -1 }; /** Used when there is no transition table entry for a particular state */ #define dfa2_T_empty NULL static const ANTLR3_INT32 dfa2_T0[] = { 1 }; static const ANTLR3_INT32 dfa2_T1[] = { 1, -1, -1, -1, -1, 3 }; /* Transition tables are a table of sub tables, with some tables * reused for efficiency. */ static const ANTLR3_INT32 * const dfa2_transitions[] = { dfa2_T0, dfa2_T1, NULL, NULL }; /* Declare tracking structure for Cyclic DFA 2 */ static ANTLR3_CYCLIC_DFA cdfa2 = { 2, /* Decision number of this dfa */ /* Which decision this represents: */ (const pANTLR3_UCHAR)"()* loopback of 22:28: ( ( NEWLINE !)+ equation )*", (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition, /* Default special state transition function */ antlr3dfaspecialTransition, /* DFA specialTransition is currently just a default function in the runtime */ antlr3dfapredict, /* DFA simulator function is in the runtime */ dfa2_eot, /* EOT table */ dfa2_eof, /* EOF table */ dfa2_min, /* Minimum tokens for each state */ dfa2_max, /* Maximum tokens for each state */ dfa2_accept, /* Accept table */ dfa2_special, /* Special transition states */ dfa2_transitions /* Table of transition tables */ }; /* End of Cyclic DFA 2 * --------------------- */ /* ========================================================================= * End of DFA tables for the parser */ /* ============================================== * Parsing rules */ /** * $ANTLR start equation_system * EquationSystem.g:22:1: equation_system : equation ( ( NEWLINE !)+ equation )* ( NEWLINE !)* ; */ static EquationSystemParser_equation_system_return equation_system(pEquationSystemParser ctx) { EquationSystemParser_equation_system_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN NEWLINE2; pANTLR3_COMMON_TOKEN NEWLINE4; EquationSystemParser_equation_return equation1; #undef RETURN_TYPE_equation1 #define RETURN_TYPE_equation1 EquationSystemParser_equation_return EquationSystemParser_equation_return equation3; #undef RETURN_TYPE_equation3 #define RETURN_TYPE_equation3 EquationSystemParser_equation_return pANTLR3_BASE_TREE NEWLINE2_tree; pANTLR3_BASE_TREE NEWLINE4_tree; /* Initialize rule variables */ root_0 = NULL; NEWLINE2 = NULL; NEWLINE4 = NULL; equation1.tree = NULL; equation3.tree = NULL; retval.start = LT(1); retval.stop = retval.start; NEWLINE2_tree = NULL; NEWLINE4_tree = NULL; retval.tree = NULL; { // EquationSystem.g:22:17: ( equation ( ( NEWLINE !)+ equation )* ( NEWLINE !)* ) // EquationSystem.g:22:19: equation ( ( NEWLINE !)+ equation )* ( NEWLINE !)* { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); FOLLOWPUSH(FOLLOW_equation_in_equation_system141); equation1=equation(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleequation_systemEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, equation1.tree); // EquationSystem.g:22:28: ( ( NEWLINE !)+ equation )* for (;;) { int alt2=2; alt2 = cdfa2.predict(ctx, RECOGNIZER, ISTREAM, &cdfa2); if (HASEXCEPTION()) { goto ruleequation_systemEx; } if (HASFAILED()) { return retval; } switch (alt2) { case 1: // EquationSystem.g:22:30: ( NEWLINE !)+ equation { // EquationSystem.g:22:37: ( NEWLINE !)+ { int cnt1=0; for (;;) { int alt1=2; switch ( LA(1) ) { case NEWLINE: { alt1=1; } break; } switch (alt1) { case 1: // EquationSystem.g:22:37: NEWLINE ! { NEWLINE2 = (pANTLR3_COMMON_TOKEN) MATCHT(NEWLINE, &FOLLOW_NEWLINE_in_equation_system145); if (HASEXCEPTION()) { goto ruleequation_systemEx; } if (HASFAILED()) { return retval; } } break; default: if ( cnt1 >= 1 ) { goto loop1; } if (BACKTRACKING>0) { FAILEDFLAG = ANTLR3_TRUE; return retval; } /* mismatchedSetEx() */ CONSTRUCTEX(); EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; goto ruleequation_systemEx; } cnt1++; } loop1: ; /* Jump to here if this rule does not match */ } FOLLOWPUSH(FOLLOW_equation_in_equation_system150); equation3=equation(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleequation_systemEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, equation3.tree); } break; default: goto loop2; /* break out of the loop */ break; } } loop2: ; /* Jump out to here if this rule does not match */ // EquationSystem.g:22:54: ( NEWLINE !)* for (;;) { int alt3=2; switch ( LA(1) ) { case NEWLINE: { alt3=1; } break; } switch (alt3) { case 1: // EquationSystem.g:22:55: NEWLINE ! { NEWLINE4 = (pANTLR3_COMMON_TOKEN) MATCHT(NEWLINE, &FOLLOW_NEWLINE_in_equation_system157); if (HASEXCEPTION()) { goto ruleequation_systemEx; } if (HASFAILED()) { return retval; } } break; default: goto loop3; /* break out of the loop */ break; } } loop3: ; /* Jump out to here if this rule does not match */ } } // This is where rules clean up and exit // goto ruleequation_systemEx; /* Prevent compiler warnings */ ruleequation_systemEx: ; retval.stop = LT(-1); if ( BACKTRACKING==0 ) { 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 equation_system */ /** * $ANTLR start equation * EquationSystem.g:23:1: equation : VARIABLE '=' ! maxExpr ; */ static EquationSystemParser_equation_return equation(pEquationSystemParser ctx) { EquationSystemParser_equation_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN VARIABLE5; pANTLR3_COMMON_TOKEN char_literal6; EquationSystemParser_maxExpr_return maxExpr7; #undef RETURN_TYPE_maxExpr7 #define RETURN_TYPE_maxExpr7 EquationSystemParser_maxExpr_return pANTLR3_BASE_TREE VARIABLE5_tree; pANTLR3_BASE_TREE char_literal6_tree; /* Initialize rule variables */ root_0 = NULL; VARIABLE5 = NULL; char_literal6 = NULL; maxExpr7.tree = NULL; retval.start = LT(1); retval.stop = retval.start; VARIABLE5_tree = NULL; char_literal6_tree = NULL; retval.tree = NULL; { // EquationSystem.g:23:10: ( VARIABLE '=' ! maxExpr ) // EquationSystem.g:23:12: VARIABLE '=' ! maxExpr { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); VARIABLE5 = (pANTLR3_COMMON_TOKEN) MATCHT(VARIABLE, &FOLLOW_VARIABLE_in_equation168); if (HASEXCEPTION()) { goto ruleequationEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { VARIABLE5_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, VARIABLE5)); ADAPTOR->addChild(ADAPTOR, root_0, VARIABLE5_tree); } char_literal6 = (pANTLR3_COMMON_TOKEN) MATCHT(22, &FOLLOW_22_in_equation170); if (HASEXCEPTION()) { goto ruleequationEx; } if (HASFAILED()) { return retval; } FOLLOWPUSH(FOLLOW_maxExpr_in_equation173); maxExpr7=maxExpr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleequationEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, maxExpr7.tree); } } // This is where rules clean up and exit // goto ruleequationEx; /* Prevent compiler warnings */ ruleequationEx: ; retval.stop = LT(-1); if ( BACKTRACKING==0 ) { 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 equation */ /** * $ANTLR start maxExpr * EquationSystem.g:25:1: maxExpr : ( MAXIMUM ^ '(' ! minExpr ( ',' ! minExpr )* ')' !| minExpr ); */ static EquationSystemParser_maxExpr_return maxExpr(pEquationSystemParser ctx) { EquationSystemParser_maxExpr_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN MAXIMUM8; pANTLR3_COMMON_TOKEN char_literal9; pANTLR3_COMMON_TOKEN char_literal11; pANTLR3_COMMON_TOKEN char_literal13; EquationSystemParser_minExpr_return minExpr10; #undef RETURN_TYPE_minExpr10 #define RETURN_TYPE_minExpr10 EquationSystemParser_minExpr_return EquationSystemParser_minExpr_return minExpr12; #undef RETURN_TYPE_minExpr12 #define RETURN_TYPE_minExpr12 EquationSystemParser_minExpr_return EquationSystemParser_minExpr_return minExpr14; #undef RETURN_TYPE_minExpr14 #define RETURN_TYPE_minExpr14 EquationSystemParser_minExpr_return pANTLR3_BASE_TREE MAXIMUM8_tree; pANTLR3_BASE_TREE char_literal9_tree; pANTLR3_BASE_TREE char_literal11_tree; pANTLR3_BASE_TREE char_literal13_tree; /* Initialize rule variables */ root_0 = NULL; MAXIMUM8 = NULL; char_literal9 = NULL; char_literal11 = NULL; char_literal13 = NULL; minExpr10.tree = NULL; minExpr12.tree = NULL; minExpr14.tree = NULL; retval.start = LT(1); retval.stop = retval.start; MAXIMUM8_tree = NULL; char_literal9_tree = NULL; char_literal11_tree = NULL; char_literal13_tree = NULL; retval.tree = NULL; { { // EquationSystem.g:25:9: ( MAXIMUM ^ '(' ! minExpr ( ',' ! minExpr )* ')' !| minExpr ) ANTLR3_UINT32 alt5; alt5=2; switch ( LA(1) ) { case MAXIMUM: { alt5=1; } break; case MINIMUM: case NUMBER: case SUB: case VARIABLE: case 19: { alt5=2; } break; default: if (BACKTRACKING>0) { FAILEDFLAG = ANTLR3_TRUE; return retval; } CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 5; EXCEPTION->state = 0; goto rulemaxExprEx; } switch (alt5) { case 1: // EquationSystem.g:25:11: MAXIMUM ^ '(' ! minExpr ( ',' ! minExpr )* ')' ! { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); MAXIMUM8 = (pANTLR3_COMMON_TOKEN) MATCHT(MAXIMUM, &FOLLOW_MAXIMUM_in_maxExpr182); if (HASEXCEPTION()) { goto rulemaxExprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { MAXIMUM8_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, MAXIMUM8)) ; root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, MAXIMUM8_tree, root_0)); } char_literal9 = (pANTLR3_COMMON_TOKEN) MATCHT(19, &FOLLOW_19_in_maxExpr185); if (HASEXCEPTION()) { goto rulemaxExprEx; } if (HASFAILED()) { return retval; } FOLLOWPUSH(FOLLOW_minExpr_in_maxExpr188); minExpr10=minExpr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulemaxExprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, minExpr10.tree); // EquationSystem.g:25:33: ( ',' ! minExpr )* for (;;) { int alt4=2; switch ( LA(1) ) { case 21: { alt4=1; } break; } switch (alt4) { case 1: // EquationSystem.g:25:35: ',' ! minExpr { char_literal11 = (pANTLR3_COMMON_TOKEN) MATCHT(21, &FOLLOW_21_in_maxExpr192); if (HASEXCEPTION()) { goto rulemaxExprEx; } if (HASFAILED()) { return retval; } FOLLOWPUSH(FOLLOW_minExpr_in_maxExpr195); minExpr12=minExpr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulemaxExprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, minExpr12.tree); } break; default: goto loop4; /* break out of the loop */ break; } } loop4: ; /* Jump out to here if this rule does not match */ char_literal13 = (pANTLR3_COMMON_TOKEN) MATCHT(20, &FOLLOW_20_in_maxExpr200); if (HASEXCEPTION()) { goto rulemaxExprEx; } if (HASFAILED()) { return retval; } } break; case 2: // EquationSystem.g:25:58: minExpr { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); FOLLOWPUSH(FOLLOW_minExpr_in_maxExpr205); minExpr14=minExpr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulemaxExprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, minExpr14.tree); } break; } } } // This is where rules clean up and exit // goto rulemaxExprEx; /* Prevent compiler warnings */ rulemaxExprEx: ; retval.stop = LT(-1); if ( BACKTRACKING==0 ) { 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 maxExpr */ /** * $ANTLR start minExpr * EquationSystem.g:26:1: minExpr : ( MINIMUM ^ '(' ! maxExpr ( ',' ! maxExpr )* ')' !| expr ); */ static EquationSystemParser_minExpr_return minExpr(pEquationSystemParser ctx) { EquationSystemParser_minExpr_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN MINIMUM15; pANTLR3_COMMON_TOKEN char_literal16; pANTLR3_COMMON_TOKEN char_literal18; pANTLR3_COMMON_TOKEN char_literal20; EquationSystemParser_maxExpr_return maxExpr17; #undef RETURN_TYPE_maxExpr17 #define RETURN_TYPE_maxExpr17 EquationSystemParser_maxExpr_return EquationSystemParser_maxExpr_return maxExpr19; #undef RETURN_TYPE_maxExpr19 #define RETURN_TYPE_maxExpr19 EquationSystemParser_maxExpr_return EquationSystemParser_expr_return expr21; #undef RETURN_TYPE_expr21 #define RETURN_TYPE_expr21 EquationSystemParser_expr_return pANTLR3_BASE_TREE MINIMUM15_tree; pANTLR3_BASE_TREE char_literal16_tree; pANTLR3_BASE_TREE char_literal18_tree; pANTLR3_BASE_TREE char_literal20_tree; /* Initialize rule variables */ root_0 = NULL; MINIMUM15 = NULL; char_literal16 = NULL; char_literal18 = NULL; char_literal20 = NULL; maxExpr17.tree = NULL; maxExpr19.tree = NULL; expr21.tree = NULL; retval.start = LT(1); retval.stop = retval.start; MINIMUM15_tree = NULL; char_literal16_tree = NULL; char_literal18_tree = NULL; char_literal20_tree = NULL; retval.tree = NULL; { { // EquationSystem.g:26:9: ( MINIMUM ^ '(' ! maxExpr ( ',' ! maxExpr )* ')' !| expr ) ANTLR3_UINT32 alt7; alt7=2; switch ( LA(1) ) { case MINIMUM: { alt7=1; } break; case NUMBER: case SUB: case VARIABLE: case 19: { alt7=2; } break; default: if (BACKTRACKING>0) { FAILEDFLAG = ANTLR3_TRUE; return retval; } CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 7; EXCEPTION->state = 0; goto ruleminExprEx; } switch (alt7) { case 1: // EquationSystem.g:26:11: MINIMUM ^ '(' ! maxExpr ( ',' ! maxExpr )* ')' ! { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); MINIMUM15 = (pANTLR3_COMMON_TOKEN) MATCHT(MINIMUM, &FOLLOW_MINIMUM_in_minExpr213); if (HASEXCEPTION()) { goto ruleminExprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { MINIMUM15_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, MINIMUM15)) ; root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, MINIMUM15_tree, root_0)); } char_literal16 = (pANTLR3_COMMON_TOKEN) MATCHT(19, &FOLLOW_19_in_minExpr216); if (HASEXCEPTION()) { goto ruleminExprEx; } if (HASFAILED()) { return retval; } FOLLOWPUSH(FOLLOW_maxExpr_in_minExpr219); maxExpr17=maxExpr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleminExprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, maxExpr17.tree); // EquationSystem.g:26:33: ( ',' ! maxExpr )* for (;;) { int alt6=2; switch ( LA(1) ) { case 21: { alt6=1; } break; } switch (alt6) { case 1: // EquationSystem.g:26:35: ',' ! maxExpr { char_literal18 = (pANTLR3_COMMON_TOKEN) MATCHT(21, &FOLLOW_21_in_minExpr223); if (HASEXCEPTION()) { goto ruleminExprEx; } if (HASFAILED()) { return retval; } FOLLOWPUSH(FOLLOW_maxExpr_in_minExpr226); maxExpr19=maxExpr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleminExprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, maxExpr19.tree); } break; default: goto loop6; /* break out of the loop */ break; } } loop6: ; /* Jump out to here if this rule does not match */ char_literal20 = (pANTLR3_COMMON_TOKEN) MATCHT(20, &FOLLOW_20_in_minExpr231); if (HASEXCEPTION()) { goto ruleminExprEx; } if (HASFAILED()) { return retval; } } break; case 2: // EquationSystem.g:26:58: expr { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); FOLLOWPUSH(FOLLOW_expr_in_minExpr236); expr21=expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleminExprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, expr21.tree); } break; } } } // This is where rules clean up and exit // goto ruleminExprEx; /* Prevent compiler warnings */ ruleminExprEx: ; retval.stop = LT(-1); if ( BACKTRACKING==0 ) { 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 minExpr */ /** * $ANTLR start expr * EquationSystem.g:28:1: expr : ( '(' expr GREATER_EQUAL expr QUESTION_MARK expr ')' -> ^( GUARD expr expr expr ) | term ( ( PLUS | MULT | SUB | COMMA ) ^ expr )* ); */ static EquationSystemParser_expr_return expr(pEquationSystemParser ctx) { EquationSystemParser_expr_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN char_literal22; pANTLR3_COMMON_TOKEN GREATER_EQUAL24; pANTLR3_COMMON_TOKEN QUESTION_MARK26; pANTLR3_COMMON_TOKEN char_literal28; pANTLR3_COMMON_TOKEN set30; EquationSystemParser_expr_return expr23; #undef RETURN_TYPE_expr23 #define RETURN_TYPE_expr23 EquationSystemParser_expr_return EquationSystemParser_expr_return expr25; #undef RETURN_TYPE_expr25 #define RETURN_TYPE_expr25 EquationSystemParser_expr_return EquationSystemParser_expr_return expr27; #undef RETURN_TYPE_expr27 #define RETURN_TYPE_expr27 EquationSystemParser_expr_return EquationSystemParser_term_return term29; #undef RETURN_TYPE_term29 #define RETURN_TYPE_term29 EquationSystemParser_term_return EquationSystemParser_expr_return expr31; #undef RETURN_TYPE_expr31 #define RETURN_TYPE_expr31 EquationSystemParser_expr_return pANTLR3_BASE_TREE char_literal22_tree; pANTLR3_BASE_TREE GREATER_EQUAL24_tree; pANTLR3_BASE_TREE QUESTION_MARK26_tree; pANTLR3_BASE_TREE char_literal28_tree; pANTLR3_BASE_TREE set30_tree; pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_20; pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_19; pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_GREATER_EQUAL; pANTLR3_REWRITE_RULE_TOKEN_STREAM stream_QUESTION_MARK; pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream_expr; /* Initialize rule variables */ root_0 = NULL; char_literal22 = NULL; GREATER_EQUAL24 = NULL; QUESTION_MARK26 = NULL; char_literal28 = NULL; set30 = NULL; expr23.tree = NULL; expr25.tree = NULL; expr27.tree = NULL; term29.tree = NULL; expr31.tree = NULL; retval.start = LT(1); retval.stop = retval.start; char_literal22_tree = NULL; GREATER_EQUAL24_tree = NULL; QUESTION_MARK26_tree = NULL; char_literal28_tree = NULL; set30_tree = NULL; stream_20 = NULL; #define CREATE_stream_20 if (stream_20 == NULL) {stream_20 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 20"); } stream_19 = NULL; #define CREATE_stream_19 if (stream_19 == NULL) {stream_19 = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token 19"); } stream_GREATER_EQUAL = NULL; #define CREATE_stream_GREATER_EQUAL if (stream_GREATER_EQUAL == NULL) {stream_GREATER_EQUAL = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token GREATER_EQUAL"); } stream_QUESTION_MARK = NULL; #define CREATE_stream_QUESTION_MARK if (stream_QUESTION_MARK == NULL) {stream_QUESTION_MARK = antlr3RewriteRuleTOKENStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"token QUESTION_MARK"); } stream_expr = NULL; #define CREATE_stream_expr if (stream_expr == NULL) {stream_expr = antlr3RewriteRuleSubtreeStreamNewAE(ADAPTOR, RECOGNIZER, (pANTLR3_UINT8)"rule expr"); } retval.tree = NULL; { { // EquationSystem.g:28:6: ( '(' expr GREATER_EQUAL expr QUESTION_MARK expr ')' -> ^( GUARD expr expr expr ) | term ( ( PLUS | MULT | SUB | COMMA ) ^ expr )* ) ANTLR3_UINT32 alt9; alt9=2; switch ( LA(1) ) { case 19: { { int LA9_1 = LA(2); if ( (synpred8_EquationSystem(ctx))) { alt9=1; } else if ( (ANTLR3_TRUE)) { alt9=2; } else { if (BACKTRACKING>0) { FAILEDFLAG = ANTLR3_TRUE; return retval; } CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 9; EXCEPTION->state = 1; goto ruleexprEx; } } } break; case NUMBER: case SUB: case VARIABLE: { alt9=2; } break; default: if (BACKTRACKING>0) { FAILEDFLAG = ANTLR3_TRUE; return retval; } CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 9; EXCEPTION->state = 0; goto ruleexprEx; } switch (alt9) { case 1: // EquationSystem.g:28:8: '(' expr GREATER_EQUAL expr QUESTION_MARK expr ')' { char_literal22 = (pANTLR3_COMMON_TOKEN) MATCHT(19, &FOLLOW_19_in_expr245); if (HASEXCEPTION()) { goto ruleexprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { CREATE_stream_19; stream_19->add(stream_19, char_literal22, NULL); } FOLLOWPUSH(FOLLOW_expr_in_expr247); expr23=expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleexprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { CREATE_stream_expr; stream_expr->add(stream_expr, expr23.tree, NULL); } GREATER_EQUAL24 = (pANTLR3_COMMON_TOKEN) MATCHT(GREATER_EQUAL, &FOLLOW_GREATER_EQUAL_in_expr249); if (HASEXCEPTION()) { goto ruleexprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { CREATE_stream_GREATER_EQUAL; stream_GREATER_EQUAL->add(stream_GREATER_EQUAL, GREATER_EQUAL24, NULL); } FOLLOWPUSH(FOLLOW_expr_in_expr251); expr25=expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleexprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { CREATE_stream_expr; stream_expr->add(stream_expr, expr25.tree, NULL); } QUESTION_MARK26 = (pANTLR3_COMMON_TOKEN) MATCHT(QUESTION_MARK, &FOLLOW_QUESTION_MARK_in_expr253); if (HASEXCEPTION()) { goto ruleexprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { CREATE_stream_QUESTION_MARK; stream_QUESTION_MARK->add(stream_QUESTION_MARK, QUESTION_MARK26, NULL); } FOLLOWPUSH(FOLLOW_expr_in_expr255); expr27=expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleexprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { CREATE_stream_expr; stream_expr->add(stream_expr, expr27.tree, NULL); } char_literal28 = (pANTLR3_COMMON_TOKEN) MATCHT(20, &FOLLOW_20_in_expr257); if (HASEXCEPTION()) { goto ruleexprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { CREATE_stream_20; stream_20->add(stream_20, char_literal28, NULL); } /* AST REWRITE * elements : expr, expr, expr * token labels : * rule labels : retval * token list labels : * rule list labels : */ if ( BACKTRACKING==0 ) { 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; // 28:59: -> ^( GUARD expr expr expr ) { // EquationSystem.g:28:62: ^( GUARD expr expr expr ) { 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, GUARD, (pANTLR3_UINT8)"GUARD") , root_1)); ADAPTOR->addChild(ADAPTOR, root_1, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr)); ADAPTOR->addChild(ADAPTOR, root_1, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr)); ADAPTOR->addChild(ADAPTOR, root_1, stream_expr == NULL ? NULL : stream_expr->nextTree(stream_expr)); 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: // EquationSystem.g:29:8: term ( ( PLUS | MULT | SUB | COMMA ) ^ expr )* { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); FOLLOWPUSH(FOLLOW_term_in_expr278); term29=term(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleexprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, term29.tree); // EquationSystem.g:29:13: ( ( PLUS | MULT | SUB | COMMA ) ^ expr )* for (;;) { int alt8=2; switch ( LA(1) ) { case COMMA: case MULT: case PLUS: case SUB: { { /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) */ int LA8_2 = LA(2); if ( (synpred12_EquationSystem(ctx))) { alt8=1; } } } break; } switch (alt8) { case 1: // EquationSystem.g:29:15: ( PLUS | MULT | SUB | COMMA ) ^ expr { set30=(pANTLR3_COMMON_TOKEN)LT(1); set30=(pANTLR3_COMMON_TOKEN)LT(1); if ( LA(1) == COMMA || LA(1) == MULT || LA(1) == PLUS || LA(1) == SUB ) { CONSUME(); if ( BACKTRACKING==0 ) root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, set30)) , root_0)); PERRORRECOVERY=ANTLR3_FALSE; FAILEDFLAG=ANTLR3_FALSE; } else { if (BACKTRACKING>0) { FAILEDFLAG = ANTLR3_TRUE; return retval; } CONSTRUCTEX(); EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; EXCEPTION->expectingSet = NULL; goto ruleexprEx; } FOLLOWPUSH(FOLLOW_expr_in_expr299); expr31=expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruleexprEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, expr31.tree); } break; default: goto loop8; /* break out of the loop */ break; } } loop8: ; /* Jump out to here if this rule does not match */ } break; } } } // This is where rules clean up and exit // goto ruleexprEx; /* Prevent compiler warnings */ ruleexprEx: ; retval.stop = LT(-1); if ( BACKTRACKING==0 ) { 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_20 != NULL) stream_20->free(stream_20); if (stream_19 != NULL) stream_19->free(stream_19); if (stream_GREATER_EQUAL != NULL) stream_GREATER_EQUAL->free(stream_GREATER_EQUAL); if (stream_QUESTION_MARK != NULL) stream_QUESTION_MARK->free(stream_QUESTION_MARK); if (stream_expr != NULL) stream_expr->free(stream_expr); } if (HASEXCEPTION()) { PREPORTERROR(); PRECOVER(); retval.tree = (pANTLR3_BASE_TREE)(ADAPTOR->errorNode(ADAPTOR, INPUT, retval.start, LT(-1), EXCEPTION)); } return retval; } /* $ANTLR end expr */ /** * $ANTLR start term * EquationSystem.g:31:1: term : ( NUMBER | VARIABLE | '-' ^ term | '(' ! expr ')' !); */ static EquationSystemParser_term_return term(pEquationSystemParser ctx) { EquationSystemParser_term_return retval; pANTLR3_BASE_TREE root_0; pANTLR3_COMMON_TOKEN NUMBER32; pANTLR3_COMMON_TOKEN VARIABLE33; pANTLR3_COMMON_TOKEN char_literal34; pANTLR3_COMMON_TOKEN char_literal36; pANTLR3_COMMON_TOKEN char_literal38; EquationSystemParser_term_return term35; #undef RETURN_TYPE_term35 #define RETURN_TYPE_term35 EquationSystemParser_term_return EquationSystemParser_expr_return expr37; #undef RETURN_TYPE_expr37 #define RETURN_TYPE_expr37 EquationSystemParser_expr_return pANTLR3_BASE_TREE NUMBER32_tree; pANTLR3_BASE_TREE VARIABLE33_tree; pANTLR3_BASE_TREE char_literal34_tree; pANTLR3_BASE_TREE char_literal36_tree; pANTLR3_BASE_TREE char_literal38_tree; /* Initialize rule variables */ root_0 = NULL; NUMBER32 = NULL; VARIABLE33 = NULL; char_literal34 = NULL; char_literal36 = NULL; char_literal38 = NULL; term35.tree = NULL; expr37.tree = NULL; retval.start = LT(1); retval.stop = retval.start; NUMBER32_tree = NULL; VARIABLE33_tree = NULL; char_literal34_tree = NULL; char_literal36_tree = NULL; char_literal38_tree = NULL; retval.tree = NULL; { { // EquationSystem.g:31:6: ( NUMBER | VARIABLE | '-' ^ term | '(' ! expr ')' !) ANTLR3_UINT32 alt10; alt10=4; switch ( LA(1) ) { case NUMBER: { alt10=1; } break; case VARIABLE: { alt10=2; } break; case SUB: { alt10=3; } break; case 19: { alt10=4; } break; default: if (BACKTRACKING>0) { FAILEDFLAG = ANTLR3_TRUE; return retval; } CONSTRUCTEX(); EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; EXCEPTION->message = (void *)""; EXCEPTION->decisionNum = 10; EXCEPTION->state = 0; goto ruletermEx; } switch (alt10) { case 1: // EquationSystem.g:31:8: NUMBER { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); NUMBER32 = (pANTLR3_COMMON_TOKEN) MATCHT(NUMBER, &FOLLOW_NUMBER_in_term311); if (HASEXCEPTION()) { goto ruletermEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { NUMBER32_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, NUMBER32)); ADAPTOR->addChild(ADAPTOR, root_0, NUMBER32_tree); } } break; case 2: // EquationSystem.g:32:8: VARIABLE { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); VARIABLE33 = (pANTLR3_COMMON_TOKEN) MATCHT(VARIABLE, &FOLLOW_VARIABLE_in_term320); if (HASEXCEPTION()) { goto ruletermEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { VARIABLE33_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, VARIABLE33)); ADAPTOR->addChild(ADAPTOR, root_0, VARIABLE33_tree); } } break; case 3: // EquationSystem.g:33:8: '-' ^ term { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); char_literal34 = (pANTLR3_COMMON_TOKEN) MATCHT(SUB, &FOLLOW_SUB_in_term329); if (HASEXCEPTION()) { goto ruletermEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) { char_literal34_tree = (pANTLR3_BASE_TREE)(ADAPTOR->create(ADAPTOR, char_literal34)) ; root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->becomeRoot(ADAPTOR, char_literal34_tree, root_0)); } FOLLOWPUSH(FOLLOW_term_in_term332); term35=term(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruletermEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, term35.tree); } break; case 4: // EquationSystem.g:34:8: '(' ! expr ')' ! { root_0 = (pANTLR3_BASE_TREE)(ADAPTOR->nilNode(ADAPTOR)); char_literal36 = (pANTLR3_COMMON_TOKEN) MATCHT(19, &FOLLOW_19_in_term341); if (HASEXCEPTION()) { goto ruletermEx; } if (HASFAILED()) { return retval; } FOLLOWPUSH(FOLLOW_expr_in_term344); expr37=expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto ruletermEx; } if (HASFAILED()) { return retval; } if ( BACKTRACKING==0 ) ADAPTOR->addChild(ADAPTOR, root_0, expr37.tree); char_literal38 = (pANTLR3_COMMON_TOKEN) MATCHT(20, &FOLLOW_20_in_term346); if (HASEXCEPTION()) { goto ruletermEx; } if (HASFAILED()) { return retval; } } break; } } } // This is where rules clean up and exit // goto ruletermEx; /* Prevent compiler warnings */ ruletermEx: ; retval.stop = LT(-1); if ( BACKTRACKING==0 ) { 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 term */ // $ANTLR start synpred8_EquationSystem static void synpred8_EquationSystem_fragment(pEquationSystemParser ctx ) { // EquationSystem.g:28:8: ( '(' expr GREATER_EQUAL expr QUESTION_MARK expr ')' ) // EquationSystem.g:28:8: '(' expr GREATER_EQUAL expr QUESTION_MARK expr ')' { MATCHT(19, &FOLLOW_19_in_synpred8_EquationSystem245); if (HASEXCEPTION()) { goto rulesynpred8_EquationSystemEx; } if (HASFAILED()) { return ; } FOLLOWPUSH(FOLLOW_expr_in_synpred8_EquationSystem247); expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulesynpred8_EquationSystemEx; } if (HASFAILED()) { return ; } MATCHT(GREATER_EQUAL, &FOLLOW_GREATER_EQUAL_in_synpred8_EquationSystem249); if (HASEXCEPTION()) { goto rulesynpred8_EquationSystemEx; } if (HASFAILED()) { return ; } FOLLOWPUSH(FOLLOW_expr_in_synpred8_EquationSystem251); expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulesynpred8_EquationSystemEx; } if (HASFAILED()) { return ; } MATCHT(QUESTION_MARK, &FOLLOW_QUESTION_MARK_in_synpred8_EquationSystem253); if (HASEXCEPTION()) { goto rulesynpred8_EquationSystemEx; } if (HASFAILED()) { return ; } FOLLOWPUSH(FOLLOW_expr_in_synpred8_EquationSystem255); expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulesynpred8_EquationSystemEx; } if (HASFAILED()) { return ; } MATCHT(20, &FOLLOW_20_in_synpred8_EquationSystem257); if (HASEXCEPTION()) { goto rulesynpred8_EquationSystemEx; } if (HASFAILED()) { return ; } } // This is where rules clean up and exit // goto rulesynpred8_EquationSystemEx; /* Prevent compiler warnings */ rulesynpred8_EquationSystemEx: ; } // $ANTLR end synpred8_EquationSystem // $ANTLR start synpred12_EquationSystem static void synpred12_EquationSystem_fragment(pEquationSystemParser ctx ) { // EquationSystem.g:29:15: ( ( PLUS | MULT | SUB | COMMA ) expr ) // EquationSystem.g:29:15: ( PLUS | MULT | SUB | COMMA ) expr { if ( LA(1) == COMMA || LA(1) == MULT || LA(1) == PLUS || LA(1) == SUB ) { CONSUME(); PERRORRECOVERY=ANTLR3_FALSE; FAILEDFLAG=ANTLR3_FALSE; } else { if (BACKTRACKING>0) { FAILEDFLAG = ANTLR3_TRUE; return ; } CONSTRUCTEX(); EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; EXCEPTION->expectingSet = NULL; goto rulesynpred12_EquationSystemEx; } FOLLOWPUSH(FOLLOW_expr_in_synpred12_EquationSystem299); expr(ctx); FOLLOWPOP(); if (HASEXCEPTION()) { goto rulesynpred12_EquationSystemEx; } if (HASFAILED()) { return ; } } // This is where rules clean up and exit // goto rulesynpred12_EquationSystemEx; /* Prevent compiler warnings */ rulesynpred12_EquationSystemEx: ; } // $ANTLR end synpred12_EquationSystem /* End of parsing rules * ============================================== */ /* ============================================== * Syntactic predicates */ static ANTLR3_BOOLEAN synpred12_EquationSystem(pEquationSystemParser ctx) { ANTLR3_MARKER start; ANTLR3_BOOLEAN success; BACKTRACKING++; start = MARK(); synpred12_EquationSystem_fragment(ctx); // can never throw exception success = !(FAILEDFLAG); REWIND(start); BACKTRACKING--; FAILEDFLAG = ANTLR3_FALSE; return success; } static ANTLR3_BOOLEAN synpred8_EquationSystem(pEquationSystemParser ctx) { ANTLR3_MARKER start; ANTLR3_BOOLEAN success; BACKTRACKING++; start = MARK(); synpred8_EquationSystem_fragment(ctx); // can never throw exception success = !(FAILEDFLAG); REWIND(start); BACKTRACKING--; FAILEDFLAG = ANTLR3_FALSE; return success; } /* End of syntactic predicates * ============================================== */ /* End of code * ============================================================================= */