diff options
Diffstat (limited to 'impl/EquationSystemLexer.c')
| -rw-r--r-- | impl/EquationSystemLexer.c | 2087 |
1 files changed, 2087 insertions, 0 deletions
diff --git a/impl/EquationSystemLexer.c b/impl/EquationSystemLexer.c new file mode 100644 index 0000000..9236614 --- /dev/null +++ b/impl/EquationSystemLexer.c @@ -0,0 +1,2087 @@ +/** \file + * This C source file was generated by $ANTLR version 3.4 + * + * - From the grammar source file : EquationSystem.g + * - On : 2012-07-09 19:58:46 + * - for the lexer : EquationSystemLexerLexer + * + * 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 "EquationSystemLexer.h" +/* ----------------------------------------- */ + + +/** String literals used by EquationSystemLexer that we must do things like MATCHS() with. + * C will normally just lay down 8 bit characters, and you can use L"xxx" to + * get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so + * we perform this little trick of defining the literals as arrays of UINT32 + * and passing in the address of these. + */ +static ANTLR3_UCHAR lit_1[] = { 0x3E, 0x3D, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_2[] = { 0x67, 0x75, 0x61, 0x72, 0x64, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_3[] = { 0x6D, 0x61, 0x78, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_4[] = { 0x6D, 0x69, 0x6E, ANTLR3_STRING_TERMINATOR}; + + + + + +/* 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) pEquationSystemLexer_##scope##_SCOPE +#define SCOPE_STACK(scope) pEquationSystemLexer_##scope##Stack +#define SCOPE_TOP(scope) ctx->pEquationSystemLexer_##scope##Top +#define SCOPE_SIZE(scope) ctx->pEquationSystemLexer_##scope##Stack_limit +#define SCOPE_INSTANCE(scope, i) (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i)) + + +/* Macros for accessing things in a lexer + */ +#undef LEXER +#undef RECOGNIZER +#undef RULEMEMO +#undef GETCHARINDEX +#undef GETLINE +#undef GETCHARPOSITIONINLINE +#undef EMIT +#undef EMITNEW +#undef MATCHC +#undef MATCHS +#undef MATCHRANGE +#undef LTOKEN +#undef HASFAILED +#undef FAILEDFLAG +#undef INPUT +#undef STRSTREAM +#undef LA +#undef HASEXCEPTION +#undef EXCEPTION +#undef CONSTRUCTEX +#undef CONSUME +#undef LRECOVER +#undef MARK +#undef REWIND +#undef REWINDLAST +#undef BACKTRACKING +#undef MATCHANY +#undef MEMOIZE +#undef HAVEPARSEDRULE +#undef GETTEXT +#undef INDEX +#undef SEEK +#undef PUSHSTREAM +#undef POPSTREAM +#undef SETTEXT +#undef SETTEXT8 + +#define LEXER ctx->pLexer +#define RECOGNIZER LEXER->rec +#define LEXSTATE RECOGNIZER->state +#define TOKSOURCE LEXSTATE->tokSource +#define GETCHARINDEX() LEXER->getCharIndex(LEXER) +#define GETLINE() LEXER->getLine(LEXER) +#define GETTEXT() LEXER->getText(LEXER) +#define GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER) +#define EMIT() LEXSTATE->type = _type; LEXER->emit(LEXER) +#define EMITNEW(t) LEXER->emitNew(LEXER, t) +#define MATCHC(c) LEXER->matchc(LEXER, c) +#define MATCHS(s) LEXER->matchs(LEXER, s) +#define MATCHRANGE(c1,c2) LEXER->matchRange(LEXER, c1, c2) +#define MATCHANY() LEXER->matchAny(LEXER) +#define LTOKEN LEXSTATE->token +#define HASFAILED() (LEXSTATE->failed == ANTLR3_TRUE) +#define BACKTRACKING LEXSTATE->backtracking +#define FAILEDFLAG LEXSTATE->failed +#define INPUT LEXER->input +#define STRSTREAM INPUT +#define ISTREAM INPUT->istream +#define INDEX() ISTREAM->index(ISTREAM) +#define SEEK(n) ISTREAM->seek(ISTREAM, n) +#define EOF_TOKEN &(LEXSTATE->tokSource->eofToken) +#define HASEXCEPTION() (LEXSTATE->error == ANTLR3_TRUE) +#define EXCEPTION LEXSTATE->exception +#define CONSTRUCTEX() RECOGNIZER->exConstruct(RECOGNIZER) +#define LRECOVER() LEXER->recover(LEXER) +#define MARK() ISTREAM->mark(ISTREAM) +#define REWIND(m) ISTREAM->rewind(ISTREAM, m) +#define REWINDLAST() ISTREAM->rewindLast(ISTREAM) +#define MEMOIZE(ri,si) RECOGNIZER->memoize(RECOGNIZER, ri, si) +#define HAVEPARSEDRULE(r) RECOGNIZER->alreadyParsedRule(RECOGNIZER, r) +#define PUSHSTREAM(str) LEXER->pushCharStream(LEXER, str) +#define POPSTREAM() LEXER->popCharStream(LEXER) +#define SETTEXT(str) LEXSTATE->text = str +#define SKIP() LEXSTATE->token = &(TOKSOURCE->skipToken) +#define USER1 LEXSTATE->user1 +#define USER2 LEXSTATE->user2 +#define USER3 LEXSTATE->user3 +#define CUSTOM LEXSTATE->custom +#define RULEMEMO LEXSTATE->ruleMemo +#define DBG RECOGNIZER->debugger + +/* If we have been told we can rely on the standard 8 bit or UTF16 input + * stream, then we can define our macros to use the direct pointers + * in the input object, which is much faster than indirect calls. This + * is really only significant to lexers with a lot of fragment rules (which + * do not place LA(1) in a temporary at the moment) and even then + * only if there is a lot of input (order of say 1M or so). + */ +#if defined(ANTLR3_INLINE_INPUT_8BIT) || defined(ANTLR3_INLINE_INPUT_UTF16) + +# ifdef ANTLR3_INLINE_INPUT_8BIT + +/* 8 bit character set */ + +# define NEXTCHAR ((pANTLR3_UINT8)(INPUT->nextChar)) +# define DATAP ((pANTLR3_UINT8)(INPUT->data)) + +# else + +# define NEXTCHAR ((pANTLR3_UINT16)(INPUT->nextChar)) +# define DATAP ((pANTLR3_UINT16)(INPUT->data)) + +# endif + +# define LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1))) +# define CONSUME() \ +{ \ + if (NEXTCHAR < (DATAP + INPUT->sizeBuf)) \ + { \ + INPUT->charPositionInLine++; \ + if ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar) \ + { \ + INPUT->line++; \ + INPUT->charPositionInLine = 0; \ + INPUT->currentLine = (void *)(NEXTCHAR + 1); \ + } \ + INPUT->nextChar = (void *)(NEXTCHAR + 1); \ + } \ +} + +#else + +// Pick up the input character by calling the input stream implementation. +// +#define CONSUME() INPUT->istream->consume(INPUT->istream) +#define LA(n) INPUT->istream->_LA(INPUT->istream, n) + +#endif + +#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 + */ + +/* Forward declare the locally static matching functions we have generated and any predicate functions. + */ +static ANTLR3_INLINE + void + mCOMMA (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mGREATER_EQUAL (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mGUARD (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mMAXIMUM (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mMINIMUM (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mMULT (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mNEWLINE (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mPLUS (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mQUESTION_MARK (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mSUB (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mT__19 (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mT__20 (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mT__21 (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mT__22 (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mNUMBER (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mVARIABLE (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mWHITESPACE (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mDIGIT (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mLETTER (pEquationSystemLexer ctx); +static ANTLR3_INLINE + void + mTokens (pEquationSystemLexer ctx); +static void EquationSystemLexerFree(pEquationSystemLexer ctx); + +/* ========================================================================= + * Lexer matching rules end. + * ========================================================================= + */ + + + +static void +EquationSystemLexerFree (pEquationSystemLexer ctx) +{ + LEXER->free(LEXER); + + ANTLR3_FREE(ctx); +} + +static void +EquationSystemLexerReset (pEquationSystemLexer ctx) +{ + RECOGNIZER->reset(RECOGNIZER); +} + +/** \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 lexer called EquationSystemLexer + * + * \param[in] instream Pointer to an initialized input stream + * \return + * - Success pEquationSystemLexer initialized for the lex start + * - Fail NULL + */ +ANTLR3_API pEquationSystemLexer EquationSystemLexerNew +( +pANTLR3_INPUT_STREAM + instream) +{ + // See if we can create a new lexer with the standard constructor + // + return EquationSystemLexerNewSSD(instream, NULL); +} + +/** \brief Create a new lexer called EquationSystemLexer + * + * \param[in] instream Pointer to an initialized input stream + * \param[state] state Previously created shared recognizer stat + * \return + * - Success pEquationSystemLexer initialized for the lex start + * - Fail NULL + */ +ANTLR3_API pEquationSystemLexer EquationSystemLexerNewSSD +(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state) +{ + pEquationSystemLexer ctx; // Context structure we will build and return + + ctx = (pEquationSystemLexer) ANTLR3_CALLOC(1, sizeof(EquationSystemLexer)); + + if (ctx == NULL) + { + // Failed to allocate memory for lexer context + return NULL; + } + + /* ------------------------------------------------------------------- + * Memory for basic structure is allocated, now to fill in + * in base ANTLR3 structures. We initialize the function pointers + * for the standard ANTLR3 lexer 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 EquationSystemLexer.h here so you can get a sense + * of what goes where. + */ + + /* Create a base lexer, using the supplied input stream + */ + ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state); + + /* Check that we allocated the memory correctly + */ + if (ctx->pLexer == NULL) + { + ANTLR3_FREE(ctx); + return NULL; + } + /* Install the implementation of our EquationSystemLexer interface + */ + ctx->mCOMMA = mCOMMA; + ctx->mGREATER_EQUAL = mGREATER_EQUAL; + ctx->mGUARD = mGUARD; + ctx->mMAXIMUM = mMAXIMUM; + ctx->mMINIMUM = mMINIMUM; + ctx->mMULT = mMULT; + ctx->mNEWLINE = mNEWLINE; + ctx->mPLUS = mPLUS; + ctx->mQUESTION_MARK = mQUESTION_MARK; + ctx->mSUB = mSUB; + ctx->mT__19 = mT__19; + ctx->mT__20 = mT__20; + ctx->mT__21 = mT__21; + ctx->mT__22 = mT__22; + ctx->mNUMBER = mNUMBER; + ctx->mVARIABLE = mVARIABLE; + ctx->mWHITESPACE = mWHITESPACE; + ctx->mDIGIT = mDIGIT; + ctx->mLETTER = mLETTER; + ctx->mTokens = mTokens; + + /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE + * it will call mTokens() in this generated code, and will pass it the ctx + * pointer of this lexer, not the context of the base lexer, so store that now. + */ + ctx->pLexer->ctx = ctx; + + /**Install the token matching function + */ + ctx->pLexer->mTokens = (void (*) (void *))(mTokens); + + ctx->getGrammarFileName = getGrammarFileName; + ctx->free = EquationSystemLexerFree; + ctx->reset = EquationSystemLexerReset; + + + /* Return the newly built lexer to the caller + */ + return ctx; +} +/* ========================================================================= + * Functions to match the lexer grammar defined tokens from the input stream + */ + +// Comes from: 7:7: ( ';' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start COMMA + * + * Looks to match the characters the constitute the token COMMA + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mCOMMA(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = COMMA; + + + // EquationSystem.g:7:7: ( ';' ) + // EquationSystem.g:7:9: ';' + { + MATCHC(';'); + if (HASEXCEPTION()) + { + goto ruleCOMMAEx; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleCOMMAEx; /* Prevent compiler warnings */ + ruleCOMMAEx: ; + +} +// $ANTLR end COMMA + +// Comes from: 8:15: ( '>=' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start GREATER_EQUAL + * + * Looks to match the characters the constitute the token GREATER_EQUAL + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mGREATER_EQUAL(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = GREATER_EQUAL; + + + // EquationSystem.g:8:15: ( '>=' ) + // EquationSystem.g:8:17: '>=' + { + MATCHS(lit_1); + if (HASEXCEPTION()) + { + goto ruleGREATER_EQUALEx; + } + + + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleGREATER_EQUALEx; /* Prevent compiler warnings */ + ruleGREATER_EQUALEx: ; + +} +// $ANTLR end GREATER_EQUAL + +// Comes from: 9:7: ( 'guard' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start GUARD + * + * Looks to match the characters the constitute the token GUARD + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mGUARD(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = GUARD; + + + // EquationSystem.g:9:7: ( 'guard' ) + // EquationSystem.g:9:9: 'guard' + { + MATCHS(lit_2); + if (HASEXCEPTION()) + { + goto ruleGUARDEx; + } + + + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleGUARDEx; /* Prevent compiler warnings */ + ruleGUARDEx: ; + +} +// $ANTLR end GUARD + +// Comes from: 10:9: ( 'max' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start MAXIMUM + * + * Looks to match the characters the constitute the token MAXIMUM + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mMAXIMUM(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = MAXIMUM; + + + // EquationSystem.g:10:9: ( 'max' ) + // EquationSystem.g:10:11: 'max' + { + MATCHS(lit_3); + if (HASEXCEPTION()) + { + goto ruleMAXIMUMEx; + } + + + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleMAXIMUMEx; /* Prevent compiler warnings */ + ruleMAXIMUMEx: ; + +} +// $ANTLR end MAXIMUM + +// Comes from: 11:9: ( 'min' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start MINIMUM + * + * Looks to match the characters the constitute the token MINIMUM + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mMINIMUM(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = MINIMUM; + + + // EquationSystem.g:11:9: ( 'min' ) + // EquationSystem.g:11:11: 'min' + { + MATCHS(lit_4); + if (HASEXCEPTION()) + { + goto ruleMINIMUMEx; + } + + + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleMINIMUMEx; /* Prevent compiler warnings */ + ruleMINIMUMEx: ; + +} +// $ANTLR end MINIMUM + +// Comes from: 12:6: ( '*' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start MULT + * + * Looks to match the characters the constitute the token MULT + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mMULT(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = MULT; + + + // EquationSystem.g:12:6: ( '*' ) + // EquationSystem.g:12:8: '*' + { + MATCHC('*'); + if (HASEXCEPTION()) + { + goto ruleMULTEx; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleMULTEx; /* Prevent compiler warnings */ + ruleMULTEx: ; + +} +// $ANTLR end MULT + +// Comes from: 13:9: ( '\\n' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start NEWLINE + * + * Looks to match the characters the constitute the token NEWLINE + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mNEWLINE(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = NEWLINE; + + + // EquationSystem.g:13:9: ( '\\n' ) + // EquationSystem.g:13:11: '\\n' + { + MATCHC('\n'); + if (HASEXCEPTION()) + { + goto ruleNEWLINEEx; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleNEWLINEEx; /* Prevent compiler warnings */ + ruleNEWLINEEx: ; + +} +// $ANTLR end NEWLINE + +// Comes from: 14:6: ( '+' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start PLUS + * + * Looks to match the characters the constitute the token PLUS + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mPLUS(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = PLUS; + + + // EquationSystem.g:14:6: ( '+' ) + // EquationSystem.g:14:8: '+' + { + MATCHC('+'); + if (HASEXCEPTION()) + { + goto rulePLUSEx; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto rulePLUSEx; /* Prevent compiler warnings */ + rulePLUSEx: ; + +} +// $ANTLR end PLUS + +// Comes from: 15:15: ( '?' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start QUESTION_MARK + * + * Looks to match the characters the constitute the token QUESTION_MARK + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mQUESTION_MARK(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = QUESTION_MARK; + + + // EquationSystem.g:15:15: ( '?' ) + // EquationSystem.g:15:17: '?' + { + MATCHC('?'); + if (HASEXCEPTION()) + { + goto ruleQUESTION_MARKEx; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleQUESTION_MARKEx; /* Prevent compiler warnings */ + ruleQUESTION_MARKEx: ; + +} +// $ANTLR end QUESTION_MARK + +// Comes from: 16:5: ( '-' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start SUB + * + * Looks to match the characters the constitute the token SUB + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mSUB(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = SUB; + + + // EquationSystem.g:16:5: ( '-' ) + // EquationSystem.g:16:7: '-' + { + MATCHC('-'); + if (HASEXCEPTION()) + { + goto ruleSUBEx; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleSUBEx; /* Prevent compiler warnings */ + ruleSUBEx: ; + +} +// $ANTLR end SUB + +// Comes from: 17:7: ( '(' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__19 + * + * Looks to match the characters the constitute the token T__19 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__19(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__19; + + + // EquationSystem.g:17:7: ( '(' ) + // EquationSystem.g:17:9: '(' + { + MATCHC('('); + if (HASEXCEPTION()) + { + goto ruleT__19Ex; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleT__19Ex; /* Prevent compiler warnings */ + ruleT__19Ex: ; + +} +// $ANTLR end T__19 + +// Comes from: 18:7: ( ')' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__20 + * + * Looks to match the characters the constitute the token T__20 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__20(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__20; + + + // EquationSystem.g:18:7: ( ')' ) + // EquationSystem.g:18:9: ')' + { + MATCHC(')'); + if (HASEXCEPTION()) + { + goto ruleT__20Ex; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleT__20Ex; /* Prevent compiler warnings */ + ruleT__20Ex: ; + +} +// $ANTLR end T__20 + +// Comes from: 19:7: ( ',' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__21 + * + * Looks to match the characters the constitute the token T__21 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__21(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__21; + + + // EquationSystem.g:19:7: ( ',' ) + // EquationSystem.g:19:9: ',' + { + MATCHC(','); + if (HASEXCEPTION()) + { + goto ruleT__21Ex; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleT__21Ex; /* Prevent compiler warnings */ + ruleT__21Ex: ; + +} +// $ANTLR end T__21 + +// Comes from: 20:7: ( '=' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__22 + * + * Looks to match the characters the constitute the token T__22 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__22(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__22; + + + // EquationSystem.g:20:7: ( '=' ) + // EquationSystem.g:20:9: '=' + { + MATCHC('='); + if (HASEXCEPTION()) + { + goto ruleT__22Ex; + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleT__22Ex; /* Prevent compiler warnings */ + ruleT__22Ex: ; + +} +// $ANTLR end T__22 + +// Comes from: 36:8: ( ( DIGIT )+ ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start NUMBER + * + * Looks to match the characters the constitute the token NUMBER + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mNUMBER(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = NUMBER; + + + // EquationSystem.g:36:8: ( ( DIGIT )+ ) + // EquationSystem.g:36:10: ( DIGIT )+ + { + // EquationSystem.g:36:10: ( DIGIT )+ + { + int cnt1=0; + + for (;;) + { + int alt1=2; + switch ( LA(1) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt1=1; + } + break; + + } + + switch (alt1) + { + case 1: + // EquationSystem.g: + { + if ( ((LA(1) >= '0') && (LA(1) <= '9')) ) + { + CONSUME(); + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); + goto ruleNUMBEREx; + } + + + } + break; + + default: + + if ( cnt1 >= 1 ) + { + goto loop1; + } + /* mismatchedSetEx() + */ + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; + + + goto ruleNUMBEREx; + } + cnt1++; + } + loop1: ; /* Jump to here if this rule does not match */ + } + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleNUMBEREx; /* Prevent compiler warnings */ + ruleNUMBEREx: ; + +} +// $ANTLR end NUMBER + +// Comes from: 37:9: ( ( LETTER ) ( LETTER | DIGIT )* ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start VARIABLE + * + * Looks to match the characters the constitute the token VARIABLE + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mVARIABLE(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = VARIABLE; + + + // EquationSystem.g:37:9: ( ( LETTER ) ( LETTER | DIGIT )* ) + // EquationSystem.g:37:11: ( LETTER ) ( LETTER | DIGIT )* + { + if ( ((LA(1) >= 'a') && (LA(1) <= 'z')) ) + { + CONSUME(); + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); + goto ruleVARIABLEEx; + } + + + // EquationSystem.g:37:20: ( LETTER | DIGIT )* + + for (;;) + { + int alt2=2; + switch ( LA(1) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt2=1; + } + break; + + } + + switch (alt2) + { + case 1: + // EquationSystem.g: + { + if ( ((LA(1) >= '0') && (LA(1) <= '9')) || ((LA(1) >= 'a') && (LA(1) <= 'z')) ) + { + CONSUME(); + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); + goto ruleVARIABLEEx; + } + + + } + break; + + default: + goto loop2; /* break out of the loop */ + break; + } + } + loop2: ; /* Jump out to here if this rule does not match */ + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleVARIABLEEx; /* Prevent compiler warnings */ + ruleVARIABLEEx: ; + +} +// $ANTLR end VARIABLE + +// Comes from: 38:12: ( ( '\\t' | ' ' | '\\u000C' )+ ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start WHITESPACE + * + * Looks to match the characters the constitute the token WHITESPACE + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mWHITESPACE(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = WHITESPACE; + + + // EquationSystem.g:38:12: ( ( '\\t' | ' ' | '\\u000C' )+ ) + // EquationSystem.g:38:14: ( '\\t' | ' ' | '\\u000C' )+ + { + // EquationSystem.g:38:14: ( '\\t' | ' ' | '\\u000C' )+ + { + int cnt3=0; + + for (;;) + { + int alt3=2; + switch ( LA(1) ) + { + case '\t': + case '\f': + case ' ': + { + alt3=1; + } + break; + + } + + switch (alt3) + { + case 1: + // EquationSystem.g: + { + if ( LA(1) == '\t' || LA(1) == '\f' || LA(1) == ' ' ) + { + CONSUME(); + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); + goto ruleWHITESPACEEx; + } + + + } + break; + + default: + + if ( cnt3 >= 1 ) + { + goto loop3; + } + /* mismatchedSetEx() + */ + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; + + + goto ruleWHITESPACEEx; + } + cnt3++; + } + loop3: ; /* Jump to here if this rule does not match */ + } + + { + + LEXSTATE->channel = HIDDEN; + + } + + + } + + LEXSTATE->type = _type; + // This is where rules clean up and exit + // + goto ruleWHITESPACEEx; /* Prevent compiler warnings */ + ruleWHITESPACEEx: ; + +} +// $ANTLR end WHITESPACE + +// Comes from: 45:7: ( '0' .. '9' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start DIGIT + * + * Looks to match the characters the constitute the token DIGIT + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mDIGIT(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + + // EquationSystem.g:45:7: ( '0' .. '9' ) + // EquationSystem.g: + { + if ( ((LA(1) >= '0') && (LA(1) <= '9')) ) + { + CONSUME(); + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); + goto ruleDIGITEx; + } + + + } + + + // This is where rules clean up and exit + // + goto ruleDIGITEx; /* Prevent compiler warnings */ + ruleDIGITEx: ; + +} +// $ANTLR end DIGIT + +// Comes from: 47:7: ( 'a' .. 'z' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start LETTER + * + * Looks to match the characters the constitute the token LETTER + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mLETTER(pEquationSystemLexer ctx) +{ + ANTLR3_UINT32 _type; + + + // EquationSystem.g:47:7: ( 'a' .. 'z' ) + // EquationSystem.g: + { + if ( ((LA(1) >= 'a') && (LA(1) <= 'z')) ) + { + CONSUME(); + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); + goto ruleLETTEREx; + } + + + } + + + // This is where rules clean up and exit + // + goto ruleLETTEREx; /* Prevent compiler warnings */ + ruleLETTEREx: ; + +} +// $ANTLR end LETTER + +/** This is the entry point in to the lexer from an object that + * wants to generate the next token, such as a pCOMMON_TOKEN_STREAM + */ +static void +mTokens(pEquationSystemLexer ctx) +{ + { + // EquationSystem.g:1:8: ( COMMA | GREATER_EQUAL | GUARD | MAXIMUM | MINIMUM | MULT | NEWLINE | PLUS | QUESTION_MARK | SUB | T__19 | T__20 | T__21 | T__22 | NUMBER | VARIABLE | WHITESPACE ) + + ANTLR3_UINT32 alt4; + + alt4=17; + + switch ( LA(1) ) + { + case ';': + { + alt4=1; + } + break; + case '>': + { + alt4=2; + } + break; + case 'g': + { + switch ( LA(2) ) + { + case 'u': + { + switch ( LA(3) ) + { + case 'a': + { + switch ( LA(4) ) + { + case 'r': + { + switch ( LA(5) ) + { + case 'd': + { + switch ( LA(6) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt4=16; + } + break; + + default: + alt4=3; + } + + } + break; + + default: + alt4=16; + } + + } + break; + + default: + alt4=16; + } + + } + break; + + default: + alt4=16; + } + + } + break; + + default: + alt4=16; + } + + } + break; + case 'm': + { + switch ( LA(2) ) + { + case 'a': + { + switch ( LA(3) ) + { + case 'x': + { + switch ( LA(4) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt4=16; + } + break; + + default: + alt4=4; + } + + } + break; + + default: + alt4=16; + } + + } + break; + case 'i': + { + switch ( LA(3) ) + { + case 'n': + { + switch ( LA(4) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'g': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt4=16; + } + break; + + default: + alt4=5; + } + + } + break; + + default: + alt4=16; + } + + } + break; + + default: + alt4=16; + } + + } + break; + case '*': + { + alt4=6; + } + break; + case '\n': + { + alt4=7; + } + break; + case '+': + { + alt4=8; + } + break; + case '?': + { + alt4=9; + } + break; + case '-': + { + alt4=10; + } + break; + case '(': + { + alt4=11; + } + break; + case ')': + { + alt4=12; + } + break; + case ',': + { + alt4=13; + } + break; + case '=': + { + alt4=14; + } + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt4=15; + } + break; + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + case 'f': + case 'h': + case 'i': + case 'j': + case 'k': + case 'l': + case 'n': + case 'o': + case 'p': + case 'q': + case 'r': + case 's': + case 't': + case 'u': + case 'v': + case 'w': + case 'x': + case 'y': + case 'z': + { + alt4=16; + } + break; + case '\t': + case '\f': + case ' ': + { + alt4=17; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 4; + EXCEPTION->state = 0; + + + goto ruleTokensEx; + + } + + switch (alt4) + { + case 1: + // EquationSystem.g:1:10: COMMA + { + /* 1:10: COMMA */ + mCOMMA(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 2: + // EquationSystem.g:1:16: GREATER_EQUAL + { + /* 1:16: GREATER_EQUAL */ + mGREATER_EQUAL(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 3: + // EquationSystem.g:1:30: GUARD + { + /* 1:30: GUARD */ + mGUARD(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 4: + // EquationSystem.g:1:36: MAXIMUM + { + /* 1:36: MAXIMUM */ + mMAXIMUM(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 5: + // EquationSystem.g:1:44: MINIMUM + { + /* 1:44: MINIMUM */ + mMINIMUM(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 6: + // EquationSystem.g:1:52: MULT + { + /* 1:52: MULT */ + mMULT(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 7: + // EquationSystem.g:1:57: NEWLINE + { + /* 1:57: NEWLINE */ + mNEWLINE(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 8: + // EquationSystem.g:1:65: PLUS + { + /* 1:65: PLUS */ + mPLUS(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 9: + // EquationSystem.g:1:70: QUESTION_MARK + { + /* 1:70: QUESTION_MARK */ + mQUESTION_MARK(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 10: + // EquationSystem.g:1:84: SUB + { + /* 1:84: SUB */ + mSUB(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 11: + // EquationSystem.g:1:88: T__19 + { + /* 1:88: T__19 */ + mT__19(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 12: + // EquationSystem.g:1:94: T__20 + { + /* 1:94: T__20 */ + mT__20(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 13: + // EquationSystem.g:1:100: T__21 + { + /* 1:100: T__21 */ + mT__21(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 14: + // EquationSystem.g:1:106: T__22 + { + /* 1:106: T__22 */ + mT__22(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 15: + // EquationSystem.g:1:112: NUMBER + { + /* 1:112: NUMBER */ + mNUMBER(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 16: + // EquationSystem.g:1:119: VARIABLE + { + /* 1:119: VARIABLE */ + mVARIABLE(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + case 17: + // EquationSystem.g:1:128: WHITESPACE + { + /* 1:128: WHITESPACE */ + mWHITESPACE(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + + } + break; + + } + } + + + goto ruleTokensEx; /* Prevent compiler warnings */ +ruleTokensEx: ; +} + +/* ========================================================================= + * Lexer matching rules end. + * ========================================================================= + */ +/* End of Lexer code + * ================================================ + * ================================================ + */ + + +/* End of code + * ============================================================================= + */ |