nemo-impl/src/main/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/NEMOParse/NEMOparserTokenManager.java

   1 /*\r
   2  * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 /* Generated By:JavaCC: Do not edit this line. NEMOparserTokenManager.java */\r
   9 package org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOParse;\r
  10 /** Token Manager. */\r
  11 public class NEMOparserTokenManager implements NEMOparserConstants\r
  12 {\r
  13 \r
  14   /** Debug output. */\r
  15   public static  java.io.PrintStream debugStream = System.out;\r
  16   /** Set debug output. */\r
  17   public static  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }\r
  18 private static final int jjStopStringLiteralDfa_0(int pos, long active0)\r
  19 {\r
  20    switch (pos)\r
  21    {\r
  22       case 0:\r
  23          if ((active0 & 0x9000000000000L) != 0L)\r
  24          {\r
  25             jjmatchedKind = 53;\r
  26             return 203;\r
  27          }\r
  28          if ((active0 & 0x6000000000000L) != 0L)\r
  29          {\r
  30             jjmatchedKind = 53;\r
  31             return 84;\r
  32          }\r
  33          return -1;\r
  34       case 1:\r
  35          if ((active0 & 0xf000000000000L) != 0L)\r
  36          {\r
  37             jjmatchedKind = 53;\r
  38             jjmatchedPos = 1;\r
  39             return 203;\r
  40          }\r
  41          return -1;\r
  42       case 2:\r
  43          if ((active0 & 0xf000000000000L) != 0L)\r
  44          {\r
  45             if (jjmatchedPos != 2)\r
  46             {\r
  47                jjmatchedKind = 53;\r
  48                jjmatchedPos = 2;\r
  49             }\r
  50             return 203;\r
  51          }\r
  52          return -1;\r
  53       case 3:\r
  54          if ((active0 & 0xf000000000000L) != 0L)\r
  55          {\r
  56             jjmatchedKind = 53;\r
  57             jjmatchedPos = 3;\r
  58             return 203;\r
  59          }\r
  60          return -1;\r
  61       case 4:\r
  62          if ((active0 & 0xa000000000000L) != 0L)\r
  63          {\r
  64             jjmatchedKind = 53;\r
  65             jjmatchedPos = 4;\r
  66             return 203;\r
  67          }\r
  68          if ((active0 & 0x5000000000000L) != 0L)\r
  69             return 203;\r
  70          return -1;\r
  71       case 5:\r
  72          if ((active0 & 0xa000000000000L) != 0L)\r
  73          {\r
  74             jjmatchedKind = 53;\r
  75             jjmatchedPos = 5;\r
  76             return 203;\r
  77          }\r
  78          return -1;\r
  79       case 6:\r
  80          if ((active0 & 0xa000000000000L) != 0L)\r
  81          {\r
  82             jjmatchedKind = 53;\r
  83             jjmatchedPos = 6;\r
  84             return 203;\r
  85          }\r
  86          return -1;\r
  87       case 7:\r
  88          if ((active0 & 0xa000000000000L) != 0L)\r
  89          {\r
  90             jjmatchedKind = 53;\r
  91             jjmatchedPos = 7;\r
  92             return 203;\r
  93          }\r
  94          return -1;\r
  95       case 8:\r
  96          if ((active0 & 0xa000000000000L) != 0L)\r
  97          {\r
  98             jjmatchedKind = 53;\r
  99             jjmatchedPos = 8;\r
 100             return 203;\r
 101          }\r
 102          return -1;\r
 103       case 9:\r
 104          if ((active0 & 0x2000000000000L) != 0L)\r
 105          {\r
 106             jjmatchedKind = 53;\r
 107             jjmatchedPos = 9;\r
 108             return 203;\r
 109          }\r
 110          if ((active0 & 0x8000000000000L) != 0L)\r
 111             return 203;\r
 112          return -1;\r
 113       default :\r
 114          return -1;\r
 115    }\r
 116 }\r
 117 private static final int jjStartNfa_0(int pos, long active0)\r
 118 {\r
 119    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);\r
 120 }\r
 121 static private int jjStopAtPos(int pos, int kind)\r
 122 {\r
 123    jjmatchedKind = kind;\r
 124    jjmatchedPos = pos;\r
 125    return pos + 1;\r
 126 }\r
 127 static private int jjMoveStringLiteralDfa0_0()\r
 128 {\r
 129    switch(curChar)\r
 130    {\r
 131       case 33:\r
 132          return jjStopAtPos(0, 14);\r
 133       case 38:\r
 134          return jjMoveStringLiteralDfa1_0(0x1000L);\r
 135       case 40:\r
 136          return jjStopAtPos(0, 8);\r
 137       case 41:\r
 138          return jjStopAtPos(0, 9);\r
 139       case 42:\r
 140          return jjStopAtPos(0, 20);\r
 141       case 44:\r
 142          return jjStopAtPos(0, 6);\r
 143       case 58:\r
 144          return jjStopAtPos(0, 5);\r
 145       case 59:\r
 146          return jjStopAtPos(0, 7);\r
 147       case 60:\r
 148          jjmatchedKind = 17;\r
 149          return jjMoveStringLiteralDfa1_0(0x80000L);\r
 150       case 61:\r
 151          return jjMoveStringLiteralDfa1_0(0x8000L);\r
 152       case 62:\r
 153          jjmatchedKind = 16;\r
 154          return jjMoveStringLiteralDfa1_0(0x40000L);\r
 155       case 65:\r
 156          return jjMoveStringLiteralDfa1_0(0x20000000000L);\r
 157       case 66:\r
 158          return jjMoveStringLiteralDfa1_0(0x400000000000L);\r
 159       case 67:\r
 160          return jjMoveStringLiteralDfa1_0(0x10502000000L);\r
 161       case 68:\r
 162          return jjMoveStringLiteralDfa1_0(0x10000000L);\r
 163       case 69:\r
 164          return jjMoveStringLiteralDfa1_0(0x800800000000L);\r
 165       case 70:\r
 166          return jjMoveStringLiteralDfa1_0(0x81000000000L);\r
 167       case 73:\r
 168          return jjMoveStringLiteralDfa1_0(0x4000000L);\r
 169       case 77:\r
 170          return jjMoveStringLiteralDfa1_0(0x2000000000L);\r
 171       case 78:\r
 172          return jjMoveStringLiteralDfa1_0(0x40000000L);\r
 173       case 79:\r
 174          return jjMoveStringLiteralDfa1_0(0x4000000000L);\r
 175       case 80:\r
 176          return jjMoveStringLiteralDfa1_0(0x100200000000L);\r
 177       case 81:\r
 178          return jjMoveStringLiteralDfa1_0(0x40000000000L);\r
 179       case 84:\r
 180          return jjMoveStringLiteralDfa1_0(0x208080000000L);\r
 181       case 85:\r
 182          return jjMoveStringLiteralDfa1_0(0x28000000L);\r
 183       case 91:\r
 184          return jjStopAtPos(0, 10);\r
 185       case 93:\r
 186          return jjStopAtPos(0, 11);\r
 187       case 99:\r
 188          return jjMoveStringLiteralDfa1_0(0x2000000000000L);\r
 189       case 102:\r
 190          return jjMoveStringLiteralDfa1_0(0x4000000000000L);\r
 191       case 110:\r
 192          return jjMoveStringLiteralDfa1_0(0x1000000000000L);\r
 193       case 111:\r
 194          return jjMoveStringLiteralDfa1_0(0x8000000000000L);\r
 195       case 124:\r
 196          return jjMoveStringLiteralDfa1_0(0x2000L);\r
 197       default :\r
 198          return jjMoveNfa_0(0, 0);\r
 199    }\r
 200 }\r
 201 static private int jjMoveStringLiteralDfa1_0(long active0)\r
 202 {\r
 203    try { curChar = input_stream.readChar(); }\r
 204    catch(java.io.IOException e) {\r
 205       jjStopStringLiteralDfa_0(0, active0);\r
 206       return 1;\r
 207    }\r
 208    switch(curChar)\r
 209    {\r
 210       case 38:\r
 211          if ((active0 & 0x1000L) != 0L)\r
 212             return jjStopAtPos(1, 12);\r
 213          break;\r
 214       case 61:\r
 215          if ((active0 & 0x8000L) != 0L)\r
 216             return jjStopAtPos(1, 15);\r
 217          else if ((active0 & 0x40000L) != 0L)\r
 218             return jjStopAtPos(1, 18);\r
 219          else if ((active0 & 0x80000L) != 0L)\r
 220             return jjStopAtPos(1, 19);\r
 221          break;\r
 222       case 69:\r
 223          return jjMoveStringLiteralDfa2_0(active0, 0x10000000L);\r
 224       case 77:\r
 225          return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);\r
 226       case 80:\r
 227          return jjMoveStringLiteralDfa2_0(active0, 0x8000000L);\r
 228       case 82:\r
 229          return jjMoveStringLiteralDfa2_0(active0, 0x2000000L);\r
 230       case 97:\r
 231          return jjMoveStringLiteralDfa2_0(active0, 0xa000000000L);\r
 232       case 99:\r
 233          return jjMoveStringLiteralDfa2_0(active0, 0x20000000000L);\r
 234       case 101:\r
 235          return jjMoveStringLiteralDfa2_0(active0, 0x400000000000L);\r
 236       case 108:\r
 237          return jjMoveStringLiteralDfa2_0(active0, 0x4001000000000L);\r
 238       case 110:\r
 239          return jjMoveStringLiteralDfa2_0(active0, 0x800800000000L);\r
 240       case 111:\r
 241          return jjMoveStringLiteralDfa2_0(active0, 0x3010540000000L);\r
 242       case 112:\r
 243          return jjMoveStringLiteralDfa2_0(active0, 0x8004000000000L);\r
 244       case 114:\r
 245          return jjMoveStringLiteralDfa2_0(active0, 0x380200000000L);\r
 246       case 115:\r
 247          return jjMoveStringLiteralDfa2_0(active0, 0x20000000L);\r
 248       case 117:\r
 249          return jjMoveStringLiteralDfa2_0(active0, 0x40000000000L);\r
 250       case 121:\r
 251          return jjMoveStringLiteralDfa2_0(active0, 0x80000000L);\r
 252       case 124:\r
 253          if ((active0 & 0x2000L) != 0L)\r
 254             return jjStopAtPos(1, 13);\r
 255          break;\r
 256       default :\r
 257          break;\r
 258    }\r
 259    return jjStartNfa_0(0, active0);\r
 260 }\r
 261 static private int jjMoveStringLiteralDfa2_0(long old0, long active0)\r
 262 {\r
 263    if (((active0 &= old0)) == 0L)\r
 264       return jjStartNfa_0(0, old0);\r
 265    try { curChar = input_stream.readChar(); }\r
 266    catch(java.io.IOException e) {\r
 267       jjStopStringLiteralDfa_0(1, active0);\r
 268       return 2;\r
 269    }\r
 270    switch(curChar)\r
 271    {\r
 272       case 68:\r
 273          return jjMoveStringLiteralDfa3_0(active0, 0x8000000L);\r
 274       case 69:\r
 275          return jjMoveStringLiteralDfa3_0(active0, 0x2000000L);\r
 276       case 76:\r
 277          return jjMoveStringLiteralDfa3_0(active0, 0x10000000L);\r
 278       case 80:\r
 279          return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);\r
 280       case 97:\r
 281          return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L);\r
 282       case 100:\r
 283          if ((active0 & 0x800000000000L) != 0L)\r
 284          {\r
 285             jjmatchedKind = 47;\r
 286             jjmatchedPos = 2;\r
 287          }\r
 288          return jjMoveStringLiteralDfa3_0(active0, 0x1000840000000L);\r
 289       case 101:\r
 290          return jjMoveStringLiteralDfa3_0(active0, 0x8044020000000L);\r
 291       case 103:\r
 292          return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L);\r
 293       case 105:\r
 294          return jjMoveStringLiteralDfa3_0(active0, 0x100000000000L);\r
 295       case 110:\r
 296          return jjMoveStringLiteralDfa3_0(active0, 0x2010500000000L);\r
 297       case 111:\r
 298          return jjMoveStringLiteralDfa3_0(active0, 0x4081200000000L);\r
 299       case 112:\r
 300          return jjMoveStringLiteralDfa3_0(active0, 0x80000000L);\r
 301       case 114:\r
 302          return jjMoveStringLiteralDfa3_0(active0, 0x8000000000L);\r
 303       case 116:\r
 304          return jjMoveStringLiteralDfa3_0(active0, 0x22000000000L);\r
 305       default :\r
 306          break;\r
 307    }\r
 308    return jjStartNfa_0(1, active0);\r
 309 }\r
 310 static private int jjMoveStringLiteralDfa3_0(long old0, long active0)\r
 311 {\r
 312    if (((active0 &= old0)) == 0L)\r
 313       return jjStartNfa_0(1, old0);\r
 314    try { curChar = input_stream.readChar(); }\r
 315    catch(java.io.IOException e) {\r
 316       jjStopStringLiteralDfa_0(2, active0);\r
 317       return 3;\r
 318    }\r
 319    switch(curChar)\r
 320    {\r
 321       case 65:\r
 322          return jjMoveStringLiteralDfa4_0(active0, 0xa000000L);\r
 323       case 69:\r
 324          return jjMoveStringLiteralDfa4_0(active0, 0x10000000L);\r
 325       case 79:\r
 326          return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);\r
 327       case 99:\r
 328          return jjMoveStringLiteralDfa4_0(active0, 0x2000000000L);\r
 329       case 100:\r
 330          return jjMoveStringLiteralDfa4_0(active0, 0x10000000000L);\r
 331       case 101:\r
 332          if ((active0 & 0x40000000L) != 0L)\r
 333             return jjStopAtPos(3, 30);\r
 334          else if ((active0 & 0x80000000L) != 0L)\r
 335             return jjStopAtPos(3, 31);\r
 336          return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000L);\r
 337       case 103:\r
 338          return jjMoveStringLiteralDfa4_0(active0, 0x8000000000L);\r
 339       case 105:\r
 340          return jjMoveStringLiteralDfa4_0(active0, 0x420000000000L);\r
 341       case 109:\r
 342          if ((active0 & 0x80000000000L) != 0L)\r
 343             return jjStopAtPos(3, 43);\r
 344          break;\r
 345       case 110:\r
 346          return jjMoveStringLiteralDfa4_0(active0, 0x2200c00000000L);\r
 347       case 111:\r
 348          return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L);\r
 349       case 112:\r
 350          return jjMoveStringLiteralDfa4_0(active0, 0x200000000L);\r
 351       case 114:\r
 352          if ((active0 & 0x20000000L) != 0L)\r
 353             return jjStopAtPos(3, 29);\r
 354          return jjMoveStringLiteralDfa4_0(active0, 0x8044000000000L);\r
 355       case 116:\r
 356          return jjMoveStringLiteralDfa4_0(active0, 0x100000000L);\r
 357       case 119:\r
 358          if ((active0 & 0x1000000000L) != 0L)\r
 359             return jjStopAtPos(3, 36);\r
 360          return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L);\r
 361       default :\r
 362          break;\r
 363    }\r
 364    return jjStartNfa_0(2, active0);\r
 365 }\r
 366 static private int jjMoveStringLiteralDfa4_0(long old0, long active0)\r
 367 {\r
 368    if (((active0 &= old0)) == 0L)\r
 369       return jjStartNfa_0(2, old0);\r
 370    try { curChar = input_stream.readChar(); }\r
 371    catch(java.io.IOException e) {\r
 372       jjStopStringLiteralDfa_0(3, active0);\r
 373       return 4;\r
 374    }\r
 375    switch(curChar)\r
 376    {\r
 377       case 82:\r
 378          return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);\r
 379       case 84:\r
 380          return jjMoveStringLiteralDfa5_0(active0, 0x1a000000L);\r
 381       case 97:\r
 382          return jjMoveStringLiteralDfa5_0(active0, 0x8004100000000L);\r
 383       case 101:\r
 384          return jjMoveStringLiteralDfa5_0(active0, 0x2008600000000L);\r
 385       case 104:\r
 386          if ((active0 & 0x2000000000L) != 0L)\r
 387             return jjStopAtPos(4, 37);\r
 388          break;\r
 389       case 105:\r
 390          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000L);\r
 391       case 110:\r
 392          if ((active0 & 0x400000000000L) != 0L)\r
 393             return jjStopAtPos(4, 46);\r
 394          break;\r
 395       case 111:\r
 396          return jjMoveStringLiteralDfa5_0(active0, 0x20800000000L);\r
 397       case 114:\r
 398          return jjMoveStringLiteralDfa5_0(active0, 0x100000000000L);\r
 399       case 115:\r
 400          if ((active0 & 0x1000000000000L) != 0L)\r
 401             return jjStartNfaWithStates_0(4, 48, 203);\r
 402          else if ((active0 & 0x4000000000000L) != 0L)\r
 403             return jjStartNfaWithStates_0(4, 50, 203);\r
 404          return jjMoveStringLiteralDfa5_0(active0, 0x200000000000L);\r
 405       case 121:\r
 406          if ((active0 & 0x40000000000L) != 0L)\r
 407             return jjStopAtPos(4, 42);\r
 408          break;\r
 409       default :\r
 410          break;\r
 411    }\r
 412    return jjStartNfa_0(3, active0);\r
 413 }\r
 414 static private int jjMoveStringLiteralDfa5_0(long old0, long active0)\r
 415 {\r
 416    if (((active0 &= old0)) == 0L)\r
 417       return jjStartNfa_0(3, old0);\r
 418    try { curChar = input_stream.readChar(); }\r
 419    catch(java.io.IOException e) {\r
 420       jjStopStringLiteralDfa_0(4, active0);\r
 421       return 5;\r
 422    }\r
 423    switch(curChar)\r
 424    {\r
 425       case 69:\r
 426          if ((active0 & 0x2000000L) != 0L)\r
 427             return jjStopAtPos(5, 25);\r
 428          else if ((active0 & 0x8000000L) != 0L)\r
 429             return jjStopAtPos(5, 27);\r
 430          else if ((active0 & 0x10000000L) != 0L)\r
 431             return jjStopAtPos(5, 28);\r
 432          break;\r
 433       case 84:\r
 434          if ((active0 & 0x4000000L) != 0L)\r
 435             return jjStopAtPos(5, 26);\r
 436          break;\r
 437       case 97:\r
 438          return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);\r
 439       case 99:\r
 440          return jjMoveStringLiteralDfa6_0(active0, 0x2000400000000L);\r
 441       case 100:\r
 442          return jjMoveStringLiteralDfa6_0(active0, 0x800000000L);\r
 443       case 105:\r
 444          return jjMoveStringLiteralDfa6_0(active0, 0x100100000000L);\r
 445       case 110:\r
 446          if ((active0 & 0x20000000000L) != 0L)\r
 447             return jjStopAtPos(5, 41);\r
 448          break;\r
 449       case 114:\r
 450          return jjMoveStringLiteralDfa6_0(active0, 0x200000000L);\r
 451       case 116:\r
 452          if ((active0 & 0x8000000000L) != 0L)\r
 453             return jjStopAtPos(5, 39);\r
 454          return jjMoveStringLiteralDfa6_0(active0, 0x8014000000000L);\r
 455       default :\r
 456          break;\r
 457    }\r
 458    return jjStartNfa_0(4, active0);\r
 459 }\r
 460 static private int jjMoveStringLiteralDfa6_0(long old0, long active0)\r
 461 {\r
 462    if (((active0 &= old0)) == 0L)\r
 463       return jjStartNfa_0(4, old0);\r
 464    try { curChar = input_stream.readChar(); }\r
 465    catch(java.io.IOException e) {\r
 466       jjStopStringLiteralDfa_0(5, active0);\r
 467       return 6;\r
 468    }\r
 469    switch(curChar)\r
 470    {\r
 471       case 99:\r
 472          return jjMoveStringLiteralDfa7_0(active0, 0x200000000000L);\r
 473       case 101:\r
 474          return jjMoveStringLiteralDfa7_0(active0, 0x800000000L);\r
 475       case 105:\r
 476          return jjMoveStringLiteralDfa7_0(active0, 0x8014000000000L);\r
 477       case 110:\r
 478          if ((active0 & 0x100000000L) != 0L)\r
 479             return jjStopAtPos(6, 32);\r
 480          break;\r
 481       case 116:\r
 482          return jjMoveStringLiteralDfa7_0(active0, 0x2100600000000L);\r
 483       default :\r
 484          break;\r
 485    }\r
 486    return jjStartNfa_0(5, active0);\r
 487 }\r
 488 static private int jjMoveStringLiteralDfa7_0(long old0, long active0)\r
 489 {\r
 490    if (((active0 &= old0)) == 0L)\r
 491       return jjStartNfa_0(5, old0);\r
 492    try { curChar = input_stream.readChar(); }\r
 493    catch(java.io.IOException e) {\r
 494       jjStopStringLiteralDfa_0(6, active0);\r
 495       return 7;\r
 496    }\r
 497    switch(curChar)\r
 498    {\r
 499       case 105:\r
 500          return jjMoveStringLiteralDfa8_0(active0, 0x2000400000000L);\r
 501       case 111:\r
 502          return jjMoveStringLiteralDfa8_0(active0, 0x8014000000000L);\r
 503       case 115:\r
 504          if ((active0 & 0x800000000L) != 0L)\r
 505             return jjStopAtPos(7, 35);\r
 506          break;\r
 507       case 116:\r
 508          return jjMoveStringLiteralDfa8_0(active0, 0x200000000000L);\r
 509       case 121:\r
 510          if ((active0 & 0x200000000L) != 0L)\r
 511             return jjStopAtPos(7, 33);\r
 512          else if ((active0 & 0x100000000000L) != 0L)\r
 513             return jjStopAtPos(7, 44);\r
 514          break;\r
 515       default :\r
 516          break;\r
 517    }\r
 518    return jjStartNfa_0(6, active0);\r
 519 }\r
 520 static private int jjMoveStringLiteralDfa8_0(long old0, long active0)\r
 521 {\r
 522    if (((active0 &= old0)) == 0L)\r
 523       return jjStartNfa_0(6, old0);\r
 524    try { curChar = input_stream.readChar(); }\r
 525    catch(java.io.IOException e) {\r
 526       jjStopStringLiteralDfa_0(7, active0);\r
 527       return 8;\r
 528    }\r
 529    switch(curChar)\r
 530    {\r
 531       case 105:\r
 532          return jjMoveStringLiteralDfa9_0(active0, 0x200000000000L);\r
 533       case 110:\r
 534          if ((active0 & 0x4000000000L) != 0L)\r
 535             return jjStopAtPos(8, 38);\r
 536          else if ((active0 & 0x10000000000L) != 0L)\r
 537             return jjStopAtPos(8, 40);\r
 538          return jjMoveStringLiteralDfa9_0(active0, 0x8000000000000L);\r
 539       case 111:\r
 540          return jjMoveStringLiteralDfa9_0(active0, 0x2000400000000L);\r
 541       default :\r
 542          break;\r
 543    }\r
 544    return jjStartNfa_0(7, active0);\r
 545 }\r
 546 static private int jjMoveStringLiteralDfa9_0(long old0, long active0)\r
 547 {\r
 548    if (((active0 &= old0)) == 0L)\r
 549       return jjStartNfa_0(7, old0);\r
 550    try { curChar = input_stream.readChar(); }\r
 551    catch(java.io.IOException e) {\r
 552       jjStopStringLiteralDfa_0(8, active0);\r
 553       return 9;\r
 554    }\r
 555    switch(curChar)\r
 556    {\r
 557       case 110:\r
 558          if ((active0 & 0x400000000L) != 0L)\r
 559             return jjStopAtPos(9, 34);\r
 560          return jjMoveStringLiteralDfa10_0(active0, 0x2000000000000L);\r
 561       case 111:\r
 562          return jjMoveStringLiteralDfa10_0(active0, 0x200000000000L);\r
 563       case 115:\r
 564          if ((active0 & 0x8000000000000L) != 0L)\r
 565             return jjStartNfaWithStates_0(9, 51, 203);\r
 566          break;\r
 567       default :\r
 568          break;\r
 569    }\r
 570    return jjStartNfa_0(8, active0);\r
 571 }\r
 572 static private int jjMoveStringLiteralDfa10_0(long old0, long active0)\r
 573 {\r
 574    if (((active0 &= old0)) == 0L)\r
 575       return jjStartNfa_0(8, old0);\r
 576    try { curChar = input_stream.readChar(); }\r
 577    catch(java.io.IOException e) {\r
 578       jjStopStringLiteralDfa_0(9, active0);\r
 579       return 10;\r
 580    }\r
 581    switch(curChar)\r
 582    {\r
 583       case 110:\r
 584          if ((active0 & 0x200000000000L) != 0L)\r
 585             return jjStopAtPos(10, 45);\r
 586          break;\r
 587       case 115:\r
 588          if ((active0 & 0x2000000000000L) != 0L)\r
 589             return jjStartNfaWithStates_0(10, 49, 203);\r
 590          break;\r
 591       default :\r
 592          break;\r
 593    }\r
 594    return jjStartNfa_0(9, active0);\r
 595 }\r
 596 static private int jjStartNfaWithStates_0(int pos, int kind, int state)\r
 597 {\r
 598    jjmatchedKind = kind;\r
 599    jjmatchedPos = pos;\r
 600    try { curChar = input_stream.readChar(); }\r
 601    catch(java.io.IOException e) { return pos + 1; }\r
 602    return jjMoveNfa_0(state, pos + 1);\r
 603 }\r
 604 static private int jjMoveNfa_0(int startState, int curPos)\r
 605 {\r
 606    int startsAt = 0;\r
 607    jjnewStateCnt = 203;\r
 608    int i = 1;\r
 609    jjstateSet[0] = startState;\r
 610    int kind = 0x7fffffff;\r
 611    for (;;)\r
 612    {\r
 613       if (++jjround == 0x7fffffff)\r
 614          ReInitRounds();\r
 615       if (curChar < 64)\r
 616       {\r
 617          long l = 1L << curChar;\r
 618          do\r
 619          {\r
 620             switch(jjstateSet[--i])\r
 621             {\r
 622                case 84:\r
 623                   if ((0x3ff200000000000L & l) != 0L)\r
 624                      jjCheckNAddTwoStates(1, 2);\r
 625                   if ((0x3ff000000000000L & l) != 0L)\r
 626                      jjstateSet[jjnewStateCnt++] = 107;\r
 627                   if ((0x3ff000000000000L & l) != 0L)\r
 628                      jjstateSet[jjnewStateCnt++] = 85;\r
 629                   if ((0x3ff000000000000L & l) != 0L)\r
 630                   {\r
 631                      if (kind > 53)\r
 632                         kind = 53;\r
 633                      jjCheckNAdd(2);\r
 634                   }\r
 635                   break;\r
 636                case 203:\r
 637                   if ((0x3ff200000000000L & l) != 0L)\r
 638                      jjCheckNAddTwoStates(1, 2);\r
 639                   if ((0x3ff000000000000L & l) != 0L)\r
 640                   {\r
 641                      if (kind > 53)\r
 642                         kind = 53;\r
 643                      jjCheckNAdd(2);\r
 644                   }\r
 645                   break;\r
 646                case 0:\r
 647                   if ((0x3ff000000000000L & l) != 0L)\r
 648                      jjCheckNAddStates(0, 4);\r
 649                   if ((0x3ff000000000000L & l) != 0L)\r
 650                      jjAddStates(5, 6);\r
 651                   if ((0x3fe000000000000L & l) != 0L)\r
 652                   {\r
 653                      if (kind > 52)\r
 654                         kind = 52;\r
 655                      jjCheckNAddStates(7, 9);\r
 656                   }\r
 657                   else if (curChar == 48)\r
 658                   {\r
 659                      if (kind > 52)\r
 660                         kind = 52;\r
 661                      jjCheckNAdd(4);\r
 662                   }\r
 663                   if (curChar == 50)\r
 664                      jjAddStates(10, 11);\r
 665                   else if (curChar == 49)\r
 666                      jjCheckNAddStates(12, 14);\r
 667                   if (curChar == 50)\r
 668                      jjAddStates(15, 17);\r
 669                   break;\r
 670                case 1:\r
 671                   if ((0x3ff200000000000L & l) != 0L)\r
 672                      jjCheckNAddTwoStates(1, 2);\r
 673                   break;\r
 674                case 2:\r
 675                   if ((0x3ff000000000000L & l) == 0L)\r
 676                      break;\r
 677                   if (kind > 53)\r
 678                      kind = 53;\r
 679                   jjCheckNAdd(2);\r
 680                   break;\r
 681                case 3:\r
 682                   if (curChar != 48)\r
 683                      break;\r
 684                   if (kind > 52)\r
 685                      kind = 52;\r
 686                   jjCheckNAdd(4);\r
 687                   break;\r
 688                case 4:\r
 689                   if ((0x3ff000000000000L & l) != 0L)\r
 690                      jjCheckNAdd(5);\r
 691                   break;\r
 692                case 5:\r
 693                   if (curChar == 58)\r
 694                      jjCheckNAddStates(18, 20);\r
 695                   break;\r
 696                case 6:\r
 697                   if (curChar == 48)\r
 698                      jjCheckNAdd(7);\r
 699                   break;\r
 700                case 7:\r
 701                   if ((0x3ff000000000000L & l) != 0L)\r
 702                      jjstateSet[jjnewStateCnt++] = 8;\r
 703                   break;\r
 704                case 8:\r
 705                   if (curChar == 58)\r
 706                      jjCheckNAddStates(21, 23);\r
 707                   break;\r
 708                case 9:\r
 709                   if (curChar == 48)\r
 710                      jjCheckNAdd(10);\r
 711                   break;\r
 712                case 10:\r
 713                   if ((0x3ff000000000000L & l) != 0L && kind > 57)\r
 714                      kind = 57;\r
 715                   break;\r
 716                case 11:\r
 717                   if ((0x3e000000000000L & l) != 0L)\r
 718                      jjCheckNAdd(10);\r
 719                   break;\r
 720                case 12:\r
 721                   if ((0x3e000000000000L & l) != 0L)\r
 722                      jjCheckNAdd(7);\r
 723                   break;\r
 724                case 13:\r
 725                   if ((0x3fe000000000000L & l) == 0L)\r
 726                      break;\r
 727                   if (kind > 52)\r
 728                      kind = 52;\r
 729                   jjCheckNAddStates(7, 9);\r
 730                   break;\r
 731                case 14:\r
 732                   if ((0x3ff000000000000L & l) == 0L)\r
 733                      break;\r
 734                   if (kind > 52)\r
 735                      kind = 52;\r
 736                   jjCheckNAdd(14);\r
 737                   break;\r
 738                case 15:\r
 739                   if ((0x3ff000000000000L & l) != 0L)\r
 740                      jjCheckNAdd(16);\r
 741                   break;\r
 742                case 16:\r
 743                   if (curChar == 46)\r
 744                      jjCheckNAddStates(24, 28);\r
 745                   break;\r
 746                case 17:\r
 747                   if ((0x3ff000000000000L & l) != 0L)\r
 748                      jjCheckNAdd(18);\r
 749                   break;\r
 750                case 18:\r
 751                   if (curChar == 46)\r
 752                      jjCheckNAddStates(29, 33);\r
 753                   break;\r
 754                case 19:\r
 755                   if ((0x3ff000000000000L & l) != 0L)\r
 756                      jjCheckNAdd(20);\r
 757                   break;\r
 758                case 20:\r
 759                   if (curChar == 46)\r
 760                      jjCheckNAddStates(34, 38);\r
 761                   break;\r
 762                case 21:\r
 763                   if ((0x3ff000000000000L & l) == 0L)\r
 764                      break;\r
 765                   if (kind > 55)\r
 766                      kind = 55;\r
 767                   jjCheckNAdd(22);\r
 768                   break;\r
 769                case 22:\r
 770                   if (curChar == 47)\r
 771                      jjAddStates(39, 41);\r
 772                   break;\r
 773                case 23:\r
 774                   if ((0x3fe000000000000L & l) != 0L && kind > 55)\r
 775                      kind = 55;\r
 776                   break;\r
 777                case 24:\r
 778                   if ((0x6000000000000L & l) != 0L)\r
 779                      jjstateSet[jjnewStateCnt++] = 25;\r
 780                   break;\r
 781                case 25:\r
 782                   if ((0x3ff000000000000L & l) != 0L && kind > 55)\r
 783                      kind = 55;\r
 784                   break;\r
 785                case 26:\r
 786                   if (curChar == 51)\r
 787                      jjstateSet[jjnewStateCnt++] = 27;\r
 788                   break;\r
 789                case 27:\r
 790                   if ((0x7000000000000L & l) != 0L && kind > 55)\r
 791                      kind = 55;\r
 792                   break;\r
 793                case 28:\r
 794                   if ((0x3fe000000000000L & l) != 0L)\r
 795                      jjCheckNAdd(21);\r
 796                   break;\r
 797                case 29:\r
 798                   if (curChar == 49)\r
 799                      jjstateSet[jjnewStateCnt++] = 30;\r
 800                   break;\r
 801                case 30:\r
 802                   if ((0x3ff000000000000L & l) != 0L)\r
 803                      jjCheckNAdd(21);\r
 804                   break;\r
 805                case 31:\r
 806                   if (curChar == 50)\r
 807                      jjstateSet[jjnewStateCnt++] = 32;\r
 808                   break;\r
 809                case 32:\r
 810                   if ((0x1f000000000000L & l) != 0L)\r
 811                      jjCheckNAdd(21);\r
 812                   break;\r
 813                case 33:\r
 814                   if (curChar == 53)\r
 815                      jjstateSet[jjnewStateCnt++] = 34;\r
 816                   break;\r
 817                case 34:\r
 818                   if ((0x3f000000000000L & l) == 0L)\r
 819                      break;\r
 820                   if (kind > 55)\r
 821                      kind = 55;\r
 822                   jjCheckNAdd(22);\r
 823                   break;\r
 824                case 35:\r
 825                   if (curChar == 50)\r
 826                      jjstateSet[jjnewStateCnt++] = 33;\r
 827                   break;\r
 828                case 36:\r
 829                   if ((0x3fe000000000000L & l) != 0L)\r
 830                      jjCheckNAdd(19);\r
 831                   break;\r
 832                case 37:\r
 833                   if (curChar == 49)\r
 834                      jjstateSet[jjnewStateCnt++] = 38;\r
 835                   break;\r
 836                case 38:\r
 837                   if ((0x3ff000000000000L & l) != 0L)\r
 838                      jjCheckNAdd(19);\r
 839                   break;\r
 840                case 39:\r
 841                   if (curChar == 50)\r
 842                      jjstateSet[jjnewStateCnt++] = 40;\r
 843                   break;\r
 844                case 40:\r
 845                   if ((0x1f000000000000L & l) != 0L)\r
 846                      jjCheckNAdd(19);\r
 847                   break;\r
 848                case 41:\r
 849                   if (curChar == 53)\r
 850                      jjstateSet[jjnewStateCnt++] = 42;\r
 851                   break;\r
 852                case 42:\r
 853                   if ((0x3f000000000000L & l) != 0L)\r
 854                      jjCheckNAdd(20);\r
 855                   break;\r
 856                case 43:\r
 857                   if (curChar == 50)\r
 858                      jjstateSet[jjnewStateCnt++] = 41;\r
 859                   break;\r
 860                case 44:\r
 861                   if ((0x3fe000000000000L & l) != 0L)\r
 862                      jjCheckNAdd(17);\r
 863                   break;\r
 864                case 45:\r
 865                   if (curChar == 49)\r
 866                      jjstateSet[jjnewStateCnt++] = 46;\r
 867                   break;\r
 868                case 46:\r
 869                   if ((0x3ff000000000000L & l) != 0L)\r
 870                      jjCheckNAdd(17);\r
 871                   break;\r
 872                case 47:\r
 873                   if (curChar == 50)\r
 874                      jjstateSet[jjnewStateCnt++] = 48;\r
 875                   break;\r
 876                case 48:\r
 877                   if ((0x1f000000000000L & l) != 0L)\r
 878                      jjCheckNAdd(17);\r
 879                   break;\r
 880                case 49:\r
 881                   if (curChar == 53)\r
 882                      jjstateSet[jjnewStateCnt++] = 50;\r
 883                   break;\r
 884                case 50:\r
 885                   if ((0x3f000000000000L & l) != 0L)\r
 886                      jjCheckNAdd(18);\r
 887                   break;\r
 888                case 51:\r
 889                   if (curChar == 50)\r
 890                      jjstateSet[jjnewStateCnt++] = 49;\r
 891                   break;\r
 892                case 52:\r
 893                   if ((0x3ff000000000000L & l) != 0L)\r
 894                      jjCheckNAdd(53);\r
 895                   break;\r
 896                case 53:\r
 897                   if (curChar == 46)\r
 898                      jjCheckNAddStates(42, 46);\r
 899                   break;\r
 900                case 54:\r
 901                   if ((0x3ff000000000000L & l) != 0L)\r
 902                      jjCheckNAdd(55);\r
 903                   break;\r
 904                case 55:\r
 905                   if (curChar == 46)\r
 906                      jjCheckNAddStates(47, 51);\r
 907                   break;\r
 908                case 56:\r
 909                   if ((0x3ff000000000000L & l) != 0L)\r
 910                      jjCheckNAdd(57);\r
 911                   break;\r
 912                case 57:\r
 913                   if (curChar == 46)\r
 914                      jjCheckNAddStates(52, 56);\r
 915                   break;\r
 916                case 58:\r
 917                   if ((0x3ff000000000000L & l) != 0L && kind > 60)\r
 918                      kind = 60;\r
 919                   break;\r
 920                case 59:\r
 921                   if ((0x3fe000000000000L & l) != 0L)\r
 922                      jjCheckNAdd(58);\r
 923                   break;\r
 924                case 60:\r
 925                   if (curChar == 49)\r
 926                      jjstateSet[jjnewStateCnt++] = 61;\r
 927                   break;\r
 928                case 61:\r
 929                   if ((0x3ff000000000000L & l) != 0L)\r
 930                      jjCheckNAdd(58);\r
 931                   break;\r
 932                case 62:\r
 933                   if (curChar == 50)\r
 934                      jjstateSet[jjnewStateCnt++] = 63;\r
 935                   break;\r
 936                case 63:\r
 937                   if ((0x1f000000000000L & l) != 0L)\r
 938                      jjCheckNAdd(58);\r
 939                   break;\r
 940                case 64:\r
 941                   if (curChar == 53)\r
 942                      jjstateSet[jjnewStateCnt++] = 65;\r
 943                   break;\r
 944                case 65:\r
 945                   if ((0x3f000000000000L & l) != 0L && kind > 60)\r
 946                      kind = 60;\r
 947                   break;\r
 948                case 66:\r
 949                   if (curChar == 50)\r
 950                      jjstateSet[jjnewStateCnt++] = 64;\r
 951                   break;\r
 952                case 67:\r
 953                   if ((0x3fe000000000000L & l) != 0L)\r
 954                      jjCheckNAdd(56);\r
 955                   break;\r
 956                case 68:\r
 957                   if (curChar == 49)\r
 958                      jjstateSet[jjnewStateCnt++] = 69;\r
 959                   break;\r
 960                case 69:\r
 961                   if ((0x3ff000000000000L & l) != 0L)\r
 962                      jjCheckNAdd(56);\r
 963                   break;\r
 964                case 70:\r
 965                   if (curChar == 50)\r
 966                      jjstateSet[jjnewStateCnt++] = 71;\r
 967                   break;\r
 968                case 71:\r
 969                   if ((0x1f000000000000L & l) != 0L)\r
 970                      jjCheckNAdd(56);\r
 971                   break;\r
 972                case 72:\r
 973                   if (curChar == 53)\r
 974                      jjstateSet[jjnewStateCnt++] = 73;\r
 975                   break;\r
 976                case 73:\r
 977                   if ((0x3f000000000000L & l) != 0L)\r
 978                      jjCheckNAdd(57);\r
 979                   break;\r
 980                case 74:\r
 981                   if (curChar == 50)\r
 982                      jjstateSet[jjnewStateCnt++] = 72;\r
 983                   break;\r
 984                case 75:\r
 985                   if ((0x3fe000000000000L & l) != 0L)\r
 986                      jjCheckNAdd(54);\r
 987                   break;\r
 988                case 76:\r
 989                   if (curChar == 49)\r
 990                      jjstateSet[jjnewStateCnt++] = 77;\r
 991                   break;\r
 992                case 77:\r
 993                   if ((0x3ff000000000000L & l) != 0L)\r
 994                      jjCheckNAdd(54);\r
 995                   break;\r
 996                case 78:\r
 997                   if (curChar == 50)\r
 998                      jjstateSet[jjnewStateCnt++] = 79;\r
 999                   break;\r
1000                case 79:\r
1001                   if ((0x1f000000000000L & l) != 0L)\r
1002                      jjCheckNAdd(54);\r
1003                   break;\r
1004                case 80:\r
1005                   if (curChar == 53)\r
1006                      jjstateSet[jjnewStateCnt++] = 81;\r
1007                   break;\r
1008                case 81:\r
1009                   if ((0x3f000000000000L & l) != 0L)\r
1010                      jjCheckNAdd(55);\r
1011                   break;\r
1012                case 82:\r
1013                   if (curChar == 50)\r
1014                      jjstateSet[jjnewStateCnt++] = 80;\r
1015                   break;\r
1016                case 83:\r
1017                   if ((0x3ff000000000000L & l) != 0L)\r
1018                      jjAddStates(5, 6);\r
1019                   break;\r
1020                case 85:\r
1021                   if (curChar == 58)\r
1022                      jjstateSet[jjnewStateCnt++] = 86;\r
1023                   break;\r
1024                case 86:\r
1025                   if ((0x3ff000000000000L & l) != 0L)\r
1026                      jjstateSet[jjnewStateCnt++] = 87;\r
1027                   break;\r
1028                case 87:\r
1029                   if ((0x3ff000000000000L & l) != 0L)\r
1030                      jjstateSet[jjnewStateCnt++] = 88;\r
1031                   break;\r
1032                case 88:\r
1033                   if (curChar == 58)\r
1034                      jjstateSet[jjnewStateCnt++] = 89;\r
1035                   break;\r
1036                case 89:\r
1037                   if ((0x3ff000000000000L & l) != 0L)\r
1038                      jjstateSet[jjnewStateCnt++] = 90;\r
1039                   break;\r
1040                case 90:\r
1041                   if ((0x3ff000000000000L & l) != 0L)\r
1042                      jjstateSet[jjnewStateCnt++] = 91;\r
1043                   break;\r
1044                case 91:\r
1045                   if (curChar == 58)\r
1046                      jjstateSet[jjnewStateCnt++] = 92;\r
1047                   break;\r
1048                case 92:\r
1049                   if ((0x3ff000000000000L & l) != 0L)\r
1050                      jjstateSet[jjnewStateCnt++] = 93;\r
1051                   break;\r
1052                case 93:\r
1053                   if ((0x3ff000000000000L & l) != 0L)\r
1054                      jjstateSet[jjnewStateCnt++] = 94;\r
1055                   break;\r
1056                case 94:\r
1057                   if (curChar == 58)\r
1058                      jjstateSet[jjnewStateCnt++] = 95;\r
1059                   break;\r
1060                case 95:\r
1061                   if ((0x3ff000000000000L & l) != 0L)\r
1062                      jjstateSet[jjnewStateCnt++] = 96;\r
1063                   break;\r
1064                case 96:\r
1065                   if ((0x3ff000000000000L & l) != 0L)\r
1066                      jjstateSet[jjnewStateCnt++] = 97;\r
1067                   break;\r
1068                case 97:\r
1069                   if (curChar == 58)\r
1070                      jjstateSet[jjnewStateCnt++] = 98;\r
1071                   break;\r
1072                case 98:\r
1073                   if ((0x3ff000000000000L & l) != 0L)\r
1074                      jjstateSet[jjnewStateCnt++] = 99;\r
1075                   break;\r
1076                case 99:\r
1077                   if ((0x3ff000000000000L & l) == 0L)\r
1078                      break;\r
1079                   if (kind > 54)\r
1080                      kind = 54;\r
1081                   jjstateSet[jjnewStateCnt++] = 100;\r
1082                   break;\r
1083                case 100:\r
1084                   if (curChar == 47)\r
1085                      jjAddStates(57, 59);\r
1086                   break;\r
1087                case 101:\r
1088                   if ((0x3fe000000000000L & l) != 0L && kind > 54)\r
1089                      kind = 54;\r
1090                   break;\r
1091                case 102:\r
1092                   if ((0xe000000000000L & l) != 0L)\r
1093                      jjstateSet[jjnewStateCnt++] = 103;\r
1094                   break;\r
1095                case 103:\r
1096                   if ((0x3ff000000000000L & l) != 0L && kind > 54)\r
1097                      kind = 54;\r
1098                   break;\r
1099                case 104:\r
1100                   if (curChar == 52)\r
1101                      jjstateSet[jjnewStateCnt++] = 105;\r
1102                   break;\r
1103                case 105:\r
1104                   if ((0x1ff000000000000L & l) != 0L && kind > 54)\r
1105                      kind = 54;\r
1106                   break;\r
1107                case 106:\r
1108                   if ((0x3ff000000000000L & l) != 0L)\r
1109                      jjstateSet[jjnewStateCnt++] = 107;\r
1110                   break;\r
1111                case 107:\r
1112                   if (curChar == 58)\r
1113                      jjstateSet[jjnewStateCnt++] = 108;\r
1114                   break;\r
1115                case 108:\r
1116                   if ((0x3ff000000000000L & l) != 0L)\r
1117                      jjstateSet[jjnewStateCnt++] = 109;\r
1118                   break;\r
1119                case 109:\r
1120                   if ((0x3ff000000000000L & l) != 0L)\r
1121                      jjstateSet[jjnewStateCnt++] = 110;\r
1122                   break;\r
1123                case 110:\r
1124                   if (curChar == 58)\r
1125                      jjstateSet[jjnewStateCnt++] = 111;\r
1126                   break;\r
1127                case 111:\r
1128                   if ((0x3ff000000000000L & l) != 0L)\r
1129                      jjstateSet[jjnewStateCnt++] = 112;\r
1130                   break;\r
1131                case 112:\r
1132                   if ((0x3ff000000000000L & l) != 0L)\r
1133                      jjstateSet[jjnewStateCnt++] = 113;\r
1134                   break;\r
1135                case 113:\r
1136                   if (curChar == 58)\r
1137                      jjstateSet[jjnewStateCnt++] = 114;\r
1138                   break;\r
1139                case 114:\r
1140                   if ((0x3ff000000000000L & l) != 0L)\r
1141                      jjstateSet[jjnewStateCnt++] = 115;\r
1142                   break;\r
1143                case 115:\r
1144                   if ((0x3ff000000000000L & l) != 0L)\r
1145                      jjstateSet[jjnewStateCnt++] = 116;\r
1146                   break;\r
1147                case 116:\r
1148                   if (curChar == 58)\r
1149                      jjstateSet[jjnewStateCnt++] = 117;\r
1150                   break;\r
1151                case 117:\r
1152                   if ((0x3ff000000000000L & l) != 0L)\r
1153                      jjstateSet[jjnewStateCnt++] = 118;\r
1154                   break;\r
1155                case 118:\r
1156                   if ((0x3ff000000000000L & l) != 0L)\r
1157                      jjstateSet[jjnewStateCnt++] = 119;\r
1158                   break;\r
1159                case 119:\r
1160                   if (curChar == 58)\r
1161                      jjstateSet[jjnewStateCnt++] = 120;\r
1162                   break;\r
1163                case 120:\r
1164                   if ((0x3ff000000000000L & l) != 0L)\r
1165                      jjstateSet[jjnewStateCnt++] = 121;\r
1166                   break;\r
1167                case 121:\r
1168                   if ((0x3ff000000000000L & l) != 0L && kind > 59)\r
1169                      kind = 59;\r
1170                   break;\r
1171                case 122:\r
1172                   if ((0x3ff000000000000L & l) != 0L)\r
1173                      jjCheckNAddStates(0, 4);\r
1174                   break;\r
1175                case 123:\r
1176                   if ((0x3ff000000000000L & l) != 0L)\r
1177                      jjstateSet[jjnewStateCnt++] = 124;\r
1178                   break;\r
1179                case 124:\r
1180                   if ((0x3ff000000000000L & l) != 0L)\r
1181                      jjstateSet[jjnewStateCnt++] = 125;\r
1182                   break;\r
1183                case 125:\r
1184                   if ((0x3ff000000000000L & l) != 0L)\r
1185                      jjstateSet[jjnewStateCnt++] = 126;\r
1186                   break;\r
1187                case 126:\r
1188                   if (curChar == 45)\r
1189                      jjCheckNAddStates(60, 64);\r
1190                   break;\r
1191                case 127:\r
1192                   if ((0x1aa000000000000L & l) != 0L)\r
1193                      jjCheckNAdd(128);\r
1194                   break;\r
1195                case 128:\r
1196                   if (curChar == 45)\r
1197                      jjCheckNAddStates(65, 68);\r
1198                   break;\r
1199                case 129:\r
1200                case 137:\r
1201                case 142:\r
1202                   if (curChar == 48)\r
1203                      jjCheckNAdd(130);\r
1204                   break;\r
1205                case 130:\r
1206                   if ((0x3fe000000000000L & l) != 0L && kind > 56)\r
1207                      kind = 56;\r
1208                   break;\r
1209                case 131:\r
1210                case 138:\r
1211                case 143:\r
1212                   if ((0x6000000000000L & l) != 0L)\r
1213                      jjCheckNAdd(132);\r
1214                   break;\r
1215                case 132:\r
1216                   if ((0x3ff000000000000L & l) != 0L && kind > 56)\r
1217                      kind = 56;\r
1218                   break;\r
1219                case 133:\r
1220                   if (curChar == 51)\r
1221                      jjstateSet[jjnewStateCnt++] = 134;\r
1222                   break;\r
1223                case 134:\r
1224                   if ((0x3000000000000L & l) != 0L && kind > 56)\r
1225                      kind = 56;\r
1226                   break;\r
1227                case 135:\r
1228                   if ((0x250000000000000L & l) != 0L)\r
1229                      jjCheckNAdd(136);\r
1230                   break;\r
1231                case 136:\r
1232                   if (curChar == 45)\r
1233                      jjCheckNAddStates(69, 72);\r
1234                   break;\r
1235                case 139:\r
1236                   if (curChar == 48 && kind > 56)\r
1237                      kind = 56;\r
1238                   break;\r
1239                case 140:\r
1240                   if (curChar == 51)\r
1241                      jjstateSet[jjnewStateCnt++] = 139;\r
1242                   break;\r
1243                case 141:\r
1244                   if (curChar == 45)\r
1245                      jjCheckNAddStates(73, 75);\r
1246                   break;\r
1247                case 144:\r
1248                   if (curChar == 50)\r
1249                      jjstateSet[jjnewStateCnt++] = 141;\r
1250                   break;\r
1251                case 145:\r
1252                   if (curChar == 48)\r
1253                      jjCheckNAddStates(76, 78);\r
1254                   break;\r
1255                case 146:\r
1256                   if (curChar == 49)\r
1257                      jjAddStates(79, 81);\r
1258                   break;\r
1259                case 147:\r
1260                   if (curChar == 48)\r
1261                      jjCheckNAdd(128);\r
1262                   break;\r
1263                case 148:\r
1264                   if (curChar == 50)\r
1265                      jjCheckNAdd(128);\r
1266                   break;\r
1267                case 149:\r
1268                   if (curChar == 49)\r
1269                      jjCheckNAdd(136);\r
1270                   break;\r
1271                case 150:\r
1272                   if ((0x3ff000000000000L & l) != 0L)\r
1273                      jjstateSet[jjnewStateCnt++] = 151;\r
1274                   break;\r
1275                case 151:\r
1276                   if ((0x3ff000000000000L & l) != 0L)\r
1277                      jjstateSet[jjnewStateCnt++] = 152;\r
1278                   break;\r
1279                case 152:\r
1280                   if ((0x3ff000000000000L & l) != 0L)\r
1281                      jjstateSet[jjnewStateCnt++] = 153;\r
1282                   break;\r
1283                case 153:\r
1284                   if (curChar == 45)\r
1285                      jjCheckNAddStates(82, 86);\r
1286                   break;\r
1287                case 154:\r
1288                   if ((0x1aa000000000000L & l) != 0L)\r
1289                      jjCheckNAdd(155);\r
1290                   break;\r
1291                case 155:\r
1292                   if (curChar == 45)\r
1293                      jjCheckNAddStates(87, 90);\r
1294                   break;\r
1295                case 156:\r
1296                case 178:\r
1297                case 183:\r
1298                   if (curChar == 48)\r
1299                      jjCheckNAdd(157);\r
1300                   break;\r
1301                case 157:\r
1302                   if ((0x3fe000000000000L & l) != 0L)\r
1303                      jjCheckNAdd(158);\r
1304                   break;\r
1305                case 158:\r
1306                   if (curChar == 44)\r
1307                      jjCheckNAddStates(91, 94);\r
1308                   break;\r
1309                case 159:\r
1310                   if (curChar == 48)\r
1311                      jjCheckNAdd(160);\r
1312                   break;\r
1313                case 160:\r
1314                   if ((0x3ff000000000000L & l) != 0L)\r
1315                      jjCheckNAdd(161);\r
1316                   break;\r
1317                case 161:\r
1318                   if (curChar == 58)\r
1319                      jjCheckNAddStates(95, 97);\r
1320                   break;\r
1321                case 162:\r
1322                   if (curChar == 48)\r
1323                      jjCheckNAdd(163);\r
1324                   break;\r
1325                case 163:\r
1326                   if ((0x3ff000000000000L & l) != 0L)\r
1327                      jjstateSet[jjnewStateCnt++] = 164;\r
1328                   break;\r
1329                case 164:\r
1330                   if (curChar == 58)\r
1331                      jjCheckNAddStates(98, 100);\r
1332                   break;\r
1333                case 165:\r
1334                   if (curChar == 48)\r
1335                      jjCheckNAdd(166);\r
1336                   break;\r
1337                case 166:\r
1338                   if ((0x3ff000000000000L & l) != 0L && kind > 58)\r
1339                      kind = 58;\r
1340                   break;\r
1341                case 167:\r
1342                   if ((0x3e000000000000L & l) != 0L)\r
1343                      jjCheckNAdd(166);\r
1344                   break;\r
1345                case 168:\r
1346                   if ((0x3e000000000000L & l) != 0L)\r
1347                      jjCheckNAdd(163);\r
1348                   break;\r
1349                case 169:\r
1350                   if (curChar == 49)\r
1351                      jjCheckNAdd(160);\r
1352                   break;\r
1353                case 170:\r
1354                   if (curChar == 50)\r
1355                      jjstateSet[jjnewStateCnt++] = 171;\r
1356                   break;\r
1357                case 171:\r
1358                   if ((0xf000000000000L & l) != 0L)\r
1359                      jjCheckNAdd(161);\r
1360                   break;\r
1361                case 172:\r
1362                case 179:\r
1363                case 184:\r
1364                   if ((0x6000000000000L & l) != 0L)\r
1365                      jjCheckNAdd(173);\r
1366                   break;\r
1367                case 173:\r
1368                   if ((0x3ff000000000000L & l) != 0L)\r
1369                      jjCheckNAdd(158);\r
1370                   break;\r
1371                case 174:\r
1372                   if (curChar == 51)\r
1373                      jjstateSet[jjnewStateCnt++] = 175;\r
1374                   break;\r
1375                case 175:\r
1376                   if ((0x3000000000000L & l) != 0L)\r
1377                      jjCheckNAdd(158);\r
1378                   break;\r
1379                case 176:\r
1380                   if ((0x250000000000000L & l) != 0L)\r
1381                      jjCheckNAdd(177);\r
1382                   break;\r
1383                case 177:\r
1384                   if (curChar == 45)\r
1385                      jjCheckNAddStates(101, 104);\r
1386                   break;\r
1387                case 180:\r
1388                   if (curChar == 48)\r
1389                      jjCheckNAdd(158);\r
1390                   break;\r
1391                case 181:\r
1392                   if (curChar == 51)\r
1393                      jjstateSet[jjnewStateCnt++] = 180;\r
1394                   break;\r
1395                case 182:\r
1396                   if (curChar == 45)\r
1397                      jjCheckNAddStates(105, 107);\r
1398                   break;\r
1399                case 185:\r
1400                   if (curChar == 50)\r
1401                      jjstateSet[jjnewStateCnt++] = 182;\r
1402                   break;\r
1403                case 186:\r
1404                   if (curChar == 48)\r
1405                      jjCheckNAddStates(108, 110);\r
1406                   break;\r
1407                case 187:\r
1408                   if (curChar == 49)\r
1409                      jjAddStates(111, 113);\r
1410                   break;\r
1411                case 188:\r
1412                   if (curChar == 48)\r
1413                      jjCheckNAdd(155);\r
1414                   break;\r
1415                case 189:\r
1416                   if (curChar == 50)\r
1417                      jjCheckNAdd(155);\r
1418                   break;\r
1419                case 190:\r
1420                   if (curChar == 49)\r
1421                      jjCheckNAdd(177);\r
1422                   break;\r
1423                case 191:\r
1424                   if (curChar == 49)\r
1425                      jjCheckNAddStates(12, 14);\r
1426                   break;\r
1427                case 192:\r
1428                   if ((0x3ff000000000000L & l) != 0L)\r
1429                      jjCheckNAdd(15);\r
1430                   break;\r
1431                case 193:\r
1432                   if ((0x3ff000000000000L & l) != 0L)\r
1433                      jjCheckNAdd(52);\r
1434                   break;\r
1435                case 194:\r
1436                   if (curChar == 50)\r
1437                      jjAddStates(15, 17);\r
1438                   break;\r
1439                case 195:\r
1440                   if ((0x1f000000000000L & l) != 0L)\r
1441                      jjCheckNAdd(15);\r
1442                   break;\r
1443                case 196:\r
1444                   if ((0xf000000000000L & l) != 0L)\r
1445                      jjCheckNAdd(5);\r
1446                   break;\r
1447                case 197:\r
1448                   if ((0x1f000000000000L & l) != 0L)\r
1449                      jjCheckNAdd(52);\r
1450                   break;\r
1451                case 198:\r
1452                   if (curChar == 50)\r
1453                      jjAddStates(10, 11);\r
1454                   break;\r
1455                case 199:\r
1456                   if (curChar == 53)\r
1457                      jjstateSet[jjnewStateCnt++] = 200;\r
1458                   break;\r
1459                case 200:\r
1460                   if ((0x3f000000000000L & l) != 0L)\r
1461                      jjCheckNAdd(16);\r
1462                   break;\r
1463                case 201:\r
1464                   if (curChar == 53)\r
1465                      jjstateSet[jjnewStateCnt++] = 202;\r
1466                   break;\r
1467                case 202:\r
1468                   if ((0x3f000000000000L & l) != 0L)\r
1469                      jjCheckNAdd(53);\r
1470                   break;\r
1471                default : break;\r
1472             }\r
1473          } while(i != startsAt);\r
1474       }\r
1475       else if (curChar < 128)\r
1476       {\r
1477          long l = 1L << (curChar & 077);\r
1478          do\r
1479          {\r
1480             switch(jjstateSet[--i])\r
1481             {\r
1482                case 84:\r
1483                   if ((0x7fffffe80000000L & l) != 0L)\r
1484                      jjCheckNAddTwoStates(1, 2);\r
1485                   if ((0x7fffffe00000000L & l) != 0L)\r
1486                   {\r
1487                      if (kind > 53)\r
1488                         kind = 53;\r
1489                      jjCheckNAdd(2);\r
1490                   }\r
1491                   if ((0x7e00000000L & l) != 0L)\r
1492                      jjstateSet[jjnewStateCnt++] = 107;\r
1493                   if ((0x7e00000000L & l) != 0L)\r
1494                      jjstateSet[jjnewStateCnt++] = 85;\r
1495                   break;\r
1496                case 203:\r
1497                   if ((0x7fffffe80000000L & l) != 0L)\r
1498                      jjCheckNAddTwoStates(1, 2);\r
1499                   if ((0x7fffffe00000000L & l) != 0L)\r
1500                   {\r
1501                      if (kind > 53)\r
1502                         kind = 53;\r
1503                      jjCheckNAdd(2);\r
1504                   }\r
1505                   break;\r
1506                case 0:\r
1507                   if ((0x7fffffe00000000L & l) != 0L)\r
1508                   {\r
1509                      if (kind > 53)\r
1510                         kind = 53;\r
1511                      jjCheckNAddTwoStates(1, 2);\r
1512                   }\r
1513                   if ((0x7e00000000L & l) != 0L)\r
1514                      jjAddStates(5, 6);\r
1515                   break;\r
1516                case 1:\r
1517                   if ((0x7fffffe80000000L & l) != 0L)\r
1518                      jjCheckNAddTwoStates(1, 2);\r
1519                   break;\r
1520                case 2:\r
1521                   if ((0x7fffffe00000000L & l) == 0L)\r
1522                      break;\r
1523                   if (kind > 53)\r
1524                      kind = 53;\r
1525                   jjCheckNAdd(2);\r
1526                   break;\r
1527                case 83:\r
1528                   if ((0x7e00000000L & l) != 0L)\r
1529                      jjAddStates(5, 6);\r
1530                   break;\r
1531                case 86:\r
1532                   if ((0x7e00000000L & l) != 0L)\r
1533                      jjstateSet[jjnewStateCnt++] = 87;\r
1534                   break;\r
1535                case 87:\r
1536                   if ((0x7e00000000L & l) != 0L)\r
1537                      jjstateSet[jjnewStateCnt++] = 88;\r
1538                   break;\r
1539                case 89:\r
1540                   if ((0x7e00000000L & l) != 0L)\r
1541                      jjstateSet[jjnewStateCnt++] = 90;\r
1542                   break;\r
1543                case 90:\r
1544                   if ((0x7e00000000L & l) != 0L)\r
1545                      jjstateSet[jjnewStateCnt++] = 91;\r
1546                   break;\r
1547                case 92:\r
1548                   if ((0x7e00000000L & l) != 0L)\r
1549                      jjstateSet[jjnewStateCnt++] = 93;\r
1550                   break;\r
1551                case 93:\r
1552                   if ((0x7e00000000L & l) != 0L)\r
1553                      jjstateSet[jjnewStateCnt++] = 94;\r
1554                   break;\r
1555                case 95:\r
1556                   if ((0x7e00000000L & l) != 0L)\r
1557                      jjstateSet[jjnewStateCnt++] = 96;\r
1558                   break;\r
1559                case 96:\r
1560                   if ((0x7e00000000L & l) != 0L)\r
1561                      jjstateSet[jjnewStateCnt++] = 97;\r
1562                   break;\r
1563                case 98:\r
1564                   if ((0x7e00000000L & l) != 0L)\r
1565                      jjstateSet[jjnewStateCnt++] = 99;\r
1566                   break;\r
1567                case 99:\r
1568                   if ((0x7e00000000L & l) == 0L)\r
1569                      break;\r
1570                   if (kind > 54)\r
1571                      kind = 54;\r
1572                   jjstateSet[jjnewStateCnt++] = 100;\r
1573                   break;\r
1574                case 106:\r
1575                   if ((0x7e00000000L & l) != 0L)\r
1576                      jjstateSet[jjnewStateCnt++] = 107;\r
1577                   break;\r
1578                case 108:\r
1579                   if ((0x7e00000000L & l) != 0L)\r
1580                      jjstateSet[jjnewStateCnt++] = 109;\r
1581                   break;\r
1582                case 109:\r
1583                   if ((0x7e00000000L & l) != 0L)\r
1584                      jjstateSet[jjnewStateCnt++] = 110;\r
1585                   break;\r
1586                case 111:\r
1587                   if ((0x7e00000000L & l) != 0L)\r
1588                      jjstateSet[jjnewStateCnt++] = 112;\r
1589                   break;\r
1590                case 112:\r
1591                   if ((0x7e00000000L & l) != 0L)\r
1592                      jjstateSet[jjnewStateCnt++] = 113;\r
1593                   break;\r
1594                case 114:\r
1595                   if ((0x7e00000000L & l) != 0L)\r
1596                      jjstateSet[jjnewStateCnt++] = 115;\r
1597                   break;\r
1598                case 115:\r
1599                   if ((0x7e00000000L & l) != 0L)\r
1600                      jjstateSet[jjnewStateCnt++] = 116;\r
1601                   break;\r
1602                case 117:\r
1603                   if ((0x7e00000000L & l) != 0L)\r
1604                      jjstateSet[jjnewStateCnt++] = 118;\r
1605                   break;\r
1606                case 118:\r
1607                   if ((0x7e00000000L & l) != 0L)\r
1608                      jjstateSet[jjnewStateCnt++] = 119;\r
1609                   break;\r
1610                case 120:\r
1611                   if ((0x7e00000000L & l) != 0L)\r
1612                      jjstateSet[jjnewStateCnt++] = 121;\r
1613                   break;\r
1614                case 121:\r
1615                   if ((0x7e00000000L & l) != 0L && kind > 59)\r
1616                      kind = 59;\r
1617                   break;\r
1618                default : break;\r
1619             }\r
1620          } while(i != startsAt);\r
1621       }\r
1622       else\r
1623       {\r
1624          int i2 = (curChar & 0xff) >> 6;\r
1625          long l2 = 1L << (curChar & 077);\r
1626          do\r
1627          {\r
1628             switch(jjstateSet[--i])\r
1629             {\r
1630                default : break;\r
1631             }\r
1632          } while(i != startsAt);\r
1633       }\r
1634       if (kind != 0x7fffffff)\r
1635       {\r
1636          jjmatchedKind = kind;\r
1637          jjmatchedPos = curPos;\r
1638          kind = 0x7fffffff;\r
1639       }\r
1640       ++curPos;\r
1641       if ((i = jjnewStateCnt) == (startsAt = 203 - (jjnewStateCnt = startsAt)))\r
1642          return curPos;\r
1643       try { curChar = input_stream.readChar(); }\r
1644       catch(java.io.IOException e) { return curPos; }\r
1645    }\r
1646 }\r
1647 static final int[] jjnextStates = {\r
1648    16, 123, 5, 150, 53, 84, 106, 14, 15, 52, 199, 201, 192, 4, 193, 195, \r
1649    196, 197, 6, 7, 12, 9, 10, 11, 17, 44, 45, 47, 51, 19, 36, 37, \r
1650    39, 43, 21, 28, 29, 31, 35, 23, 24, 26, 54, 75, 76, 78, 82, 56, \r
1651    67, 68, 70, 74, 58, 59, 60, 62, 66, 101, 102, 104, 127, 135, 144, 145, \r
1652    146, 129, 130, 131, 133, 137, 130, 138, 140, 142, 130, 143, 127, 135, 144, 147, \r
1653    148, 149, 154, 176, 185, 186, 187, 156, 157, 172, 174, 159, 160, 169, 170, 162, \r
1654    163, 168, 165, 166, 167, 178, 157, 179, 181, 183, 157, 184, 154, 176, 185, 188, \r
1655    189, 190, \r
1656 };\r
1657 \r
1658 /** Token literal values. */\r
1659 public static final String[] jjstrLiteralImages = {\r
1660 "", null, null, null, null, "\72", "\54", "\73", "\50", "\51", "\133", "\135", \r
1661 "\46\46", "\174\174", "\41", "\75\75", "\76", "\74", "\76\75", "\74\75", "\52", null, \r
1662 null, null, null, "\103\122\105\101\124\105", "\111\115\120\117\122\124", \r
1663 "\125\120\104\101\124\105", "\104\105\114\105\124\105", "\125\163\145\162", "\116\157\144\145", \r
1664 "\124\171\160\145", "\103\157\156\164\141\151\156", "\120\162\157\160\145\162\164\171", \r
1665 "\103\157\156\156\145\143\164\151\157\156", "\105\156\144\156\157\144\145\163", "\106\154\157\167", \r
1666 "\115\141\164\143\150", "\117\160\145\162\141\164\151\157\156", "\124\141\162\147\145\164", \r
1667 "\103\157\156\144\151\164\151\157\156", "\101\143\164\151\157\156", "\121\165\145\162\171", "\106\162\157\155", \r
1668 "\120\162\151\157\162\151\164\171", "\124\162\141\156\163\141\143\164\151\157\156", "\102\145\147\151\156", \r
1669 "\105\156\144", "\156\157\144\145\163", "\143\157\156\156\145\143\164\151\157\156\163", \r
1670 "\146\154\157\167\163", "\157\160\145\162\141\164\151\157\156\163", null, null, null, null, null, null, \r
1671 null, null, null, null, null, null, null, null, null, null, null, null, null, null, };\r
1672 \r
1673 /** Lexer state names. */\r
1674 public static final String[] lexStateNames = {\r
1675    "DEFAULT",\r
1676 };\r
1677 static final long[] jjtoToken = {\r
1678    0x1ffffffffe1fffe1L, 0x0L, \r
1679 };\r
1680 static final long[] jjtoSkip = {\r
1681    0x1eL, 0x0L, \r
1682 };\r
1683 static protected SimpleCharStream input_stream;\r
1684 static private final int[] jjrounds = new int[203];\r
1685 static private final int[] jjstateSet = new int[406];\r
1686 static protected char curChar;\r
1687 /** Constructor. */\r
1688 public NEMOparserTokenManager(SimpleCharStream stream){\r
1689    if (input_stream != null)\r
1690       throw new TokenMgrError("ERROR: Second call to constructor of static lexer. You must use ReInit() to initialize the static variables.", TokenMgrError.STATIC_LEXER_ERROR);\r
1691    input_stream = stream;\r
1692 }\r
1693 \r
1694 /** Constructor. */\r
1695 public NEMOparserTokenManager(SimpleCharStream stream, int lexState){\r
1696    this(stream);\r
1697    SwitchTo(lexState);\r
1698 }\r
1699 \r
1700 /** Reinitialise parser. */\r
1701 static public void ReInit(SimpleCharStream stream)\r
1702 {\r
1703    jjmatchedPos = jjnewStateCnt = 0;\r
1704    curLexState = defaultLexState;\r
1705    input_stream = stream;\r
1706    ReInitRounds();\r
1707 }\r
1708 static private void ReInitRounds()\r
1709 {\r
1710    int i;\r
1711    jjround = 0x80000001;\r
1712    for (i = 203; i-- > 0;)\r
1713       jjrounds[i] = 0x80000000;\r
1714 }\r
1715 \r
1716 /** Reinitialise parser. */\r
1717 static public void ReInit(SimpleCharStream stream, int lexState)\r
1718 {\r
1719    ReInit(stream);\r
1720    SwitchTo(lexState);\r
1721 }\r
1722 \r
1723 /** Switch to specified lex state. */\r
1724 static public void SwitchTo(int lexState)\r
1725 {\r
1726    if (lexState >= 1 || lexState < 0)\r
1727       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);\r
1728    else\r
1729       curLexState = lexState;\r
1730 }\r
1731 \r
1732 static protected Token jjFillToken()\r
1733 {\r
1734    final Token t;\r
1735    final String curTokenImage;\r
1736    final int beginLine;\r
1737    final int endLine;\r
1738    final int beginColumn;\r
1739    final int endColumn;\r
1740    String im = jjstrLiteralImages[jjmatchedKind];\r
1741    curTokenImage = (im == null) ? input_stream.GetImage() : im;\r
1742    beginLine = input_stream.getBeginLine();\r
1743    beginColumn = input_stream.getBeginColumn();\r
1744    endLine = input_stream.getEndLine();\r
1745    endColumn = input_stream.getEndColumn();\r
1746    t = Token.newToken(jjmatchedKind, curTokenImage);\r
1747 \r
1748    t.beginLine = beginLine;\r
1749    t.endLine = endLine;\r
1750    t.beginColumn = beginColumn;\r
1751    t.endColumn = endColumn;\r
1752 \r
1753    return t;\r
1754 }\r
1755 \r
1756 static int curLexState = 0;\r
1757 static int defaultLexState = 0;\r
1758 static int jjnewStateCnt;\r
1759 static int jjround;\r
1760 static int jjmatchedPos;\r
1761 static int jjmatchedKind;\r
1762 \r
1763 /** Get the next Token. */\r
1764 public static Token getNextToken() \r
1765 {\r
1766   Token matchedToken;\r
1767   int curPos = 0;\r
1768 \r
1769   EOFLoop :\r
1770   for (;;)\r
1771   {\r
1772    try\r
1773    {\r
1774       curChar = input_stream.BeginToken();\r
1775    }\r
1776    catch(java.io.IOException e)\r
1777    {\r
1778       jjmatchedKind = 0;\r
1779       matchedToken = jjFillToken();\r
1780       return matchedToken;\r
1781    }\r
1782 \r
1783    try { input_stream.backup(0);\r
1784       while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)\r
1785          curChar = input_stream.BeginToken();\r
1786    }\r
1787    catch (java.io.IOException e1) { continue EOFLoop; }\r
1788    jjmatchedKind = 0x7fffffff;\r
1789    jjmatchedPos = 0;\r
1790    curPos = jjMoveStringLiteralDfa0_0();\r
1791    if (jjmatchedKind != 0x7fffffff)\r
1792    {\r
1793       if (jjmatchedPos + 1 < curPos)\r
1794          input_stream.backup(curPos - jjmatchedPos - 1);\r
1795       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)\r
1796       {\r
1797          matchedToken = jjFillToken();\r
1798          return matchedToken;\r
1799       }\r
1800       else\r
1801       {\r
1802          continue EOFLoop;\r
1803       }\r
1804    }\r
1805    int error_line = input_stream.getEndLine();\r
1806    int error_column = input_stream.getEndColumn();\r
1807    String error_after = null;\r
1808    boolean EOFSeen = false;\r
1809    try { input_stream.readChar(); input_stream.backup(1); }\r
1810    catch (java.io.IOException e1) {\r
1811       EOFSeen = true;\r
1812       error_after = curPos <= 1 ? "" : input_stream.GetImage();\r
1813       if (curChar == '\n' || curChar == '\r') {\r
1814          error_line++;\r
1815          error_column = 0;\r
1816       }\r
1817       else\r
1818          error_column++;\r
1819    }\r
1820    if (!EOFSeen) {\r
1821       input_stream.backup(1);\r
1822       error_after = curPos <= 1 ? "" : input_stream.GetImage();\r
1823    }\r
1824    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);\r
1825   }\r
1826 }\r
1827 \r
1828 static private void jjCheckNAdd(int state)\r
1829 {\r
1830    if (jjrounds[state] != jjround)\r
1831    {\r
1832       jjstateSet[jjnewStateCnt++] = state;\r
1833       jjrounds[state] = jjround;\r
1834    }\r
1835 }\r
1836 static private void jjAddStates(int start, int end)\r
1837 {\r
1838    do {\r
1839       jjstateSet[jjnewStateCnt++] = jjnextStates[start];\r
1840    } while (start++ != end);\r
1841 }\r
1842 static private void jjCheckNAddTwoStates(int state1, int state2)\r
1843 {\r
1844    jjCheckNAdd(state1);\r
1845    jjCheckNAdd(state2);\r
1846 }\r
1847 \r
1848 static private void jjCheckNAddStates(int start, int end)\r
1849 {\r
1850    do {\r
1851       jjCheckNAdd(jjnextStates[start]);\r
1852    } while (start++ != end);\r
1853 }\r
1854 \r
1855 }\r