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

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