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