gerrit.simantics Code Review - simantics/sysdyn.git/blob

   1 /* Generated By:JavaCC: Do not edit this line. ExpressionParserTokenManager.java */\r
   2 package org.simantics.sysdyn.expressionParser;\r
   3 import java.util.Set;\r
   4 import java.util.HashSet;\r
   5 import java.util.List;\r
   6 import java.util.ArrayList;\r
   7 import java.util.HashMap;\r
   8 \r
   9 /** Token Manager. */\r
  10 public class ExpressionParserTokenManager implements ExpressionParserConstants\r
  11 {\r
  12 \r
  13   /** Debug output. */\r
  14   public  java.io.PrintStream debugStream = System.out;\r
  15   /** Set debug output. */\r
  16   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }\r
  17 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
  18 {\r
  19    switch (pos)
  20    {\r
  21       case 0:\r
  22          if ((active0 & 0xffffffffffffff0L) != 0L)\r
  23          {\r
  24             jjmatchedKind = 88;\r
  25             return 2;\r
  26          }\r
  27          if ((active1 & 0x20000L) != 0L)\r
  28             return 13;\r
  29          if ((active1 & 0x2cc004L) != 0L)\r
  30             return 9;\r
  31          return -1;\r
  32       case 1:\r
  33          if ((active0 & 0x84020080400000L) != 0L)\r
  34             return 2;\r
  35          if ((active0 & 0xf7bfdff7fbffff0L) != 0L)\r
  36          {\r
  37             if (jjmatchedPos != 1)\r
  38             {\r
  39                jjmatchedKind = 88;\r
  40                jjmatchedPos = 1;\r
  41             }\r
  42             return 2;\r
  43          }\r
  44          return -1;\r
  45       case 2:\r
  46          if ((active0 & 0x800201200L) != 0L)\r
  47             return 2;\r
  48          if ((active0 & 0xffffdf77f9fedf0L) != 0L)\r
  49          {\r
  50             jjmatchedKind = 88;\r
  51             jjmatchedPos = 2;\r
  52             return 2;\r
  53          }\r
  54          return -1;\r
  55       case 3:\r
  56          if ((active0 & 0x400084212118400L) != 0L)\r
  57             return 2;\r
  58          if ((active0 & 0xbfff5b56d8e69f0L) != 0L)\r
  59          {\r
  60             if (jjmatchedPos != 3)\r
  61             {\r
  62                jjmatchedKind = 88;\r
  63                jjmatchedPos = 3;\r
  64             }\r
  65             return 2;\r
  66          }\r
  67          return -1;\r
  68       case 4:\r
  69          if ((active0 & 0x848004290008c0L) != 0L)\r
  70             return 2;\r
  71          if ((active0 & 0xb7b75b1469e6130L) != 0L)\r
  72          {\r
  73             jjmatchedKind = 88;\r
  74             jjmatchedPos = 4;\r
  75             return 2;\r
  76          }\r
  77          return -1;\r
  78       case 5:\r
  79          if ((active0 & 0x9100011009c0000L) != 0L)\r
  80             return 2;\r
  81          if ((active0 & 0x26b75a046026130L) != 0L)\r
  82          {\r
  83             jjmatchedKind = 88;\r
  84             jjmatchedPos = 5;\r
  85             return 2;\r
  86          }\r
  87          return -1;\r
  88       case 6:\r
  89          if ((active0 & 0x4050a000000000L) != 0L)\r
  90             return 2;\r
  91          if ((active0 & 0x22b250046026130L) != 0L)\r
  92          {\r
  93             if (jjmatchedPos != 6)\r
  94             {\r
  95                jjmatchedKind = 88;\r
  96                jjmatchedPos = 6;\r
  97             }\r
  98             return 2;\r
  99          }\r
 100          return -1;\r
 101       case 7:\r
 102          if ((active0 & 0x201200006020020L) != 0L)\r
 103             return 2;\r
 104          if ((active0 & 0x2a150040006110L) != 0L)\r
 105          {\r
 106             jjmatchedKind = 88;\r
 107             jjmatchedPos = 7;\r
 108             return 2;\r
 109          }\r
 110          return -1;\r
 111       case 8:\r
 112          if ((active0 & 0x22010040006000L) != 0L)\r
 113          {\r
 114             jjmatchedKind = 88;\r
 115             jjmatchedPos = 8;\r
 116             return 2;\r
 117          }\r
 118          if ((active0 & 0x8140000000110L) != 0L)\r
 119             return 2;\r
 120          return -1;\r
 121       case 9:\r
 122          if ((active0 & 0x2000000004000L) != 0L)\r
 123             return 2;\r
 124          if ((active0 & 0x20010040002000L) != 0L)\r
 125          {\r
 126             jjmatchedKind = 88;\r
 127             jjmatchedPos = 9;\r
 128             return 2;\r
 129          }\r
 130          return -1;\r
 131       case 10:\r
 132          if ((active0 & 0x10000002000L) != 0L)\r
 133             return 2;\r
 134          if ((active0 & 0x20000040000000L) != 0L)\r
 135          {\r
 136             jjmatchedKind = 88;\r
 137             jjmatchedPos = 10;\r
 138             return 2;\r
 139          }\r
 140          return -1;\r
 141       case 11:\r
 142          if ((active0 & 0x40000000L) != 0L)\r
 143             return 2;\r
 144          if ((active0 & 0x20000000000000L) != 0L)\r
 145          {\r
 146             jjmatchedKind = 88;\r
 147             jjmatchedPos = 11;\r
 148             return 2;\r
 149          }\r
 150          return -1;\r
 151       default :\r
 152          return -1;\r
 153    }\r
 154 }\r
 155 private final int jjStartNfa_0(int pos, long active0, long active1)
 156 {\r
 157    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);\r
 158 }\r
 159 private int jjStopAtPos(int pos, int kind)\r
 160 {\r
 161    jjmatchedKind = kind;\r
 162    jjmatchedPos = pos;\r
 163    return pos + 1;\r
 164 }\r
 165 private int jjMoveStringLiteralDfa0_0()\r
 166 {\r
 167    switch(curChar)\r
 168    {\r
 169       case 40:\r
 170          return jjStopAtPos(0, 60);\r
 171       case 41:\r
 172          return jjStopAtPos(0, 61);\r
 173       case 42:\r
 174          return jjStopAtPos(0, 80);\r
 175       case 43:\r
 176          return jjStopAtPos(0, 76);\r
 177       case 44:\r
 178          return jjStopAtPos(0, 69);\r
 179       case 45:\r
 180          return jjStopAtPos(0, 77);\r
 181       case 46:\r
 182          jjmatchedKind = 66;\r
 183          return jjMoveStringLiteralDfa1_0(0x0L, 0x2cc000L);\r
 184       case 47:\r
 185          return jjStartNfaWithStates_0(0, 81, 13);\r
 186       case 58:\r
 187          jjmatchedKind = 67;\r
 188          return jjMoveStringLiteralDfa1_0(0x0L, 0x800000L);\r
 189       case 59:\r
 190          return jjStopAtPos(0, 68);\r
 191       case 60:\r
 192          jjmatchedKind = 70;\r
 193          return jjMoveStringLiteralDfa1_0(0x0L, 0x880L);\r
 194       case 61:\r
 195          jjmatchedKind = 86;\r
 196          return jjMoveStringLiteralDfa1_0(0x0L, 0x400L);\r
 197       case 62:\r
 198          jjmatchedKind = 72;\r
 199          return jjMoveStringLiteralDfa1_0(0x0L, 0x200L);\r
 200       case 91:\r
 201          return jjStopAtPos(0, 64);\r
 202       case 93:\r
 203          return jjStopAtPos(0, 65);\r
 204       case 94:\r
 205          return jjStopAtPos(0, 84);\r
 206       case 97:\r
 207          return jjMoveStringLiteralDfa1_0(0x84210L, 0x0L);\r
 208       case 98:\r
 209          return jjMoveStringLiteralDfa1_0(0x21000000L, 0x0L);\r
 210       case 99:\r
 211          return jjMoveStringLiteralDfa1_0(0x21108400000000L, 0x0L);\r
 212       case 100:\r
 213          return jjMoveStringLiteralDfa1_0(0x20L, 0x0L);\r
 214       case 101:\r
 215          return jjMoveStringLiteralDfa1_0(0x242210842108400L, 0x0L);\r
 216       case 102:\r
 217          return jjMoveStringLiteralDfa1_0(0x4210840L, 0x0L);\r
 218       case 105:\r
 219          return jjMoveStringLiteralDfa1_0(0x84021080000000L, 0x0L);\r
 220       case 108:\r
 221          return jjMoveStringLiteralDfa1_0(0x400000000000000L, 0x0L);\r
 222       case 109:\r
 223          return jjMoveStringLiteralDfa1_0(0x80L, 0x0L);\r
 224       case 110:\r
 225          return jjMoveStringLiteralDfa1_0(0x1000L, 0x0L);\r
 226       case 111:\r
 227          return jjMoveStringLiteralDfa1_0(0x108420000L, 0x0L);\r
 228       case 112:\r
 229          return jjMoveStringLiteralDfa1_0(0x108442000000000L, 0x0L);\r
 230       case 114:\r
 231          return jjMoveStringLiteralDfa1_0(0x800000000042100L, 0x0L);\r
 232       case 115:\r
 233          return jjMoveStringLiteralDfa1_0(0x800000L, 0x0L);\r
 234       case 116:\r
 235          return jjMoveStringLiteralDfa1_0(0x4210000000L, 0x0L);\r
 236       case 119:\r
 237          return jjMoveStringLiteralDfa1_0(0x10880000000000L, 0x0L);\r
 238       case 123:\r
 239          return jjStopAtPos(0, 62);\r
 240       case 125:\r
 241          return jjStopAtPos(0, 63);\r
 242       default :\r
 243          return jjMoveNfa_0(0, 0);\r
 244    }\r
 245 }\r
 246 private int jjMoveStringLiteralDfa1_0(long active0, long active1)\r
 247 {\r
 248    try { curChar = input_stream.readChar(); }\r
 249    catch(java.io.IOException e) {\r
 250       jjStopStringLiteralDfa_0(0, active0, active1);\r
 251       return 1;\r
 252    }\r
 253    switch(curChar)\r
 254    {\r
 255       case 42:\r
 256          if ((active1 & 0x40000L) != 0L)\r
 257             return jjStopAtPos(1, 82);\r
 258          break;\r
 259       case 43:\r
 260          if ((active1 & 0x4000L) != 0L)\r
 261             return jjStopAtPos(1, 78);\r
 262          break;\r
 263       case 45:\r
 264          if ((active1 & 0x8000L) != 0L)\r
 265             return jjStopAtPos(1, 79);\r
 266          break;\r
 267       case 47:\r
 268          if ((active1 & 0x80000L) != 0L)\r
 269             return jjStopAtPos(1, 83);\r
 270          break;\r
 271       case 61:\r
 272          if ((active1 & 0x80L) != 0L)\r
 273             return jjStopAtPos(1, 71);\r
 274          else if ((active1 & 0x200L) != 0L)\r
 275             return jjStopAtPos(1, 73);\r
 276          else if ((active1 & 0x400L) != 0L)\r
 277             return jjStopAtPos(1, 74);\r
 278          else if ((active1 & 0x800000L) != 0L)\r
 279             return jjStopAtPos(1, 87);\r
 280          break;\r
 281       case 62:\r
 282          if ((active1 & 0x800L) != 0L)\r
 283             return jjStopAtPos(1, 75);\r
 284          break;\r
 285       case 94:\r
 286          if ((active1 & 0x200000L) != 0L)\r
 287             return jjStopAtPos(1, 85);\r
 288          break;\r
 289       case 97:\r
 290          return jjMoveStringLiteralDfa2_0(active0, 0x442000000440L, active1, 0L);\r
 291       case 101:\r
 292          return jjMoveStringLiteralDfa2_0(active0, 0x800000000042100L, active1, 0L);\r
 293       case 102:\r
 294          if ((active0 & 0x80000000L) != 0L)\r
 295             return jjStartNfaWithStates_0(1, 31, 2);\r
 296          break;\r
 297       case 104:\r
 298          return jjMoveStringLiteralDfa2_0(active0, 0x880010000000L, active1, 0L);\r
 299       case 105:\r
 300          return jjMoveStringLiteralDfa2_0(active0, 0x10000000000820L, active1, 0L);\r
 301       case 108:\r
 302          return jjMoveStringLiteralDfa2_0(active0, 0x403118010L, active1, 0L);\r
 303       case 109:\r
 304          return jjMoveStringLiteralDfa2_0(active0, 0x1000000000L, active1, 0L);\r
 305       case 110:\r
 306          if ((active0 & 0x20000000000L) != 0L)\r
 307          {\r
 308             jjmatchedKind = 41;\r
 309             jjmatchedPos = 1;\r
 310          }\r
 311          return jjMoveStringLiteralDfa2_0(active0, 0x84010840004200L, active1, 0L);\r
 312       case 111:\r
 313          return jjMoveStringLiteralDfa2_0(active0, 0x421108000201080L, active1, 0L);\r
 314       case 112:\r
 315          return jjMoveStringLiteralDfa2_0(active0, 0x20000L, active1, 0L);\r
 316       case 113:\r
 317          return jjMoveStringLiteralDfa2_0(active0, 0x200000000000L, active1, 0L);\r
 318       case 114:\r
 319          if ((active0 & 0x400000L) != 0L)\r
 320             return jjStartNfaWithStates_0(1, 22, 2);\r
 321          return jjMoveStringLiteralDfa2_0(active0, 0x8000220000000L, active1, 0L);\r
 322       case 115:\r
 323          return jjMoveStringLiteralDfa2_0(active0, 0x80000L, active1, 0L);\r
 324       case 116:\r
 325          return jjMoveStringLiteralDfa2_0(active0, 0x800000L, active1, 0L);\r
 326       case 117:\r
 327          return jjMoveStringLiteralDfa2_0(active0, 0x10000010c000000L, active1, 0L);\r
 328       case 120:\r
 329          return jjMoveStringLiteralDfa2_0(active0, 0x242000000000000L, active1, 0L);\r
 330       case 121:\r
 331          return jjMoveStringLiteralDfa2_0(active0, 0x4000000000L, active1, 0L);\r
 332       default :\r
 333          break;\r
 334    }\r
 335    return jjStartNfa_0(0, active0, active1);\r
 336 }\r
 337 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)\r
 338 {\r
 339    if (((active0 &= old0) | (active1 &= old1)) == 0L)\r
 340       return jjStartNfa_0(0, old0, old1);\r
 341    try { curChar = input_stream.readChar(); }\r
 342    catch(java.io.IOException e) {\r
 343       jjStopStringLiteralDfa_0(1, active0, 0L);\r
 344       return 2;\r
 345    }\r
 346    switch(curChar)\r
 347    {\r
 348       case 97:\r
 349          return jjMoveStringLiteralDfa3_0(active0, 0x400000000L);\r
 350       case 98:\r
 351          return jjMoveStringLiteralDfa3_0(active0, 0x100000000000000L);\r
 352       case 99:\r
 353          return jjMoveStringLiteralDfa3_0(active0, 0x800002040000400L);\r
 354       case 100:\r
 355          if ((active0 & 0x200L) != 0L)\r
 356             return jjStartNfaWithStates_0(2, 9, 2);\r
 357          else if ((active0 & 0x800000000L) != 0L)\r
 358             return jjStartNfaWithStates_0(2, 35, 2);\r
 359          return jjMoveStringLiteralDfa3_0(active0, 0x180L);\r
 360       case 101:\r
 361          return jjMoveStringLiteralDfa3_0(active0, 0x80030020000L);\r
 362       case 103:\r
 363          return jjMoveStringLiteralDfa3_0(active0, 0x10L);\r
 364       case 105:\r
 365          return jjMoveStringLiteralDfa3_0(active0, 0x800000000000L);\r
 366       case 108:\r
 367          return jjMoveStringLiteralDfa3_0(active0, 0x40L);\r
 368       case 110:\r
 369          return jjMoveStringLiteralDfa3_0(active0, 0x25108004004800L);\r
 370       case 111:\r
 371          return jjMoveStringLiteralDfa3_0(active0, 0x408000001010000L);\r
 372       case 112:\r
 373          return jjMoveStringLiteralDfa3_0(active0, 0x82005000002000L);\r
 374       case 114:\r
 375          if ((active0 & 0x200000L) != 0L)\r
 376             return jjStartNfaWithStates_0(2, 21, 2);\r
 377          return jjMoveStringLiteralDfa3_0(active0, 0x440000800000L);\r
 378       case 115:\r
 379          return jjMoveStringLiteralDfa3_0(active0, 0x2188020L);\r
 380       case 116:\r
 381          if ((active0 & 0x1000L) != 0L)\r
 382             return jjStartNfaWithStates_0(2, 12, 2);\r
 383          return jjMoveStringLiteralDfa3_0(active0, 0x250000108040000L);\r
 384       case 117:\r
 385          return jjMoveStringLiteralDfa3_0(active0, 0x210200000000L);\r
 386       default :\r
 387          break;\r
 388    }\r
 389    return jjStartNfa_0(1, active0, 0L);\r
 390 }\r
 391 private int jjMoveStringLiteralDfa3_0(long old0, long active0)\r
 392 {\r
 393    if (((active0 &= old0)) == 0L)\r
 394       return jjStartNfa_0(1, old0, 0L);\r
 395    try { curChar = input_stream.readChar(); }\r
 396    catch(java.io.IOException e) {\r
 397       jjStopStringLiteralDfa_0(2, active0, 0L);\r
 398       return 3;\r
 399    }\r
 400    switch(curChar)\r
 401    {\r
 402       case 97:\r
 403          return jjMoveStringLiteralDfa4_0(active0, 0x2240060000800L);\r
 404       case 99:\r
 405          return jjMoveStringLiteralDfa4_0(active0, 0x5000020L);\r
 406       case 101:\r
 407          if ((active0 & 0x8000L) != 0L)\r
 408          {\r
 409             jjmatchedKind = 15;\r
 410             jjmatchedPos = 3;\r
 411          }\r
 412          else if ((active0 & 0x200000000L) != 0L)\r
 413             return jjStartNfaWithStates_0(3, 33, 2);\r
 414          else if ((active0 & 0x4000000000L) != 0L)\r
 415             return jjStartNfaWithStates_0(3, 38, 2);\r
 416          return jjMoveStringLiteralDfa4_0(active0, 0x24400000a980180L);\r
 417       case 104:\r
 418          if ((active0 & 0x400L) != 0L)\r
 419             return jjStartNfaWithStates_0(3, 10, 2);\r
 420          return jjMoveStringLiteralDfa4_0(active0, 0x10000000000000L);\r
 421       case 107:\r
 422          return jjMoveStringLiteralDfa4_0(active0, 0x2000000000L);\r
 423       case 108:\r
 424          return jjMoveStringLiteralDfa4_0(active0, 0x100800000002000L);\r
 425       case 109:\r
 426          return jjMoveStringLiteralDfa4_0(active0, 0x10000000000L);\r
 427       case 110:\r
 428          if ((active0 & 0x10000000L) != 0L)\r
 429             return jjStartNfaWithStates_0(3, 28, 2);\r
 430          else if ((active0 & 0x80000000000L) != 0L)\r
 431             return jjStartNfaWithStates_0(3, 43, 2);\r
 432          return jjMoveStringLiteralDfa4_0(active0, 0x108000000000L);\r
 433       case 111:\r
 434          return jjMoveStringLiteralDfa4_0(active0, 0x800001000004010L);\r
 435       case 112:\r
 436          if ((active0 & 0x400000000000000L) != 0L)\r
 437             return jjStartNfaWithStates_0(3, 58, 2);\r
 438          return jjMoveStringLiteralDfa4_0(active0, 0x100000000L);\r
 439       case 114:\r
 440          return jjMoveStringLiteralDfa4_0(active0, 0x20000L);\r
 441       case 115:\r
 442          return jjMoveStringLiteralDfa4_0(active0, 0x21000400000040L);\r
 443       case 116:\r
 444          return jjMoveStringLiteralDfa4_0(active0, 0x8400000000000L);\r
 445       case 117:\r
 446          return jjMoveStringLiteralDfa4_0(active0, 0x80000000040000L);\r
 447       case 119:\r
 448          if ((active0 & 0x10000L) != 0L)\r
 449             return jjStartNfaWithStates_0(3, 16, 2);\r
 450          break;\r
 451       default :\r
 452          break;\r
 453    }\r
 454    return jjStartNfa_0(2, active0, 0L);\r
 455 }\r
 456 private int jjMoveStringLiteralDfa4_0(long old0, long active0)\r
 457 {\r
 458    if (((active0 &= old0)) == 0L)\r
 459       return jjStartNfa_0(2, old0, 0L);\r
 460    try { curChar = input_stream.readChar(); }\r
 461    catch(java.io.IOException e) {\r
 462       jjStopStringLiteralDfa_0(3, active0, 0L);\r
 463       return 4;\r
 464    }\r
 465    switch(curChar)\r
 466    {\r
 467       case 97:\r
 468          return jjMoveStringLiteralDfa5_0(active0, 0x2000822000L);\r
 469       case 99:\r
 470          return jjMoveStringLiteralDfa5_0(active0, 0x100L);\r
 471       case 101:\r
 472          if ((active0 & 0x40L) != 0L)\r
 473             return jjStartNfaWithStates_0(4, 6, 2);\r
 474          else if ((active0 & 0x800000000000L) != 0L)\r
 475             return jjStartNfaWithStates_0(4, 47, 2);\r
 476          return jjMoveStringLiteralDfa5_0(active0, 0x8118000000000L);\r
 477       case 105:\r
 478          return jjMoveStringLiteralDfa5_0(active0, 0x110400000100000L);\r
 479       case 107:\r
 480          if ((active0 & 0x1000000L) != 0L)\r
 481             return jjStartNfaWithStates_0(4, 24, 2);\r
 482          else if ((active0 & 0x20000000L) != 0L)\r
 483             return jjStartNfaWithStates_0(4, 29, 2);\r
 484          break;\r
 485       case 108:\r
 486          if ((active0 & 0x80L) != 0L)\r
 487             return jjStartNfaWithStates_0(4, 7, 2);\r
 488          else if ((active0 & 0x800L) != 0L)\r
 489             return jjStartNfaWithStates_0(4, 11, 2);\r
 490          break;\r
 491       case 109:\r
 492          return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L);\r
 493       case 110:\r
 494          return jjMoveStringLiteralDfa5_0(active0, 0x42000000000000L);\r
 495       case 112:\r
 496          return jjMoveStringLiteralDfa5_0(active0, 0x40000000L);\r
 497       case 114:\r
 498          if ((active0 & 0x8000000L) != 0L)\r
 499             return jjStartNfaWithStates_0(4, 27, 2);\r
 500          else if ((active0 & 0x4000000000000L) != 0L)\r
 501             return jjStartNfaWithStates_0(4, 50, 2);\r
 502          return jjMoveStringLiteralDfa5_0(active0, 0xa000010000c0030L);\r
 503       case 115:\r
 504          if ((active0 & 0x400000000L) != 0L)\r
 505             return jjStartNfaWithStates_0(4, 34, 2);\r
 506          break;\r
 507       case 116:\r
 508          if ((active0 & 0x80000000000000L) != 0L)\r
 509             return jjStartNfaWithStates_0(4, 55, 2);\r
 510          return jjMoveStringLiteralDfa5_0(active0, 0x21200004004000L);\r
 511       case 117:\r
 512          return jjMoveStringLiteralDfa5_0(active0, 0x100000000L);\r
 513       case 119:\r
 514          return jjMoveStringLiteralDfa5_0(active0, 0x2000000L);\r
 515       default :\r
 516          break;\r
 517    }\r
 518    return jjStartNfa_0(3, active0, 0L);\r
 519 }\r
 520 private int jjMoveStringLiteralDfa5_0(long old0, long active0)\r
 521 {\r
 522    if (((active0 &= old0)) == 0L)\r
 523       return jjStartNfa_0(3, old0, 0L);\r
 524    try { curChar = input_stream.readChar(); }\r
 525    catch(java.io.IOException e) {\r
 526       jjStopStringLiteralDfa_0(4, active0, 0L);\r
 527       return 5;\r
 528    }\r
 529    switch(curChar)\r
 530    {\r
 531       case 97:\r
 532          return jjMoveStringLiteralDfa6_0(active0, 0x1400000004000L);\r
 533       case 99:\r
 534          if ((active0 & 0x100000000000000L) != 0L)\r
 535             return jjStartNfaWithStates_0(5, 56, 2);\r
 536          return jjMoveStringLiteralDfa6_0(active0, 0x8108000002000L);\r
 537       case 100:\r
 538          if ((active0 & 0x800000000000000L) != 0L)\r
 539             return jjStartNfaWithStates_0(5, 59, 2);\r
 540          return jjMoveStringLiteralDfa6_0(active0, 0x42000000000000L);\r
 541       case 101:\r
 542          return jjMoveStringLiteralDfa6_0(active0, 0x40000000020L);\r
 543       case 102:\r
 544          if ((active0 & 0x100000L) != 0L)\r
 545             return jjStartNfaWithStates_0(5, 20, 2);\r
 546          break;\r
 547       case 103:\r
 548          return jjMoveStringLiteralDfa6_0(active0, 0x2000000000L);\r
 549       case 104:\r
 550          return jjMoveStringLiteralDfa6_0(active0, 0x2000000L);\r
 551       case 105:\r
 552          return jjMoveStringLiteralDfa6_0(active0, 0x200004000010L);\r
 553       case 108:\r
 554          return jjMoveStringLiteralDfa6_0(active0, 0x100L);\r
 555       case 109:\r
 556          if ((active0 & 0x800000L) != 0L)\r
 557             return jjStartNfaWithStates_0(5, 23, 2);\r
 558          break;\r
 559       case 110:\r
 560          if ((active0 & 0x40000L) != 0L)\r
 561             return jjStartNfaWithStates_0(5, 18, 2);\r
 562          else if ((active0 & 0x10000000000000L) != 0L)\r
 563             return jjStartNfaWithStates_0(5, 52, 2);\r
 564          return jjMoveStringLiteralDfa6_0(active0, 0x200000000000000L);\r
 565       case 114:\r
 566          return jjMoveStringLiteralDfa6_0(active0, 0x20010000000000L);\r
 567       case 115:\r
 568          return jjMoveStringLiteralDfa6_0(active0, 0x40000000L);\r
 569       case 116:\r
 570          if ((active0 & 0x80000L) != 0L)\r
 571             return jjStartNfaWithStates_0(5, 19, 2);\r
 572          else if ((active0 & 0x100000000L) != 0L)\r
 573             return jjStartNfaWithStates_0(5, 32, 2);\r
 574          else if ((active0 & 0x1000000000L) != 0L)\r
 575             return jjStartNfaWithStates_0(5, 36, 2);\r
 576          return jjMoveStringLiteralDfa6_0(active0, 0x20000L);\r
 577       default :\r
 578          break;\r
 579    }\r
 580    return jjStartNfa_0(4, active0, 0L);\r
 581 }\r
 582 private int jjMoveStringLiteralDfa6_0(long old0, long active0)\r
 583 {\r
 584    if (((active0 &= old0)) == 0L)\r
 585       return jjStartNfa_0(4, old0, 0L);\r
 586    try { curChar = input_stream.readChar(); }\r
 587    catch(java.io.IOException e) {\r
 588       jjStopStringLiteralDfa_0(5, active0, 0L);\r
 589       return 6;\r
 590    }\r
 591    switch(curChar)\r
 592    {\r
 593       case 97:\r
 594          return jjMoveStringLiteralDfa7_0(active0, 0x222010000000100L);\r
 595       case 101:\r
 596          if ((active0 & 0x2000000000L) != 0L)\r
 597             return jjStartNfaWithStates_0(6, 37, 2);\r
 598          return jjMoveStringLiteralDfa7_0(active0, 0x2002000L);\r
 599       case 108:\r
 600          if ((active0 & 0x400000000000L) != 0L)\r
 601             return jjStartNfaWithStates_0(6, 46, 2);\r
 602          break;\r
 603       case 110:\r
 604          return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000L);\r
 605       case 111:\r
 606          return jjMoveStringLiteralDfa7_0(active0, 0x200004020000L);\r
 607       case 115:\r
 608          if ((active0 & 0x40000000000000L) != 0L)\r
 609             return jjStartNfaWithStates_0(6, 54, 2);\r
 610          break;\r
 611       case 116:\r
 612          if ((active0 & 0x8000000000L) != 0L)\r
 613          {\r
 614             jjmatchedKind = 39;\r
 615             jjmatchedPos = 6;\r
 616          }\r
 617          return jjMoveStringLiteralDfa7_0(active0, 0x8140000004030L);\r
 618       case 117:\r
 619          return jjMoveStringLiteralDfa7_0(active0, 0x40000000L);\r
 620       default :\r
 621          break;\r
 622    }\r
 623    return jjStartNfa_0(5, active0, 0L);\r
 624 }\r
 625 private int jjMoveStringLiteralDfa7_0(long old0, long active0)\r
 626 {\r
 627    if (((active0 &= old0)) == 0L)\r
 628       return jjStartNfa_0(5, old0, 0L);\r
 629    try { curChar = input_stream.readChar(); }\r
 630    catch(java.io.IOException e) {\r
 631       jjStopStringLiteralDfa_0(6, active0, 0L);\r
 632       return 7;\r
 633    }\r
 634    switch(curChar)\r
 635    {\r
 636       case 97:\r
 637          return jjMoveStringLiteralDfa8_0(active0, 0x2000L);\r
 638       case 98:\r
 639          return jjMoveStringLiteralDfa8_0(active0, 0x2000000000000L);\r
 640       case 101:\r
 641          if ((active0 & 0x20L) != 0L)\r
 642             return jjStartNfaWithStates_0(7, 5, 2);\r
 643          return jjMoveStringLiteralDfa8_0(active0, 0x8040000000000L);\r
 644       case 104:\r
 645          return jjMoveStringLiteralDfa8_0(active0, 0x10L);\r
 646       case 105:\r
 647          return jjMoveStringLiteralDfa8_0(active0, 0x20000000004000L);\r
 648       case 108:\r
 649          if ((active0 & 0x200000000000000L) != 0L)\r
 650             return jjStartNfaWithStates_0(7, 57, 2);\r
 651          return jjMoveStringLiteralDfa8_0(active0, 0x40000000L);\r
 652       case 110:\r
 653          if ((active0 & 0x2000000L) != 0L)\r
 654             return jjStartNfaWithStates_0(7, 25, 2);\r
 655          else if ((active0 & 0x4000000L) != 0L)\r
 656             return jjStartNfaWithStates_0(7, 26, 2);\r
 657          else if ((active0 & 0x200000000000L) != 0L)\r
 658             return jjStartNfaWithStates_0(7, 45, 2);\r
 659          break;\r
 660       case 111:\r
 661          return jjMoveStringLiteralDfa8_0(active0, 0x100000000000L);\r
 662       case 114:\r
 663          if ((active0 & 0x20000L) != 0L)\r
 664             return jjStartNfaWithStates_0(7, 17, 2);\r
 665          return jjMoveStringLiteralDfa8_0(active0, 0x100L);\r
 666       case 116:\r
 667          if ((active0 & 0x1000000000000L) != 0L)\r
 668             return jjStartNfaWithStates_0(7, 48, 2);\r
 669          return jjMoveStringLiteralDfa8_0(active0, 0x10000000000L);\r
 670       default :\r
 671          break;\r
 672    }\r
 673    return jjStartNfa_0(6, active0, 0L);\r
 674 }\r
 675 private int jjMoveStringLiteralDfa8_0(long old0, long active0)\r
 676 {\r
 677    if (((active0 &= old0)) == 0L)\r
 678       return jjStartNfa_0(6, old0, 0L);\r
 679    try { curChar = input_stream.readChar(); }\r
 680    catch(java.io.IOException e) {\r
 681       jjStopStringLiteralDfa_0(7, active0, 0L);\r
 682       return 8;\r
 683    }\r
 684    switch(curChar)\r
 685    {\r
 686       case 97:\r
 687          return jjMoveStringLiteralDfa9_0(active0, 0x40000000L);\r
 688       case 98:\r
 689          return jjMoveStringLiteralDfa9_0(active0, 0x2000L);\r
 690       case 100:\r
 691          if ((active0 & 0x8000000000000L) != 0L)\r
 692             return jjStartNfaWithStates_0(8, 51, 2);\r
 693          break;\r
 694       case 101:\r
 695          if ((active0 & 0x100L) != 0L)\r
 696             return jjStartNfaWithStates_0(8, 8, 2);\r
 697          break;\r
 698       case 105:\r
 699          return jjMoveStringLiteralDfa9_0(active0, 0x10000000000L);\r
 700       case 108:\r
 701          return jjMoveStringLiteralDfa9_0(active0, 0x2000000000000L);\r
 702       case 109:\r
 703          if ((active0 & 0x10L) != 0L)\r
 704             return jjStartNfaWithStates_0(8, 4, 2);\r
 705          break;\r
 706       case 110:\r
 707          return jjMoveStringLiteralDfa9_0(active0, 0x20000000000000L);\r
 708       case 111:\r
 709          return jjMoveStringLiteralDfa9_0(active0, 0x4000L);\r
 710       case 114:\r
 711          if ((active0 & 0x40000000000L) != 0L)\r
 712             return jjStartNfaWithStates_0(8, 42, 2);\r
 713          else if ((active0 & 0x100000000000L) != 0L)\r
 714             return jjStartNfaWithStates_0(8, 44, 2);\r
 715          break;\r
 716       default :\r
 717          break;\r
 718    }\r
 719    return jjStartNfa_0(7, active0, 0L);\r
 720 }\r
 721 private int jjMoveStringLiteralDfa9_0(long old0, long active0)\r
 722 {\r
 723    if (((active0 &= old0)) == 0L)\r
 724       return jjStartNfa_0(7, old0, 0L);\r
 725    try { curChar = input_stream.readChar(); }\r
 726    catch(java.io.IOException e) {\r
 727       jjStopStringLiteralDfa_0(8, active0, 0L);\r
 728       return 9;\r
 729    }\r
 730    switch(curChar)\r
 731    {\r
 732       case 101:\r
 733          if ((active0 & 0x2000000000000L) != 0L)\r
 734             return jjStartNfaWithStates_0(9, 49, 2);\r
 735          return jjMoveStringLiteralDfa10_0(active0, 0x20000000000000L);\r
 736       case 108:\r
 737          return jjMoveStringLiteralDfa10_0(active0, 0x2000L);\r
 738       case 110:\r
 739          if ((active0 & 0x4000L) != 0L)\r
 740             return jjStartNfaWithStates_0(9, 14, 2);\r
 741          break;\r
 742       case 111:\r
 743          return jjMoveStringLiteralDfa10_0(active0, 0x10000000000L);\r
 744       case 116:\r
 745          return jjMoveStringLiteralDfa10_0(active0, 0x40000000L);\r
 746       default :\r
 747          break;\r
 748    }\r
 749    return jjStartNfa_0(8, active0, 0L);\r
 750 }\r
 751 private int jjMoveStringLiteralDfa10_0(long old0, long active0)\r
 752 {\r
 753    if (((active0 &= old0)) == 0L)\r
 754       return jjStartNfa_0(8, old0, 0L);\r
 755    try { curChar = input_stream.readChar(); }\r
 756    catch(java.io.IOException e) {\r
 757       jjStopStringLiteralDfa_0(9, active0, 0L);\r
 758       return 10;\r
 759    }\r
 760    switch(curChar)\r
 761    {\r
 762       case 100:\r
 763          return jjMoveStringLiteralDfa11_0(active0, 0x20000000000000L);\r
 764       case 101:\r
 765          if ((active0 & 0x2000L) != 0L)\r
 766             return jjStartNfaWithStates_0(10, 13, 2);\r
 767          return jjMoveStringLiteralDfa11_0(active0, 0x40000000L);\r
 768       case 110:\r
 769          if ((active0 & 0x10000000000L) != 0L)\r
 770             return jjStartNfaWithStates_0(10, 40, 2);\r
 771          break;\r
 772       default :\r
 773          break;\r
 774    }\r
 775    return jjStartNfa_0(9, active0, 0L);\r
 776 }\r
 777 private int jjMoveStringLiteralDfa11_0(long old0, long active0)\r
 778 {\r
 779    if (((active0 &= old0)) == 0L)\r
 780       return jjStartNfa_0(9, old0, 0L);\r
 781    try { curChar = input_stream.readChar(); }\r
 782    catch(java.io.IOException e) {\r
 783       jjStopStringLiteralDfa_0(10, active0, 0L);\r
 784       return 11;\r
 785    }\r
 786    switch(curChar)\r
 787    {\r
 788       case 98:\r
 789          return jjMoveStringLiteralDfa12_0(active0, 0x20000000000000L);\r
 790       case 100:\r
 791          if ((active0 & 0x40000000L) != 0L)\r
 792             return jjStartNfaWithStates_0(11, 30, 2);\r
 793          break;\r
 794       default :\r
 795          break;\r
 796    }\r
 797    return jjStartNfa_0(10, active0, 0L);\r
 798 }\r
 799 private int jjMoveStringLiteralDfa12_0(long old0, long active0)\r
 800 {\r
 801    if (((active0 &= old0)) == 0L)\r
 802       return jjStartNfa_0(10, old0, 0L);\r
 803    try { curChar = input_stream.readChar(); }\r
 804    catch(java.io.IOException e) {\r
 805       jjStopStringLiteralDfa_0(11, active0, 0L);\r
 806       return 12;\r
 807    }\r
 808    switch(curChar)\r
 809    {\r
 810       case 121:\r
 811          if ((active0 & 0x20000000000000L) != 0L)\r
 812             return jjStartNfaWithStates_0(12, 53, 2);\r
 813          break;\r
 814       default :\r
 815          break;\r
 816    }\r
 817    return jjStartNfa_0(11, active0, 0L);\r
 818 }\r
 819 private int jjStartNfaWithStates_0(int pos, int kind, int state)\r
 820 {\r
 821    jjmatchedKind = kind;\r
 822    jjmatchedPos = pos;\r
 823    try { curChar = input_stream.readChar(); }\r
 824    catch(java.io.IOException e) { return pos + 1; }\r
 825    return jjMoveNfa_0(state, pos + 1);\r
 826 }\r
 827 static final long[] jjbitVec0 = {
 828    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 829 };\r
 830 private int jjMoveNfa_0(int startState, int curPos)\r
 831 {\r
 832    int startsAt = 0;\r
 833    jjnewStateCnt = 31;\r
 834    int i = 1;\r
 835    jjstateSet[0] = startState;\r
 836    int kind = 0x7fffffff;\r
 837    for (;;)\r
 838    {\r
 839       if (++jjround == 0x7fffffff)\r
 840          ReInitRounds();\r
 841       if (curChar < 64)\r
 842       {\r
 843          long l = 1L << curChar;\r
 844          do\r
 845          {\r
 846             switch(jjstateSet[--i])\r
 847             {\r
 848                case 13:\r
 849                   if (curChar == 47)\r
 850                   {\r
 851                      if (kind > 3)\r
 852                         kind = 3;\r
 853                      jjCheckNAdd(20);\r
 854                   }\r
 855                   else if (curChar == 42)\r
 856                      jjCheckNAddStates(0, 2);\r
 857                   break;\r
 858                case 0:\r
 859                   if ((0x3ff000000000000L & l) != 0L)\r
 860                   {\r
 861                      if (kind > 90)\r
 862                         kind = 90;\r
 863                      jjCheckNAddStates(3, 7);\r
 864                   }\r
 865                   else if ((0x100002600L & l) != 0L)\r
 866                   {\r
 867                      if (kind > 1)\r
 868                         kind = 1;\r
 869                   }\r
 870                   else if (curChar == 47)\r
 871                      jjAddStates(8, 9);\r
 872                   else if (curChar == 46)\r
 873                      jjCheckNAdd(9);\r
 874                   else if (curChar == 34)\r
 875                      jjCheckNAddStates(10, 12);\r
 876                   break;\r
 877                case 2:\r
 878                   if ((0x3ff000000000000L & l) == 0L)\r
 879                      break;\r
 880                   if (kind > 88)\r
 881                      kind = 88;\r
 882                   jjstateSet[jjnewStateCnt++] = 2;\r
 883                   break;\r
 884                case 3:\r
 885                   if (curChar == 34)\r
 886                      jjCheckNAddStates(10, 12);\r
 887                   break;\r
 888                case 4:\r
 889                   if ((0xfffffffbfffffbffL & l) != 0L)\r
 890                      jjCheckNAddStates(10, 12);\r
 891                   break;\r
 892                case 6:\r
 893                   if ((0xfffffffffffffbffL & l) != 0L)\r
 894                      jjCheckNAddStates(10, 12);\r
 895                   break;\r
 896                case 7:\r
 897                   if (curChar == 34 && kind > 89)\r
 898                      kind = 89;\r
 899                   break;\r
 900                case 8:\r
 901                   if (curChar == 46)\r
 902                      jjCheckNAdd(9);\r
 903                   break;\r
 904                case 9:\r
 905                   if ((0x3ff000000000000L & l) == 0L)\r
 906                      break;\r
 907                   if (kind > 91)\r
 908                      kind = 91;\r
 909                   jjCheckNAddTwoStates(9, 10);\r
 910                   break;\r
 911                case 11:\r
 912                   if ((0x3ff000000000000L & l) == 0L)\r
 913                      break;\r
 914                   if (kind > 91)\r
 915                      kind = 91;\r
 916                   jjstateSet[jjnewStateCnt++] = 11;\r
 917                   break;\r
 918                case 12:\r
 919                   if (curChar == 47)\r
 920                      jjAddStates(8, 9);\r
 921                   break;\r
 922                case 14:\r
 923                   if ((0xfffffbffffffffffL & l) != 0L)\r
 924                      jjCheckNAddStates(0, 2);\r
 925                   break;\r
 926                case 15:\r
 927                   if (curChar == 42)\r
 928                      jjstateSet[jjnewStateCnt++] = 16;\r
 929                   break;\r
 930                case 16:\r
 931                   if ((0xffff7fffffffffffL & l) != 0L)\r
 932                      jjCheckNAddStates(0, 2);\r
 933                   break;\r
 934                case 17:\r
 935                   if (curChar == 47 && kind > 2)\r
 936                      kind = 2;\r
 937                   break;\r
 938                case 18:\r
 939                   if (curChar == 42)\r
 940                      jjstateSet[jjnewStateCnt++] = 17;\r
 941                   break;\r
 942                case 19:\r
 943                   if (curChar != 47)\r
 944                      break;\r
 945                   if (kind > 3)\r
 946                      kind = 3;\r
 947                   jjCheckNAdd(20);\r
 948                   break;\r
 949                case 20:\r
 950                   if ((0xfffffffffffffbffL & l) == 0L)\r
 951                      break;\r
 952                   if (kind > 3)\r
 953                      kind = 3;\r
 954                   jjCheckNAdd(20);\r
 955                   break;\r
 956                case 21:\r
 957                   if ((0x3ff000000000000L & l) == 0L)\r
 958                      break;\r
 959                   if (kind > 90)\r
 960                      kind = 90;\r
 961                   jjCheckNAddStates(3, 7);\r
 962                   break;\r
 963                case 22:\r
 964                   if ((0x3ff000000000000L & l) == 0L)\r
 965                      break;\r
 966                   if (kind > 90)\r
 967                      kind = 90;\r
 968                   jjCheckNAdd(22);\r
 969                   break;\r
 970                case 23:\r
 971                   if ((0x3ff000000000000L & l) != 0L)\r
 972                      jjCheckNAddTwoStates(23, 24);\r
 973                   break;\r
 974                case 24:\r
 975                   if (curChar != 46)\r
 976                      break;\r
 977                   if (kind > 91)\r
 978                      kind = 91;\r
 979                   jjCheckNAddTwoStates(25, 26);\r
 980                   break;\r
 981                case 25:\r
 982                   if ((0x3ff000000000000L & l) == 0L)\r
 983                      break;\r
 984                   if (kind > 91)\r
 985                      kind = 91;\r
 986                   jjCheckNAddTwoStates(25, 26);\r
 987                   break;\r
 988                case 27:\r
 989                   if ((0x3ff000000000000L & l) == 0L)\r
 990                      break;\r
 991                   if (kind > 91)\r
 992                      kind = 91;\r
 993                   jjstateSet[jjnewStateCnt++] = 27;\r
 994                   break;\r
 995                case 28:\r
 996                   if ((0x3ff000000000000L & l) != 0L)\r
 997                      jjCheckNAddTwoStates(28, 29);\r
 998                   break;\r
 999                case 30:\r
1000                   if ((0x3ff000000000000L & l) == 0L)\r
1001                      break;\r
1002                   if (kind > 91)\r
1003                      kind = 91;\r
1004                   jjstateSet[jjnewStateCnt++] = 30;\r
1005                   break;\r
1006                default : break;\r
1007             }\r
1008          } while(i != startsAt);\r
1009       }\r
1010       else if (curChar < 128)\r
1011       {\r
1012          long l = 1L << (curChar & 077);\r
1013          do\r
1014          {\r
1015             switch(jjstateSet[--i])\r
1016             {\r
1017                case 0:\r
1018                case 2:\r
1019                   if ((0x7fffffe87fffffeL & l) == 0L)\r
1020                      break;\r
1021                   if (kind > 88)\r
1022                      kind = 88;\r
1023                   jjCheckNAdd(2);\r
1024                   break;\r
1025                case 4:\r
1026                   if ((0xffffffffefffffffL & l) != 0L)\r
1027                      jjCheckNAddStates(10, 12);\r
1028                   break;\r
1029                case 5:\r
1030                   if (curChar == 92)\r
1031                      jjstateSet[jjnewStateCnt++] = 6;\r
1032                   break;\r
1033                case 6:\r
1034                   jjCheckNAddStates(10, 12);\r
1035                   break;\r
1036                case 10:\r
1037                   if ((0x2000000020L & l) != 0L)\r
1038                      jjstateSet[jjnewStateCnt++] = 11;\r
1039                   break;\r
1040                case 14:\r
1041                case 16:\r
1042                   jjCheckNAddStates(0, 2);\r
1043                   break;\r
1044                case 20:\r
1045                   if (kind > 3)\r
1046                      kind = 3;\r
1047                   jjstateSet[jjnewStateCnt++] = 20;\r
1048                   break;\r
1049                case 26:\r
1050                   if ((0x2000000020L & l) != 0L)\r
1051                      jjstateSet[jjnewStateCnt++] = 27;\r
1052                   break;\r
1053                case 29:\r
1054                   if ((0x2000000020L & l) != 0L)\r
1055                      jjstateSet[jjnewStateCnt++] = 30;\r
1056                   break;\r
1057                default : break;\r
1058             }\r
1059          } while(i != startsAt);\r
1060       }\r
1061       else\r
1062       {\r
1063          int i2 = (curChar & 0xff) >> 6;\r
1064          long l2 = 1L << (curChar & 077);\r
1065          do\r
1066          {\r
1067             switch(jjstateSet[--i])\r
1068             {\r
1069                case 4:\r
1070                case 6:\r
1071                   if ((jjbitVec0[i2] & l2) != 0L)\r
1072                      jjCheckNAddStates(10, 12);\r
1073                   break;\r
1074                case 14:\r
1075                case 16:\r
1076                   if ((jjbitVec0[i2] & l2) != 0L)\r
1077                      jjCheckNAddStates(0, 2);\r
1078                   break;\r
1079                case 20:\r
1080                   if ((jjbitVec0[i2] & l2) == 0L)\r
1081                      break;\r
1082                   if (kind > 3)\r
1083                      kind = 3;\r
1084                   jjstateSet[jjnewStateCnt++] = 20;\r
1085                   break;\r
1086                default : break;\r
1087             }\r
1088          } while(i != startsAt);\r
1089       }\r
1090       if (kind != 0x7fffffff)\r
1091       {\r
1092          jjmatchedKind = kind;\r
1093          jjmatchedPos = curPos;\r
1094          kind = 0x7fffffff;\r
1095       }\r
1096       ++curPos;\r
1097       if ((i = jjnewStateCnt) == (startsAt = 31 - (jjnewStateCnt = startsAt)))\r
1098          return curPos;\r
1099       try { curChar = input_stream.readChar(); }\r
1100       catch(java.io.IOException e) { return curPos; }\r
1101    }\r
1102 }\r
1103 static final int[] jjnextStates = {
1104    14, 15, 18, 22, 23, 24, 28, 29, 13, 19, 4, 5, 7,
1105 };\r
1106 \r
1107 /** Token literal values. */\r
1108 public static final String[] jjstrLiteralImages = {\r
1109 "", null, null, null, "\141\154\147\157\162\151\164\150\155", \r
1110 "\144\151\163\143\162\145\164\145", "\146\141\154\163\145", "\155\157\144\145\154", \r
1111 "\162\145\144\145\143\154\141\162\145", "\141\156\144", "\145\141\143\150", "\146\151\156\141\154", "\156\157\164", \r
1112 "\162\145\160\154\141\143\145\141\142\154\145", "\141\156\156\157\164\141\164\151\157\156", "\145\154\163\145", \r
1113 "\146\154\157\167", "\157\160\145\162\141\164\157\162", "\162\145\164\165\162\156", \r
1114 "\141\163\163\145\162\164", "\145\154\163\145\151\146", "\146\157\162", "\157\162", \r
1115 "\163\164\162\145\141\155", "\142\154\157\143\153", "\145\154\163\145\167\150\145\156", \r
1116 "\146\165\156\143\164\151\157\156", "\157\165\164\145\162", "\164\150\145\156", "\142\162\145\141\153", \r
1117 "\145\156\143\141\160\163\165\154\141\164\145\144", "\151\146", "\157\165\164\160\165\164", "\164\162\165\145", \r
1118 "\143\154\141\163\163", "\145\156\144", "\151\155\160\157\162\164", "\160\141\143\153\141\147\145", \r
1119 "\164\171\160\145", "\143\157\156\156\145\143\164", \r
1120 "\145\156\165\155\145\162\141\164\151\157\156", "\151\156", "\160\141\162\141\155\145\164\145\162", "\167\150\145\156", \r
1121 "\143\157\156\156\145\143\164\157\162", "\145\161\165\141\164\151\157\156", "\160\141\162\164\151\141\154", \r
1122 "\167\150\151\154\145", "\143\157\156\163\164\141\156\164", \r
1123 "\145\170\160\141\156\144\141\142\154\145", "\151\156\156\145\162", "\160\162\157\164\145\143\164\145\144", \r
1124 "\167\151\164\150\151\156", "\143\157\156\163\164\162\141\151\156\145\144\142\171", \r
1125 "\145\170\164\145\156\144\163", "\151\156\160\165\164", "\160\165\142\154\151\143", \r
1126 "\145\170\164\145\162\156\141\154", "\154\157\157\160", "\162\145\143\157\162\144", "\50", "\51", "\173", "\175", \r
1127 "\133", "\135", "\56", "\72", "\73", "\54", "\74", "\74\75", "\76", "\76\75", \r
1128 "\75\75", "\74\76", "\53", "\55", "\56\53", "\56\55", "\52", "\57", "\56\52", "\56\57", \r
1129 "\136", "\56\136", "\75", "\72\75", null, null, null, null, };\r
1130 \r
1131 /** Lexer state names. */\r
1132 public static final String[] lexStateNames = {\r
1133    "DEFAULT",\r
1134 };\r
1135 static final long[] jjtoToken = {
1136    0xfffffffffffffff1L, 0xfffffffL,
1137 };\r
1138 static final long[] jjtoSkip = {
1139    0xeL, 0x0L,
1140 };\r
1141 protected SimpleCharStream input_stream;\r
1142 private final int[] jjrounds = new int[31];\r
1143 private final int[] jjstateSet = new int[62];\r
1144 private final StringBuilder jjimage = new StringBuilder();\r
1145 private StringBuilder image = jjimage;\r
1146 private int jjimageLen;\r
1147 private int lengthOfMatch;\r
1148 protected char curChar;\r
1149 /** Constructor. */\r
1150 public ExpressionParserTokenManager(SimpleCharStream stream){\r
1151    if (SimpleCharStream.staticFlag)\r
1152       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");\r
1153    input_stream = stream;\r
1154 }\r
1155 \r
1156 /** Constructor. */\r
1157 public ExpressionParserTokenManager(SimpleCharStream stream, int lexState){\r
1158    this(stream);\r
1159    SwitchTo(lexState);\r
1160 }\r
1161 \r
1162 /** Reinitialise parser. */\r
1163 public void ReInit(SimpleCharStream stream)\r
1164 {\r
1165    jjmatchedPos = jjnewStateCnt = 0;\r
1166    curLexState = defaultLexState;\r
1167    input_stream = stream;\r
1168    ReInitRounds();\r
1169 }\r
1170 private void ReInitRounds()\r
1171 {\r
1172    int i;\r
1173    jjround = 0x80000001;\r
1174    for (i = 31; i-- > 0;)\r
1175       jjrounds[i] = 0x80000000;\r
1176 }\r
1177 \r
1178 /** Reinitialise parser. */\r
1179 public void ReInit(SimpleCharStream stream, int lexState)\r
1180 {\r
1181    ReInit(stream);\r
1182    SwitchTo(lexState);\r
1183 }\r
1184 \r
1185 /** Switch to specified lex state. */\r
1186 public void SwitchTo(int lexState)\r
1187 {\r
1188    if (lexState >= 1 || lexState < 0)\r
1189       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);\r
1190    else\r
1191       curLexState = lexState;\r
1192 }\r
1193 \r
1194 protected Token jjFillToken()\r
1195 {\r
1196    final Token t;\r
1197    final String curTokenImage;\r
1198    final int beginLine;\r
1199    final int endLine;\r
1200    final int beginColumn;\r
1201    final int endColumn;\r
1202    String im = jjstrLiteralImages[jjmatchedKind];\r
1203    curTokenImage = (im == null) ? input_stream.GetImage() : im;\r
1204    beginLine = input_stream.getBeginLine();\r
1205    beginColumn = input_stream.getBeginColumn();\r
1206    endLine = input_stream.getEndLine();\r
1207    endColumn = input_stream.getEndColumn();\r
1208    t = Token.newToken(jjmatchedKind);\r
1209    t.kind = jjmatchedKind;\r
1210    t.image = curTokenImage;\r
1211 \r
1212    t.beginLine = beginLine;\r
1213    t.endLine = endLine;\r
1214    t.beginColumn = beginColumn;\r
1215    t.endColumn = endColumn;\r
1216 \r
1217    return t;\r
1218 }\r
1219 \r
1220 int curLexState = 0;\r
1221 int defaultLexState = 0;\r
1222 int jjnewStateCnt;\r
1223 int jjround;\r
1224 int jjmatchedPos;\r
1225 int jjmatchedKind;\r
1226 \r
1227 /** Get the next Token. */\r
1228 public Token getNextToken() \r
1229 {\r
1230   Token matchedToken;\r
1231   int curPos = 0;\r
1232 \r
1233   EOFLoop :
1234   for (;;)\r
1235   {\r
1236    try\r
1237    {\r
1238       curChar = input_stream.BeginToken();\r
1239    }\r
1240    catch(java.io.IOException e)\r
1241    {\r
1242       jjmatchedKind = 0;\r
1243       matchedToken = jjFillToken();\r
1244       return matchedToken;\r
1245    }\r
1246    image = jjimage;\r
1247    image.setLength(0);\r
1248    jjimageLen = 0;\r
1249 \r
1250    jjmatchedKind = 0x7fffffff;\r
1251    jjmatchedPos = 0;\r
1252    curPos = jjMoveStringLiteralDfa0_0();\r
1253    if (jjmatchedKind != 0x7fffffff)\r
1254    {\r
1255       if (jjmatchedPos + 1 < curPos)\r
1256          input_stream.backup(curPos - jjmatchedPos - 1);\r
1257       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)\r
1258       {\r
1259          matchedToken = jjFillToken();\r
1260          TokenLexicalActions(matchedToken);\r
1261          return matchedToken;\r
1262       }\r
1263       else\r
1264       {\r
1265          continue EOFLoop;\r
1266       }\r
1267    }\r
1268    int error_line = input_stream.getEndLine();\r
1269    int error_column = input_stream.getEndColumn();\r
1270    String error_after = null;\r
1271    boolean EOFSeen = false;\r
1272    try { input_stream.readChar(); input_stream.backup(1); }\r
1273    catch (java.io.IOException e1) {\r
1274       EOFSeen = true;\r
1275       error_after = curPos <= 1 ? "" : input_stream.GetImage();\r
1276       if (curChar == '\n' || curChar == '\r') {\r
1277          error_line++;\r
1278          error_column = 0;\r
1279       }\r
1280       else\r
1281          error_column++;\r
1282    }\r
1283    if (!EOFSeen) {\r
1284       input_stream.backup(1);\r
1285       error_after = curPos <= 1 ? "" : input_stream.GetImage();\r
1286    }\r
1287    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);\r
1288   }\r
1289 }\r
1290 \r
1291 void TokenLexicalActions(Token matchedToken)\r
1292 {\r
1293    switch(jjmatchedKind)\r
1294    {\r
1295       case 89 :\r
1296         image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));\r
1297       matchedToken.image = matchedToken.image.substring(1,matchedToken.image.length()-1);\r
1298          break;\r
1299       default :\r
1300          break;\r
1301    }\r
1302 }\r
1303 private void jjCheckNAdd(int state)\r
1304 {\r
1305    if (jjrounds[state] != jjround)\r
1306    {\r
1307       jjstateSet[jjnewStateCnt++] = state;\r
1308       jjrounds[state] = jjround;\r
1309    }\r
1310 }\r
1311 private void jjAddStates(int start, int end)\r
1312 {\r
1313    do {\r
1314       jjstateSet[jjnewStateCnt++] = jjnextStates[start];\r
1315    } while (start++ != end);\r
1316 }\r
1317 private void jjCheckNAddTwoStates(int state1, int state2)\r
1318 {\r
1319    jjCheckNAdd(state1);\r
1320    jjCheckNAdd(state2);\r
1321 }\r
1322 \r
1323 private void jjCheckNAddStates(int start, int end)\r
1324 {\r
1325    do {\r
1326       jjCheckNAdd(jjnextStates[start]);\r
1327    } while (start++ != end);\r
1328 }\r
1329 \r
1330 }\r