bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/SimanticsDataLexer.c

   1 /** \file\r
   2  *  This C source file was generated by $ANTLR version 3.2 Sep 23, 2009 12:02:23\r
   3  *\r
   4  *     -  From the grammar source file : C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g\r
   5  *     -                            On : 2010-03-26 13:33:28\r
   6  *     -                 for the lexer : SimanticsDataLexerLexer *\r
   7  * Editing it, at least manually, is not wise. \r
   8  *\r
   9  * C language generator and runtime by Jim Idle, jimi|hereisanat|idle|dotgoeshere|ws.\r
  10  *\r
  11  *\r
  12 */\r
  13 // [The "BSD licence"]\r
  14 // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC\r
  15 // http://www.temporal-wave.com\r
  16 // http://www.linkedin.com/in/jimidle\r
  17 //\r
  18 // All rights reserved.\r
  19 //\r
  20 // Redistribution and use in source and binary forms, with or without\r
  21 // modification, are permitted provided that the following conditions\r
  22 // are met:\r
  23 // 1. Redistributions of source code must retain the above copyright\r
  24 //    notice, this list of conditions and the following disclaimer.\r
  25 // 2. Redistributions in binary form must reproduce the above copyright\r
  26 //    notice, this list of conditions and the following disclaimer in the\r
  27 //    documentation and/or other materials provided with the distribution.\r
  28 // 3. The name of the author may not be used to endorse or promote products\r
  29 //    derived from this software without specific prior written permission.\r
  30 //\r
  31 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\r
  32 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\r
  33 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
  34 // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\r
  35 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
  36 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
  37 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
  38 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
  39 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\r
  40 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  41 \r
  42 /* -----------------------------------------\r
  43  * Include the ANTLR3 generated header file.\r
  44  */\r
  45 #include    "SimanticsDataLexer.h"\r
  46 /* ----------------------------------------- */\r
  47 \r
  48 \r
  49 /** String literals used by SimanticsDataLexer that we must do things like MATCHS() with.\r
  50  *  C will normally just lay down 8 bit characters, and you can use L"xxx" to\r
  51  *  get wchar_t, but wchar_t is 16 bits on Windows, which is not UTF32 and so\r
  52  *  we perform this little trick of defining the literals as arrays of UINT32\r
  53  *  and passing in the address of these.\r
  54  */\r
  55 static ANTLR3_UCHAR     lit_1[]  = { 0x74, 0x79, 0x70, 0x65,  ANTLR3_STRING_TERMINATOR};\r
  56 static ANTLR3_UCHAR     lit_2[]  = { 0x2E, 0x2E,  ANTLR3_STRING_TERMINATOR};\r
  57 static ANTLR3_UCHAR     lit_3[]  = { 0x74, 0x72, 0x75, 0x65,  ANTLR3_STRING_TERMINATOR};\r
  58 static ANTLR3_UCHAR     lit_4[]  = { 0x66, 0x61, 0x6C, 0x73, 0x65,  ANTLR3_STRING_TERMINATOR};\r
  59 static ANTLR3_UCHAR     lit_5[]  = { 0x6E, 0x75, 0x6C, 0x6C,  ANTLR3_STRING_TERMINATOR};\r
  60 static ANTLR3_UCHAR     lit_6[]  = { 0x6D, 0x61, 0x70,  ANTLR3_STRING_TERMINATOR};\r
  61 static ANTLR3_UCHAR     lit_7[]  = { 0x2F, 0x2F,  ANTLR3_STRING_TERMINATOR};\r
  62 static ANTLR3_UCHAR     lit_8[]  = { 0x2F, 0x2A,  ANTLR3_STRING_TERMINATOR};\r
  63 static ANTLR3_UCHAR     lit_9[]  = { 0x2A, 0x2F,  ANTLR3_STRING_TERMINATOR};\r
  64 static ANTLR3_UCHAR     lit_10[]  = { 0x22, 0x22, 0x22,  ANTLR3_STRING_TERMINATOR};\r
  65 static ANTLR3_UCHAR     lit_11[]  = { 0x22, 0x22,  ANTLR3_STRING_TERMINATOR};\r
  66 \r
  67 \r
  68 \r
  69 \r
  70 /* MACROS that hide the C interface implementations from the\r
  71  * generated code, which makes it a little more understandable to the human eye.\r
  72  * I am very much against using C pre-processor macros for function calls and bits\r
  73  * of code as you cannot see what is happening when single stepping in debuggers\r
  74  * and so on. The exception (in my book at least) is for generated code, where you are\r
  75  * not maintaining it, but may wish to read and understand it. If you single step it, you know that input()\r
  76  * hides some indirect calls, but is always referring to the input stream. This is\r
  77  * probably more readable than ctx->input->istream->input(snarfle0->blarg) and allows me to rejig\r
  78  * the runtime interfaces without changing the generated code too often, without\r
  79  * confusing the reader of the generated output, who may not wish to know the gory\r
  80  * details of the interface inheritance.\r
  81  */\r
  82  \r
  83 #define         CTX     ctx\r
  84 \r
  85 /* Aids in accessing scopes for grammar programmers\r
  86  */\r
  87 #undef  SCOPE_TYPE\r
  88 #undef  SCOPE_STACK\r
  89 #undef  SCOPE_TOP\r
  90 #define SCOPE_TYPE(scope)   pSimanticsDataLexer_##scope##_SCOPE\r
  91 #define SCOPE_STACK(scope)  pSimanticsDataLexer_##scope##Stack\r
  92 #define SCOPE_TOP(scope)    ctx->pSimanticsDataLexer_##scope##Top\r
  93 #define SCOPE_SIZE(scope)               ctx->pSimanticsDataLexer_##scope##Stack_limit\r
  94 #define SCOPE_INSTANCE(scope, i)        (ctx->SCOPE_STACK(scope)->get(ctx->SCOPE_STACK(scope),i))\r
  95 \r
  96  \r
  97 /* Macros for accessing things in a lexer\r
  98  */\r
  99 #undef      LEXER\r
 100 #undef      RECOGNIZER              \r
 101 #undef      RULEMEMO                \r
 102 #undef      GETCHARINDEX\r
 103 #undef      GETLINE\r
 104 #undef      GETCHARPOSITIONINLINE\r
 105 #undef      EMIT\r
 106 #undef      EMITNEW\r
 107 #undef      MATCHC\r
 108 #undef      MATCHS\r
 109 #undef      MATCHRANGE\r
 110 #undef      LTOKEN\r
 111 #undef      HASFAILED\r
 112 #undef      FAILEDFLAG\r
 113 #undef      INPUT\r
 114 #undef      STRSTREAM\r
 115 #undef      LA\r
 116 #undef      HASEXCEPTION\r
 117 #undef      EXCEPTION\r
 118 #undef      CONSTRUCTEX\r
 119 #undef      CONSUME\r
 120 #undef      LRECOVER\r
 121 #undef      MARK\r
 122 #undef      REWIND\r
 123 #undef      REWINDLAST\r
 124 #undef      BACKTRACKING\r
 125 #undef          MATCHANY\r
 126 #undef          MEMOIZE\r
 127 #undef          HAVEPARSEDRULE\r
 128 #undef          GETTEXT\r
 129 #undef          INDEX\r
 130 #undef          SEEK\r
 131 #undef          PUSHSTREAM\r
 132 #undef          POPSTREAM\r
 133 #undef          SETTEXT\r
 134 #undef          SETTEXT8\r
 135 \r
 136 #define     LEXER                                       ctx->pLexer\r
 137 #define     RECOGNIZER                      LEXER->rec\r
 138 #define         LEXSTATE                                RECOGNIZER->state\r
 139 #define         TOKSOURCE                               LEXSTATE->tokSource\r
 140 #define     GETCHARINDEX()                      LEXER->getCharIndex(LEXER)\r
 141 #define     GETLINE()                           LEXER->getLine(LEXER)\r
 142 #define     GETTEXT()                           LEXER->getText(LEXER)\r
 143 #define     GETCHARPOSITIONINLINE() LEXER->getCharPositionInLine(LEXER)\r
 144 #define     EMIT()                                      LEXSTATE->type = _type; LEXER->emit(LEXER)\r
 145 #define     EMITNEW(t)                          LEXER->emitNew(LEXER, t)\r
 146 #define     MATCHC(c)                           LEXER->matchc(LEXER, c)\r
 147 #define     MATCHS(s)                           LEXER->matchs(LEXER, s)\r
 148 #define     MATCHRANGE(c1,c2)       LEXER->matchRange(LEXER, c1, c2)\r
 149 #define     MATCHANY()                          LEXER->matchAny(LEXER)\r
 150 #define     LTOKEN                              LEXSTATE->token\r
 151 #define     HASFAILED()                         (LEXSTATE->failed == ANTLR3_TRUE)\r
 152 #define     BACKTRACKING                        LEXSTATE->backtracking\r
 153 #define     FAILEDFLAG                          LEXSTATE->failed\r
 154 #define     INPUT                                       LEXER->input\r
 155 #define     STRSTREAM                           INPUT\r
 156 #define         ISTREAM                                 INPUT->istream\r
 157 #define         INDEX()                                 ISTREAM->index(ISTREAM)\r
 158 #define         SEEK(n)                                 ISTREAM->seek(ISTREAM, n)\r
 159 #define     EOF_TOKEN                           &(LEXSTATE->tokSource->eofToken)\r
 160 #define     HASEXCEPTION()                      (LEXSTATE->error == ANTLR3_TRUE)\r
 161 #define     EXCEPTION                           LEXSTATE->exception\r
 162 #define     CONSTRUCTEX()                       RECOGNIZER->exConstruct(RECOGNIZER)\r
 163 #define     LRECOVER()                          LEXER->recover(LEXER)\r
 164 #define     MARK()                                      ISTREAM->mark(ISTREAM)\r
 165 #define     REWIND(m)                           ISTREAM->rewind(ISTREAM, m)\r
 166 #define     REWINDLAST()                        ISTREAM->rewindLast(ISTREAM)\r
 167 #define         MEMOIZE(ri,si)                  RECOGNIZER->memoize(RECOGNIZER, ri, si)\r
 168 #define         HAVEPARSEDRULE(r)               RECOGNIZER->alreadyParsedRule(RECOGNIZER, r)\r
 169 #define         PUSHSTREAM(str)                 LEXER->pushCharStream(LEXER, str)\r
 170 #define         POPSTREAM()                             LEXER->popCharStream(LEXER)\r
 171 #define         SETTEXT(str)                    LEXSTATE->text = str\r
 172 #define         SKIP()                                  LEXSTATE->token = &(TOKSOURCE->skipToken)\r
 173 #define         USER1                                   LEXSTATE->user1\r
 174 #define         USER2                                   LEXSTATE->user2\r
 175 #define         USER3                                   LEXSTATE->user3\r
 176 #define         CUSTOM                                  LEXSTATE->custom\r
 177 #define         RULEMEMO                                LEXSTATE->ruleMemo\r
 178 #define         DBG                                             RECOGNIZER->debugger\r
 179 \r
 180 /* If we have been told we can rely on the standard 8 bit or 16 bit input\r
 181  * stream, then we can define our macros to use the direct pointers\r
 182  * in the input object, which is much faster than indirect calls. This\r
 183  * is really only significant to lexers with a lot of fragment rules (which\r
 184  * do not place LA(1) in a temporary at the moment) and even then\r
 185  * only if there is a lot of input (order of say 1M or so).\r
 186  */\r
 187 #if     defined(ANTLR3_INLINE_INPUT_ASCII) || defined(ANTLR3_INLINE_INPUT_UTF16)\r
 188 \r
 189 # ifdef ANTLR3_INLINE_INPUT_ASCII\r
 190 \r
 191 /* 8 bit "ASCII" (actually any 8 bit character set) */\r
 192 \r
 193 #  define           NEXTCHAR                    ((pANTLR3_UINT8)(INPUT->nextChar))\r
 194 #  define           DATAP                               ((pANTLR3_UINT8)(INPUT->data))\r
 195 \r
 196 # else\r
 197 \r
 198 #  define           NEXTCHAR                    ((pANTLR3_UINT16)(INPUT->nextChar)) \r
 199 #  define           DATAP                               ((pANTLR3_UINT16)(INPUT->data))\r
 200 \r
 201 # endif\r
 202 \r
 203 # define            LA(n) ((NEXTCHAR + n) > (DATAP + INPUT->sizeBuf) ? ANTLR3_CHARSTREAM_EOF : (ANTLR3_UCHAR)(*(NEXTCHAR + n - 1)))\r
 204 # define            CONSUME()                                                                                   \\r
 205 {                                                                                                                                       \\r
 206     if  (NEXTCHAR < (DATAP + INPUT->sizeBuf))                                           \\r
 207     {                                                                                                                           \\r
 208                 INPUT->charPositionInLine++;                                                            \\r
 209                 if  ((ANTLR3_UCHAR)(*NEXTCHAR) == INPUT->newlineChar)           \\r
 210                 {                                                                                                                       \\r
 211                         INPUT->line++;                                                                                  \\r
 212                         INPUT->charPositionInLine       = 0;                                            \\r
 213                         INPUT->currentLine              = (void *)(NEXTCHAR + 1);               \\r
 214                 }                                                                                                                       \\r
 215                 INPUT->nextChar = (void *)(NEXTCHAR + 1);                                       \\r
 216     }                                                                                                                           \\r
 217 }\r
 218 \r
 219 #else\r
 220 \r
 221 // Pick up the input character by calling the input stream implementation.\r
 222 //\r
 223 #define     CONSUME()                           INPUT->istream->consume(INPUT->istream)\r
 224 #define     LA(n)                                       INPUT->istream->_LA(INPUT->istream, n)\r
 225 \r
 226 #endif\r
 227 #define         TOKTEXT(tok, txt)                               tok, (pANTLR3_UINT8)txt\r
 228 \r
 229 /* The 4 tokens defined below may well clash with your own #defines or token types. If so\r
 230  * then for the present you must use different names for your defines as these are hard coded\r
 231  * in the code generator. It would be better not to use such names internally, and maybe\r
 232  * we can change this in a forthcoming release. I deliberately do not #undef these\r
 233  * here as this will at least give you a redefined error somewhere if they clash.\r
 234  */\r
 235 #define     UP      ANTLR3_TOKEN_UP\r
 236 #define     DOWN    ANTLR3_TOKEN_DOWN\r
 237 #define     EOR     ANTLR3_TOKEN_EOR\r
 238 #define     INVALID ANTLR3_TOKEN_INVALID\r
 239 \r
 240 \r
 241 /* =============================================================================\r
 242  * Functions to create and destroy scopes. First come the rule scopes, followed\r
 243  * by the global declared scopes.\r
 244  */\r
 245 \r
 246 \r
 247 \r
 248 /* ============================================================================= */\r
 249 \r
 250 /* =============================================================================\r
 251  * Start of recognizer\r
 252  */\r
 253 \r
 254 \r
 255 /* Forward declare the locally static matching functions we have generated and any predicate functions.\r
 256  */\r
 257 static ANTLR3_INLINE  void      mT__34    (pSimanticsDataLexer ctx);\r
 258 static ANTLR3_INLINE  void      mT__35    (pSimanticsDataLexer ctx);\r
 259 static ANTLR3_INLINE  void      mT__36    (pSimanticsDataLexer ctx);\r
 260 static ANTLR3_INLINE  void      mT__37    (pSimanticsDataLexer ctx);\r
 261 static ANTLR3_INLINE  void      mT__38    (pSimanticsDataLexer ctx);\r
 262 static ANTLR3_INLINE  void      mT__39    (pSimanticsDataLexer ctx);\r
 263 static ANTLR3_INLINE  void      mT__40    (pSimanticsDataLexer ctx);\r
 264 static ANTLR3_INLINE  void      mT__41    (pSimanticsDataLexer ctx);\r
 265 static ANTLR3_INLINE  void      mT__42    (pSimanticsDataLexer ctx);\r
 266 static ANTLR3_INLINE  void      mT__43    (pSimanticsDataLexer ctx);\r
 267 static ANTLR3_INLINE  void      mT__44    (pSimanticsDataLexer ctx);\r
 268 static ANTLR3_INLINE  void      mT__45    (pSimanticsDataLexer ctx);\r
 269 static ANTLR3_INLINE  void      mT__46    (pSimanticsDataLexer ctx);\r
 270 static ANTLR3_INLINE  void      mT__47    (pSimanticsDataLexer ctx);\r
 271 static ANTLR3_INLINE  void      mT__48    (pSimanticsDataLexer ctx);\r
 272 static ANTLR3_INLINE  void      mT__49    (pSimanticsDataLexer ctx);\r
 273 static ANTLR3_INLINE  void      mID    (pSimanticsDataLexer ctx);\r
 274 static ANTLR3_INLINE  void      mINT    (pSimanticsDataLexer ctx);\r
 275 static ANTLR3_INLINE  void      mFLOAT    (pSimanticsDataLexer ctx);\r
 276 static ANTLR3_INLINE  void      mCOMMENT    (pSimanticsDataLexer ctx);\r
 277 static ANTLR3_INLINE  void      mWS    (pSimanticsDataLexer ctx);\r
 278 static ANTLR3_INLINE  void      mSTRING    (pSimanticsDataLexer ctx);\r
 279 static ANTLR3_INLINE  void      mEXPONENT    (pSimanticsDataLexer ctx);\r
 280 static ANTLR3_INLINE  void      mHEX_DIGIT    (pSimanticsDataLexer ctx);\r
 281 static ANTLR3_INLINE  void      mESC_SEQ    (pSimanticsDataLexer ctx);\r
 282 static ANTLR3_INLINE  void      mOCTAL_ESC    (pSimanticsDataLexer ctx);\r
 283 static ANTLR3_INLINE  void      mUNICODE_ESC    (pSimanticsDataLexer ctx);\r
 284 static ANTLR3_INLINE  void      mTokens    (pSimanticsDataLexer ctx);\r
 285 static void     SimanticsDataLexerFree(pSimanticsDataLexer ctx);\r
 286 \r
 287 /* =========================================================================\r
 288  * Lexer matching rules end.\r
 289  * =========================================================================\r
 290  */\r
 291 \r
 292 \r
 293 \r
 294 static void\r
 295 SimanticsDataLexerFree  (pSimanticsDataLexer ctx)\r
 296 {\r
 297     LEXER->free(LEXER);\r
 298     \r
 299     ANTLR3_FREE(ctx);\r
 300 }\r
 301 \r
 302 /** \brief Name of the grammar file that generated this code\r
 303  */\r
 304 static const char fileName[] = "C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g";\r
 305 \r
 306 /** \brief Return the name of the grammar file that generated this code.\r
 307  */\r
 308 static const char * getGrammarFileName()\r
 309 {\r
 310         return fileName;\r
 311 }\r
 312 \r
 313 /** \brief Create a new lexer called SimanticsDataLexer\r
 314  *\r
 315  * \param[in]    instream Pointer to an initialized input stream\r
 316  * \return \r
 317  *     - Success pSimanticsDataLexer initialized for the lex start\r
 318  *     - Fail NULL\r
 319  */\r
 320 ANTLR3_API pSimanticsDataLexer SimanticsDataLexerNew         \r
 321 (pANTLR3_INPUT_STREAM instream)\r
 322 {\r
 323         // See if we can create a new lexer with the standard constructor\r
 324         //\r
 325         return SimanticsDataLexerNewSSD(instream, NULL);\r
 326 }\r
 327 \r
 328 /** \brief Create a new lexer called SimanticsDataLexer\r
 329  *\r
 330  * \param[in]    instream Pointer to an initialized input stream\r
 331  * \param[state] state Previously created shared recognizer stat\r
 332  * \return \r
 333  *     - Success pSimanticsDataLexer initialized for the lex start\r
 334  *     - Fail NULL\r
 335  */\r
 336 ANTLR3_API pSimanticsDataLexer SimanticsDataLexerNewSSD         \r
 337 (pANTLR3_INPUT_STREAM instream, pANTLR3_RECOGNIZER_SHARED_STATE state)\r
 338 {\r
 339     pSimanticsDataLexer ctx; // Context structure we will build and return\r
 340 \r
 341     ctx = (pSimanticsDataLexer) ANTLR3_CALLOC(1, sizeof(SimanticsDataLexer));\r
 342 \r
 343     if  (ctx == NULL)\r
 344     {\r
 345         // Failed to allocate memory for lexer context\r
 346         return  NULL;\r
 347     }\r
 348 \r
 349     /* -------------------------------------------------------------------\r
 350      * Memory for basic structure is allocated, now to fill in\r
 351      * in base ANTLR3 structures. We initialize the function pointers\r
 352      * for the standard ANTLR3 lexer function set, but upon return\r
 353      * from here, the programmer may set the pointers to provide custom\r
 354      * implementations of each function. \r
 355      *\r
 356      * We don't use the macros defined in SimanticsDataLexer.h here so you can get a sense\r
 357      * of what goes where.\r
 358      */\r
 359     \r
 360     /* Create a base lexer, using the supplied input stream\r
 361      */\r
 362     ctx->pLexer = antlr3LexerNewStream(ANTLR3_SIZE_HINT, instream, state);\r
 363     \r
 364     /* Check that we allocated the memory correctly\r
 365      */\r
 366     if  (ctx->pLexer == NULL)\r
 367     {\r
 368                 ANTLR3_FREE(ctx);\r
 369                 return  NULL;\r
 370     }\r
 371     /* Install the implementation of our SimanticsDataLexer interface\r
 372      */\r
 373     ctx->mT__34 = mT__34;\r
 374     ctx->mT__35 = mT__35;\r
 375     ctx->mT__36 = mT__36;\r
 376     ctx->mT__37 = mT__37;\r
 377     ctx->mT__38 = mT__38;\r
 378     ctx->mT__39 = mT__39;\r
 379     ctx->mT__40 = mT__40;\r
 380     ctx->mT__41 = mT__41;\r
 381     ctx->mT__42 = mT__42;\r
 382     ctx->mT__43 = mT__43;\r
 383     ctx->mT__44 = mT__44;\r
 384     ctx->mT__45 = mT__45;\r
 385     ctx->mT__46 = mT__46;\r
 386     ctx->mT__47 = mT__47;\r
 387     ctx->mT__48 = mT__48;\r
 388     ctx->mT__49 = mT__49;\r
 389     ctx->mID    = mID;\r
 390     ctx->mINT   = mINT;\r
 391     ctx->mFLOAT = mFLOAT;\r
 392     ctx->mCOMMENT       = mCOMMENT;\r
 393     ctx->mWS    = mWS;\r
 394     ctx->mSTRING        = mSTRING;\r
 395     ctx->mEXPONENT      = mEXPONENT;\r
 396     ctx->mHEX_DIGIT     = mHEX_DIGIT;\r
 397     ctx->mESC_SEQ       = mESC_SEQ;\r
 398     ctx->mOCTAL_ESC     = mOCTAL_ESC;\r
 399     ctx->mUNICODE_ESC   = mUNICODE_ESC;\r
 400     ctx->mTokens        = mTokens;\r
 401     \r
 402     /** When the nextToken() call is made to this lexer's pANTLR3_TOKEN_SOURCE\r
 403      *  it will call mTokens() in this generated code, and will pass it the ctx\r
 404      * pointer of this lexer, not the context of the base lexer, so store that now.\r
 405      */\r
 406     ctx->pLexer->ctx        = ctx;\r
 407     \r
 408     /**Install the token matching function\r
 409      */\r
 410     ctx->pLexer->mTokens = (void (*) (void *))(mTokens);\r
 411     \r
 412     ctx->getGrammarFileName     = getGrammarFileName;\r
 413     ctx->free           = SimanticsDataLexerFree;\r
 414 \r
 415     \r
 416     \r
 417 \r
 418 \r
 419     /* Return the newly built lexer to the caller\r
 420      */\r
 421     return  ctx;\r
 422 }\r
 423 \r
 424 /* =========================================================================\r
 425  * DFA tables for the lexer\r
 426  */\r
 427 /** Static dfa state tables for Cyclic dfa:\r
 428  *    40:1: FLOAT : ( ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '-' )? ( '0' .. '9' )+ EXPONENT );\r
 429  */\r
 430 static const ANTLR3_INT32 dfa10_eot[5] =\r
 431     {\r
 432         -1, -1, -1, -1, -1\r
 433     };\r
 434 static const ANTLR3_INT32 dfa10_eof[5] =\r
 435     {\r
 436         -1, -1, -1, -1, -1\r
 437     };\r
 438 static const ANTLR3_INT32 dfa10_min[5] =\r
 439     {\r
 440         45, 48, 46, -1, -1\r
 441     };\r
 442 static const ANTLR3_INT32 dfa10_max[5] =\r
 443     {\r
 444         57, 57, 101, -1, -1\r
 445     };\r
 446 static const ANTLR3_INT32 dfa10_accept[5] =\r
 447     {\r
 448         -1, -1, -1, 2, 1\r
 449     };\r
 450 static const ANTLR3_INT32 dfa10_special[5] =\r
 451     {   \r
 452         -1, -1, -1, -1, -1\r
 453     };\r
 454 \r
 455 /** Used when there is no transition table entry for a particular state */\r
 456 #define dfa10_T_empty       NULL\r
 457 \r
 458 static const ANTLR3_INT32 dfa10_T0[] =\r
 459     {\r
 460         2, 2, 2, 2, 2, 2, 2, 2, 2, 2\r
 461     };static const ANTLR3_INT32 dfa10_T1[] =\r
 462     {\r
 463         1, -1, -1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\r
 464     };static const ANTLR3_INT32 dfa10_T2[] =\r
 465     {\r
 466         4, -1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 467         -1, -1, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 468         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 3\r
 469     };\r
 470 \r
 471 /* Transition tables are a table of sub tables, with some tables\r
 472  * reused for efficiency.\r
 473  */\r
 474 static const ANTLR3_INT32 * const dfa10_transitions[] =\r
 475 {\r
 476     dfa10_T1, dfa10_T0, dfa10_T2, dfa10_T_empty, dfa10_T_empty  \r
 477 };\r
 478 \r
 479 \r
 480 /* Declare tracking structure for Cyclic DFA 10\r
 481  */\r
 482 static\r
 483 ANTLR3_CYCLIC_DFA cdfa10\r
 484     =   {\r
 485             10,             /* Decision number of this dfa          */\r
 486             /* Which decision this represents:   */\r
 487             (const pANTLR3_UCHAR)"40:1: FLOAT : ( ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '-' )? ( '0' .. '9' )+ EXPONENT );",   \r
 488             (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,        /* Default special state transition function    */\r
 489             antlr3dfaspecialTransition,         /* DFA specialTransition is currently just a default function in the runtime */\r
 490             antlr3dfapredict,                   /* DFA simulator function is in the runtime */\r
 491             dfa10_eot,      /* EOT table                            */\r
 492             dfa10_eof,      /* EOF table                            */\r
 493             dfa10_min,      /* Minimum tokens for each state    */\r
 494             dfa10_max,      /* Maximum tokens for each state    */\r
 495             dfa10_accept,       /* Accept table                     */\r
 496             dfa10_special,      /* Special transition states        */\r
 497             dfa10_transitions   /* Table of transition tables       */\r
 498 \r
 499         };          \r
 500 /* End of Cyclic DFA 10\r
 501  * ---------------------\r
 502  *//** Static dfa state tables for Cyclic dfa:\r
 503  *    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 );\r
 504  */\r
 505 static const ANTLR3_INT32 dfa22_eot[44] =\r
 506     {\r
 507         -1, 16, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 16, 16, 16, -1, -1, \r
 508         28, -1, -1, -1, 16, 16, 16, 16, 16, -1, -1, 16, 16, 16, 16, 38, 39, 40, \r
 509         16, 42, -1, -1, -1, 43, -1, -1\r
 510     };\r
 511 static const ANTLR3_INT32 dfa22_eof[44] =\r
 512     {\r
 513         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 514         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 515         -1, -1, -1, -1, -1, -1, -1, -1\r
 516     };\r
 517 static const ANTLR3_INT32 dfa22_min[44] =\r
 518     {\r
 519         9, 114, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, 117, 97, -1, 48, \r
 520         46, -1, -1, -1, 112, 117, 108, 108, 112, -1, -1, 101, 101, 115, 108, 48, \r
 521         48, 48, 101, 48, -1, -1, -1, 48, -1, -1\r
 522     };\r
 523 static const ANTLR3_INT32 dfa22_max[44] =\r
 524     {\r
 525         125, 121, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 97, 117, 97, -1, \r
 526         57, 101, -1, -1, -1, 112, 117, 108, 108, 112, -1, -1, 101, 101, 115, 108, \r
 527         122, 122, 122, 101, 122, -1, -1, -1, 122, -1, -1\r
 528     };\r
 529 static const ANTLR3_INT32 dfa22_accept[44] =\r
 530     {\r
 531         -1, -1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, 17, -1, -1, 20, \r
 532         21, 22, -1, -1, -1, -1, -1, 19, 18, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 533         16, 1, 13, -1, 15, 14\r
 534     };\r
 535 static const ANTLR3_INT32 dfa22_special[44] =\r
 536     {   \r
 537         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 538         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 539         -1, -1, -1, -1, -1, -1, -1, -1\r
 540     };\r
 541 \r
 542 /** Used when there is no transition table entry for a particular state */\r
 543 #define dfa22_T_empty       NULL\r
 544 \r
 545 static const ANTLR3_INT32 dfa22_T0[] =\r
 546     {\r
 547         16, 16, 16, 16, 16, 16, 16, 16, 16, 16, -1, -1, -1, -1, -1, -1, -1, 16, \r
 548         16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, \r
 549         16, 16, 16, 16, 16, 16, 16, -1, -1, -1, -1, 16, -1, 16, 16, 16, 16, 16, \r
 550         16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, \r
 551         16, 16, 16\r
 552     };static const ANTLR3_INT32 dfa22_T1[] =\r
 553     {\r
 554         41\r
 555     };static const ANTLR3_INT32 dfa22_T2[] =\r
 556     {\r
 557         36\r
 558     };static const ANTLR3_INT32 dfa22_T3[] =\r
 559     {\r
 560         31\r
 561     };static const ANTLR3_INT32 dfa22_T4[] =\r
 562     {\r
 563         26\r
 564     };static const ANTLR3_INT32 dfa22_T5[] =\r
 565     {\r
 566         35\r
 567     };static const ANTLR3_INT32 dfa22_T6[] =\r
 568     {\r
 569         30\r
 570     };static const ANTLR3_INT32 dfa22_T7[] =\r
 571     {\r
 572         33\r
 573     };static const ANTLR3_INT32 dfa22_T8[] =\r
 574     {\r
 575         25\r
 576     };static const ANTLR3_INT32 dfa22_T9[] =\r
 577     {\r
 578         20, 20, -1, -1, 20, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 579         -1, -1, -1, -1, -1, 20, -1, 21, -1, -1, -1, -1, -1, 7, 9, -1, -1, 8, 17, \r
 580         6, 19, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 12, -1, -1, 2, -1, -1, -1, \r
 581         16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, \r
 582         16, 16, 16, 16, 16, 16, 16, 16, 4, -1, 5, -1, 16, -1, 16, 16, 16, 16, 16, \r
 583         13, 16, 16, 16, 16, 16, 16, 15, 14, 16, 16, 16, 16, 16, 1, 16, 16, 16, \r
 584         16, 16, 16, 10, 3, 11\r
 585     };static const ANTLR3_INT32 dfa22_T10[] =\r
 586     {\r
 587         24\r
 588     };static const ANTLR3_INT32 dfa22_T11[] =\r
 589     {\r
 590         32\r
 591     };static const ANTLR3_INT32 dfa22_T12[] =\r
 592     {\r
 593         37\r
 594     };static const ANTLR3_INT32 dfa22_T13[] =\r
 595     {\r
 596         29\r
 597     };static const ANTLR3_INT32 dfa22_T14[] =\r
 598     {\r
 599         34\r
 600     };static const ANTLR3_INT32 dfa22_T15[] =\r
 601     {\r
 602         27, -1, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, -1, -1, -1, -1, -1, -1, \r
 603         -1, -1, -1, -1, -1, 27, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 604         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, \r
 605         -1, 27\r
 606     };static const ANTLR3_INT32 dfa22_T16[] =\r
 607     {\r
 608         23, -1, -1, -1, -1, -1, -1, 22\r
 609     };static const ANTLR3_INT32 dfa22_T17[] =\r
 610     {\r
 611         18, 18, 18, 18, 18, 18, 18, 18, 18, 18\r
 612     };\r
 613 \r
 614 /* Transition tables are a table of sub tables, with some tables\r
 615  * reused for efficiency.\r
 616  */\r
 617 static const ANTLR3_INT32 * const dfa22_transitions[] =\r
 618 {\r
 619     dfa22_T9, dfa22_T16, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, \r
 620     dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, \r
 621     dfa22_T_empty, dfa22_T_empty, dfa22_T10, dfa22_T8, dfa22_T4, dfa22_T_empty, \r
 622     dfa22_T17, dfa22_T15, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T13, \r
 623     dfa22_T6, dfa22_T3, dfa22_T11, dfa22_T7, dfa22_T_empty, dfa22_T_empty, \r
 624     dfa22_T14, dfa22_T5, dfa22_T2, dfa22_T12, dfa22_T0, dfa22_T0, dfa22_T0, \r
 625     dfa22_T1, dfa22_T0, dfa22_T_empty, dfa22_T_empty, dfa22_T_empty, dfa22_T0, \r
 626     dfa22_T_empty, dfa22_T_empty        \r
 627 };\r
 628 \r
 629 \r
 630 /* Declare tracking structure for Cyclic DFA 22\r
 631  */\r
 632 static\r
 633 ANTLR3_CYCLIC_DFA cdfa22\r
 634     =   {\r
 635             22,             /* Decision number of this dfa          */\r
 636             /* Which decision this represents:   */\r
 637             (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 );", \r
 638             (CDFA_SPECIAL_FUNC) antlr3dfaspecialStateTransition,        /* Default special state transition function    */\r
 639             antlr3dfaspecialTransition,         /* DFA specialTransition is currently just a default function in the runtime */\r
 640             antlr3dfapredict,                   /* DFA simulator function is in the runtime */\r
 641             dfa22_eot,      /* EOT table                            */\r
 642             dfa22_eof,      /* EOF table                            */\r
 643             dfa22_min,      /* Minimum tokens for each state    */\r
 644             dfa22_max,      /* Maximum tokens for each state    */\r
 645             dfa22_accept,       /* Accept table                     */\r
 646             dfa22_special,      /* Special transition states        */\r
 647             dfa22_transitions   /* Table of transition tables       */\r
 648 \r
 649         };          \r
 650 /* End of Cyclic DFA 22\r
 651  * ---------------------\r
 652  */ \r
 653 /* =========================================================================\r
 654  * End of DFA tables for the lexer\r
 655  */ \r
 656 \r
 657 /* =========================================================================\r
 658  * Functions to match the lexer grammar defined tokens from the input stream\r
 659  */\r
 660 \r
 661 //   Comes from: 7:7: ( 'type' )\r
 662 /** \brief Lexer rule generated by ANTLR3\r
 663  *\r
 664  * $ANTLR start T__34\r
 665  *\r
 666  * Looks to match the characters the constitute the token T__34\r
 667  * from the attached input stream.\r
 668  *\r
 669  *\r
 670  * \remark\r
 671  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
 672  */\r
 673 static ANTLR3_INLINE\r
 674 void mT__34(pSimanticsDataLexer ctx)\r
 675 {\r
 676         ANTLR3_UINT32   _type;\r
 677 \r
 678     _type           = T__34;\r
 679        \r
 680     \r
 681     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:7:7: ( 'type' )\r
 682     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:7:9: 'type'\r
 683     {\r
 684         MATCHS(lit_1); \r
 685         if  (HASEXCEPTION())\r
 686         {\r
 687             goto ruleT__34Ex;\r
 688         }\r
 689 \r
 690 \r
 691 \r
 692     }\r
 693 \r
 694         LEXSTATE->type = _type;\r
 695 \r
 696     // This is where rules clean up and exit\r
 697     //\r
 698     goto ruleT__34Ex; /* Prevent compiler warnings */\r
 699     ruleT__34Ex: ;\r
 700 \r
 701 }\r
 702 // $ANTLR end T__34\r
 703 \r
 704 //   Comes from: 8:7: ( '=' )\r
 705 /** \brief Lexer rule generated by ANTLR3\r
 706  *\r
 707  * $ANTLR start T__35\r
 708  *\r
 709  * Looks to match the characters the constitute the token T__35\r
 710  * from the attached input stream.\r
 711  *\r
 712  *\r
 713  * \remark\r
 714  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
 715  */\r
 716 static ANTLR3_INLINE\r
 717 void mT__35(pSimanticsDataLexer ctx)\r
 718 {\r
 719         ANTLR3_UINT32   _type;\r
 720 \r
 721     _type           = T__35;\r
 722        \r
 723     \r
 724     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:8:7: ( '=' )\r
 725     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:8:9: '='\r
 726     {\r
 727         MATCHC('='); \r
 728         if  (HASEXCEPTION())\r
 729         {\r
 730             goto ruleT__35Ex;\r
 731         }\r
 732 \r
 733 \r
 734     }\r
 735 \r
 736         LEXSTATE->type = _type;\r
 737 \r
 738     // This is where rules clean up and exit\r
 739     //\r
 740     goto ruleT__35Ex; /* Prevent compiler warnings */\r
 741     ruleT__35Ex: ;\r
 742 \r
 743 }\r
 744 // $ANTLR end T__35\r
 745 \r
 746 //   Comes from: 9:7: ( '|' )\r
 747 /** \brief Lexer rule generated by ANTLR3\r
 748  *\r
 749  * $ANTLR start T__36\r
 750  *\r
 751  * Looks to match the characters the constitute the token T__36\r
 752  * from the attached input stream.\r
 753  *\r
 754  *\r
 755  * \remark\r
 756  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
 757  */\r
 758 static ANTLR3_INLINE\r
 759 void mT__36(pSimanticsDataLexer ctx)\r
 760 {\r
 761         ANTLR3_UINT32   _type;\r
 762 \r
 763     _type           = T__36;\r
 764        \r
 765     \r
 766     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:9:7: ( '|' )\r
 767     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:9:9: '|'\r
 768     {\r
 769         MATCHC('|'); \r
 770         if  (HASEXCEPTION())\r
 771         {\r
 772             goto ruleT__36Ex;\r
 773         }\r
 774 \r
 775 \r
 776     }\r
 777 \r
 778         LEXSTATE->type = _type;\r
 779 \r
 780     // This is where rules clean up and exit\r
 781     //\r
 782     goto ruleT__36Ex; /* Prevent compiler warnings */\r
 783     ruleT__36Ex: ;\r
 784 \r
 785 }\r
 786 // $ANTLR end T__36\r
 787 \r
 788 //   Comes from: 10:7: ( '[' )\r
 789 /** \brief Lexer rule generated by ANTLR3\r
 790  *\r
 791  * $ANTLR start T__37\r
 792  *\r
 793  * Looks to match the characters the constitute the token T__37\r
 794  * from the attached input stream.\r
 795  *\r
 796  *\r
 797  * \remark\r
 798  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
 799  */\r
 800 static ANTLR3_INLINE\r
 801 void mT__37(pSimanticsDataLexer ctx)\r
 802 {\r
 803         ANTLR3_UINT32   _type;\r
 804 \r
 805     _type           = T__37;\r
 806        \r
 807     \r
 808     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:10:7: ( '[' )\r
 809     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:10:9: '['\r
 810     {\r
 811         MATCHC('['); \r
 812         if  (HASEXCEPTION())\r
 813         {\r
 814             goto ruleT__37Ex;\r
 815         }\r
 816 \r
 817 \r
 818     }\r
 819 \r
 820         LEXSTATE->type = _type;\r
 821 \r
 822     // This is where rules clean up and exit\r
 823     //\r
 824     goto ruleT__37Ex; /* Prevent compiler warnings */\r
 825     ruleT__37Ex: ;\r
 826 \r
 827 }\r
 828 // $ANTLR end T__37\r
 829 \r
 830 //   Comes from: 11:7: ( ']' )\r
 831 /** \brief Lexer rule generated by ANTLR3\r
 832  *\r
 833  * $ANTLR start T__38\r
 834  *\r
 835  * Looks to match the characters the constitute the token T__38\r
 836  * from the attached input stream.\r
 837  *\r
 838  *\r
 839  * \remark\r
 840  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
 841  */\r
 842 static ANTLR3_INLINE\r
 843 void mT__38(pSimanticsDataLexer ctx)\r
 844 {\r
 845         ANTLR3_UINT32   _type;\r
 846 \r
 847     _type           = T__38;\r
 848        \r
 849     \r
 850     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:11:7: ( ']' )\r
 851     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:11:9: ']'\r
 852     {\r
 853         MATCHC(']'); \r
 854         if  (HASEXCEPTION())\r
 855         {\r
 856             goto ruleT__38Ex;\r
 857         }\r
 858 \r
 859 \r
 860     }\r
 861 \r
 862         LEXSTATE->type = _type;\r
 863 \r
 864     // This is where rules clean up and exit\r
 865     //\r
 866     goto ruleT__38Ex; /* Prevent compiler warnings */\r
 867     ruleT__38Ex: ;\r
 868 \r
 869 }\r
 870 // $ANTLR end T__38\r
 871 \r
 872 //   Comes from: 12:7: ( '..' )\r
 873 /** \brief Lexer rule generated by ANTLR3\r
 874  *\r
 875  * $ANTLR start T__39\r
 876  *\r
 877  * Looks to match the characters the constitute the token T__39\r
 878  * from the attached input stream.\r
 879  *\r
 880  *\r
 881  * \remark\r
 882  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
 883  */\r
 884 static ANTLR3_INLINE\r
 885 void mT__39(pSimanticsDataLexer ctx)\r
 886 {\r
 887         ANTLR3_UINT32   _type;\r
 888 \r
 889     _type           = T__39;\r
 890        \r
 891     \r
 892     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:12:7: ( '..' )\r
 893     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:12:9: '..'\r
 894     {\r
 895         MATCHS(lit_2); \r
 896         if  (HASEXCEPTION())\r
 897         {\r
 898             goto ruleT__39Ex;\r
 899         }\r
 900 \r
 901 \r
 902 \r
 903     }\r
 904 \r
 905         LEXSTATE->type = _type;\r
 906 \r
 907     // This is where rules clean up and exit\r
 908     //\r
 909     goto ruleT__39Ex; /* Prevent compiler warnings */\r
 910     ruleT__39Ex: ;\r
 911 \r
 912 }\r
 913 // $ANTLR end T__39\r
 914 \r
 915 //   Comes from: 13:7: ( '(' )\r
 916 /** \brief Lexer rule generated by ANTLR3\r
 917  *\r
 918  * $ANTLR start T__40\r
 919  *\r
 920  * Looks to match the characters the constitute the token T__40\r
 921  * from the attached input stream.\r
 922  *\r
 923  *\r
 924  * \remark\r
 925  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
 926  */\r
 927 static ANTLR3_INLINE\r
 928 void mT__40(pSimanticsDataLexer ctx)\r
 929 {\r
 930         ANTLR3_UINT32   _type;\r
 931 \r
 932     _type           = T__40;\r
 933        \r
 934     \r
 935     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:13:7: ( '(' )\r
 936     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:13:9: '('\r
 937     {\r
 938         MATCHC('('); \r
 939         if  (HASEXCEPTION())\r
 940         {\r
 941             goto ruleT__40Ex;\r
 942         }\r
 943 \r
 944 \r
 945     }\r
 946 \r
 947         LEXSTATE->type = _type;\r
 948 \r
 949     // This is where rules clean up and exit\r
 950     //\r
 951     goto ruleT__40Ex; /* Prevent compiler warnings */\r
 952     ruleT__40Ex: ;\r
 953 \r
 954 }\r
 955 // $ANTLR end T__40\r
 956 \r
 957 //   Comes from: 14:7: ( ',' )\r
 958 /** \brief Lexer rule generated by ANTLR3\r
 959  *\r
 960  * $ANTLR start T__41\r
 961  *\r
 962  * Looks to match the characters the constitute the token T__41\r
 963  * from the attached input stream.\r
 964  *\r
 965  *\r
 966  * \remark\r
 967  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
 968  */\r
 969 static ANTLR3_INLINE\r
 970 void mT__41(pSimanticsDataLexer ctx)\r
 971 {\r
 972         ANTLR3_UINT32   _type;\r
 973 \r
 974     _type           = T__41;\r
 975        \r
 976     \r
 977     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:14:7: ( ',' )\r
 978     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:14:9: ','\r
 979     {\r
 980         MATCHC(','); \r
 981         if  (HASEXCEPTION())\r
 982         {\r
 983             goto ruleT__41Ex;\r
 984         }\r
 985 \r
 986 \r
 987     }\r
 988 \r
 989         LEXSTATE->type = _type;\r
 990 \r
 991     // This is where rules clean up and exit\r
 992     //\r
 993     goto ruleT__41Ex; /* Prevent compiler warnings */\r
 994     ruleT__41Ex: ;\r
 995 \r
 996 }\r
 997 // $ANTLR end T__41\r
 998 \r
 999 //   Comes from: 15:7: ( ')' )\r
1000 /** \brief Lexer rule generated by ANTLR3\r
1001  *\r
1002  * $ANTLR start T__42\r
1003  *\r
1004  * Looks to match the characters the constitute the token T__42\r
1005  * from the attached input stream.\r
1006  *\r
1007  *\r
1008  * \remark\r
1009  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1010  */\r
1011 static ANTLR3_INLINE\r
1012 void mT__42(pSimanticsDataLexer ctx)\r
1013 {\r
1014         ANTLR3_UINT32   _type;\r
1015 \r
1016     _type           = T__42;\r
1017        \r
1018     \r
1019     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:15:7: ( ')' )\r
1020     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:15:9: ')'\r
1021     {\r
1022         MATCHC(')'); \r
1023         if  (HASEXCEPTION())\r
1024         {\r
1025             goto ruleT__42Ex;\r
1026         }\r
1027 \r
1028 \r
1029     }\r
1030 \r
1031         LEXSTATE->type = _type;\r
1032 \r
1033     // This is where rules clean up and exit\r
1034     //\r
1035     goto ruleT__42Ex; /* Prevent compiler warnings */\r
1036     ruleT__42Ex: ;\r
1037 \r
1038 }\r
1039 // $ANTLR end T__42\r
1040 \r
1041 //   Comes from: 16:7: ( '{' )\r
1042 /** \brief Lexer rule generated by ANTLR3\r
1043  *\r
1044  * $ANTLR start T__43\r
1045  *\r
1046  * Looks to match the characters the constitute the token T__43\r
1047  * from the attached input stream.\r
1048  *\r
1049  *\r
1050  * \remark\r
1051  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1052  */\r
1053 static ANTLR3_INLINE\r
1054 void mT__43(pSimanticsDataLexer ctx)\r
1055 {\r
1056         ANTLR3_UINT32   _type;\r
1057 \r
1058     _type           = T__43;\r
1059        \r
1060     \r
1061     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:16:7: ( '{' )\r
1062     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:16:9: '{'\r
1063     {\r
1064         MATCHC('{'); \r
1065         if  (HASEXCEPTION())\r
1066         {\r
1067             goto ruleT__43Ex;\r
1068         }\r
1069 \r
1070 \r
1071     }\r
1072 \r
1073         LEXSTATE->type = _type;\r
1074 \r
1075     // This is where rules clean up and exit\r
1076     //\r
1077     goto ruleT__43Ex; /* Prevent compiler warnings */\r
1078     ruleT__43Ex: ;\r
1079 \r
1080 }\r
1081 // $ANTLR end T__43\r
1082 \r
1083 //   Comes from: 17:7: ( '}' )\r
1084 /** \brief Lexer rule generated by ANTLR3\r
1085  *\r
1086  * $ANTLR start T__44\r
1087  *\r
1088  * Looks to match the characters the constitute the token T__44\r
1089  * from the attached input stream.\r
1090  *\r
1091  *\r
1092  * \remark\r
1093  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1094  */\r
1095 static ANTLR3_INLINE\r
1096 void mT__44(pSimanticsDataLexer ctx)\r
1097 {\r
1098         ANTLR3_UINT32   _type;\r
1099 \r
1100     _type           = T__44;\r
1101        \r
1102     \r
1103     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:17:7: ( '}' )\r
1104     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:17:9: '}'\r
1105     {\r
1106         MATCHC('}'); \r
1107         if  (HASEXCEPTION())\r
1108         {\r
1109             goto ruleT__44Ex;\r
1110         }\r
1111 \r
1112 \r
1113     }\r
1114 \r
1115         LEXSTATE->type = _type;\r
1116 \r
1117     // This is where rules clean up and exit\r
1118     //\r
1119     goto ruleT__44Ex; /* Prevent compiler warnings */\r
1120     ruleT__44Ex: ;\r
1121 \r
1122 }\r
1123 // $ANTLR end T__44\r
1124 \r
1125 //   Comes from: 18:7: ( ':' )\r
1126 /** \brief Lexer rule generated by ANTLR3\r
1127  *\r
1128  * $ANTLR start T__45\r
1129  *\r
1130  * Looks to match the characters the constitute the token T__45\r
1131  * from the attached input stream.\r
1132  *\r
1133  *\r
1134  * \remark\r
1135  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1136  */\r
1137 static ANTLR3_INLINE\r
1138 void mT__45(pSimanticsDataLexer ctx)\r
1139 {\r
1140         ANTLR3_UINT32   _type;\r
1141 \r
1142     _type           = T__45;\r
1143        \r
1144     \r
1145     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:18:7: ( ':' )\r
1146     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:18:9: ':'\r
1147     {\r
1148         MATCHC(':'); \r
1149         if  (HASEXCEPTION())\r
1150         {\r
1151             goto ruleT__45Ex;\r
1152         }\r
1153 \r
1154 \r
1155     }\r
1156 \r
1157         LEXSTATE->type = _type;\r
1158 \r
1159     // This is where rules clean up and exit\r
1160     //\r
1161     goto ruleT__45Ex; /* Prevent compiler warnings */\r
1162     ruleT__45Ex: ;\r
1163 \r
1164 }\r
1165 // $ANTLR end T__45\r
1166 \r
1167 //   Comes from: 19:7: ( 'true' )\r
1168 /** \brief Lexer rule generated by ANTLR3\r
1169  *\r
1170  * $ANTLR start T__46\r
1171  *\r
1172  * Looks to match the characters the constitute the token T__46\r
1173  * from the attached input stream.\r
1174  *\r
1175  *\r
1176  * \remark\r
1177  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1178  */\r
1179 static ANTLR3_INLINE\r
1180 void mT__46(pSimanticsDataLexer ctx)\r
1181 {\r
1182         ANTLR3_UINT32   _type;\r
1183 \r
1184     _type           = T__46;\r
1185        \r
1186     \r
1187     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:19:7: ( 'true' )\r
1188     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:19:9: 'true'\r
1189     {\r
1190         MATCHS(lit_3); \r
1191         if  (HASEXCEPTION())\r
1192         {\r
1193             goto ruleT__46Ex;\r
1194         }\r
1195 \r
1196 \r
1197 \r
1198     }\r
1199 \r
1200         LEXSTATE->type = _type;\r
1201 \r
1202     // This is where rules clean up and exit\r
1203     //\r
1204     goto ruleT__46Ex; /* Prevent compiler warnings */\r
1205     ruleT__46Ex: ;\r
1206 \r
1207 }\r
1208 // $ANTLR end T__46\r
1209 \r
1210 //   Comes from: 20:7: ( 'false' )\r
1211 /** \brief Lexer rule generated by ANTLR3\r
1212  *\r
1213  * $ANTLR start T__47\r
1214  *\r
1215  * Looks to match the characters the constitute the token T__47\r
1216  * from the attached input stream.\r
1217  *\r
1218  *\r
1219  * \remark\r
1220  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1221  */\r
1222 static ANTLR3_INLINE\r
1223 void mT__47(pSimanticsDataLexer ctx)\r
1224 {\r
1225         ANTLR3_UINT32   _type;\r
1226 \r
1227     _type           = T__47;\r
1228        \r
1229     \r
1230     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:20:7: ( 'false' )\r
1231     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:20:9: 'false'\r
1232     {\r
1233         MATCHS(lit_4); \r
1234         if  (HASEXCEPTION())\r
1235         {\r
1236             goto ruleT__47Ex;\r
1237         }\r
1238 \r
1239 \r
1240 \r
1241     }\r
1242 \r
1243         LEXSTATE->type = _type;\r
1244 \r
1245     // This is where rules clean up and exit\r
1246     //\r
1247     goto ruleT__47Ex; /* Prevent compiler warnings */\r
1248     ruleT__47Ex: ;\r
1249 \r
1250 }\r
1251 // $ANTLR end T__47\r
1252 \r
1253 //   Comes from: 21:7: ( 'null' )\r
1254 /** \brief Lexer rule generated by ANTLR3\r
1255  *\r
1256  * $ANTLR start T__48\r
1257  *\r
1258  * Looks to match the characters the constitute the token T__48\r
1259  * from the attached input stream.\r
1260  *\r
1261  *\r
1262  * \remark\r
1263  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1264  */\r
1265 static ANTLR3_INLINE\r
1266 void mT__48(pSimanticsDataLexer ctx)\r
1267 {\r
1268         ANTLR3_UINT32   _type;\r
1269 \r
1270     _type           = T__48;\r
1271        \r
1272     \r
1273     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:21:7: ( 'null' )\r
1274     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:21:9: 'null'\r
1275     {\r
1276         MATCHS(lit_5); \r
1277         if  (HASEXCEPTION())\r
1278         {\r
1279             goto ruleT__48Ex;\r
1280         }\r
1281 \r
1282 \r
1283 \r
1284     }\r
1285 \r
1286         LEXSTATE->type = _type;\r
1287 \r
1288     // This is where rules clean up and exit\r
1289     //\r
1290     goto ruleT__48Ex; /* Prevent compiler warnings */\r
1291     ruleT__48Ex: ;\r
1292 \r
1293 }\r
1294 // $ANTLR end T__48\r
1295 \r
1296 //   Comes from: 22:7: ( 'map' )\r
1297 /** \brief Lexer rule generated by ANTLR3\r
1298  *\r
1299  * $ANTLR start T__49\r
1300  *\r
1301  * Looks to match the characters the constitute the token T__49\r
1302  * from the attached input stream.\r
1303  *\r
1304  *\r
1305  * \remark\r
1306  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1307  */\r
1308 static ANTLR3_INLINE\r
1309 void mT__49(pSimanticsDataLexer ctx)\r
1310 {\r
1311         ANTLR3_UINT32   _type;\r
1312 \r
1313     _type           = T__49;\r
1314        \r
1315     \r
1316     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:22:7: ( 'map' )\r
1317     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:22:9: 'map'\r
1318     {\r
1319         MATCHS(lit_6); \r
1320         if  (HASEXCEPTION())\r
1321         {\r
1322             goto ruleT__49Ex;\r
1323         }\r
1324 \r
1325 \r
1326 \r
1327     }\r
1328 \r
1329         LEXSTATE->type = _type;\r
1330 \r
1331     // This is where rules clean up and exit\r
1332     //\r
1333     goto ruleT__49Ex; /* Prevent compiler warnings */\r
1334     ruleT__49Ex: ;\r
1335 \r
1336 }\r
1337 // $ANTLR end T__49\r
1338 \r
1339 //   Comes from: 34:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )\r
1340 /** \brief Lexer rule generated by ANTLR3\r
1341  *\r
1342  * $ANTLR start ID\r
1343  *\r
1344  * Looks to match the characters the constitute the token ID\r
1345  * from the attached input stream.\r
1346  *\r
1347  *\r
1348  * \remark\r
1349  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1350  */\r
1351 static ANTLR3_INLINE\r
1352 void mID(pSimanticsDataLexer ctx)\r
1353 {\r
1354         ANTLR3_UINT32   _type;\r
1355 \r
1356     _type           = ID;\r
1357        \r
1358     \r
1359     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:34:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )\r
1360     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:34:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*\r
1361     {\r
1362         if ( ((LA(1) >= 'A') && (LA(1) <= 'Z')) || LA(1) == '_' || ((LA(1) >= 'a') && (LA(1) <= 'z')) )\r
1363         {\r
1364             CONSUME();\r
1365 \r
1366         }\r
1367         else \r
1368         {\r
1369             CONSTRUCTEX();\r
1370             EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
1371             EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
1372 \r
1373             LRECOVER();    goto ruleIDEx;\r
1374         }\r
1375 \r
1376 \r
1377         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:34:31: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*\r
1378 \r
1379         for (;;)\r
1380         {\r
1381             int alt1=2;\r
1382             switch ( LA(1) ) \r
1383             {\r
1384             case '0':\r
1385             case '1':\r
1386             case '2':\r
1387             case '3':\r
1388             case '4':\r
1389             case '5':\r
1390             case '6':\r
1391             case '7':\r
1392             case '8':\r
1393             case '9':\r
1394             case 'A':\r
1395             case 'B':\r
1396             case 'C':\r
1397             case 'D':\r
1398             case 'E':\r
1399             case 'F':\r
1400             case 'G':\r
1401             case 'H':\r
1402             case 'I':\r
1403             case 'J':\r
1404             case 'K':\r
1405             case 'L':\r
1406             case 'M':\r
1407             case 'N':\r
1408             case 'O':\r
1409             case 'P':\r
1410             case 'Q':\r
1411             case 'R':\r
1412             case 'S':\r
1413             case 'T':\r
1414             case 'U':\r
1415             case 'V':\r
1416             case 'W':\r
1417             case 'X':\r
1418             case 'Y':\r
1419             case 'Z':\r
1420             case '_':\r
1421             case 'a':\r
1422             case 'b':\r
1423             case 'c':\r
1424             case 'd':\r
1425             case 'e':\r
1426             case 'f':\r
1427             case 'g':\r
1428             case 'h':\r
1429             case 'i':\r
1430             case 'j':\r
1431             case 'k':\r
1432             case 'l':\r
1433             case 'm':\r
1434             case 'n':\r
1435             case 'o':\r
1436             case 'p':\r
1437             case 'q':\r
1438             case 'r':\r
1439             case 's':\r
1440             case 't':\r
1441             case 'u':\r
1442             case 'v':\r
1443             case 'w':\r
1444             case 'x':\r
1445             case 'y':\r
1446             case 'z':\r
1447                 {\r
1448                         alt1=1;\r
1449                 }\r
1450                 break;\r
1451 \r
1452             }\r
1453 \r
1454             switch (alt1) \r
1455             {\r
1456                 case 1:\r
1457                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:\r
1458                     {\r
1459                         if ( ((LA(1) >= '0') && (LA(1) <= '9')) || ((LA(1) >= 'A') && (LA(1) <= 'Z')) || LA(1) == '_' || ((LA(1) >= 'a') && (LA(1) <= 'z')) )\r
1460                         {\r
1461                             CONSUME();\r
1462 \r
1463                         }\r
1464                         else \r
1465                         {\r
1466                             CONSTRUCTEX();\r
1467                             EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
1468                             EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
1469 \r
1470                             LRECOVER();    goto ruleIDEx;\r
1471                         }\r
1472 \r
1473 \r
1474                     }\r
1475                     break;\r
1476 \r
1477                 default:\r
1478                     goto loop1; /* break out of the loop */\r
1479                     break;\r
1480             }\r
1481         }\r
1482         loop1: ; /* Jump out to here if this rule does not match */\r
1483 \r
1484 \r
1485     }\r
1486 \r
1487         LEXSTATE->type = _type;\r
1488 \r
1489     // This is where rules clean up and exit\r
1490     //\r
1491     goto ruleIDEx; /* Prevent compiler warnings */\r
1492     ruleIDEx: ;\r
1493 \r
1494 }\r
1495 // $ANTLR end ID\r
1496 \r
1497 //   Comes from: 37:5: ( ( '-' )? ( '0' .. '9' )+ )\r
1498 /** \brief Lexer rule generated by ANTLR3\r
1499  *\r
1500  * $ANTLR start INT\r
1501  *\r
1502  * Looks to match the characters the constitute the token INT\r
1503  * from the attached input stream.\r
1504  *\r
1505  *\r
1506  * \remark\r
1507  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1508  */\r
1509 static ANTLR3_INLINE\r
1510 void mINT(pSimanticsDataLexer ctx)\r
1511 {\r
1512         ANTLR3_UINT32   _type;\r
1513 \r
1514     _type           = INT;\r
1515        \r
1516     \r
1517     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:5: ( ( '-' )? ( '0' .. '9' )+ )\r
1518     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:7: ( '-' )? ( '0' .. '9' )+\r
1519     {\r
1520 \r
1521         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:7: ( '-' )?\r
1522         {\r
1523             int alt2=2;\r
1524             switch ( LA(1) ) \r
1525             {\r
1526                 case '-':\r
1527                         {\r
1528                                 alt2=1;\r
1529                         }\r
1530                     break;\r
1531             }\r
1532 \r
1533             switch (alt2) \r
1534             {\r
1535                 case 1:\r
1536                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:7: '-'\r
1537                     {\r
1538                         MATCHC('-'); \r
1539                         if  (HASEXCEPTION())\r
1540                         {\r
1541                             goto ruleINTEx;\r
1542                         }\r
1543 \r
1544 \r
1545                     }\r
1546                     break;\r
1547 \r
1548             }\r
1549         }\r
1550         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:12: ( '0' .. '9' )+\r
1551         {\r
1552             int cnt3=0;\r
1553 \r
1554             for (;;)\r
1555             {\r
1556                 int alt3=2;\r
1557                 switch ( LA(1) ) \r
1558                 {\r
1559                 case '0':\r
1560                 case '1':\r
1561                 case '2':\r
1562                 case '3':\r
1563                 case '4':\r
1564                 case '5':\r
1565                 case '6':\r
1566                 case '7':\r
1567                 case '8':\r
1568                 case '9':\r
1569                         {\r
1570                                 alt3=1;\r
1571                         }\r
1572                     break;\r
1573 \r
1574                 }\r
1575 \r
1576                 switch (alt3) \r
1577                 {\r
1578                     case 1:\r
1579                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:37:12: '0' .. '9'\r
1580                         {\r
1581                             MATCHRANGE('0', '9'); \r
1582                             if  (HASEXCEPTION())\r
1583                             {\r
1584                                 goto ruleINTEx;\r
1585                             }\r
1586 \r
1587 \r
1588                         }\r
1589                         break;\r
1590 \r
1591                     default:\r
1592                     \r
1593                         if ( cnt3 >= 1 )\r
1594                         {\r
1595                             goto loop3;\r
1596                         }\r
1597                         /* mismatchedSetEx()\r
1598                          */\r
1599                         CONSTRUCTEX();\r
1600                         EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;\r
1601                         EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;\r
1602 \r
1603 \r
1604                         goto ruleINTEx;\r
1605                 }\r
1606                 cnt3++;\r
1607             }\r
1608             loop3: ;    /* Jump to here if this rule does not match */\r
1609         }\r
1610 \r
1611     }\r
1612 \r
1613         LEXSTATE->type = _type;\r
1614 \r
1615     // This is where rules clean up and exit\r
1616     //\r
1617     goto ruleINTEx; /* Prevent compiler warnings */\r
1618     ruleINTEx: ;\r
1619 \r
1620 }\r
1621 // $ANTLR end INT\r
1622 \r
1623 //   Comes from: 41:5: ( ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '-' )? ( '0' .. '9' )+ EXPONENT )\r
1624 /** \brief Lexer rule generated by ANTLR3\r
1625  *\r
1626  * $ANTLR start FLOAT\r
1627  *\r
1628  * Looks to match the characters the constitute the token FLOAT\r
1629  * from the attached input stream.\r
1630  *\r
1631  *\r
1632  * \remark\r
1633  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1634  */\r
1635 static ANTLR3_INLINE\r
1636 void mFLOAT(pSimanticsDataLexer ctx)\r
1637 {\r
1638         ANTLR3_UINT32   _type;\r
1639 \r
1640     _type           = FLOAT;\r
1641        \r
1642     \r
1643     {\r
1644         //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:5: ( ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )? | ( '-' )? ( '0' .. '9' )+ EXPONENT )\r
1645         \r
1646         ANTLR3_UINT32 alt10;\r
1647 \r
1648         alt10=2;\r
1649 \r
1650         alt10 = cdfa10.predict(ctx, RECOGNIZER, ISTREAM, &cdfa10);\r
1651         if  (HASEXCEPTION())\r
1652         {\r
1653             goto ruleFLOATEx;\r
1654         }\r
1655 \r
1656         switch (alt10) \r
1657         {\r
1658         case 1:\r
1659             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:9: ( '-' )? ( '0' .. '9' )+ '.' ( '0' .. '9' )+ ( EXPONENT )?\r
1660             {\r
1661 \r
1662                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:9: ( '-' )?\r
1663                 {\r
1664                     int alt4=2;\r
1665                     switch ( LA(1) ) \r
1666                     {\r
1667                         case '-':\r
1668                                 {\r
1669                                         alt4=1;\r
1670                                 }\r
1671                             break;\r
1672                     }\r
1673 \r
1674                     switch (alt4) \r
1675                     {\r
1676                         case 1:\r
1677                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:9: '-'\r
1678                             {\r
1679                                 MATCHC('-'); \r
1680                                 if  (HASEXCEPTION())\r
1681                                 {\r
1682                                     goto ruleFLOATEx;\r
1683                                 }\r
1684 \r
1685 \r
1686                             }\r
1687                             break;\r
1688 \r
1689                     }\r
1690                 }\r
1691                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:14: ( '0' .. '9' )+\r
1692                 {\r
1693                     int cnt5=0;\r
1694 \r
1695                     for (;;)\r
1696                     {\r
1697                         int alt5=2;\r
1698                         switch ( LA(1) ) \r
1699                         {\r
1700                         case '0':\r
1701                         case '1':\r
1702                         case '2':\r
1703                         case '3':\r
1704                         case '4':\r
1705                         case '5':\r
1706                         case '6':\r
1707                         case '7':\r
1708                         case '8':\r
1709                         case '9':\r
1710                                 {\r
1711                                         alt5=1;\r
1712                                 }\r
1713                             break;\r
1714 \r
1715                         }\r
1716 \r
1717                         switch (alt5) \r
1718                         {\r
1719                             case 1:\r
1720                                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:15: '0' .. '9'\r
1721                                 {\r
1722                                     MATCHRANGE('0', '9'); \r
1723                                     if  (HASEXCEPTION())\r
1724                                     {\r
1725                                         goto ruleFLOATEx;\r
1726                                     }\r
1727 \r
1728 \r
1729                                 }\r
1730                                 break;\r
1731 \r
1732                             default:\r
1733                             \r
1734                                 if ( cnt5 >= 1 )\r
1735                                 {\r
1736                                     goto loop5;\r
1737                                 }\r
1738                                 /* mismatchedSetEx()\r
1739                                  */\r
1740                                 CONSTRUCTEX();\r
1741                                 EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;\r
1742                                 EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;\r
1743 \r
1744 \r
1745                                 goto ruleFLOATEx;\r
1746                         }\r
1747                         cnt5++;\r
1748                     }\r
1749                     loop5: ;    /* Jump to here if this rule does not match */\r
1750                 }\r
1751                 MATCHC('.'); \r
1752                 if  (HASEXCEPTION())\r
1753                 {\r
1754                     goto ruleFLOATEx;\r
1755                 }\r
1756 \r
1757                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:30: ( '0' .. '9' )+\r
1758                 {\r
1759                     int cnt6=0;\r
1760 \r
1761                     for (;;)\r
1762                     {\r
1763                         int alt6=2;\r
1764                         switch ( LA(1) ) \r
1765                         {\r
1766                         case '0':\r
1767                         case '1':\r
1768                         case '2':\r
1769                         case '3':\r
1770                         case '4':\r
1771                         case '5':\r
1772                         case '6':\r
1773                         case '7':\r
1774                         case '8':\r
1775                         case '9':\r
1776                                 {\r
1777                                         alt6=1;\r
1778                                 }\r
1779                             break;\r
1780 \r
1781                         }\r
1782 \r
1783                         switch (alt6) \r
1784                         {\r
1785                             case 1:\r
1786                                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:31: '0' .. '9'\r
1787                                 {\r
1788                                     MATCHRANGE('0', '9'); \r
1789                                     if  (HASEXCEPTION())\r
1790                                     {\r
1791                                         goto ruleFLOATEx;\r
1792                                     }\r
1793 \r
1794 \r
1795                                 }\r
1796                                 break;\r
1797 \r
1798                             default:\r
1799                             \r
1800                                 if ( cnt6 >= 1 )\r
1801                                 {\r
1802                                     goto loop6;\r
1803                                 }\r
1804                                 /* mismatchedSetEx()\r
1805                                  */\r
1806                                 CONSTRUCTEX();\r
1807                                 EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;\r
1808                                 EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;\r
1809 \r
1810 \r
1811                                 goto ruleFLOATEx;\r
1812                         }\r
1813                         cnt6++;\r
1814                     }\r
1815                     loop6: ;    /* Jump to here if this rule does not match */\r
1816                 }\r
1817 \r
1818                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:42: ( EXPONENT )?\r
1819                 {\r
1820                     int alt7=2;\r
1821                     switch ( LA(1) ) \r
1822                     {\r
1823                         case 'E':\r
1824                         case 'e':\r
1825                                 {\r
1826                                         alt7=1;\r
1827                                 }\r
1828                             break;\r
1829                     }\r
1830 \r
1831                     switch (alt7) \r
1832                     {\r
1833                         case 1:\r
1834                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:41:42: EXPONENT\r
1835                             {\r
1836                                 /* 41:42: EXPONENT */\r
1837                                 mEXPONENT(ctx ); \r
1838                                 if  (HASEXCEPTION())\r
1839                                 {\r
1840                                     goto ruleFLOATEx;\r
1841                                 }\r
1842 \r
1843 \r
1844                             }\r
1845                             break;\r
1846 \r
1847                     }\r
1848                 }\r
1849 \r
1850             }\r
1851             break;\r
1852         case 2:\r
1853             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:9: ( '-' )? ( '0' .. '9' )+ EXPONENT\r
1854             {\r
1855 \r
1856                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:9: ( '-' )?\r
1857                 {\r
1858                     int alt8=2;\r
1859                     switch ( LA(1) ) \r
1860                     {\r
1861                         case '-':\r
1862                                 {\r
1863                                         alt8=1;\r
1864                                 }\r
1865                             break;\r
1866                     }\r
1867 \r
1868                     switch (alt8) \r
1869                     {\r
1870                         case 1:\r
1871                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:9: '-'\r
1872                             {\r
1873                                 MATCHC('-'); \r
1874                                 if  (HASEXCEPTION())\r
1875                                 {\r
1876                                     goto ruleFLOATEx;\r
1877                                 }\r
1878 \r
1879 \r
1880                             }\r
1881                             break;\r
1882 \r
1883                     }\r
1884                 }\r
1885                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:14: ( '0' .. '9' )+\r
1886                 {\r
1887                     int cnt9=0;\r
1888 \r
1889                     for (;;)\r
1890                     {\r
1891                         int alt9=2;\r
1892                         switch ( LA(1) ) \r
1893                         {\r
1894                         case '0':\r
1895                         case '1':\r
1896                         case '2':\r
1897                         case '3':\r
1898                         case '4':\r
1899                         case '5':\r
1900                         case '6':\r
1901                         case '7':\r
1902                         case '8':\r
1903                         case '9':\r
1904                                 {\r
1905                                         alt9=1;\r
1906                                 }\r
1907                             break;\r
1908 \r
1909                         }\r
1910 \r
1911                         switch (alt9) \r
1912                         {\r
1913                             case 1:\r
1914                                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:43:15: '0' .. '9'\r
1915                                 {\r
1916                                     MATCHRANGE('0', '9'); \r
1917                                     if  (HASEXCEPTION())\r
1918                                     {\r
1919                                         goto ruleFLOATEx;\r
1920                                     }\r
1921 \r
1922 \r
1923                                 }\r
1924                                 break;\r
1925 \r
1926                             default:\r
1927                             \r
1928                                 if ( cnt9 >= 1 )\r
1929                                 {\r
1930                                     goto loop9;\r
1931                                 }\r
1932                                 /* mismatchedSetEx()\r
1933                                  */\r
1934                                 CONSTRUCTEX();\r
1935                                 EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;\r
1936                                 EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;\r
1937 \r
1938 \r
1939                                 goto ruleFLOATEx;\r
1940                         }\r
1941                         cnt9++;\r
1942                     }\r
1943                     loop9: ;    /* Jump to here if this rule does not match */\r
1944                 }\r
1945                 /* 43:9: ( '-' )? ( '0' .. '9' )+ EXPONENT */\r
1946                 mEXPONENT(ctx ); \r
1947                 if  (HASEXCEPTION())\r
1948                 {\r
1949                     goto ruleFLOATEx;\r
1950                 }\r
1951 \r
1952 \r
1953             }\r
1954             break;\r
1955 \r
1956         }\r
1957     }\r
1958         LEXSTATE->type = _type;\r
1959 \r
1960     // This is where rules clean up and exit\r
1961     //\r
1962     goto ruleFLOATEx; /* Prevent compiler warnings */\r
1963     ruleFLOATEx: ;\r
1964 \r
1965 }\r
1966 // $ANTLR end FLOAT\r
1967 \r
1968 //   Comes from: 47:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | '/*' ( options {greedy=false; } : . )* '*/' )\r
1969 /** \brief Lexer rule generated by ANTLR3\r
1970  *\r
1971  * $ANTLR start COMMENT\r
1972  *\r
1973  * Looks to match the characters the constitute the token COMMENT\r
1974  * from the attached input stream.\r
1975  *\r
1976  *\r
1977  * \remark\r
1978  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
1979  */\r
1980 static ANTLR3_INLINE\r
1981 void mCOMMENT(pSimanticsDataLexer ctx)\r
1982 {\r
1983         ANTLR3_UINT32   _type;\r
1984 \r
1985     _type           = COMMENT;\r
1986        \r
1987     \r
1988     {\r
1989         //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | '/*' ( options {greedy=false; } : . )* '*/' )\r
1990         \r
1991         ANTLR3_UINT32 alt14;\r
1992 \r
1993         alt14=2;\r
1994 \r
1995         switch ( LA(1) ) \r
1996         {\r
1997         case '/':\r
1998                 {\r
1999                         switch ( LA(2) ) \r
2000                         {\r
2001                         case '/':\r
2002                                 {\r
2003                                         alt14=1;\r
2004                                 }\r
2005                             break;\r
2006                         case '*':\r
2007                                 {\r
2008                                         alt14=2;\r
2009                                 }\r
2010                             break;\r
2011 \r
2012                         default:\r
2013                             CONSTRUCTEX();\r
2014                             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
2015                             EXCEPTION->message      = (void *)"";\r
2016                             EXCEPTION->decisionNum  = 14;\r
2017                             EXCEPTION->state        = 1;\r
2018 \r
2019 \r
2020                             goto ruleCOMMENTEx;\r
2021                         }\r
2022 \r
2023                 }\r
2024             break;\r
2025 \r
2026         default:\r
2027             CONSTRUCTEX();\r
2028             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
2029             EXCEPTION->message      = (void *)"";\r
2030             EXCEPTION->decisionNum  = 14;\r
2031             EXCEPTION->state        = 0;\r
2032 \r
2033 \r
2034             goto ruleCOMMENTEx;\r
2035         }\r
2036 \r
2037         switch (alt14) \r
2038         {\r
2039         case 1:\r
2040             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:9: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'\r
2041             {\r
2042                 MATCHS(lit_7); \r
2043                 if  (HASEXCEPTION())\r
2044                 {\r
2045                     goto ruleCOMMENTEx;\r
2046                 }\r
2047 \r
2048 \r
2049 \r
2050                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:14: (~ ( '\\n' | '\\r' ) )*\r
2051 \r
2052                 for (;;)\r
2053                 {\r
2054                     int alt11=2;\r
2055                     {\r
2056                        /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)\r
2057                         */\r
2058                         int LA11_0 = LA(1);\r
2059                         if ( (((LA11_0 >= 0x0000) && (LA11_0 <= '\t')) || ((LA11_0 >= 0x000B) && (LA11_0 <= '\f')) || ((LA11_0 >= 0x000E) && (LA11_0 <= 0xFFFF))) ) \r
2060                         {\r
2061                             alt11=1;\r
2062                         }\r
2063 \r
2064                     }\r
2065                     switch (alt11) \r
2066                     {\r
2067                         case 1:\r
2068                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:14: ~ ( '\\n' | '\\r' )\r
2069                             {\r
2070                                 if ( ((LA(1) >= 0x0000) && (LA(1) <= '\t')) || ((LA(1) >= 0x000B) && (LA(1) <= '\f')) || ((LA(1) >= 0x000E) && (LA(1) <= 0xFFFF)) )\r
2071                                 {\r
2072                                     CONSUME();\r
2073 \r
2074                                 }\r
2075                                 else \r
2076                                 {\r
2077                                     CONSTRUCTEX();\r
2078                                     EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2079                                     EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2080 \r
2081                                     LRECOVER();    goto ruleCOMMENTEx;\r
2082                                 }\r
2083 \r
2084 \r
2085                             }\r
2086                             break;\r
2087 \r
2088                         default:\r
2089                             goto loop11;        /* break out of the loop */\r
2090                             break;\r
2091                     }\r
2092                 }\r
2093                 loop11: ; /* Jump out to here if this rule does not match */\r
2094 \r
2095 \r
2096                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:28: ( '\\r' )?\r
2097                 {\r
2098                     int alt12=2;\r
2099                     switch ( LA(1) ) \r
2100                     {\r
2101                         case '\r':\r
2102                                 {\r
2103                                         alt12=1;\r
2104                                 }\r
2105                             break;\r
2106                     }\r
2107 \r
2108                     switch (alt12) \r
2109                     {\r
2110                         case 1:\r
2111                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:47:28: '\\r'\r
2112                             {\r
2113                                 MATCHC('\r'); \r
2114                                 if  (HASEXCEPTION())\r
2115                                 {\r
2116                                     goto ruleCOMMENTEx;\r
2117                                 }\r
2118 \r
2119 \r
2120                             }\r
2121                             break;\r
2122 \r
2123                     }\r
2124                 }\r
2125                 MATCHC('\n'); \r
2126                 if  (HASEXCEPTION())\r
2127                 {\r
2128                     goto ruleCOMMENTEx;\r
2129                 }\r
2130 \r
2131                 {\r
2132                     LEXSTATE->channel=HIDDEN;\r
2133                 }\r
2134 \r
2135             }\r
2136             break;\r
2137         case 2:\r
2138             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:48:9: '/*' ( options {greedy=false; } : . )* '*/'\r
2139             {\r
2140                 MATCHS(lit_8); \r
2141                 if  (HASEXCEPTION())\r
2142                 {\r
2143                     goto ruleCOMMENTEx;\r
2144                 }\r
2145 \r
2146 \r
2147 \r
2148                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:48:14: ( options {greedy=false; } : . )*\r
2149 \r
2150                 for (;;)\r
2151                 {\r
2152                     int alt13=2;\r
2153                     {\r
2154                        /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)\r
2155                         */\r
2156                         int LA13_0 = LA(1);\r
2157                         if ( (LA13_0 == '*') ) \r
2158                         {\r
2159                             {\r
2160                                /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)\r
2161                                 */\r
2162                                 int LA13_1 = LA(2);\r
2163                                 if ( (LA13_1 == '/') ) \r
2164                                 {\r
2165                                     alt13=2;\r
2166                                 }\r
2167                                 else if ( (((LA13_1 >= 0x0000) && (LA13_1 <= '.')) || ((LA13_1 >= '0') && (LA13_1 <= 0xFFFF))) ) \r
2168                                 {\r
2169                                     alt13=1;\r
2170                                 }\r
2171 \r
2172                             }\r
2173                         }\r
2174                         else if ( (((LA13_0 >= 0x0000) && (LA13_0 <= ')')) || ((LA13_0 >= '+') && (LA13_0 <= 0xFFFF))) ) \r
2175                         {\r
2176                             alt13=1;\r
2177                         }\r
2178 \r
2179                     }\r
2180                     switch (alt13) \r
2181                     {\r
2182                         case 1:\r
2183                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:48:42: .\r
2184                             {\r
2185                                 MATCHANY(); \r
2186                                 if  (HASEXCEPTION())\r
2187                                 {\r
2188                                     goto ruleCOMMENTEx;\r
2189                                 }\r
2190 \r
2191 \r
2192                             }\r
2193                             break;\r
2194 \r
2195                         default:\r
2196                             goto loop13;        /* break out of the loop */\r
2197                             break;\r
2198                     }\r
2199                 }\r
2200                 loop13: ; /* Jump out to here if this rule does not match */\r
2201 \r
2202                 MATCHS(lit_9); \r
2203                 if  (HASEXCEPTION())\r
2204                 {\r
2205                     goto ruleCOMMENTEx;\r
2206                 }\r
2207 \r
2208 \r
2209                 {\r
2210                     LEXSTATE->channel=HIDDEN;\r
2211                 }\r
2212 \r
2213             }\r
2214             break;\r
2215 \r
2216         }\r
2217     }\r
2218         LEXSTATE->type = _type;\r
2219 \r
2220     // This is where rules clean up and exit\r
2221     //\r
2222     goto ruleCOMMENTEx; /* Prevent compiler warnings */\r
2223     ruleCOMMENTEx: ;\r
2224 \r
2225 }\r
2226 // $ANTLR end COMMENT\r
2227 \r
2228 //   Comes from: 51:5: ( ( ' ' | '\\t' | '\\r' | '\\n' ) )\r
2229 /** \brief Lexer rule generated by ANTLR3\r
2230  *\r
2231  * $ANTLR start WS\r
2232  *\r
2233  * Looks to match the characters the constitute the token WS\r
2234  * from the attached input stream.\r
2235  *\r
2236  *\r
2237  * \remark\r
2238  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
2239  */\r
2240 static ANTLR3_INLINE\r
2241 void mWS(pSimanticsDataLexer ctx)\r
2242 {\r
2243         ANTLR3_UINT32   _type;\r
2244 \r
2245     _type           = WS;\r
2246        \r
2247     \r
2248     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:51:5: ( ( ' ' | '\\t' | '\\r' | '\\n' ) )\r
2249     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:51:9: ( ' ' | '\\t' | '\\r' | '\\n' )\r
2250     {\r
2251         if ( ((LA(1) >= '\t') && (LA(1) <= '\n')) || LA(1) == '\r' || LA(1) == ' ' )\r
2252         {\r
2253             CONSUME();\r
2254 \r
2255         }\r
2256         else \r
2257         {\r
2258             CONSTRUCTEX();\r
2259             EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2260             EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2261 \r
2262             LRECOVER();    goto ruleWSEx;\r
2263         }\r
2264 \r
2265         {\r
2266             LEXSTATE->channel=HIDDEN;\r
2267         }\r
2268 \r
2269     }\r
2270 \r
2271         LEXSTATE->type = _type;\r
2272 \r
2273     // This is where rules clean up and exit\r
2274     //\r
2275     goto ruleWSEx; /* Prevent compiler warnings */\r
2276     ruleWSEx: ;\r
2277 \r
2278 }\r
2279 // $ANTLR end WS\r
2280 \r
2281 //   Comes from: 59:5: ( '\"' ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )* '\"' | '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"' )\r
2282 /** \brief Lexer rule generated by ANTLR3\r
2283  *\r
2284  * $ANTLR start STRING\r
2285  *\r
2286  * Looks to match the characters the constitute the token STRING\r
2287  * from the attached input stream.\r
2288  *\r
2289  *\r
2290  * \remark\r
2291  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
2292  */\r
2293 static ANTLR3_INLINE\r
2294 void mSTRING(pSimanticsDataLexer ctx)\r
2295 {\r
2296         ANTLR3_UINT32   _type;\r
2297 \r
2298     _type           = STRING;\r
2299        \r
2300     \r
2301     {\r
2302         //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:5: ( '\"' ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )* '\"' | '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"' )\r
2303         \r
2304         ANTLR3_UINT32 alt17;\r
2305 \r
2306         alt17=2;\r
2307 \r
2308         switch ( LA(1) ) \r
2309         {\r
2310         case '"':\r
2311                 {\r
2312 \r
2313                         {\r
2314                             int LA17_1 = LA(2);\r
2315                             if ( (LA17_1 == '"') ) \r
2316                             {\r
2317                                 switch ( LA(3) ) \r
2318                                 {\r
2319                                 case '"':\r
2320                                         {\r
2321                                                 alt17=2;\r
2322                                         }\r
2323                                     break;\r
2324 \r
2325                                 default:\r
2326                                     alt17=1;}\r
2327 \r
2328                             }\r
2329                             else if ( (((LA17_1 >= 0x0000) && (LA17_1 <= '!')) || ((LA17_1 >= '#') && (LA17_1 <= 0xFFFF))) ) \r
2330                             {\r
2331                                 alt17=1;\r
2332                             }\r
2333                             else \r
2334                             {\r
2335                             \r
2336                                 CONSTRUCTEX();\r
2337                                 EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
2338                                 EXCEPTION->message      = (void *)"";\r
2339                                 EXCEPTION->decisionNum  = 17;\r
2340                                 EXCEPTION->state        = 1;\r
2341 \r
2342 \r
2343                                 goto ruleSTRINGEx;\r
2344                             }\r
2345                         }\r
2346                 }\r
2347             break;\r
2348 \r
2349         default:\r
2350             CONSTRUCTEX();\r
2351             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
2352             EXCEPTION->message      = (void *)"";\r
2353             EXCEPTION->decisionNum  = 17;\r
2354             EXCEPTION->state        = 0;\r
2355 \r
2356 \r
2357             goto ruleSTRINGEx;\r
2358         }\r
2359 \r
2360         switch (alt17) \r
2361         {\r
2362         case 1:\r
2363             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:8: '\"' ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )* '\"'\r
2364             {\r
2365                 MATCHC('"'); \r
2366                 if  (HASEXCEPTION())\r
2367                 {\r
2368                     goto ruleSTRINGEx;\r
2369                 }\r
2370 \r
2371 \r
2372                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:12: ( ESC_SEQ | ~ ( '\\\\' | '\"' ) )*\r
2373 \r
2374                 for (;;)\r
2375                 {\r
2376                     int alt15=3;\r
2377                     {\r
2378                        /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)\r
2379                         */\r
2380                         int LA15_0 = LA(1);\r
2381                         if ( (LA15_0 == '\\') ) \r
2382                         {\r
2383                             alt15=1;\r
2384                         }\r
2385                         else if ( (((LA15_0 >= 0x0000) && (LA15_0 <= '!')) || ((LA15_0 >= '#') && (LA15_0 <= '[')) || ((LA15_0 >= ']') && (LA15_0 <= 0xFFFF))) ) \r
2386                         {\r
2387                             alt15=2;\r
2388                         }\r
2389 \r
2390                     }\r
2391                     switch (alt15) \r
2392                     {\r
2393                         case 1:\r
2394                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:14: ESC_SEQ\r
2395                             {\r
2396                                 /* 59:14: ESC_SEQ */\r
2397                                 mESC_SEQ(ctx ); \r
2398                                 if  (HASEXCEPTION())\r
2399                                 {\r
2400                                     goto ruleSTRINGEx;\r
2401                                 }\r
2402 \r
2403 \r
2404                             }\r
2405                             break;\r
2406                         case 2:\r
2407                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:59:24: ~ ( '\\\\' | '\"' )\r
2408                             {\r
2409                                 if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= '[')) || ((LA(1) >= ']') && (LA(1) <= 0xFFFF)) )\r
2410                                 {\r
2411                                     CONSUME();\r
2412 \r
2413                                 }\r
2414                                 else \r
2415                                 {\r
2416                                     CONSTRUCTEX();\r
2417                                     EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2418                                     EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2419 \r
2420                                     LRECOVER();    goto ruleSTRINGEx;\r
2421                                 }\r
2422 \r
2423 \r
2424                             }\r
2425                             break;\r
2426 \r
2427                         default:\r
2428                             goto loop15;        /* break out of the loop */\r
2429                             break;\r
2430                     }\r
2431                 }\r
2432                 loop15: ; /* Jump out to here if this rule does not match */\r
2433 \r
2434                 MATCHC('"'); \r
2435                 if  (HASEXCEPTION())\r
2436                 {\r
2437                     goto ruleSTRINGEx;\r
2438                 }\r
2439 \r
2440 \r
2441             }\r
2442             break;\r
2443         case 2:\r
2444             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:8: '\"\"\"' (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )* '\"\"\"'\r
2445             {\r
2446                 MATCHS(lit_10); \r
2447                 if  (HASEXCEPTION())\r
2448                 {\r
2449                     goto ruleSTRINGEx;\r
2450                 }\r
2451 \r
2452 \r
2453 \r
2454                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:14: (~ ( '\"' ) | '\"' ~ ( '\"' ) | '\"\"' ~ ( '\"' ) )*\r
2455 \r
2456                 for (;;)\r
2457                 {\r
2458                     int alt16=4;\r
2459                     {\r
2460                        /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)\r
2461                         */\r
2462                         int LA16_0 = LA(1);\r
2463                         if ( (LA16_0 == '"') ) \r
2464                         {\r
2465                             {\r
2466                                /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)\r
2467                                 */\r
2468                                 int LA16_1 = LA(2);\r
2469                                 if ( (LA16_1 == '"') ) \r
2470                                 {\r
2471                                     {\r
2472                                        /* dfaLoopbackState(k,edges,eotPredictsAlt,description,stateNumber,semPredState)\r
2473                                         */\r
2474                                         int LA16_3 = LA(3);\r
2475                                         if ( (((LA16_3 >= 0x0000) && (LA16_3 <= '!')) || ((LA16_3 >= '#') && (LA16_3 <= 0xFFFF))) ) \r
2476                                         {\r
2477                                             alt16=3;\r
2478                                         }\r
2479 \r
2480                                     }\r
2481                                 }\r
2482                                 else if ( (((LA16_1 >= 0x0000) && (LA16_1 <= '!')) || ((LA16_1 >= '#') && (LA16_1 <= 0xFFFF))) ) \r
2483                                 {\r
2484                                     alt16=2;\r
2485                                 }\r
2486 \r
2487                             }\r
2488                         }\r
2489                         else if ( (((LA16_0 >= 0x0000) && (LA16_0 <= '!')) || ((LA16_0 >= '#') && (LA16_0 <= 0xFFFF))) ) \r
2490                         {\r
2491                             alt16=1;\r
2492                         }\r
2493 \r
2494                     }\r
2495                     switch (alt16) \r
2496                     {\r
2497                         case 1:\r
2498                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:16: ~ ( '\"' )\r
2499                             {\r
2500                                 if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= 0xFFFF)) )\r
2501                                 {\r
2502                                     CONSUME();\r
2503 \r
2504                                 }\r
2505                                 else \r
2506                                 {\r
2507                                     CONSTRUCTEX();\r
2508                                     EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2509                                     EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2510 \r
2511                                     LRECOVER();    goto ruleSTRINGEx;\r
2512                                 }\r
2513 \r
2514 \r
2515                             }\r
2516                             break;\r
2517                         case 2:\r
2518                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:25: '\"' ~ ( '\"' )\r
2519                             {\r
2520                                 MATCHC('"'); \r
2521                                 if  (HASEXCEPTION())\r
2522                                 {\r
2523                                     goto ruleSTRINGEx;\r
2524                                 }\r
2525 \r
2526                                 if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= 0xFFFF)) )\r
2527                                 {\r
2528                                     CONSUME();\r
2529 \r
2530                                 }\r
2531                                 else \r
2532                                 {\r
2533                                     CONSTRUCTEX();\r
2534                                     EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2535                                     EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2536 \r
2537                                     LRECOVER();    goto ruleSTRINGEx;\r
2538                                 }\r
2539 \r
2540 \r
2541                             }\r
2542                             break;\r
2543                         case 3:\r
2544                             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:60:38: '\"\"' ~ ( '\"' )\r
2545                             {\r
2546                                 MATCHS(lit_11); \r
2547                                 if  (HASEXCEPTION())\r
2548                                 {\r
2549                                     goto ruleSTRINGEx;\r
2550                                 }\r
2551 \r
2552 \r
2553                                 if ( ((LA(1) >= 0x0000) && (LA(1) <= '!')) || ((LA(1) >= '#') && (LA(1) <= 0xFFFF)) )\r
2554                                 {\r
2555                                     CONSUME();\r
2556 \r
2557                                 }\r
2558                                 else \r
2559                                 {\r
2560                                     CONSTRUCTEX();\r
2561                                     EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2562                                     EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2563 \r
2564                                     LRECOVER();    goto ruleSTRINGEx;\r
2565                                 }\r
2566 \r
2567 \r
2568                             }\r
2569                             break;\r
2570 \r
2571                         default:\r
2572                             goto loop16;        /* break out of the loop */\r
2573                             break;\r
2574                     }\r
2575                 }\r
2576                 loop16: ; /* Jump out to here if this rule does not match */\r
2577 \r
2578                 MATCHS(lit_10); \r
2579                 if  (HASEXCEPTION())\r
2580                 {\r
2581                     goto ruleSTRINGEx;\r
2582                 }\r
2583 \r
2584 \r
2585 \r
2586             }\r
2587             break;\r
2588 \r
2589         }\r
2590     }\r
2591         LEXSTATE->type = _type;\r
2592 \r
2593     // This is where rules clean up and exit\r
2594     //\r
2595     goto ruleSTRINGEx; /* Prevent compiler warnings */\r
2596     ruleSTRINGEx: ;\r
2597 \r
2598 }\r
2599 // $ANTLR end STRING\r
2600 \r
2601 //   Comes from: 64:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )\r
2602 /** \brief Lexer rule generated by ANTLR3\r
2603  *\r
2604  * $ANTLR start EXPONENT\r
2605  *\r
2606  * Looks to match the characters the constitute the token EXPONENT\r
2607  * from the attached input stream.\r
2608  *\r
2609  *\r
2610  * \remark\r
2611  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
2612  */\r
2613 static ANTLR3_INLINE\r
2614 void mEXPONENT(pSimanticsDataLexer ctx)\r
2615 {\r
2616         ANTLR3_UINT32   _type;\r
2617 \r
2618         \r
2619     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )\r
2620     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+\r
2621     {\r
2622         if ( LA(1) == 'E' || LA(1) == 'e' )\r
2623         {\r
2624             CONSUME();\r
2625 \r
2626         }\r
2627         else \r
2628         {\r
2629             CONSTRUCTEX();\r
2630             EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2631             EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2632 \r
2633             LRECOVER();    goto ruleEXPONENTEx;\r
2634         }\r
2635 \r
2636 \r
2637         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:22: ( '+' | '-' )?\r
2638         {\r
2639             int alt18=2;\r
2640             switch ( LA(1) ) \r
2641             {\r
2642                 case '+':\r
2643                 case '-':\r
2644                         {\r
2645                                 alt18=1;\r
2646                         }\r
2647                     break;\r
2648             }\r
2649 \r
2650             switch (alt18) \r
2651             {\r
2652                 case 1:\r
2653                     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:\r
2654                     {\r
2655                         if ( LA(1) == '+' || LA(1) == '-' )\r
2656                         {\r
2657                             CONSUME();\r
2658 \r
2659                         }\r
2660                         else \r
2661                         {\r
2662                             CONSTRUCTEX();\r
2663                             EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2664                             EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2665 \r
2666                             LRECOVER();    goto ruleEXPONENTEx;\r
2667                         }\r
2668 \r
2669 \r
2670                     }\r
2671                     break;\r
2672 \r
2673             }\r
2674         }\r
2675         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:33: ( '0' .. '9' )+\r
2676         {\r
2677             int cnt19=0;\r
2678 \r
2679             for (;;)\r
2680             {\r
2681                 int alt19=2;\r
2682                 switch ( LA(1) ) \r
2683                 {\r
2684                 case '0':\r
2685                 case '1':\r
2686                 case '2':\r
2687                 case '3':\r
2688                 case '4':\r
2689                 case '5':\r
2690                 case '6':\r
2691                 case '7':\r
2692                 case '8':\r
2693                 case '9':\r
2694                         {\r
2695                                 alt19=1;\r
2696                         }\r
2697                     break;\r
2698 \r
2699                 }\r
2700 \r
2701                 switch (alt19) \r
2702                 {\r
2703                     case 1:\r
2704                         // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:64:34: '0' .. '9'\r
2705                         {\r
2706                             MATCHRANGE('0', '9'); \r
2707                             if  (HASEXCEPTION())\r
2708                             {\r
2709                                 goto ruleEXPONENTEx;\r
2710                             }\r
2711 \r
2712 \r
2713                         }\r
2714                         break;\r
2715 \r
2716                     default:\r
2717                     \r
2718                         if ( cnt19 >= 1 )\r
2719                         {\r
2720                             goto loop19;\r
2721                         }\r
2722                         /* mismatchedSetEx()\r
2723                          */\r
2724                         CONSTRUCTEX();\r
2725                         EXCEPTION->type = ANTLR3_EARLY_EXIT_EXCEPTION;\r
2726                         EXCEPTION->name = (void *)ANTLR3_EARLY_EXIT_NAME;\r
2727 \r
2728 \r
2729                         goto ruleEXPONENTEx;\r
2730                 }\r
2731                 cnt19++;\r
2732             }\r
2733             loop19: ;   /* Jump to here if this rule does not match */\r
2734         }\r
2735 \r
2736     }\r
2737 \r
2738 \r
2739 \r
2740     // This is where rules clean up and exit\r
2741     //\r
2742     goto ruleEXPONENTEx; /* Prevent compiler warnings */\r
2743     ruleEXPONENTEx: ;\r
2744 \r
2745 }\r
2746 // $ANTLR end EXPONENT\r
2747 \r
2748 //   Comes from: 67:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )\r
2749 /** \brief Lexer rule generated by ANTLR3\r
2750  *\r
2751  * $ANTLR start HEX_DIGIT\r
2752  *\r
2753  * Looks to match the characters the constitute the token HEX_DIGIT\r
2754  * from the attached input stream.\r
2755  *\r
2756  *\r
2757  * \remark\r
2758  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
2759  */\r
2760 static ANTLR3_INLINE\r
2761 void mHEX_DIGIT(pSimanticsDataLexer ctx)\r
2762 {\r
2763         ANTLR3_UINT32   _type;\r
2764 \r
2765         \r
2766     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:67:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )\r
2767     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:67:13: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )\r
2768     {\r
2769         if ( ((LA(1) >= '0') && (LA(1) <= '9')) || ((LA(1) >= 'A') && (LA(1) <= 'F')) || ((LA(1) >= 'a') && (LA(1) <= 'f')) )\r
2770         {\r
2771             CONSUME();\r
2772 \r
2773         }\r
2774         else \r
2775         {\r
2776             CONSTRUCTEX();\r
2777             EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2778             EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2779 \r
2780             LRECOVER();    goto ruleHEX_DIGITEx;\r
2781         }\r
2782 \r
2783 \r
2784     }\r
2785 \r
2786 \r
2787 \r
2788     // This is where rules clean up and exit\r
2789     //\r
2790     goto ruleHEX_DIGITEx; /* Prevent compiler warnings */\r
2791     ruleHEX_DIGITEx: ;\r
2792 \r
2793 }\r
2794 // $ANTLR end HEX_DIGIT\r
2795 \r
2796 //   Comes from: 71:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UNICODE_ESC | OCTAL_ESC )\r
2797 /** \brief Lexer rule generated by ANTLR3\r
2798  *\r
2799  * $ANTLR start ESC_SEQ\r
2800  *\r
2801  * Looks to match the characters the constitute the token ESC_SEQ\r
2802  * from the attached input stream.\r
2803  *\r
2804  *\r
2805  * \remark\r
2806  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
2807  */\r
2808 static ANTLR3_INLINE\r
2809 void mESC_SEQ(pSimanticsDataLexer ctx)\r
2810 {\r
2811         ANTLR3_UINT32   _type;\r
2812 \r
2813         \r
2814     {\r
2815         //  C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:71:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | UNICODE_ESC | OCTAL_ESC )\r
2816         \r
2817         ANTLR3_UINT32 alt20;\r
2818 \r
2819         alt20=3;\r
2820 \r
2821         switch ( LA(1) ) \r
2822         {\r
2823         case '\\':\r
2824                 {\r
2825                         switch ( LA(2) ) \r
2826                         {\r
2827                         case '"':\r
2828                         case '\'':\r
2829                         case '\\':\r
2830                         case 'b':\r
2831                         case 'f':\r
2832                         case 'n':\r
2833                         case 'r':\r
2834                         case 't':\r
2835                                 {\r
2836                                         alt20=1;\r
2837                                 }\r
2838                             break;\r
2839                         case 'u':\r
2840                                 {\r
2841                                         alt20=2;\r
2842                                 }\r
2843                             break;\r
2844                         case '0':\r
2845                         case '1':\r
2846                         case '2':\r
2847                         case '3':\r
2848                         case '4':\r
2849                         case '5':\r
2850                         case '6':\r
2851                         case '7':\r
2852                                 {\r
2853                                         alt20=3;\r
2854                                 }\r
2855                             break;\r
2856 \r
2857                         default:\r
2858                             CONSTRUCTEX();\r
2859                             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
2860                             EXCEPTION->message      = (void *)"";\r
2861                             EXCEPTION->decisionNum  = 20;\r
2862                             EXCEPTION->state        = 1;\r
2863 \r
2864 \r
2865                             goto ruleESC_SEQEx;\r
2866                         }\r
2867 \r
2868                 }\r
2869             break;\r
2870 \r
2871         default:\r
2872             CONSTRUCTEX();\r
2873             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
2874             EXCEPTION->message      = (void *)"";\r
2875             EXCEPTION->decisionNum  = 20;\r
2876             EXCEPTION->state        = 0;\r
2877 \r
2878 \r
2879             goto ruleESC_SEQEx;\r
2880         }\r
2881 \r
2882         switch (alt20) \r
2883         {\r
2884         case 1:\r
2885             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:71:9: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )\r
2886             {\r
2887                 MATCHC('\\'); \r
2888                 if  (HASEXCEPTION())\r
2889                 {\r
2890                     goto ruleESC_SEQEx;\r
2891                 }\r
2892 \r
2893                 if ( LA(1) == '"' || LA(1) == '\'' || LA(1) == '\\' || LA(1) == 'b' || LA(1) == 'f' || LA(1) == 'n' || LA(1) == 'r' || LA(1) == 't' )\r
2894                 {\r
2895                     CONSUME();\r
2896 \r
2897                 }\r
2898                 else \r
2899                 {\r
2900                     CONSTRUCTEX();\r
2901                     EXCEPTION->type         = ANTLR3_MISMATCHED_SET_EXCEPTION;\r
2902                     EXCEPTION->name         = (void *)ANTLR3_MISMATCHED_SET_NAME;\r
2903 \r
2904                     LRECOVER();    goto ruleESC_SEQEx;\r
2905                 }\r
2906 \r
2907 \r
2908             }\r
2909             break;\r
2910         case 2:\r
2911             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:72:9: UNICODE_ESC\r
2912             {\r
2913                 /* 72:9: UNICODE_ESC */\r
2914                 mUNICODE_ESC(ctx ); \r
2915                 if  (HASEXCEPTION())\r
2916                 {\r
2917                     goto ruleESC_SEQEx;\r
2918                 }\r
2919 \r
2920 \r
2921             }\r
2922             break;\r
2923         case 3:\r
2924             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:73:9: OCTAL_ESC\r
2925             {\r
2926                 /* 73:9: OCTAL_ESC */\r
2927                 mOCTAL_ESC(ctx ); \r
2928                 if  (HASEXCEPTION())\r
2929                 {\r
2930                     goto ruleESC_SEQEx;\r
2931                 }\r
2932 \r
2933 \r
2934             }\r
2935             break;\r
2936 \r
2937         }\r
2938     }\r
2939 \r
2940 \r
2941     // This is where rules clean up and exit\r
2942     //\r
2943     goto ruleESC_SEQEx; /* Prevent compiler warnings */\r
2944     ruleESC_SEQEx: ;\r
2945 \r
2946 }\r
2947 // $ANTLR end ESC_SEQ\r
2948 \r
2949 //   Comes from: 78:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )\r
2950 /** \brief Lexer rule generated by ANTLR3\r
2951  *\r
2952  * $ANTLR start OCTAL_ESC\r
2953  *\r
2954  * Looks to match the characters the constitute the token OCTAL_ESC\r
2955  * from the attached input stream.\r
2956  *\r
2957  *\r
2958  * \remark\r
2959  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
2960  */\r
2961 static ANTLR3_INLINE\r
2962 void mOCTAL_ESC(pSimanticsDataLexer ctx)\r
2963 {\r
2964         ANTLR3_UINT32   _type;\r
2965 \r
2966         \r
2967     {\r
2968         //  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' ) )\r
2969         \r
2970         ANTLR3_UINT32 alt21;\r
2971 \r
2972         alt21=3;\r
2973 \r
2974         switch ( LA(1) ) \r
2975         {\r
2976         case '\\':\r
2977                 {\r
2978                         switch ( LA(2) ) \r
2979                         {\r
2980                         case '0':\r
2981                         case '1':\r
2982                         case '2':\r
2983                         case '3':\r
2984                                 {\r
2985                                         switch ( LA(3) ) \r
2986                                         {\r
2987                                         case '0':\r
2988                                         case '1':\r
2989                                         case '2':\r
2990                                         case '3':\r
2991                                         case '4':\r
2992                                         case '5':\r
2993                                         case '6':\r
2994                                         case '7':\r
2995                                                 {\r
2996                                                         switch ( LA(4) ) \r
2997                                                         {\r
2998                                                         case '0':\r
2999                                                         case '1':\r
3000                                                         case '2':\r
3001                                                         case '3':\r
3002                                                         case '4':\r
3003                                                         case '5':\r
3004                                                         case '6':\r
3005                                                         case '7':\r
3006                                                                 {\r
3007                                                                         alt21=1;\r
3008                                                                 }\r
3009                                                             break;\r
3010 \r
3011                                                         default:\r
3012                                                             alt21=2;}\r
3013 \r
3014                                                 }\r
3015                                             break;\r
3016 \r
3017                                         default:\r
3018                                             alt21=3;}\r
3019 \r
3020                                 }\r
3021                             break;\r
3022                         case '4':\r
3023                         case '5':\r
3024                         case '6':\r
3025                         case '7':\r
3026                                 {\r
3027                                         switch ( LA(3) ) \r
3028                                         {\r
3029                                         case '0':\r
3030                                         case '1':\r
3031                                         case '2':\r
3032                                         case '3':\r
3033                                         case '4':\r
3034                                         case '5':\r
3035                                         case '6':\r
3036                                         case '7':\r
3037                                                 {\r
3038                                                         alt21=2;\r
3039                                                 }\r
3040                                             break;\r
3041 \r
3042                                         default:\r
3043                                             alt21=3;}\r
3044 \r
3045                                 }\r
3046                             break;\r
3047 \r
3048                         default:\r
3049                             CONSTRUCTEX();\r
3050                             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
3051                             EXCEPTION->message      = (void *)"";\r
3052                             EXCEPTION->decisionNum  = 21;\r
3053                             EXCEPTION->state        = 1;\r
3054 \r
3055 \r
3056                             goto ruleOCTAL_ESCEx;\r
3057                         }\r
3058 \r
3059                 }\r
3060             break;\r
3061 \r
3062         default:\r
3063             CONSTRUCTEX();\r
3064             EXCEPTION->type         = ANTLR3_NO_VIABLE_ALT_EXCEPTION;\r
3065             EXCEPTION->message      = (void *)"";\r
3066             EXCEPTION->decisionNum  = 21;\r
3067             EXCEPTION->state        = 0;\r
3068 \r
3069 \r
3070             goto ruleOCTAL_ESCEx;\r
3071         }\r
3072 \r
3073         switch (alt21) \r
3074         {\r
3075         case 1:\r
3076             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )\r
3077             {\r
3078                 MATCHC('\\'); \r
3079                 if  (HASEXCEPTION())\r
3080                 {\r
3081                     goto ruleOCTAL_ESCEx;\r
3082                 }\r
3083 \r
3084                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:14: ( '0' .. '3' )\r
3085                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:15: '0' .. '3'\r
3086                 {\r
3087                     MATCHRANGE('0', '3'); \r
3088                     if  (HASEXCEPTION())\r
3089                     {\r
3090                         goto ruleOCTAL_ESCEx;\r
3091                     }\r
3092 \r
3093 \r
3094                 }\r
3095 \r
3096                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:25: ( '0' .. '7' )\r
3097                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:26: '0' .. '7'\r
3098                 {\r
3099                     MATCHRANGE('0', '7'); \r
3100                     if  (HASEXCEPTION())\r
3101                     {\r
3102                         goto ruleOCTAL_ESCEx;\r
3103                     }\r
3104 \r
3105 \r
3106                 }\r
3107 \r
3108                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:36: ( '0' .. '7' )\r
3109                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:78:37: '0' .. '7'\r
3110                 {\r
3111                     MATCHRANGE('0', '7'); \r
3112                     if  (HASEXCEPTION())\r
3113                     {\r
3114                         goto ruleOCTAL_ESCEx;\r
3115                     }\r
3116 \r
3117 \r
3118                 }\r
3119 \r
3120 \r
3121             }\r
3122             break;\r
3123         case 2:\r
3124             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )\r
3125             {\r
3126                 MATCHC('\\'); \r
3127                 if  (HASEXCEPTION())\r
3128                 {\r
3129                     goto ruleOCTAL_ESCEx;\r
3130                 }\r
3131 \r
3132                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:14: ( '0' .. '7' )\r
3133                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:15: '0' .. '7'\r
3134                 {\r
3135                     MATCHRANGE('0', '7'); \r
3136                     if  (HASEXCEPTION())\r
3137                     {\r
3138                         goto ruleOCTAL_ESCEx;\r
3139                     }\r
3140 \r
3141 \r
3142                 }\r
3143 \r
3144                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:25: ( '0' .. '7' )\r
3145                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:79:26: '0' .. '7'\r
3146                 {\r
3147                     MATCHRANGE('0', '7'); \r
3148                     if  (HASEXCEPTION())\r
3149                     {\r
3150                         goto ruleOCTAL_ESCEx;\r
3151                     }\r
3152 \r
3153 \r
3154                 }\r
3155 \r
3156 \r
3157             }\r
3158             break;\r
3159         case 3:\r
3160             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:80:9: '\\\\' ( '0' .. '7' )\r
3161             {\r
3162                 MATCHC('\\'); \r
3163                 if  (HASEXCEPTION())\r
3164                 {\r
3165                     goto ruleOCTAL_ESCEx;\r
3166                 }\r
3167 \r
3168                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:80:14: ( '0' .. '7' )\r
3169                 // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:80:15: '0' .. '7'\r
3170                 {\r
3171                     MATCHRANGE('0', '7'); \r
3172                     if  (HASEXCEPTION())\r
3173                     {\r
3174                         goto ruleOCTAL_ESCEx;\r
3175                     }\r
3176 \r
3177 \r
3178                 }\r
3179 \r
3180 \r
3181             }\r
3182             break;\r
3183 \r
3184         }\r
3185     }\r
3186 \r
3187 \r
3188     // This is where rules clean up and exit\r
3189     //\r
3190     goto ruleOCTAL_ESCEx; /* Prevent compiler warnings */\r
3191     ruleOCTAL_ESCEx: ;\r
3192 \r
3193 }\r
3194 // $ANTLR end OCTAL_ESC\r
3195 \r
3196 //   Comes from: 85:5: ( '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )\r
3197 /** \brief Lexer rule generated by ANTLR3\r
3198  *\r
3199  * $ANTLR start UNICODE_ESC\r
3200  *\r
3201  * Looks to match the characters the constitute the token UNICODE_ESC\r
3202  * from the attached input stream.\r
3203  *\r
3204  *\r
3205  * \remark\r
3206  *  - lexer->error == ANTLR3_TRUE if an exception was thrown.\r
3207  */\r
3208 static ANTLR3_INLINE\r
3209 void mUNICODE_ESC(pSimanticsDataLexer ctx)\r
3210 {\r
3211         ANTLR3_UINT32   _type;\r
3212 \r
3213         \r
3214     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:85:5: ( '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )\r
3215     // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT\r
3216     {\r
3217         MATCHC('\\'); \r
3218         if  (HASEXCEPTION())\r
3219         {\r
3220             goto ruleUNICODE_ESCEx;\r
3221         }\r
3222 \r
3223         MATCHC('u'); \r
3224         if  (HASEXCEPTION())\r
3225         {\r
3226             goto ruleUNICODE_ESCEx;\r
3227         }\r
3228 \r
3229         /* 85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT */\r
3230         mHEX_DIGIT(ctx ); \r
3231         if  (HASEXCEPTION())\r
3232         {\r
3233             goto ruleUNICODE_ESCEx;\r
3234         }\r
3235 \r
3236         /* 85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT */\r
3237         mHEX_DIGIT(ctx ); \r
3238         if  (HASEXCEPTION())\r
3239         {\r
3240             goto ruleUNICODE_ESCEx;\r
3241         }\r
3242 \r
3243         /* 85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT */\r
3244         mHEX_DIGIT(ctx ); \r
3245         if  (HASEXCEPTION())\r
3246         {\r
3247             goto ruleUNICODE_ESCEx;\r
3248         }\r
3249 \r
3250         /* 85:9: '\\\\' 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT */\r
3251         mHEX_DIGIT(ctx ); \r
3252         if  (HASEXCEPTION())\r
3253         {\r
3254             goto ruleUNICODE_ESCEx;\r
3255         }\r
3256 \r
3257 \r
3258     }\r
3259 \r
3260 \r
3261 \r
3262     // This is where rules clean up and exit\r
3263     //\r
3264     goto ruleUNICODE_ESCEx; /* Prevent compiler warnings */\r
3265     ruleUNICODE_ESCEx: ;\r
3266 \r
3267 }\r
3268 // $ANTLR end UNICODE_ESC\r
3269 \r
3270 /** This is the entry point in to the lexer from an object that\r
3271  *  wants to generate the next token, such as a pCOMMON_TOKEN_STREAM\r
3272  */\r
3273 static void \r
3274 mTokens(pSimanticsDataLexer ctx)\r
3275 {\r
3276     {\r
3277         //  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 )\r
3278         \r
3279         ANTLR3_UINT32 alt22;\r
3280 \r
3281         alt22=22;\r
3282 \r
3283         alt22 = cdfa22.predict(ctx, RECOGNIZER, ISTREAM, &cdfa22);\r
3284         if  (HASEXCEPTION())\r
3285         {\r
3286             goto ruleTokensEx;\r
3287         }\r
3288 \r
3289         switch (alt22) \r
3290         {\r
3291         case 1:\r
3292             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:10: T__34\r
3293             {\r
3294                 /* 1:10: T__34 */\r
3295                 mT__34(ctx ); \r
3296                 if  (HASEXCEPTION())\r
3297                 {\r
3298                     goto ruleTokensEx;\r
3299                 }\r
3300 \r
3301 \r
3302             }\r
3303             break;\r
3304         case 2:\r
3305             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:16: T__35\r
3306             {\r
3307                 /* 1:16: T__35 */\r
3308                 mT__35(ctx ); \r
3309                 if  (HASEXCEPTION())\r
3310                 {\r
3311                     goto ruleTokensEx;\r
3312                 }\r
3313 \r
3314 \r
3315             }\r
3316             break;\r
3317         case 3:\r
3318             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:22: T__36\r
3319             {\r
3320                 /* 1:22: T__36 */\r
3321                 mT__36(ctx ); \r
3322                 if  (HASEXCEPTION())\r
3323                 {\r
3324                     goto ruleTokensEx;\r
3325                 }\r
3326 \r
3327 \r
3328             }\r
3329             break;\r
3330         case 4:\r
3331             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:28: T__37\r
3332             {\r
3333                 /* 1:28: T__37 */\r
3334                 mT__37(ctx ); \r
3335                 if  (HASEXCEPTION())\r
3336                 {\r
3337                     goto ruleTokensEx;\r
3338                 }\r
3339 \r
3340 \r
3341             }\r
3342             break;\r
3343         case 5:\r
3344             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:34: T__38\r
3345             {\r
3346                 /* 1:34: T__38 */\r
3347                 mT__38(ctx ); \r
3348                 if  (HASEXCEPTION())\r
3349                 {\r
3350                     goto ruleTokensEx;\r
3351                 }\r
3352 \r
3353 \r
3354             }\r
3355             break;\r
3356         case 6:\r
3357             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:40: T__39\r
3358             {\r
3359                 /* 1:40: T__39 */\r
3360                 mT__39(ctx ); \r
3361                 if  (HASEXCEPTION())\r
3362                 {\r
3363                     goto ruleTokensEx;\r
3364                 }\r
3365 \r
3366 \r
3367             }\r
3368             break;\r
3369         case 7:\r
3370             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:46: T__40\r
3371             {\r
3372                 /* 1:46: T__40 */\r
3373                 mT__40(ctx ); \r
3374                 if  (HASEXCEPTION())\r
3375                 {\r
3376                     goto ruleTokensEx;\r
3377                 }\r
3378 \r
3379 \r
3380             }\r
3381             break;\r
3382         case 8:\r
3383             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:52: T__41\r
3384             {\r
3385                 /* 1:52: T__41 */\r
3386                 mT__41(ctx ); \r
3387                 if  (HASEXCEPTION())\r
3388                 {\r
3389                     goto ruleTokensEx;\r
3390                 }\r
3391 \r
3392 \r
3393             }\r
3394             break;\r
3395         case 9:\r
3396             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:58: T__42\r
3397             {\r
3398                 /* 1:58: T__42 */\r
3399                 mT__42(ctx ); \r
3400                 if  (HASEXCEPTION())\r
3401                 {\r
3402                     goto ruleTokensEx;\r
3403                 }\r
3404 \r
3405 \r
3406             }\r
3407             break;\r
3408         case 10:\r
3409             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:64: T__43\r
3410             {\r
3411                 /* 1:64: T__43 */\r
3412                 mT__43(ctx ); \r
3413                 if  (HASEXCEPTION())\r
3414                 {\r
3415                     goto ruleTokensEx;\r
3416                 }\r
3417 \r
3418 \r
3419             }\r
3420             break;\r
3421         case 11:\r
3422             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:70: T__44\r
3423             {\r
3424                 /* 1:70: T__44 */\r
3425                 mT__44(ctx ); \r
3426                 if  (HASEXCEPTION())\r
3427                 {\r
3428                     goto ruleTokensEx;\r
3429                 }\r
3430 \r
3431 \r
3432             }\r
3433             break;\r
3434         case 12:\r
3435             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:76: T__45\r
3436             {\r
3437                 /* 1:76: T__45 */\r
3438                 mT__45(ctx ); \r
3439                 if  (HASEXCEPTION())\r
3440                 {\r
3441                     goto ruleTokensEx;\r
3442                 }\r
3443 \r
3444 \r
3445             }\r
3446             break;\r
3447         case 13:\r
3448             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:82: T__46\r
3449             {\r
3450                 /* 1:82: T__46 */\r
3451                 mT__46(ctx ); \r
3452                 if  (HASEXCEPTION())\r
3453                 {\r
3454                     goto ruleTokensEx;\r
3455                 }\r
3456 \r
3457 \r
3458             }\r
3459             break;\r
3460         case 14:\r
3461             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:88: T__47\r
3462             {\r
3463                 /* 1:88: T__47 */\r
3464                 mT__47(ctx ); \r
3465                 if  (HASEXCEPTION())\r
3466                 {\r
3467                     goto ruleTokensEx;\r
3468                 }\r
3469 \r
3470 \r
3471             }\r
3472             break;\r
3473         case 15:\r
3474             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:94: T__48\r
3475             {\r
3476                 /* 1:94: T__48 */\r
3477                 mT__48(ctx ); \r
3478                 if  (HASEXCEPTION())\r
3479                 {\r
3480                     goto ruleTokensEx;\r
3481                 }\r
3482 \r
3483 \r
3484             }\r
3485             break;\r
3486         case 16:\r
3487             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:100: T__49\r
3488             {\r
3489                 /* 1:100: T__49 */\r
3490                 mT__49(ctx ); \r
3491                 if  (HASEXCEPTION())\r
3492                 {\r
3493                     goto ruleTokensEx;\r
3494                 }\r
3495 \r
3496 \r
3497             }\r
3498             break;\r
3499         case 17:\r
3500             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:106: ID\r
3501             {\r
3502                 /* 1:106: ID */\r
3503                 mID(ctx ); \r
3504                 if  (HASEXCEPTION())\r
3505                 {\r
3506                     goto ruleTokensEx;\r
3507                 }\r
3508 \r
3509 \r
3510             }\r
3511             break;\r
3512         case 18:\r
3513             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:109: INT\r
3514             {\r
3515                 /* 1:109: INT */\r
3516                 mINT(ctx ); \r
3517                 if  (HASEXCEPTION())\r
3518                 {\r
3519                     goto ruleTokensEx;\r
3520                 }\r
3521 \r
3522 \r
3523             }\r
3524             break;\r
3525         case 19:\r
3526             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:113: FLOAT\r
3527             {\r
3528                 /* 1:113: FLOAT */\r
3529                 mFLOAT(ctx ); \r
3530                 if  (HASEXCEPTION())\r
3531                 {\r
3532                     goto ruleTokensEx;\r
3533                 }\r
3534 \r
3535 \r
3536             }\r
3537             break;\r
3538         case 20:\r
3539             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:119: COMMENT\r
3540             {\r
3541                 /* 1:119: COMMENT */\r
3542                 mCOMMENT(ctx ); \r
3543                 if  (HASEXCEPTION())\r
3544                 {\r
3545                     goto ruleTokensEx;\r
3546                 }\r
3547 \r
3548 \r
3549             }\r
3550             break;\r
3551         case 21:\r
3552             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:127: WS\r
3553             {\r
3554                 /* 1:127: WS */\r
3555                 mWS(ctx ); \r
3556                 if  (HASEXCEPTION())\r
3557                 {\r
3558                     goto ruleTokensEx;\r
3559                 }\r
3560 \r
3561 \r
3562             }\r
3563             break;\r
3564         case 22:\r
3565             // C:\\Simantics\\workspace\\org.simantics.databoard\\cpp\\DataBoardTest\\DataBoard\\SimanticsData.g:1:130: STRING\r
3566             {\r
3567                 /* 1:130: STRING */\r
3568                 mSTRING(ctx ); \r
3569                 if  (HASEXCEPTION())\r
3570                 {\r
3571                     goto ruleTokensEx;\r
3572                 }\r
3573 \r
3574 \r
3575             }\r
3576             break;\r
3577 \r
3578         }\r
3579     }\r
3580 \r
3581     \r
3582     goto ruleTokensEx; /* Prevent compiler warnings */\r
3583 ruleTokensEx: ;\r
3584 }\r
3585 \r
3586 /* =========================================================================\r
3587  * Lexer matching rules end.\r
3588  * =========================================================================\r
3589  */\r
3590 /* End of Lexer code\r
3591  * ================================================\r
3592  * ================================================\r
3593  */ \r
3594 \r
3595 \r
3596 /* End of code\r
3597  * =============================================================================\r
3598  */\r