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

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