X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.databoard%2Fcpp%2FDataBoardTest%2FDataBoard%2FSimanticsDataLexer.c;fp=bundles%2Forg.simantics.databoard%2Fcpp%2FDataBoardTest%2FDataBoard%2FSimanticsDataLexer.c;h=d09a4345a6b7702d42eee21144256d04c3fd3542;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git diff --git a/bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/SimanticsDataLexer.c b/bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/SimanticsDataLexer.c new file mode 100644 index 000000000..d09a4345a --- /dev/null +++ b/bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/SimanticsDataLexer.c @@ -0,0 +1,3598 @@ +/** \file + * This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23 + * + * - From the grammar source file : C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g + * - On : 2010-03-26 13:33:28 + * - for the lexer : SimanticsDataLexerLexer * + * Editing it, at least manually, is not wise. + * + * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws. + * + * +*/ +// [The "BSD licence"] +// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC +// http://www.temporal-wave.com +// http://www.linkedin.com/in/jimidle +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// 1. Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// 3. The name of the author may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +/* ----------------------------------------- + * Include the ANTLR3 generated header file. + */ +#include "SimanticsDataLexer.h" +/* ----------------------------------------- */ + + +/** String literals used by SimanticsDataLexer 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[] = { 0x74, 0x79, 0x70, 0x65, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_2[] = { 0x2E, 0x2E, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_3[] = { 0x74, 0x72, 0x75, 0x65, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_4[] = { 0x66, 0x61, 0x6C, 0x73, 0x65, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_5[] = { 0x6E, 0x75, 0x6C, 0x6C, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_6[] = { 0x6D, 0x61, 0x70, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_7[] = { 0x2F, 0x2F, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_8[] = { 0x2F, 0x2A, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_9[] = { 0x2A, 0x2F, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_10[] = { 0x22, 0x22, 0x22, ANTLR3_STRING_TERMINATOR}; +static ANTLR3_UCHAR lit_11[] = { 0x22, 0x22, 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) pSimanticsDataLexer_##scope##_SCOPE +#define SCOPE_STACK(scope) pSimanticsDataLexer_##scope##Stack +#define SCOPE_TOP(scope) ctx->pSimanticsDataLexer_##scope##Top +#define SCOPE_SIZE(scope) ctx->pSimanticsDataLexer_##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 16 bit 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_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16) + +# ifdef ANTLR3_INLINE_INPUT_ASCII + +/* 8 bit "ASCII" (actually any 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 mT__34 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__35 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__36 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__37 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__38 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__39 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__40 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__41 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__42 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__43 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__44 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__45 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__46 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__47 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__48 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mT__49 (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mID (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mINT (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mFLOAT (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mCOMMENT (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mWS (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mSTRING (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mEXPONENT (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mHEX_DIGIT (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mESC_SEQ (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mOCTAL_ESC (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mUNICODE_ESC (pSimanticsDataLexer ctx); +static ANTLR3_INLINE void mTokens (pSimanticsDataLexer ctx); +static void SimanticsDataLexerFree(pSimanticsDataLexer ctx); + +/* ========================================================================= + * Lexer matching rules end. + * ========================================================================= + */ + + + +static void +SimanticsDataLexerFree (pSimanticsDataLexer ctx) +{ + LEXER->free(LEXER); + + ANTLR3_FREE(ctx); +} + +/** \brief Name of the grammar file that generated this code + */ +static const char fileName[] = "C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g"; + +/** \brief Return the name of the grammar file that generated this code. + */ +static const char * getGrammarFileName() +{ + return fileName; +} + +/** \brief Create a new lexer called SimanticsDataLexer + * + * \param[in] instream Pointer to an initialized input stream + * \return + * - Success pSimanticsDataLexer initialized for the lex start + * - Fail NULL + */ +ANTLR3_API pSimanticsDataLexer SimanticsDataLexerNew +(pANTLR3_INPUT_STREAM instream) +{ + // See if we can create a new lexer with the standard constructor + // + return SimanticsDataLexerNewSSD(instream, NULL); +} + +/** \brief Create a new lexer called SimanticsDataLexer + * + * \param[in] instream Pointer to an initialized input stream + * \param[state] state Previously created shared recognizer stat + * \return + * - Success pSimanticsDataLexer initialized for the lex start + * - Fail NULL + */ +ANTLR3_API pSimanticsDataLexer SimanticsDataLexerNewSSD +(pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state) +{ + pSimanticsDataLexer ctx; // Context structure we will build and return + + ctx = (pSimanticsDataLexer) ANTLR3_CALLOC(1, sizeof(SimanticsDataLexer)); + + 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 SimanticsDataLexer.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 SimanticsDataLexer interface + */ + ctx->mT__34 = mT__34; + ctx->mT__35 = mT__35; + ctx->mT__36 = mT__36; + ctx->mT__37 = mT__37; + ctx->mT__38 = mT__38; + ctx->mT__39 = mT__39; + ctx->mT__40 = mT__40; + ctx->mT__41 = mT__41; + ctx->mT__42 = mT__42; + ctx->mT__43 = mT__43; + ctx->mT__44 = mT__44; + ctx->mT__45 = mT__45; + ctx->mT__46 = mT__46; + ctx->mT__47 = mT__47; + ctx->mT__48 = mT__48; + ctx->mT__49 = mT__49; + ctx->mID = mID; + ctx->mINT = mINT; + ctx->mFLOAT = mFLOAT; + ctx->mCOMMENT = mCOMMENT; + ctx->mWS = mWS; + ctx->mSTRING = mSTRING; + ctx->mEXPONENT = mEXPONENT; + ctx->mHEX_DIGIT = mHEX_DIGIT; + ctx->mESC_SEQ = mESC_SEQ; + ctx->mOCTAL_ESC = mOCTAL_ESC; + ctx->mUNICODE_ESC = mUNICODE_ESC; + 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 = SimanticsDataLexerFree; + + + + + + /* Return the newly built lexer to the caller + */ + return ctx; +} + +/* ========================================================================= + * DFA tables for the lexer + */ +/** Static dfa state tables for Cyclic dfa: + * 40:1: FLOAT : ( ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '-' )? ( '0' .. '9' )+ EXPONENT ); + */ +static const ANTLR3_INT32 dfa10_eot[5] = + { + -1, -1, -1, -1, -1 + }; +static const ANTLR3_INT32 dfa10_eof[5] = + { + -1, -1, -1, -1, -1 + }; +static const ANTLR3_INT32 dfa10_min[5] = + { + 45, 48, 46, -1, -1 + }; +static const ANTLR3_INT32 dfa10_max[5] = + { + 57, 57, 101, -1, -1 + }; +static const ANTLR3_INT32 dfa10_accept[5] = + { + -1, -1, -1, 2, 1 + }; +static const ANTLR3_INT32 dfa10_special[5] = + { + -1, -1, -1, -1, -1 + }; + +/** Used when there is no transition table entry for a particular state */ +#define dfa10_T_empty NULL + +static const ANTLR3_INT32 dfa10_T0[] = + { + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 + };static const ANTLR3_INT32 dfa10_T1[] = + { + 1, -1, -1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 + };static const ANTLR3_INT32 dfa10_T2[] = + { + 4, -1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -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 dfa10_transitions[] = +{ + dfa10_T1, dfa10_T0, dfa10_T2, dfa10_T_empty, dfa10_T_empty +}; + + +/* Declare tracking structure for Cyclic DFA 10 + */ +static +ANTLR3_CYCLIC_DFA cdfa10 + = { + 10, /* Decision number of this dfa */ + /* Which decision this represents: */ + (const pANTLR3_UCHAR)"40:1: FLOAT : ( ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '-' )? ( '0' .. '9' )+ EXPONENT );", + (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 */ + dfa10_eot, /* EOT table */ + dfa10_eof, /* EOF table */ + dfa10_min, /* Minimum tokens for each state */ + dfa10_max, /* Maximum tokens for each state */ + dfa10_accept, /* Accept table */ + dfa10_special, /* Special transition states */ + dfa10_transitions /* Table of transition tables */ + + }; +/* End of Cyclic DFA 10 + * --------------------- + *//** Static dfa state tables for Cyclic dfa: + * 1:1: Tokens : ( T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | ID | INT | FLOAT | COMMENT | WS | STRING ); + */ +static const ANTLR3_INT32 dfa22_eot[44] = + { + -1, 16, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 16, 16, 16, -1, -1, + 28, -1, -1, -1, 16, 16, 16, 16, 16, -1, -1, 16, 16, 16, 16, 38, 39, 40, + 16, 42, -1, -1, -1, 43, -1, -1 + }; +static const ANTLR3_INT32 dfa22_eof[44] = + { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1 + }; +static const ANTLR3_INT32 dfa22_min[44] = + { + 9, 114, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, 117, 97, -1, 48, + 46, -1, -1, -1, 112, 117, 108, 108, 112, -1, -1, 101, 101, 115, 108, 48, + 48, 48, 101, 48, -1, -1, -1, 48, -1, -1 + }; +static const ANTLR3_INT32 dfa22_max[44] = + { + 125, 121, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, 117, 97, -1, + 57, 101, -1, -1, -1, 112, 117, 108, 108, 112, -1, -1, 101, 101, 115, 108, + 122, 122, 122, 101, 122, -1, -1, -1, 122, -1, -1 + }; +static const ANTLR3_INT32 dfa22_accept[44] = + { + -1, -1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, 17, -1, -1, 20, + 21, 22, -1, -1, -1, -1, -1, 19, 18, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 16, 1, 13, -1, 15, 14 + }; +static const ANTLR3_INT32 dfa22_special[44] = + { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1 + }; + +/** Used when there is no transition table entry for a particular state */ +#define dfa22_T_empty NULL + +static const ANTLR3_INT32 dfa22_T0[] = + { + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, -1, -1, -1, -1, -1, -1, -1, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, -1, -1, -1, -1, 16, -1, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16 + };static const ANTLR3_INT32 dfa22_T1[] = + { + 41 + };static const ANTLR3_INT32 dfa22_T2[] = + { + 36 + };static const ANTLR3_INT32 dfa22_T3[] = + { + 31 + };static const ANTLR3_INT32 dfa22_T4[] = + { + 26 + };static const ANTLR3_INT32 dfa22_T5[] = + { + 35 + };static const ANTLR3_INT32 dfa22_T6[] = + { + 30 + };static const ANTLR3_INT32 dfa22_T7[] = + { + 33 + };static const ANTLR3_INT32 dfa22_T8[] = + { + 25 + };static const ANTLR3_INT32 dfa22_T9[] = + { + 20, 20, -1, -1, 20, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 20, -1, 21, -1, -1, -1, -1, -1, 7, 9, -1, -1, 8, 17, + 6, 19, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 12, -1, -1, 2, -1, -1, -1, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 4, -1, 5, -1, 16, -1, 16, 16, 16, 16, 16, + 13, 16, 16, 16, 16, 16, 16, 15, 14, 16, 16, 16, 16, 16, 1, 16, 16, 16, + 16, 16, 16, 10, 3, 11 + };static const ANTLR3_INT32 dfa22_T10[] = + { + 24 + };static const ANTLR3_INT32 dfa22_T11[] = + { + 32 + };static const ANTLR3_INT32 dfa22_T12[] = + { + 37 + };static const ANTLR3_INT32 dfa22_T13[] = + { + 29 + };static const ANTLR3_INT32 dfa22_T14[] = + { + 34 + };static const ANTLR3_INT32 dfa22_T15[] = + { + 27, -1, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 27, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 27 + };static const ANTLR3_INT32 dfa22_T16[] = + { + 23, -1, -1, -1, -1, -1, -1, 22 + };static const ANTLR3_INT32 dfa22_T17[] = + { + 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 + }; + +/* Transition tables are a table of sub tables, with some tables + * reused for efficiency. + */ +static const ANTLR3_INT32 * const dfa22_transitions[] = +{ + dfa22_T9, dfa22_T16, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, + dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, + dfa22_T_empty, dfa22_T_empty, dfa22_T10, dfa22_T8, dfa22_T4, dfa22_T_empty, + dfa22_T17, dfa22_T15, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T13, + dfa22_T6, dfa22_T3, dfa22_T11, dfa22_T7, dfa22_T_empty, dfa22_T_empty, + dfa22_T14, dfa22_T5, dfa22_T2, dfa22_T12, dfa22_T0, dfa22_T0, dfa22_T0, + dfa22_T1, dfa22_T0, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T0, + dfa22_T_empty, dfa22_T_empty +}; + + +/* Declare tracking structure for Cyclic DFA 22 + */ +static +ANTLR3_CYCLIC_DFA cdfa22 + = { + 22, /* Decision number of this dfa */ + /* Which decision this represents: */ + (const pANTLR3_UCHAR)"1:1: Tokens : ( T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | ID | INT | FLOAT | COMMENT | WS | STRING );", + (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 */ + dfa22_eot, /* EOT table */ + dfa22_eof, /* EOF table */ + dfa22_min, /* Minimum tokens for each state */ + dfa22_max, /* Maximum tokens for each state */ + dfa22_accept, /* Accept table */ + dfa22_special, /* Special transition states */ + dfa22_transitions /* Table of transition tables */ + + }; +/* End of Cyclic DFA 22 + * --------------------- + */ +/* ========================================================================= + * End of DFA tables for the lexer + */ + +/* ========================================================================= + * Functions to match the lexer grammar defined tokens from the input stream + */ + +// Comes from: 7:7: ( 'type' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__34 + * + * Looks to match the characters the constitute the token T__34 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__34(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__34; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:7:7: ( 'type' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:7:9: 'type' + { + MATCHS(lit_1); + if (HASEXCEPTION()) + { + goto ruleT__34Ex; + } + + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__34Ex; /* Prevent compiler warnings */ + ruleT__34Ex: ; + +} +// $ANTLR end T__34 + +// Comes from: 8:7: ( '=' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__35 + * + * Looks to match the characters the constitute the token T__35 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__35(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__35; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:8:7: ( '=' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:8:9: '=' + { + MATCHC('='); + if (HASEXCEPTION()) + { + goto ruleT__35Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__35Ex; /* Prevent compiler warnings */ + ruleT__35Ex: ; + +} +// $ANTLR end T__35 + +// Comes from: 9:7: ( '|' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__36 + * + * Looks to match the characters the constitute the token T__36 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__36(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__36; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:9:7: ( '|' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:9:9: '|' + { + MATCHC('|'); + if (HASEXCEPTION()) + { + goto ruleT__36Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__36Ex; /* Prevent compiler warnings */ + ruleT__36Ex: ; + +} +// $ANTLR end T__36 + +// Comes from: 10:7: ( '[' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__37 + * + * Looks to match the characters the constitute the token T__37 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__37(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__37; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:10:7: ( '[' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:10:9: '[' + { + MATCHC('['); + if (HASEXCEPTION()) + { + goto ruleT__37Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__37Ex; /* Prevent compiler warnings */ + ruleT__37Ex: ; + +} +// $ANTLR end T__37 + +// Comes from: 11:7: ( ']' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__38 + * + * Looks to match the characters the constitute the token T__38 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__38(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__38; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:11:7: ( ']' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:11:9: ']' + { + MATCHC(']'); + if (HASEXCEPTION()) + { + goto ruleT__38Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__38Ex; /* Prevent compiler warnings */ + ruleT__38Ex: ; + +} +// $ANTLR end T__38 + +// Comes from: 12:7: ( '..' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__39 + * + * Looks to match the characters the constitute the token T__39 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__39(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__39; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:12:7: ( '..' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:12:9: '..' + { + MATCHS(lit_2); + if (HASEXCEPTION()) + { + goto ruleT__39Ex; + } + + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__39Ex; /* Prevent compiler warnings */ + ruleT__39Ex: ; + +} +// $ANTLR end T__39 + +// Comes from: 13:7: ( '(' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__40 + * + * Looks to match the characters the constitute the token T__40 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__40(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__40; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:13:7: ( '(' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:13:9: '(' + { + MATCHC('('); + if (HASEXCEPTION()) + { + goto ruleT__40Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__40Ex; /* Prevent compiler warnings */ + ruleT__40Ex: ; + +} +// $ANTLR end T__40 + +// Comes from: 14:7: ( ',' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__41 + * + * Looks to match the characters the constitute the token T__41 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__41(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__41; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:14:7: ( ',' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:14:9: ',' + { + MATCHC(','); + if (HASEXCEPTION()) + { + goto ruleT__41Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__41Ex; /* Prevent compiler warnings */ + ruleT__41Ex: ; + +} +// $ANTLR end T__41 + +// Comes from: 15:7: ( ')' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__42 + * + * Looks to match the characters the constitute the token T__42 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__42(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__42; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:15:7: ( ')' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:15:9: ')' + { + MATCHC(')'); + if (HASEXCEPTION()) + { + goto ruleT__42Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__42Ex; /* Prevent compiler warnings */ + ruleT__42Ex: ; + +} +// $ANTLR end T__42 + +// Comes from: 16:7: ( '{' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__43 + * + * Looks to match the characters the constitute the token T__43 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__43(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__43; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:16:7: ( '{' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:16:9: '{' + { + MATCHC('{'); + if (HASEXCEPTION()) + { + goto ruleT__43Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__43Ex; /* Prevent compiler warnings */ + ruleT__43Ex: ; + +} +// $ANTLR end T__43 + +// Comes from: 17:7: ( '}' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__44 + * + * Looks to match the characters the constitute the token T__44 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__44(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__44; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:17:7: ( '}' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:17:9: '}' + { + MATCHC('}'); + if (HASEXCEPTION()) + { + goto ruleT__44Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__44Ex; /* Prevent compiler warnings */ + ruleT__44Ex: ; + +} +// $ANTLR end T__44 + +// Comes from: 18:7: ( ':' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__45 + * + * Looks to match the characters the constitute the token T__45 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__45(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__45; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:18:7: ( ':' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:18:9: ':' + { + MATCHC(':'); + if (HASEXCEPTION()) + { + goto ruleT__45Ex; + } + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__45Ex; /* Prevent compiler warnings */ + ruleT__45Ex: ; + +} +// $ANTLR end T__45 + +// Comes from: 19:7: ( 'true' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__46 + * + * Looks to match the characters the constitute the token T__46 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__46(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__46; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:19:7: ( 'true' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:19:9: 'true' + { + MATCHS(lit_3); + if (HASEXCEPTION()) + { + goto ruleT__46Ex; + } + + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__46Ex; /* Prevent compiler warnings */ + ruleT__46Ex: ; + +} +// $ANTLR end T__46 + +// Comes from: 20:7: ( 'false' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__47 + * + * Looks to match the characters the constitute the token T__47 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__47(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__47; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:20:7: ( 'false' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:20:9: 'false' + { + MATCHS(lit_4); + if (HASEXCEPTION()) + { + goto ruleT__47Ex; + } + + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__47Ex; /* Prevent compiler warnings */ + ruleT__47Ex: ; + +} +// $ANTLR end T__47 + +// Comes from: 21:7: ( 'null' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__48 + * + * Looks to match the characters the constitute the token T__48 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__48(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__48; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:21:7: ( 'null' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:21:9: 'null' + { + MATCHS(lit_5); + if (HASEXCEPTION()) + { + goto ruleT__48Ex; + } + + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__48Ex; /* Prevent compiler warnings */ + ruleT__48Ex: ; + +} +// $ANTLR end T__48 + +// Comes from: 22:7: ( 'map' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start T__49 + * + * Looks to match the characters the constitute the token T__49 + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mT__49(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = T__49; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:22:7: ( 'map' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:22:9: 'map' + { + MATCHS(lit_6); + if (HASEXCEPTION()) + { + goto ruleT__49Ex; + } + + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleT__49Ex; /* Prevent compiler warnings */ + ruleT__49Ex: ; + +} +// $ANTLR end T__49 + +// Comes from: 34:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start ID + * + * Looks to match the characters the constitute the token ID + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mID(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = ID; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:34:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:34:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* + { + if ( ((LA(1) >= 'A') && (LA(1) <= 'Z')) || LA(1) == '_' || ((LA(1) >= 'a') && (LA(1) <= 'z')) ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleIDEx; + } + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:34:31: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* + + 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': + 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': + case '_': + 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': + { + alt1=1; + } + break; + + } + + switch (alt1) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g: + { + if ( ((LA(1) >= '0') && (LA(1) <= '9')) || ((LA(1) >= 'A') && (LA(1) <= 'Z')) || LA(1) == '_' || ((LA(1) >= 'a') && (LA(1) <= 'z')) ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleIDEx; + } + + + } + break; + + default: + goto loop1; /* break out of the loop */ + break; + } + } + loop1: ; /* Jump out to here if this rule does not match */ + + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleIDEx; /* Prevent compiler warnings */ + ruleIDEx: ; + +} +// $ANTLR end ID + +// Comes from: 37:5: ( ( '-' )? ( '0' .. '9' )+ ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start INT + * + * Looks to match the characters the constitute the token INT + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mINT(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = INT; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:5: ( ( '-' )? ( '0' .. '9' )+ ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:7: ( '-' )? ( '0' .. '9' )+ + { + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:7: ( '-' )? + { + int alt2=2; + switch ( LA(1) ) + { + case '-': + { + alt2=1; + } + break; + } + + switch (alt2) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:7: '-' + { + MATCHC('-'); + if (HASEXCEPTION()) + { + goto ruleINTEx; + } + + + } + break; + + } + } + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:12: ( '0' .. '9' )+ + { + int cnt3=0; + + for (;;) + { + int alt3=2; + switch ( LA(1) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt3=1; + } + break; + + } + + switch (alt3) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:12: '0' .. '9' + { + MATCHRANGE('0', '9'); + if (HASEXCEPTION()) + { + goto ruleINTEx; + } + + + } + break; + + default: + + if ( cnt3 >= 1 ) + { + goto loop3; + } + /* mismatchedSetEx() + */ + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; + + + goto ruleINTEx; + } + cnt3++; + } + loop3: ; /* Jump to here if this rule does not match */ + } + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleINTEx; /* Prevent compiler warnings */ + ruleINTEx: ; + +} +// $ANTLR end INT + +// Comes from: 41:5: ( ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '-' )? ( '0' .. '9' )+ EXPONENT ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start FLOAT + * + * Looks to match the characters the constitute the token FLOAT + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mFLOAT(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = FLOAT; + + + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:5: ( ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '-' )? ( '0' .. '9' )+ EXPONENT ) + + ANTLR3_UINT32 alt10; + + alt10=2; + + alt10 = cdfa10.predict(ctx, RECOGNIZER, ISTREAM, &cdfa10); + if (HASEXCEPTION()) + { + goto ruleFLOATEx; + } + + switch (alt10) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:9: ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )? + { + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:9: ( '-' )? + { + int alt4=2; + switch ( LA(1) ) + { + case '-': + { + alt4=1; + } + break; + } + + switch (alt4) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:9: '-' + { + MATCHC('-'); + if (HASEXCEPTION()) + { + goto ruleFLOATEx; + } + + + } + break; + + } + } + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:14: ( '0' .. '9' )+ + { + int cnt5=0; + + for (;;) + { + int alt5=2; + switch ( LA(1) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt5=1; + } + break; + + } + + switch (alt5) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:15: '0' .. '9' + { + MATCHRANGE('0', '9'); + if (HASEXCEPTION()) + { + goto ruleFLOATEx; + } + + + } + break; + + default: + + if ( cnt5 >= 1 ) + { + goto loop5; + } + /* mismatchedSetEx() + */ + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; + + + goto ruleFLOATEx; + } + cnt5++; + } + loop5: ; /* Jump to here if this rule does not match */ + } + MATCHC('.'); + if (HASEXCEPTION()) + { + goto ruleFLOATEx; + } + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:30: ( '0' .. '9' )+ + { + int cnt6=0; + + for (;;) + { + int alt6=2; + switch ( LA(1) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt6=1; + } + break; + + } + + switch (alt6) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:31: '0' .. '9' + { + MATCHRANGE('0', '9'); + if (HASEXCEPTION()) + { + goto ruleFLOATEx; + } + + + } + break; + + default: + + if ( cnt6 >= 1 ) + { + goto loop6; + } + /* mismatchedSetEx() + */ + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; + + + goto ruleFLOATEx; + } + cnt6++; + } + loop6: ; /* Jump to here if this rule does not match */ + } + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:42: ( EXPONENT )? + { + int alt7=2; + switch ( LA(1) ) + { + case 'E': + case 'e': + { + alt7=1; + } + break; + } + + switch (alt7) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:42: EXPONENT + { + /* 41:42: EXPONENT */ + mEXPONENT(ctx ); + if (HASEXCEPTION()) + { + goto ruleFLOATEx; + } + + + } + break; + + } + } + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:9: ( '-' )? ( '0' .. '9' )+ EXPONENT + { + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:9: ( '-' )? + { + int alt8=2; + switch ( LA(1) ) + { + case '-': + { + alt8=1; + } + break; + } + + switch (alt8) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:9: '-' + { + MATCHC('-'); + if (HASEXCEPTION()) + { + goto ruleFLOATEx; + } + + + } + break; + + } + } + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:14: ( '0' .. '9' )+ + { + int cnt9=0; + + for (;;) + { + int alt9=2; + switch ( LA(1) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt9=1; + } + break; + + } + + switch (alt9) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:15: '0' .. '9' + { + MATCHRANGE('0', '9'); + if (HASEXCEPTION()) + { + goto ruleFLOATEx; + } + + + } + break; + + default: + + if ( cnt9 >= 1 ) + { + goto loop9; + } + /* mismatchedSetEx() + */ + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; + + + goto ruleFLOATEx; + } + cnt9++; + } + loop9: ; /* Jump to here if this rule does not match */ + } + /* 43:9: ( '-' )? ( '0' .. '9' )+ EXPONENT */ + mEXPONENT(ctx ); + if (HASEXCEPTION()) + { + goto ruleFLOATEx; + } + + + } + break; + + } + } + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleFLOATEx; /* Prevent compiler warnings */ + ruleFLOATEx: ; + +} +// $ANTLR end FLOAT + +// Comes from: 47:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | '/*' ( options {greedy=false; } : . )* '*/' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start COMMENT + * + * Looks to match the characters the constitute the token COMMENT + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mCOMMENT(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = COMMENT; + + + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | '/*' ( options {greedy=false; } : . )* '*/' ) + + ANTLR3_UINT32 alt14; + + alt14=2; + + switch ( LA(1) ) + { + case '/': + { + switch ( LA(2) ) + { + case '/': + { + alt14=1; + } + break; + case '*': + { + alt14=2; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 14; + EXCEPTION->state = 1; + + + goto ruleCOMMENTEx; + } + + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 14; + EXCEPTION->state = 0; + + + goto ruleCOMMENTEx; + } + + switch (alt14) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:9: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' + { + MATCHS(lit_7); + if (HASEXCEPTION()) + { + goto ruleCOMMENTEx; + } + + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:14: (~ ( '\\n' | '\\r' ) )* + + for (;;) + { + int alt11=2; + { + /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) + */ + int LA11_0 = LA(1); + if ( (((LA11_0 >= 0x0000) && (LA11_0 <= '\t')) || ((LA11_0 >= 0x000B) && (LA11_0 <= '\f')) || ((LA11_0 >= 0x000E) && (LA11_0 <= 0xFFFF))) ) + { + alt11=1; + } + + } + switch (alt11) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:14: ~ ( '\\n' | '\\r' ) + { + if ( ((LA(1) >= 0x0000) && (LA(1) <= '\t')) || ((LA(1) >= 0x000B) && (LA(1) <= '\f')) || ((LA(1) >= 0x000E) && (LA(1) <= 0xFFFF)) ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleCOMMENTEx; + } + + + } + break; + + default: + goto loop11; /* break out of the loop */ + break; + } + } + loop11: ; /* Jump out to here if this rule does not match */ + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:28: ( '\\r' )? + { + int alt12=2; + switch ( LA(1) ) + { + case '\r': + { + alt12=1; + } + break; + } + + switch (alt12) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:28: '\\r' + { + MATCHC('\r'); + if (HASEXCEPTION()) + { + goto ruleCOMMENTEx; + } + + + } + break; + + } + } + MATCHC('\n'); + if (HASEXCEPTION()) + { + goto ruleCOMMENTEx; + } + + { + LEXSTATE->channel=HIDDEN; + } + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:48:9: '/*' ( options {greedy=false; } : . )* '*/' + { + MATCHS(lit_8); + if (HASEXCEPTION()) + { + goto ruleCOMMENTEx; + } + + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:48:14: ( options {greedy=false; } : . )* + + for (;;) + { + int alt13=2; + { + /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) + */ + int LA13_0 = LA(1); + if ( (LA13_0 == '*') ) + { + { + /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) + */ + int LA13_1 = LA(2); + if ( (LA13_1 == '/') ) + { + alt13=2; + } + else if ( (((LA13_1 >= 0x0000) && (LA13_1 <= '.')) || ((LA13_1 >= '0') && (LA13_1 <= 0xFFFF))) ) + { + alt13=1; + } + + } + } + else if ( (((LA13_0 >= 0x0000) && (LA13_0 <= ')')) || ((LA13_0 >= '+') && (LA13_0 <= 0xFFFF))) ) + { + alt13=1; + } + + } + switch (alt13) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:48:42: . + { + MATCHANY(); + if (HASEXCEPTION()) + { + goto ruleCOMMENTEx; + } + + + } + break; + + default: + goto loop13; /* break out of the loop */ + break; + } + } + loop13: ; /* Jump out to here if this rule does not match */ + + MATCHS(lit_9); + if (HASEXCEPTION()) + { + goto ruleCOMMENTEx; + } + + + { + LEXSTATE->channel=HIDDEN; + } + + } + break; + + } + } + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleCOMMENTEx; /* Prevent compiler warnings */ + ruleCOMMENTEx: ; + +} +// $ANTLR end COMMENT + +// Comes from: 51:5: ( ( ' ' | '\\t' | '\\r' | '\\n' ) ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start WS + * + * Looks to match the characters the constitute the token WS + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mWS(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = WS; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:51:5: ( ( ' ' | '\\t' | '\\r' | '\\n' ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:51:9: ( ' ' | '\\t' | '\\r' | '\\n' ) + { + if ( ((LA(1) >= '\t') && (LA(1) <= '\n')) || LA(1) == '\r' || LA(1) == ' ' ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleWSEx; + } + + { + LEXSTATE->channel=HIDDEN; + } + + } + + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleWSEx; /* Prevent compiler warnings */ + ruleWSEx: ; + +} +// $ANTLR end WS + +// Comes from: 59:5: ( '\"' ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )* '\"' | '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"' ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start STRING + * + * Looks to match the characters the constitute the token STRING + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mSTRING(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + _type = STRING; + + + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:5: ( '\"' ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )* '\"' | '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"' ) + + ANTLR3_UINT32 alt17; + + alt17=2; + + switch ( LA(1) ) + { + case '"': + { + + { + int LA17_1 = LA(2); + if ( (LA17_1 == '"') ) + { + switch ( LA(3) ) + { + case '"': + { + alt17=2; + } + break; + + default: + alt17=1;} + + } + else if ( (((LA17_1 >= 0x0000) && (LA17_1 <= '!')) || ((LA17_1 >= '#') && (LA17_1 <= 0xFFFF))) ) + { + alt17=1; + } + else + { + + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 17; + EXCEPTION->state = 1; + + + goto ruleSTRINGEx; + } + } + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 17; + EXCEPTION->state = 0; + + + goto ruleSTRINGEx; + } + + switch (alt17) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:8: '\"' ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )* '\"' + { + MATCHC('"'); + if (HASEXCEPTION()) + { + goto ruleSTRINGEx; + } + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:12: ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )* + + for (;;) + { + int alt15=3; + { + /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) + */ + int LA15_0 = LA(1); + if ( (LA15_0 == '\\') ) + { + alt15=1; + } + else if ( (((LA15_0 >= 0x0000) && (LA15_0 <= '!')) || ((LA15_0 >= '#') && (LA15_0 <= '[')) || ((LA15_0 >= ']') && (LA15_0 <= 0xFFFF))) ) + { + alt15=2; + } + + } + switch (alt15) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:14: ESC_SEQ + { + /* 59:14: ESC_SEQ */ + mESC_SEQ(ctx ); + if (HASEXCEPTION()) + { + goto ruleSTRINGEx; + } + + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:24: ~ ( '\\\\' | '\"' ) + { + if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= '[')) || ((LA(1) >= ']') && (LA(1) <= 0xFFFF)) ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleSTRINGEx; + } + + + } + break; + + default: + goto loop15; /* break out of the loop */ + break; + } + } + loop15: ; /* Jump out to here if this rule does not match */ + + MATCHC('"'); + if (HASEXCEPTION()) + { + goto ruleSTRINGEx; + } + + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:8: '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"' + { + MATCHS(lit_10); + if (HASEXCEPTION()) + { + goto ruleSTRINGEx; + } + + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:14: (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* + + for (;;) + { + int alt16=4; + { + /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) + */ + int LA16_0 = LA(1); + if ( (LA16_0 == '"') ) + { + { + /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) + */ + int LA16_1 = LA(2); + if ( (LA16_1 == '"') ) + { + { + /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState) + */ + int LA16_3 = LA(3); + if ( (((LA16_3 >= 0x0000) && (LA16_3 <= '!')) || ((LA16_3 >= '#') && (LA16_3 <= 0xFFFF))) ) + { + alt16=3; + } + + } + } + else if ( (((LA16_1 >= 0x0000) && (LA16_1 <= '!')) || ((LA16_1 >= '#') && (LA16_1 <= 0xFFFF))) ) + { + alt16=2; + } + + } + } + else if ( (((LA16_0 >= 0x0000) && (LA16_0 <= '!')) || ((LA16_0 >= '#') && (LA16_0 <= 0xFFFF))) ) + { + alt16=1; + } + + } + switch (alt16) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:16: ~ ( '\"' ) + { + if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= 0xFFFF)) ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleSTRINGEx; + } + + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:25: '\"' ~ ( '\"' ) + { + MATCHC('"'); + if (HASEXCEPTION()) + { + goto ruleSTRINGEx; + } + + if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= 0xFFFF)) ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleSTRINGEx; + } + + + } + break; + case 3: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:38: '\"\"' ~ ( '\"' ) + { + MATCHS(lit_11); + if (HASEXCEPTION()) + { + goto ruleSTRINGEx; + } + + + if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= 0xFFFF)) ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleSTRINGEx; + } + + + } + break; + + default: + goto loop16; /* break out of the loop */ + break; + } + } + loop16: ; /* Jump out to here if this rule does not match */ + + MATCHS(lit_10); + if (HASEXCEPTION()) + { + goto ruleSTRINGEx; + } + + + + } + break; + + } + } + LEXSTATE->type = _type; + + // This is where rules clean up and exit + // + goto ruleSTRINGEx; /* Prevent compiler warnings */ + ruleSTRINGEx: ; + +} +// $ANTLR end STRING + +// Comes from: 64:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start EXPONENT + * + * Looks to match the characters the constitute the token EXPONENT + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mEXPONENT(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ + { + if ( LA(1) == 'E' || LA(1) == 'e' ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleEXPONENTEx; + } + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:22: ( '+' | '-' )? + { + int alt18=2; + switch ( LA(1) ) + { + case '+': + case '-': + { + alt18=1; + } + break; + } + + switch (alt18) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g: + { + if ( LA(1) == '+' || LA(1) == '-' ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleEXPONENTEx; + } + + + } + break; + + } + } + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:33: ( '0' .. '9' )+ + { + int cnt19=0; + + for (;;) + { + int alt19=2; + switch ( LA(1) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + alt19=1; + } + break; + + } + + switch (alt19) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:34: '0' .. '9' + { + MATCHRANGE('0', '9'); + if (HASEXCEPTION()) + { + goto ruleEXPONENTEx; + } + + + } + break; + + default: + + if ( cnt19 >= 1 ) + { + goto loop19; + } + /* mismatchedSetEx() + */ + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME; + + + goto ruleEXPONENTEx; + } + cnt19++; + } + loop19: ; /* Jump to here if this rule does not match */ + } + + } + + + + // This is where rules clean up and exit + // + goto ruleEXPONENTEx; /* Prevent compiler warnings */ + ruleEXPONENTEx: ; + +} +// $ANTLR end EXPONENT + +// Comes from: 67:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start HEX_DIGIT + * + * Looks to match the characters the constitute the token HEX_DIGIT + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mHEX_DIGIT(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:67:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:67:13: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) + { + if ( ((LA(1) >= '0') && (LA(1) <= '9')) || ((LA(1) >= 'A') && (LA(1) <= 'F')) || ((LA(1) >= 'a') && (LA(1) <= 'f')) ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleHEX_DIGITEx; + } + + + } + + + + // This is where rules clean up and exit + // + goto ruleHEX_DIGITEx; /* Prevent compiler warnings */ + ruleHEX_DIGITEx: ; + +} +// $ANTLR end HEX_DIGIT + +// Comes from: 71:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UNICODE_ESC | OCTAL_ESC ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start ESC_SEQ + * + * Looks to match the characters the constitute the token ESC_SEQ + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mESC_SEQ(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:71:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UNICODE_ESC | OCTAL_ESC ) + + ANTLR3_UINT32 alt20; + + alt20=3; + + switch ( LA(1) ) + { + case '\\': + { + switch ( LA(2) ) + { + case '"': + case '\'': + case '\\': + case 'b': + case 'f': + case 'n': + case 'r': + case 't': + { + alt20=1; + } + break; + case 'u': + { + alt20=2; + } + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + alt20=3; + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 20; + EXCEPTION->state = 1; + + + goto ruleESC_SEQEx; + } + + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 20; + EXCEPTION->state = 0; + + + goto ruleESC_SEQEx; + } + + switch (alt20) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:71:9: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) + { + MATCHC('\\'); + if (HASEXCEPTION()) + { + goto ruleESC_SEQEx; + } + + if ( LA(1) == '"' || LA(1) == '\'' || LA(1) == '\\' || LA(1) == 'b' || LA(1) == 'f' || LA(1) == 'n' || LA(1) == 'r' || LA(1) == 't' ) + { + CONSUME(); + + } + else + { + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_MISMATCHED_SET_EXCEPTION; + EXCEPTION->name = (void *)ANTLR3_MISMATCHED_SET_NAME; + + LRECOVER(); goto ruleESC_SEQEx; + } + + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:72:9: UNICODE_ESC + { + /* 72:9: UNICODE_ESC */ + mUNICODE_ESC(ctx ); + if (HASEXCEPTION()) + { + goto ruleESC_SEQEx; + } + + + } + break; + case 3: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:73:9: OCTAL_ESC + { + /* 73:9: OCTAL_ESC */ + mOCTAL_ESC(ctx ); + if (HASEXCEPTION()) + { + goto ruleESC_SEQEx; + } + + + } + break; + + } + } + + + // This is where rules clean up and exit + // + goto ruleESC_SEQEx; /* Prevent compiler warnings */ + ruleESC_SEQEx: ; + +} +// $ANTLR end ESC_SEQ + +// Comes from: 78:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start OCTAL_ESC + * + * Looks to match the characters the constitute the token OCTAL_ESC + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mOCTAL_ESC(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ) + + ANTLR3_UINT32 alt21; + + alt21=3; + + switch ( LA(1) ) + { + case '\\': + { + switch ( LA(2) ) + { + case '0': + case '1': + case '2': + case '3': + { + switch ( LA(3) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + switch ( LA(4) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + alt21=1; + } + break; + + default: + alt21=2;} + + } + break; + + default: + alt21=3;} + + } + break; + case '4': + case '5': + case '6': + case '7': + { + switch ( LA(3) ) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + alt21=2; + } + break; + + default: + alt21=3;} + + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 21; + EXCEPTION->state = 1; + + + goto ruleOCTAL_ESCEx; + } + + } + break; + + default: + CONSTRUCTEX(); + EXCEPTION->type = ANTLR3_NO_VIABLE_ALT_EXCEPTION; + EXCEPTION->message = (void *)""; + EXCEPTION->decisionNum = 21; + EXCEPTION->state = 0; + + + goto ruleOCTAL_ESCEx; + } + + switch (alt21) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) + { + MATCHC('\\'); + if (HASEXCEPTION()) + { + goto ruleOCTAL_ESCEx; + } + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:14: ( '0' .. '3' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:15: '0' .. '3' + { + MATCHRANGE('0', '3'); + if (HASEXCEPTION()) + { + goto ruleOCTAL_ESCEx; + } + + + } + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:25: ( '0' .. '7' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:26: '0' .. '7' + { + MATCHRANGE('0', '7'); + if (HASEXCEPTION()) + { + goto ruleOCTAL_ESCEx; + } + + + } + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:36: ( '0' .. '7' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:37: '0' .. '7' + { + MATCHRANGE('0', '7'); + if (HASEXCEPTION()) + { + goto ruleOCTAL_ESCEx; + } + + + } + + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) + { + MATCHC('\\'); + if (HASEXCEPTION()) + { + goto ruleOCTAL_ESCEx; + } + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:14: ( '0' .. '7' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:15: '0' .. '7' + { + MATCHRANGE('0', '7'); + if (HASEXCEPTION()) + { + goto ruleOCTAL_ESCEx; + } + + + } + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:25: ( '0' .. '7' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:26: '0' .. '7' + { + MATCHRANGE('0', '7'); + if (HASEXCEPTION()) + { + goto ruleOCTAL_ESCEx; + } + + + } + + + } + break; + case 3: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:80:9: '\\\\' ( '0' .. '7' ) + { + MATCHC('\\'); + if (HASEXCEPTION()) + { + goto ruleOCTAL_ESCEx; + } + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:80:14: ( '0' .. '7' ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:80:15: '0' .. '7' + { + MATCHRANGE('0', '7'); + if (HASEXCEPTION()) + { + goto ruleOCTAL_ESCEx; + } + + + } + + + } + break; + + } + } + + + // This is where rules clean up and exit + // + goto ruleOCTAL_ESCEx; /* Prevent compiler warnings */ + ruleOCTAL_ESCEx: ; + +} +// $ANTLR end OCTAL_ESC + +// Comes from: 85:5: ( '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT ) +/** \brief Lexer rule generated by ANTLR3 + * + * $ANTLR start UNICODE_ESC + * + * Looks to match the characters the constitute the token UNICODE_ESC + * from the attached input stream. + * + * + * \remark + * - lexer->error == ANTLR3_TRUE if an exception was thrown. + */ +static ANTLR3_INLINE +void mUNICODE_ESC(pSimanticsDataLexer ctx) +{ + ANTLR3_UINT32 _type; + + + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:85:5: ( '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT ) + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT + { + MATCHC('\\'); + if (HASEXCEPTION()) + { + goto ruleUNICODE_ESCEx; + } + + MATCHC('u'); + if (HASEXCEPTION()) + { + goto ruleUNICODE_ESCEx; + } + + /* 85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT */ + mHEX_DIGIT(ctx ); + if (HASEXCEPTION()) + { + goto ruleUNICODE_ESCEx; + } + + /* 85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT */ + mHEX_DIGIT(ctx ); + if (HASEXCEPTION()) + { + goto ruleUNICODE_ESCEx; + } + + /* 85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT */ + mHEX_DIGIT(ctx ); + if (HASEXCEPTION()) + { + goto ruleUNICODE_ESCEx; + } + + /* 85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT */ + mHEX_DIGIT(ctx ); + if (HASEXCEPTION()) + { + goto ruleUNICODE_ESCEx; + } + + + } + + + + // This is where rules clean up and exit + // + goto ruleUNICODE_ESCEx; /* Prevent compiler warnings */ + ruleUNICODE_ESCEx: ; + +} +// $ANTLR end UNICODE_ESC + +/** 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(pSimanticsDataLexer ctx) +{ + { + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:8: ( T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | ID | INT | FLOAT | COMMENT | WS | STRING ) + + ANTLR3_UINT32 alt22; + + alt22=22; + + alt22 = cdfa22.predict(ctx, RECOGNIZER, ISTREAM, &cdfa22); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + switch (alt22) + { + case 1: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:10: T__34 + { + /* 1:10: T__34 */ + mT__34(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 2: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:16: T__35 + { + /* 1:16: T__35 */ + mT__35(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 3: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:22: T__36 + { + /* 1:22: T__36 */ + mT__36(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 4: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:28: T__37 + { + /* 1:28: T__37 */ + mT__37(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 5: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:34: T__38 + { + /* 1:34: T__38 */ + mT__38(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 6: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:40: T__39 + { + /* 1:40: T__39 */ + mT__39(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 7: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:46: T__40 + { + /* 1:46: T__40 */ + mT__40(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 8: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:52: T__41 + { + /* 1:52: T__41 */ + mT__41(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 9: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:58: T__42 + { + /* 1:58: T__42 */ + mT__42(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 10: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:64: T__43 + { + /* 1:64: T__43 */ + mT__43(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 11: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:70: T__44 + { + /* 1:70: T__44 */ + mT__44(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 12: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:76: T__45 + { + /* 1:76: T__45 */ + mT__45(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 13: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:82: T__46 + { + /* 1:82: T__46 */ + mT__46(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 14: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:88: T__47 + { + /* 1:88: T__47 */ + mT__47(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 15: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:94: T__48 + { + /* 1:94: T__48 */ + mT__48(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 16: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:100: T__49 + { + /* 1:100: T__49 */ + mT__49(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 17: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:106: ID + { + /* 1:106: ID */ + mID(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 18: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:109: INT + { + /* 1:109: INT */ + mINT(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 19: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:113: FLOAT + { + /* 1:113: FLOAT */ + mFLOAT(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 20: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:119: COMMENT + { + /* 1:119: COMMENT */ + mCOMMENT(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 21: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:127: WS + { + /* 1:127: WS */ + mWS(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + case 22: + // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:130: STRING + { + /* 1:130: STRING */ + mSTRING(ctx ); + if (HASEXCEPTION()) + { + goto ruleTokensEx; + } + + + } + break; + + } + } + + + goto ruleTokensEx; /* Prevent compiler warnings */ +ruleTokensEx: ; +} + +/* ========================================================================= + * Lexer matching rules end. + * ========================================================================= + */ +/* End of Lexer code + * ================================================ + * ================================================ + */ + + +/* End of code + * ============================================================================= + */