Coverage Report - org.webmacro.parser.WMParser_implTokenManager
 
Classes in this File Line Coverage Branch Coverage Complexity
WMParser_implTokenManager
56%
485/864
37%
291/774
13.109
 
 1  
 /* Generated By:JavaCC: Do not edit this line. WMParser_implTokenManager.java */
 2  
 package org.webmacro.parser;
 3  
 
 4  
 /** Token Manager. */
 5  
 public class WMParser_implTokenManager implements WMParser_implConstants
 6  
 {
 7  
   // Required by SetState
 8  11012
   void backup(int n) { input_stream.backup(n); }
 9  
 
 10  
   /** Debug output. */
 11  228
   public  java.io.PrintStream debugStream = System.out;
 12  
   /** Set debug output. */
 13  0
   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
 14  
 private final int jjStopStringLiteralDfa_4(int pos, long active0)
 15  
 {
 16  1356
    switch (pos)
 17  
    {
 18  
       case 0:
 19  1344
          if ((active0 & 0x400000L) != 0L)
 20  0
             return 2;
 21  1344
          return -1;
 22  
       default :
 23  12
          return -1;
 24  
    }
 25  
 }
 26  
 private final int jjStartNfa_4(int pos, long active0)
 27  
 {
 28  1356
    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
 29  
 }
 30  
 private int jjStopAtPos(int pos, int kind)
 31  
 {
 32  33982
    jjmatchedKind = kind;
 33  33982
    jjmatchedPos = pos;
 34  33982
    return pos + 1;
 35  
 }
 36  
 private int jjMoveStringLiteralDfa0_4()
 37  
 {
 38  27200
    switch(curChar)
 39  
    {
 40  
       case 35:
 41  11046
          jjmatchedKind = 23;
 42  11046
          return jjMoveStringLiteralDfa1_4(0x26000L);
 43  
       case 36:
 44  2606
          return jjStopAtPos(0, 20);
 45  
       case 92:
 46  252
          return jjStartNfaWithStates_4(0, 22, 2);
 47  
       case 123:
 48  160
          return jjStopAtPos(0, 15);
 49  
       case 125:
 50  158
          return jjStopAtPos(0, 12);
 51  
       default :
 52  12978
          return jjMoveNfa_4(1, 0);
 53  
    }
 54  
 }
 55  
 private int jjMoveStringLiteralDfa1_4(long active0)
 56  
 {
 57  11046
    try { curChar = input_stream.readChar(); }
 58  0
    catch(java.io.IOException e) {
 59  0
       jjStopStringLiteralDfa_4(0, active0);
 60  0
       return 1;
 61  11046
    }
 62  11046
    switch(curChar)
 63  
    {
 64  
       case 35:
 65  7204
          if ((active0 & 0x20000L) != 0L)
 66  7204
             return jjStopAtPos(1, 17);
 67  
          break;
 68  
       case 98:
 69  1240
          return jjMoveStringLiteralDfa2_4(active0, 0x4000L);
 70  
       case 101:
 71  1258
          return jjMoveStringLiteralDfa2_4(active0, 0x2000L);
 72  
       default :
 73  
          break;
 74  
    }
 75  1344
    return jjStartNfa_4(0, active0);
 76  
 }
 77  
 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
 78  
 {
 79  2498
    if (((active0 &= old0)) == 0L)
 80  0
       return jjStartNfa_4(0, old0); 
 81  2498
    try { curChar = input_stream.readChar(); }
 82  0
    catch(java.io.IOException e) {
 83  0
       jjStopStringLiteralDfa_4(1, active0);
 84  0
       return 2;
 85  2498
    }
 86  2498
    switch(curChar)
 87  
    {
 88  
       case 101:
 89  1246
          return jjMoveStringLiteralDfa3_4(active0, 0x4000L);
 90  
       case 110:
 91  1246
          return jjMoveStringLiteralDfa3_4(active0, 0x2000L);
 92  
       default :
 93  
          break;
 94  
    }
 95  6
    return jjStartNfa_4(1, active0);
 96  
 }
 97  
 private int jjMoveStringLiteralDfa3_4(long old0, long active0)
 98  
 {
 99  2492
    if (((active0 &= old0)) == 0L)
 100  6
       return jjStartNfa_4(1, old0); 
 101  2486
    try { curChar = input_stream.readChar(); }
 102  0
    catch(java.io.IOException e) {
 103  0
       jjStopStringLiteralDfa_4(2, active0);
 104  0
       return 3;
 105  2486
    }
 106  2486
    switch(curChar)
 107  
    {
 108  
       case 100:
 109  1246
          if ((active0 & 0x2000L) != 0L)
 110  1246
             return jjStopAtPos(3, 13);
 111  
          break;
 112  
       case 103:
 113  1240
          return jjMoveStringLiteralDfa4_4(active0, 0x4000L);
 114  
       default :
 115  
          break;
 116  
    }
 117  0
    return jjStartNfa_4(2, active0);
 118  
 }
 119  
 private int jjMoveStringLiteralDfa4_4(long old0, long active0)
 120  
 {
 121  1240
    if (((active0 &= old0)) == 0L)
 122  0
       return jjStartNfa_4(2, old0); 
 123  1240
    try { curChar = input_stream.readChar(); }
 124  0
    catch(java.io.IOException e) {
 125  0
       jjStopStringLiteralDfa_4(3, active0);
 126  0
       return 4;
 127  1240
    }
 128  1240
    switch(curChar)
 129  
    {
 130  
       case 105:
 131  1240
          return jjMoveStringLiteralDfa5_4(active0, 0x4000L);
 132  
       default :
 133  
          break;
 134  
    }
 135  0
    return jjStartNfa_4(3, active0);
 136  
 }
 137  
 private int jjMoveStringLiteralDfa5_4(long old0, long active0)
 138  
 {
 139  1240
    if (((active0 &= old0)) == 0L)
 140  0
       return jjStartNfa_4(3, old0); 
 141  1240
    try { curChar = input_stream.readChar(); }
 142  0
    catch(java.io.IOException e) {
 143  0
       jjStopStringLiteralDfa_4(4, active0);
 144  0
       return 5;
 145  1240
    }
 146  1240
    switch(curChar)
 147  
    {
 148  
       case 110:
 149  1240
          if ((active0 & 0x4000L) != 0L)
 150  1240
             return jjStopAtPos(5, 14);
 151  
          break;
 152  
       default :
 153  
          break;
 154  
    }
 155  0
    return jjStartNfa_4(4, active0);
 156  
 }
 157  
 private int jjStartNfaWithStates_4(int pos, int kind, int state)
 158  
 {
 159  252
    jjmatchedKind = kind;
 160  252
    jjmatchedPos = pos;
 161  252
    try { curChar = input_stream.readChar(); }
 162  252
    catch(java.io.IOException e) { return pos + 1; }
 163  252
    return jjMoveNfa_4(state, pos + 1);
 164  
 }
 165  2
 static final long[] jjbitVec0 = {
 166  
    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 167  
 };
 168  2
 static final long[] jjbitVec2 = {
 169  
    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 170  
 };
 171  
 private int jjMoveNfa_4(int startState, int curPos)
 172  
 {
 173  14586
    int startsAt = 0;
 174  14586
    jjnewStateCnt = 5;
 175  14586
    int i = 1;
 176  14586
    jjstateSet[0] = startState;
 177  14586
    int kind = 0x7fffffff;
 178  
    for (;;)
 179  
    {
 180  250256
       if (++jjround == 0x7fffffff)
 181  0
          ReInitRounds();
 182  250256
       if (curChar < 64)
 183  
       {
 184  115620
          long l = 1L << curChar;
 185  
          do
 186  
          {
 187  115620
             switch(jjstateSet[--i])
 188  
             {
 189  
                case 1:
 190  
                case 0:
 191  115464
                   if ((0xffffffe7ffffffffL & l) == 0L)
 192  12214
                      break;
 193  103250
                   if (kind > 11)
 194  103250
                      kind = 11;
 195  103250
                   jjCheckNAdd(0);
 196  103250
                   break;
 197  
                case 2:
 198  156
                   if ((0xfc00ffffffffffffL & l) != 0L)
 199  
                   {
 200  156
                      if (kind > 21)
 201  156
                         kind = 21;
 202  
                   }
 203  156
                   if (curChar == 13)
 204  0
                      jjstateSet[jjnewStateCnt++] = 3;
 205  
                   break;
 206  
                case 3:
 207  0
                   if (curChar == 10 && kind > 21)
 208  0
                      kind = 21;
 209  
                   break;
 210  
                case 4:
 211  0
                   if (curChar == 13)
 212  0
                      jjstateSet[jjnewStateCnt++] = 3;
 213  
                   break;
 214  
                default : break;
 215  
             }
 216  115620
          } while(i != startsAt);
 217  115620
       }
 218  134636
       else if (curChar < 128)
 219  
       {
 220  134636
          long l = 1L << (curChar & 077);
 221  
          do
 222  
          {
 223  134636
             switch(jjstateSet[--i])
 224  
             {
 225  
                case 1:
 226  854
                   if ((0xd7ffffffefffffffL & l) != 0L)
 227  
                   {
 228  854
                      if (kind > 11)
 229  854
                         kind = 11;
 230  854
                      jjCheckNAdd(0);
 231  
                   }
 232  0
                   else if (curChar == 92)
 233  0
                      jjAddStates(0, 1);
 234  
                   break;
 235  
                case 2:
 236  96
                   if ((0xf8000001f8000001L & l) != 0L && kind > 21)
 237  96
                      kind = 21;
 238  
                   break;
 239  
                case 0:
 240  132330
                   if ((0xd7ffffffefffffffL & l) == 0L)
 241  552
                      break;
 242  131778
                   if (kind > 11)
 243  131778
                      kind = 11;
 244  131778
                   jjCheckNAdd(0);
 245  131778
                   break;
 246  
                default : break;
 247  
             }
 248  134636
          } while(i != startsAt);
 249  134636
       }
 250  
       else
 251  
       {
 252  0
          int hiByte = (int)(curChar >> 8);
 253  0
          int i1 = hiByte >> 6;
 254  0
          long l1 = 1L << (hiByte & 077);
 255  0
          int i2 = (curChar & 0xff) >> 6;
 256  0
          long l2 = 1L << (curChar & 077);
 257  
          do
 258  
          {
 259  0
             switch(jjstateSet[--i])
 260  
             {
 261  
                case 1:
 262  
                case 0:
 263  0
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 264  0
                      break;
 265  0
                   if (kind > 11)
 266  0
                      kind = 11;
 267  0
                   jjCheckNAdd(0);
 268  0
                   break;
 269  
                case 2:
 270  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 21)
 271  0
                      kind = 21;
 272  
                   break;
 273  
                default : break;
 274  
             }
 275  0
          } while(i != startsAt);
 276  
       }
 277  250256
       if (kind != 0x7fffffff)
 278  
       {
 279  236134
          jjmatchedKind = kind;
 280  236134
          jjmatchedPos = curPos;
 281  236134
          kind = 0x7fffffff;
 282  
       }
 283  250256
       ++curPos;
 284  250256
       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
 285  14374
          return curPos;
 286  235882
       try { curChar = input_stream.readChar(); }
 287  235670
       catch(java.io.IOException e) { return curPos; }
 288  
    }
 289  
 }
 290  
 private int jjMoveStringLiteralDfa0_1()
 291  
 {
 292  846
    switch(curChar)
 293  
    {
 294  
       case 34:
 295  424
          return jjStopAtPos(0, 24);
 296  
       case 36:
 297  110
          return jjStopAtPos(0, 20);
 298  
       case 92:
 299  0
          return jjStartNfaWithStates_1(0, 22, 1);
 300  
       default :
 301  312
          return jjMoveNfa_1(0, 0);
 302  
    }
 303  
 }
 304  
 private int jjStartNfaWithStates_1(int pos, int kind, int state)
 305  
 {
 306  0
    jjmatchedKind = kind;
 307  0
    jjmatchedPos = pos;
 308  0
    try { curChar = input_stream.readChar(); }
 309  0
    catch(java.io.IOException e) { return pos + 1; }
 310  0
    return jjMoveNfa_1(state, pos + 1);
 311  
 }
 312  
 private int jjMoveNfa_1(int startState, int curPos)
 313  
 {
 314  312
    int startsAt = 0;
 315  312
    jjnewStateCnt = 5;
 316  312
    int i = 1;
 317  312
    jjstateSet[0] = startState;
 318  312
    int kind = 0x7fffffff;
 319  
    for (;;)
 320  
    {
 321  5202
       if (++jjround == 0x7fffffff)
 322  0
          ReInitRounds();
 323  5202
       if (curChar < 64)
 324  
       {
 325  708
          long l = 1L << curChar;
 326  
          do
 327  
          {
 328  708
             switch(jjstateSet[--i])
 329  
             {
 330  
                case 1:
 331  0
                   if ((0xfc00ffffffffffffL & l) != 0L)
 332  
                   {
 333  0
                      if (kind > 21)
 334  0
                         kind = 21;
 335  
                   }
 336  0
                   if (curChar == 13)
 337  0
                      jjstateSet[jjnewStateCnt++] = 2;
 338  
                   break;
 339  
                case 0:
 340  
                case 4:
 341  708
                   if ((0xffffffebffffdbffL & l) == 0L)
 342  312
                      break;
 343  396
                   if (kind > 57)
 344  396
                      kind = 57;
 345  396
                   jjCheckNAdd(4);
 346  396
                   break;
 347  
                case 2:
 348  0
                   if (curChar == 10 && kind > 21)
 349  0
                      kind = 21;
 350  
                   break;
 351  
                case 3:
 352  0
                   if (curChar == 13)
 353  0
                      jjstateSet[jjnewStateCnt++] = 2;
 354  
                   break;
 355  
                default : break;
 356  
             }
 357  708
          } while(i != startsAt);
 358  708
       }
 359  4494
       else if (curChar < 128)
 360  
       {
 361  4494
          long l = 1L << (curChar & 077);
 362  
          do
 363  
          {
 364  4494
             switch(jjstateSet[--i])
 365  
             {
 366  
                case 1:
 367  0
                   if ((0xf8000001f8000001L & l) != 0L && kind > 21)
 368  0
                      kind = 21;
 369  
                   break;
 370  
                case 0:
 371  270
                   if ((0xffffffffefffffffL & l) != 0L)
 372  
                   {
 373  270
                      if (kind > 57)
 374  270
                         kind = 57;
 375  270
                      jjCheckNAdd(4);
 376  
                   }
 377  0
                   else if (curChar == 92)
 378  0
                      jjAddStates(2, 3);
 379  
                   break;
 380  
                case 4:
 381  4224
                   if ((0xffffffffefffffffL & l) == 0L)
 382  0
                      break;
 383  4224
                   if (kind > 57)
 384  4224
                      kind = 57;
 385  4224
                   jjCheckNAdd(4);
 386  4224
                   break;
 387  
                default : break;
 388  
             }
 389  4494
          } while(i != startsAt);
 390  4494
       }
 391  
       else
 392  
       {
 393  0
          int hiByte = (int)(curChar >> 8);
 394  0
          int i1 = hiByte >> 6;
 395  0
          long l1 = 1L << (hiByte & 077);
 396  0
          int i2 = (curChar & 0xff) >> 6;
 397  0
          long l2 = 1L << (curChar & 077);
 398  
          do
 399  
          {
 400  0
             switch(jjstateSet[--i])
 401  
             {
 402  
                case 1:
 403  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 21)
 404  0
                      kind = 21;
 405  
                   break;
 406  
                case 0:
 407  
                case 4:
 408  0
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 409  0
                      break;
 410  0
                   if (kind > 57)
 411  0
                      kind = 57;
 412  0
                   jjCheckNAdd(4);
 413  0
                   break;
 414  
                default : break;
 415  
             }
 416  0
          } while(i != startsAt);
 417  
       }
 418  5202
       if (kind != 0x7fffffff)
 419  
       {
 420  4890
          jjmatchedKind = kind;
 421  4890
          jjmatchedPos = curPos;
 422  4890
          kind = 0x7fffffff;
 423  
       }
 424  5202
       ++curPos;
 425  5202
       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
 426  312
          return curPos;
 427  4890
       try { curChar = input_stream.readChar(); }
 428  4890
       catch(java.io.IOException e) { return curPos; }
 429  
    }
 430  
 }
 431  
 private int jjMoveStringLiteralDfa0_2()
 432  
 {
 433  7204
    return jjMoveNfa_2(0, 0);
 434  
 }
 435  
 private int jjMoveNfa_2(int startState, int curPos)
 436  
 {
 437  7204
    int startsAt = 0;
 438  7204
    jjnewStateCnt = 1;
 439  7204
    int i = 1;
 440  7204
    jjstateSet[0] = startState;
 441  7204
    int kind = 0x7fffffff;
 442  
    for (;;)
 443  
    {
 444  264974
       if (++jjround == 0x7fffffff)
 445  0
          ReInitRounds();
 446  264974
       if (curChar < 64)
 447  
       {
 448  67508
          long l = 1L << curChar;
 449  
          do
 450  
          {
 451  67508
             switch(jjstateSet[--i])
 452  
             {
 453  
                case 0:
 454  67508
                   if ((0xffffffffffffdbffL & l) == 0L)
 455  7204
                      break;
 456  60304
                   kind = 18;
 457  60304
                   jjstateSet[jjnewStateCnt++] = 0;
 458  60304
                   break;
 459  
                default : break;
 460  
             }
 461  67508
          } while(i != startsAt);
 462  67508
       }
 463  197466
       else if (curChar < 128)
 464  
       {
 465  
          //long l = 1L << (curChar & 077);
 466  
          do
 467  
          {
 468  197466
             switch(jjstateSet[--i])
 469  
             {
 470  
                case 0:
 471  197466
                   kind = 18;
 472  197466
                   jjstateSet[jjnewStateCnt++] = 0;
 473  197466
                   break;
 474  
                default : break;
 475  
             }
 476  197466
          } while(i != startsAt);
 477  
       }
 478  
       else
 479  
       {
 480  0
          int hiByte = (int)(curChar >> 8);
 481  0
          int i1 = hiByte >> 6;
 482  0
          long l1 = 1L << (hiByte & 077);
 483  0
          int i2 = (curChar & 0xff) >> 6;
 484  0
          long l2 = 1L << (curChar & 077);
 485  
          do
 486  
          {
 487  0
             switch(jjstateSet[--i])
 488  
             {
 489  
                case 0:
 490  0
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 491  0
                      break;
 492  0
                   if (kind > 18)
 493  0
                      kind = 18;
 494  0
                   jjstateSet[jjnewStateCnt++] = 0;
 495  0
                   break;
 496  
                default : break;
 497  
             }
 498  0
          } while(i != startsAt);
 499  
       }
 500  264974
       if (kind != 0x7fffffff)
 501  
       {
 502  257770
          jjmatchedKind = kind;
 503  257770
          jjmatchedPos = curPos;
 504  257770
          kind = 0x7fffffff;
 505  
       }
 506  264974
       ++curPos;
 507  264974
       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
 508  7204
          return curPos;
 509  257770
       try { curChar = input_stream.readChar(); }
 510  257770
       catch(java.io.IOException e) { return curPos; }
 511  
    }
 512  
 }
 513  
 private final int jjStopStringLiteralDfa_3(int pos, long active0)
 514  
 {
 515  2864
    switch (pos)
 516  
    {
 517  
       case 0:
 518  2704
          if ((active0 & 0x400000L) != 0L)
 519  0
             return 4;
 520  2704
          if ((active0 & 0x804000L) != 0L)
 521  654
             return 0;
 522  2050
          if ((active0 & 0x3c000000L) != 0L)
 523  
          {
 524  1182
             jjmatchedKind = 54;
 525  1182
             return 29;
 526  
          }
 527  868
          if ((active0 & 0xc000000000L) != 0L)
 528  372
             return 13;
 529  496
          return -1;
 530  
       case 1:
 531  160
          if ((active0 & 0x3c000000L) != 0L)
 532  
          {
 533  160
             jjmatchedKind = 54;
 534  160
             jjmatchedPos = 1;
 535  160
             return 29;
 536  
          }
 537  0
          return -1;
 538  
       case 2:
 539  0
          if ((active0 & 0x3c000000L) != 0L)
 540  
          {
 541  0
             jjmatchedKind = 54;
 542  0
             jjmatchedPos = 2;
 543  0
             return 29;
 544  
          }
 545  0
          return -1;
 546  
       case 3:
 547  0
          if ((active0 & 0x30000000L) != 0L)
 548  
          {
 549  0
             jjmatchedKind = 54;
 550  0
             jjmatchedPos = 3;
 551  0
             return 29;
 552  
          }
 553  0
          if ((active0 & 0xc000000L) != 0L)
 554  0
             return 29;
 555  0
          return -1;
 556  
       case 4:
 557  0
          if ((active0 & 0x20000000L) != 0L)
 558  
          {
 559  0
             jjmatchedKind = 54;
 560  0
             jjmatchedPos = 4;
 561  0
             return 29;
 562  
          }
 563  0
          if ((active0 & 0x10000000L) != 0L)
 564  0
             return 29;
 565  0
          return -1;
 566  
       case 5:
 567  0
          if ((active0 & 0x20000000L) != 0L)
 568  
          {
 569  0
             jjmatchedKind = 54;
 570  0
             jjmatchedPos = 5;
 571  0
             return 29;
 572  
          }
 573  0
          return -1;
 574  
       case 6:
 575  0
          if ((active0 & 0x20000000L) != 0L)
 576  
          {
 577  0
             jjmatchedKind = 54;
 578  0
             jjmatchedPos = 6;
 579  0
             return 29;
 580  
          }
 581  0
          return -1;
 582  
       case 7:
 583  0
          if ((active0 & 0x20000000L) != 0L)
 584  
          {
 585  0
             jjmatchedKind = 54;
 586  0
             jjmatchedPos = 7;
 587  0
             return 29;
 588  
          }
 589  0
          return -1;
 590  
       default :
 591  0
          return -1;
 592  
    }
 593  
 }
 594  
 private final int jjStartNfa_3(int pos, long active0)
 595  
 {
 596  2864
    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
 597  
 }
 598  
 private int jjMoveStringLiteralDfa0_3()
 599  
 {
 600  43972
    switch(curChar)
 601  
    {
 602  
       case 34:
 603  1458
          return jjStopAtPos(0, 24);
 604  
       case 35:
 605  1894
          jjmatchedKind = 23;
 606  1894
          return jjMoveStringLiteralDfa1_3(0x4000L);
 607  
       case 36:
 608  5968
          return jjStopAtPos(0, 20);
 609  
       case 39:
 610  472
          return jjStopAtPos(0, 25);
 611  
       case 40:
 612  3010
          return jjStopAtPos(0, 32);
 613  
       case 41:
 614  3076
          return jjStopAtPos(0, 33);
 615  
       case 42:
 616  4
          return jjStopAtPos(0, 47);
 617  
       case 43:
 618  0
          return jjStopAtPos(0, 45);
 619  
       case 44:
 620  162
          return jjStopAtPos(0, 52);
 621  
       case 45:
 622  22
          return jjStopAtPos(0, 46);
 623  
       case 46:
 624  5158
          return jjStopAtPos(0, 37);
 625  
       case 47:
 626  194
          return jjStopAtPos(0, 48);
 627  
       case 58:
 628  0
          return jjStopAtPos(0, 36);
 629  
       case 59:
 630  2
          return jjStopAtPos(0, 53);
 631  
       case 60:
 632  372
          jjmatchedKind = 38;
 633  372
          return jjMoveStringLiteralDfa1_3(0x8000000000L);
 634  
       case 61:
 635  432
          jjmatchedKind = 43;
 636  432
          return jjMoveStringLiteralDfa1_3(0x40000000000L);
 637  
       case 62:
 638  108
          jjmatchedKind = 40;
 639  108
          return jjMoveStringLiteralDfa1_3(0x20000000000L);
 640  
       case 91:
 641  0
          return jjStopAtPos(0, 34);
 642  
       case 92:
 643  0
          return jjStartNfaWithStates_3(0, 22, 4);
 644  
       case 93:
 645  14
          return jjStopAtPos(0, 35);
 646  
       case 102:
 647  836
          return jjMoveStringLiteralDfa1_3(0x10000000L);
 648  
       case 110:
 649  170
          return jjMoveStringLiteralDfa1_3(0x4000000L);
 650  
       case 116:
 651  496
          return jjMoveStringLiteralDfa1_3(0x8000000L);
 652  
       case 117:
 653  12
          return jjMoveStringLiteralDfa1_3(0x20000000L);
 654  
       case 123:
 655  10
          return jjStopAtPos(0, 15);
 656  
       default :
 657  20102
          return jjMoveNfa_3(2, 0);
 658  
    }
 659  
 }
 660  
 private int jjMoveStringLiteralDfa1_3(long active0)
 661  
 {
 662  4320
    try { curChar = input_stream.readChar(); }
 663  0
    catch(java.io.IOException e) {
 664  0
       jjStopStringLiteralDfa_3(0, active0);
 665  0
       return 1;
 666  4320
    }
 667  4320
    switch(curChar)
 668  
    {
 669  
       case 61:
 670  44
          if ((active0 & 0x8000000000L) != 0L)
 671  0
             return jjStopAtPos(1, 39);
 672  44
          else if ((active0 & 0x20000000000L) != 0L)
 673  0
             return jjStopAtPos(1, 41);
 674  44
          else if ((active0 & 0x40000000000L) != 0L)
 675  44
             return jjStopAtPos(1, 42);
 676  
          break;
 677  
       case 97:
 678  238
          return jjMoveStringLiteralDfa2_3(active0, 0x10000000L);
 679  
       case 98:
 680  1248
          return jjMoveStringLiteralDfa2_3(active0, 0x4000L);
 681  
       case 110:
 682  2
          return jjMoveStringLiteralDfa2_3(active0, 0x20000000L);
 683  
       case 114:
 684  202
          return jjMoveStringLiteralDfa2_3(active0, 0x8000000L);
 685  
       case 117:
 686  118
          return jjMoveStringLiteralDfa2_3(active0, 0x4000000L);
 687  
       default :
 688  
          break;
 689  
    }
 690  2468
    return jjStartNfa_3(0, active0);
 691  
 }
 692  
 private int jjMoveStringLiteralDfa2_3(long old0, long active0)
 693  
 {
 694  1808
    if (((active0 &= old0)) == 0L)
 695  236
       return jjStartNfa_3(0, old0); 
 696  1572
    try { curChar = input_stream.readChar(); }
 697  0
    catch(java.io.IOException e) {
 698  0
       jjStopStringLiteralDfa_3(1, active0);
 699  0
       return 2;
 700  1572
    }
 701  1572
    switch(curChar)
 702  
    {
 703  
       case 100:
 704  2
          return jjMoveStringLiteralDfa3_3(active0, 0x20000000L);
 705  
       case 101:
 706  1364
          return jjMoveStringLiteralDfa3_3(active0, 0x4000L);
 707  
       case 108:
 708  134
          return jjMoveStringLiteralDfa3_3(active0, 0x14000000L);
 709  
       case 117:
 710  36
          return jjMoveStringLiteralDfa3_3(active0, 0x8000000L);
 711  
       default :
 712  
          break;
 713  
    }
 714  36
    return jjStartNfa_3(1, active0);
 715  
 }
 716  
 private int jjMoveStringLiteralDfa3_3(long old0, long active0)
 717  
 {
 718  1536
    if (((active0 &= old0)) == 0L)
 719  124
       return jjStartNfa_3(1, old0); 
 720  1412
    try { curChar = input_stream.readChar(); }
 721  0
    catch(java.io.IOException e) {
 722  0
       jjStopStringLiteralDfa_3(2, active0);
 723  0
       return 3;
 724  1412
    }
 725  1412
    switch(curChar)
 726  
    {
 727  
       case 101:
 728  38
          if ((active0 & 0x8000000L) != 0L)
 729  36
             return jjStartNfaWithStates_3(3, 27, 29);
 730  2
          return jjMoveStringLiteralDfa4_3(active0, 0x20000000L);
 731  
       case 103:
 732  1240
          return jjMoveStringLiteralDfa4_3(active0, 0x4000L);
 733  
       case 108:
 734  118
          if ((active0 & 0x4000000L) != 0L)
 735  118
             return jjStartNfaWithStates_3(3, 26, 29);
 736  
          break;
 737  
       case 115:
 738  16
          return jjMoveStringLiteralDfa4_3(active0, 0x10000000L);
 739  
       default :
 740  
          break;
 741  
    }
 742  0
    return jjStartNfa_3(2, active0);
 743  
 }
 744  
 private int jjMoveStringLiteralDfa4_3(long old0, long active0)
 745  
 {
 746  1258
    if (((active0 &= old0)) == 0L)
 747  0
       return jjStartNfa_3(2, old0); 
 748  1258
    try { curChar = input_stream.readChar(); }
 749  0
    catch(java.io.IOException e) {
 750  0
       jjStopStringLiteralDfa_3(3, active0);
 751  0
       return 4;
 752  1258
    }
 753  1258
    switch(curChar)
 754  
    {
 755  
       case 101:
 756  16
          if ((active0 & 0x10000000L) != 0L)
 757  16
             return jjStartNfaWithStates_3(4, 28, 29);
 758  
          break;
 759  
       case 102:
 760  2
          return jjMoveStringLiteralDfa5_3(active0, 0x20000000L);
 761  
       case 105:
 762  1240
          return jjMoveStringLiteralDfa5_3(active0, 0x4000L);
 763  
       default :
 764  
          break;
 765  
    }
 766  0
    return jjStartNfa_3(3, active0);
 767  
 }
 768  
 private int jjMoveStringLiteralDfa5_3(long old0, long active0)
 769  
 {
 770  1242
    if (((active0 &= old0)) == 0L)
 771  0
       return jjStartNfa_3(3, old0); 
 772  1242
    try { curChar = input_stream.readChar(); }
 773  0
    catch(java.io.IOException e) {
 774  0
       jjStopStringLiteralDfa_3(4, active0);
 775  0
       return 5;
 776  1242
    }
 777  1242
    switch(curChar)
 778  
    {
 779  
       case 105:
 780  2
          return jjMoveStringLiteralDfa6_3(active0, 0x20000000L);
 781  
       case 110:
 782  1240
          if ((active0 & 0x4000L) != 0L)
 783  1240
             return jjStopAtPos(5, 14);
 784  
          break;
 785  
       default :
 786  
          break;
 787  
    }
 788  0
    return jjStartNfa_3(4, active0);
 789  
 }
 790  
 private int jjMoveStringLiteralDfa6_3(long old0, long active0)
 791  
 {
 792  2
    if (((active0 &= old0)) == 0L)
 793  0
       return jjStartNfa_3(4, old0); 
 794  2
    try { curChar = input_stream.readChar(); }
 795  0
    catch(java.io.IOException e) {
 796  0
       jjStopStringLiteralDfa_3(5, active0);
 797  0
       return 6;
 798  2
    }
 799  2
    switch(curChar)
 800  
    {
 801  
       case 110:
 802  2
          return jjMoveStringLiteralDfa7_3(active0, 0x20000000L);
 803  
       default :
 804  
          break;
 805  
    }
 806  0
    return jjStartNfa_3(5, active0);
 807  
 }
 808  
 private int jjMoveStringLiteralDfa7_3(long old0, long active0)
 809  
 {
 810  2
    if (((active0 &= old0)) == 0L)
 811  0
       return jjStartNfa_3(5, old0); 
 812  2
    try { curChar = input_stream.readChar(); }
 813  0
    catch(java.io.IOException e) {
 814  0
       jjStopStringLiteralDfa_3(6, active0);
 815  0
       return 7;
 816  2
    }
 817  2
    switch(curChar)
 818  
    {
 819  
       case 101:
 820  2
          return jjMoveStringLiteralDfa8_3(active0, 0x20000000L);
 821  
       default :
 822  
          break;
 823  
    }
 824  0
    return jjStartNfa_3(6, active0);
 825  
 }
 826  
 private int jjMoveStringLiteralDfa8_3(long old0, long active0)
 827  
 {
 828  2
    if (((active0 &= old0)) == 0L)
 829  0
       return jjStartNfa_3(6, old0); 
 830  2
    try { curChar = input_stream.readChar(); }
 831  0
    catch(java.io.IOException e) {
 832  0
       jjStopStringLiteralDfa_3(7, active0);
 833  0
       return 8;
 834  2
    }
 835  2
    switch(curChar)
 836  
    {
 837  
       case 100:
 838  2
          if ((active0 & 0x20000000L) != 0L)
 839  2
             return jjStartNfaWithStates_3(8, 29, 29);
 840  
          break;
 841  
       default :
 842  
          break;
 843  
    }
 844  0
    return jjStartNfa_3(7, active0);
 845  
 }
 846  
 private int jjStartNfaWithStates_3(int pos, int kind, int state)
 847  
 {
 848  172
    jjmatchedKind = kind;
 849  172
    jjmatchedPos = pos;
 850  172
    try { curChar = input_stream.readChar(); }
 851  172
    catch(java.io.IOException e) { return pos + 1; }
 852  172
    return jjMoveNfa_3(state, pos + 1);
 853  
 }
 854  
 private int jjMoveNfa_3(int startState, int curPos)
 855  
 {
 856  23138
    int startsAt = 0;
 857  23138
    jjnewStateCnt = 31;
 858  23138
    int i = 1;
 859  23138
    jjstateSet[0] = startState;
 860  23138
    int kind = 0x7fffffff;
 861  
    for (;;)
 862  
    {
 863  114592
       if (++jjround == 0x7fffffff)
 864  0
          ReInitRounds();
 865  114592
       if (curChar < 64)
 866  
       {
 867  29014
          long l = 1L << curChar;
 868  
          do
 869  
          {
 870  29014
             switch(jjstateSet[--i])
 871  
             {
 872  
                case 4:
 873  0
                   if ((0xfc00ffffffffffffL & l) != 0L)
 874  
                   {
 875  0
                      if (kind > 21)
 876  0
                         kind = 21;
 877  
                   }
 878  0
                   if (curChar == 13)
 879  0
                      jjstateSet[jjnewStateCnt++] = 5;
 880  
                   break;
 881  
                case 2:
 882  8214
                   if ((0x3ff000000000000L & l) != 0L)
 883  
                   {
 884  36
                      if (kind > 55)
 885  36
                         kind = 55;
 886  36
                      jjCheckNAdd(30);
 887  
                   }
 888  8178
                   else if ((0x2400L & l) != 0L)
 889  
                   {
 890  2864
                      if (kind > 31)
 891  2864
                         kind = 31;
 892  
                   }
 893  5314
                   else if ((0x100000200L & l) != 0L)
 894  
                   {
 895  4976
                      if (kind > 30)
 896  4976
                         kind = 30;
 897  4976
                      jjCheckNAdd(7);
 898  
                   }
 899  338
                   else if (curChar == 33)
 900  
                   {
 901  100
                      if (kind > 51)
 902  100
                         kind = 51;
 903  
                   }
 904  238
                   else if (curChar == 38)
 905  170
                      jjstateSet[jjnewStateCnt++] = 15;
 906  68
                   else if (curChar == 60)
 907  0
                      jjstateSet[jjnewStateCnt++] = 13;
 908  68
                   else if (curChar == 35)
 909  0
                      jjstateSet[jjnewStateCnt++] = 0;
 910  8214
                   if (curChar == 33)
 911  100
                      jjstateSet[jjnewStateCnt++] = 11;
 912  8114
                   else if (curChar == 13)
 913  0
                      jjstateSet[jjnewStateCnt++] = 8;
 914  
                   break;
 915  
                case 0:
 916  28
                   if (curChar != 35)
 917  0
                      break;
 918  28
                   if (kind > 16)
 919  28
                      kind = 16;
 920  28
                   jjCheckNAdd(1);
 921  28
                   break;
 922  
                case 1:
 923  260
                   if ((0xffffffffffffdbffL & l) == 0L)
 924  28
                      break;
 925  232
                   if (kind > 16)
 926  232
                      kind = 16;
 927  232
                   jjCheckNAdd(1);
 928  232
                   break;
 929  
                case 5:
 930  0
                   if (curChar == 10 && kind > 21)
 931  0
                      kind = 21;
 932  
                   break;
 933  
                case 6:
 934  0
                   if (curChar == 13)
 935  0
                      jjstateSet[jjnewStateCnt++] = 5;
 936  
                   break;
 937  
                case 7:
 938  5998
                   if ((0x100000200L & l) == 0L)
 939  4460
                      break;
 940  1538
                   if (kind > 30)
 941  1538
                      kind = 30;
 942  1538
                   jjCheckNAdd(7);
 943  1538
                   break;
 944  
                case 8:
 945  0
                   if (curChar == 10 && kind > 31)
 946  0
                      kind = 31;
 947  
                   break;
 948  
                case 9:
 949  0
                   if (curChar == 13)
 950  0
                      jjstateSet[jjnewStateCnt++] = 8;
 951  
                   break;
 952  
                case 10:
 953  0
                   if ((0x2400L & l) != 0L && kind > 31)
 954  0
                      kind = 31;
 955  
                   break;
 956  
                case 11:
 957  100
                   if (curChar == 61 && kind > 44)
 958  58
                      kind = 44;
 959  
                   break;
 960  
                case 12:
 961  0
                   if (curChar == 33)
 962  0
                      jjstateSet[jjnewStateCnt++] = 11;
 963  
                   break;
 964  
                case 13:
 965  262
                   if (curChar == 62 && kind > 44)
 966  0
                      kind = 44;
 967  
                   break;
 968  
                case 14:
 969  0
                   if (curChar == 60)
 970  0
                      jjstateSet[jjnewStateCnt++] = 13;
 971  
                   break;
 972  
                case 15:
 973  54
                   if (curChar == 38 && kind > 49)
 974  54
                      kind = 49;
 975  
                   break;
 976  
                case 16:
 977  0
                   if (curChar == 38)
 978  0
                      jjstateSet[jjnewStateCnt++] = 15;
 979  
                   break;
 980  
                case 24:
 981  0
                   if (curChar == 33 && kind > 51)
 982  0
                      kind = 51;
 983  
                   break;
 984  
                case 29:
 985  13558
                   if ((0x3ff000000000000L & l) == 0L)
 986  13352
                      break;
 987  206
                   if (kind > 54)
 988  206
                      kind = 54;
 989  206
                   jjstateSet[jjnewStateCnt++] = 29;
 990  206
                   break;
 991  
                case 30:
 992  48
                   if ((0x3ff000000000000L & l) == 0L)
 993  36
                      break;
 994  12
                   if (kind > 55)
 995  12
                      kind = 55;
 996  12
                   jjCheckNAdd(30);
 997  12
                   break;
 998  
                default : break;
 999  
             }
 1000  29014
          } while(i != startsAt);
 1001  29014
       }
 1002  85578
       else if (curChar < 128)
 1003  
       {
 1004  85578
          long l = 1L << (curChar & 077);
 1005  
          do
 1006  
          {
 1007  86420
             switch(jjstateSet[--i])
 1008  
             {
 1009  
                case 4:
 1010  0
                   if ((0xf8000001f8000001L & l) != 0L && kind > 21)
 1011  0
                      kind = 21;
 1012  
                   break;
 1013  
                case 2:
 1014  11888
                   if ((0x7fffffe07fffffeL & l) != 0L)
 1015  
                   {
 1016  11838
                      if (kind > 54)
 1017  11838
                         kind = 54;
 1018  11838
                      jjCheckNAdd(29);
 1019  
                   }
 1020  50
                   else if (curChar == 124)
 1021  18
                      jjstateSet[jjnewStateCnt++] = 20;
 1022  32
                   else if (curChar == 92)
 1023  0
                      jjAddStates(4, 5);
 1024  11888
                   if (curChar == 78)
 1025  630
                      jjstateSet[jjnewStateCnt++] = 26;
 1026  11258
                   else if (curChar == 79)
 1027  104
                      jjstateSet[jjnewStateCnt++] = 22;
 1028  11154
                   else if (curChar == 65)
 1029  108
                      jjstateSet[jjnewStateCnt++] = 18;
 1030  
                   break;
 1031  
                case 1:
 1032  752
                   if (kind > 16)
 1033  752
                      kind = 16;
 1034  752
                   jjstateSet[jjnewStateCnt++] = 1;
 1035  752
                   break;
 1036  
                case 3:
 1037  0
                   if (curChar == 92)
 1038  0
                      jjAddStates(4, 5);
 1039  
                   break;
 1040  
                case 17:
 1041  0
                   if (curChar == 68 && kind > 49)
 1042  0
                      kind = 49;
 1043  
                   break;
 1044  
                case 18:
 1045  108
                   if (curChar == 78)
 1046  0
                      jjstateSet[jjnewStateCnt++] = 17;
 1047  
                   break;
 1048  
                case 19:
 1049  0
                   if (curChar == 65)
 1050  0
                      jjstateSet[jjnewStateCnt++] = 18;
 1051  
                   break;
 1052  
                case 20:
 1053  18
                   if (curChar == 124 && kind > 50)
 1054  18
                      kind = 50;
 1055  
                   break;
 1056  
                case 21:
 1057  0
                   if (curChar == 124)
 1058  0
                      jjstateSet[jjnewStateCnt++] = 20;
 1059  
                   break;
 1060  
                case 22:
 1061  104
                   if (curChar == 82 && kind > 50)
 1062  0
                      kind = 50;
 1063  
                   break;
 1064  
                case 23:
 1065  0
                   if (curChar == 79)
 1066  0
                      jjstateSet[jjnewStateCnt++] = 22;
 1067  
                   break;
 1068  
                case 25:
 1069  0
                   if (curChar == 84 && kind > 51)
 1070  0
                      kind = 51;
 1071  
                   break;
 1072  
                case 26:
 1073  630
                   if (curChar == 79)
 1074  0
                      jjstateSet[jjnewStateCnt++] = 25;
 1075  
                   break;
 1076  
                case 27:
 1077  0
                   if (curChar == 78)
 1078  0
                      jjstateSet[jjnewStateCnt++] = 26;
 1079  
                   break;
 1080  
                case 28:
 1081  0
                   if ((0x7fffffe07fffffeL & l) == 0L)
 1082  0
                      break;
 1083  0
                   if (kind > 54)
 1084  0
                      kind = 54;
 1085  0
                   jjCheckNAdd(29);
 1086  0
                   break;
 1087  
                case 29:
 1088  71548
                   if ((0x7fffffe87fffffeL & l) == 0L)
 1089  0
                      break;
 1090  71548
                   if (kind > 54)
 1091  71548
                      kind = 54;
 1092  71548
                   jjCheckNAdd(29);
 1093  71548
                   break;
 1094  
                default : break;
 1095  
             }
 1096  86420
          } while(i != startsAt);
 1097  85578
       }
 1098  
       else
 1099  
       {
 1100  0
          int hiByte = (int)(curChar >> 8);
 1101  0
          int i1 = hiByte >> 6;
 1102  0
          long l1 = 1L << (hiByte & 077);
 1103  0
          int i2 = (curChar & 0xff) >> 6;
 1104  0
          long l2 = 1L << (curChar & 077);
 1105  
          do
 1106  
          {
 1107  0
             switch(jjstateSet[--i])
 1108  
             {
 1109  
                case 4:
 1110  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 21)
 1111  0
                      kind = 21;
 1112  
                   break;
 1113  
                case 1:
 1114  0
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 1115  0
                      break;
 1116  0
                   if (kind > 16)
 1117  0
                      kind = 16;
 1118  0
                   jjstateSet[jjnewStateCnt++] = 1;
 1119  0
                   break;
 1120  
                default : break;
 1121  
             }
 1122  0
          } while(i != startsAt);
 1123  
       }
 1124  114592
       if (kind != 0x7fffffff)
 1125  
       {
 1126  94260
          jjmatchedKind = kind;
 1127  94260
          jjmatchedPos = curPos;
 1128  94260
          kind = 0x7fffffff;
 1129  
       }
 1130  114592
       ++curPos;
 1131  114592
       if ((i = jjnewStateCnt) == (startsAt = 31 - (jjnewStateCnt = startsAt)))
 1132  23138
          return curPos;
 1133  91454
       try { curChar = input_stream.readChar(); }
 1134  91454
       catch(java.io.IOException e) { return curPos; }
 1135  
    }
 1136  
 }
 1137  
 private int jjMoveStringLiteralDfa0_0()
 1138  
 {
 1139  0
    switch(curChar)
 1140  
    {
 1141  
       case 36:
 1142  0
          return jjStopAtPos(0, 20);
 1143  
       case 39:
 1144  0
          return jjStopAtPos(0, 25);
 1145  
       case 92:
 1146  0
          return jjStartNfaWithStates_0(0, 22, 1);
 1147  
       default :
 1148  0
          return jjMoveNfa_0(0, 0);
 1149  
    }
 1150  
 }
 1151  
 private int jjStartNfaWithStates_0(int pos, int kind, int state)
 1152  
 {
 1153  0
    jjmatchedKind = kind;
 1154  0
    jjmatchedPos = pos;
 1155  0
    try { curChar = input_stream.readChar(); }
 1156  0
    catch(java.io.IOException e) { return pos + 1; }
 1157  0
    return jjMoveNfa_0(state, pos + 1);
 1158  
 }
 1159  
 private int jjMoveNfa_0(int startState, int curPos)
 1160  
 {
 1161  0
    int startsAt = 0;
 1162  0
    jjnewStateCnt = 5;
 1163  0
    int i = 1;
 1164  0
    jjstateSet[0] = startState;
 1165  0
    int kind = 0x7fffffff;
 1166  
    for (;;)
 1167  
    {
 1168  0
       if (++jjround == 0x7fffffff)
 1169  0
          ReInitRounds();
 1170  0
       if (curChar < 64)
 1171  
       {
 1172  0
          long l = 1L << curChar;
 1173  
          do
 1174  
          {
 1175  0
             switch(jjstateSet[--i])
 1176  
             {
 1177  
                case 1:
 1178  0
                   if ((0xfc00ffffffffffffL & l) != 0L)
 1179  
                   {
 1180  0
                      if (kind > 21)
 1181  0
                         kind = 21;
 1182  
                   }
 1183  0
                   if (curChar == 13)
 1184  0
                      jjstateSet[jjnewStateCnt++] = 2;
 1185  
                   break;
 1186  
                case 0:
 1187  
                case 4:
 1188  0
                   if ((0xffffff6fffffdbffL & l) == 0L)
 1189  0
                      break;
 1190  0
                   if (kind > 58)
 1191  0
                      kind = 58;
 1192  0
                   jjCheckNAdd(4);
 1193  0
                   break;
 1194  
                case 2:
 1195  0
                   if (curChar == 10 && kind > 21)
 1196  0
                      kind = 21;
 1197  
                   break;
 1198  
                case 3:
 1199  0
                   if (curChar == 13)
 1200  0
                      jjstateSet[jjnewStateCnt++] = 2;
 1201  
                   break;
 1202  
                default : break;
 1203  
             }
 1204  0
          } while(i != startsAt);
 1205  0
       }
 1206  0
       else if (curChar < 128)
 1207  
       {
 1208  0
          long l = 1L << (curChar & 077);
 1209  
          do
 1210  
          {
 1211  0
             switch(jjstateSet[--i])
 1212  
             {
 1213  
                case 1:
 1214  0
                   if ((0xf8000001f8000001L & l) != 0L && kind > 21)
 1215  0
                      kind = 21;
 1216  
                   break;
 1217  
                case 0:
 1218  0
                   if ((0xffffffffefffffffL & l) != 0L)
 1219  
                   {
 1220  0
                      if (kind > 58)
 1221  0
                         kind = 58;
 1222  0
                      jjCheckNAdd(4);
 1223  
                   }
 1224  0
                   else if (curChar == 92)
 1225  0
                      jjAddStates(2, 3);
 1226  
                   break;
 1227  
                case 4:
 1228  0
                   if ((0xffffffffefffffffL & l) == 0L)
 1229  0
                      break;
 1230  0
                   if (kind > 58)
 1231  0
                      kind = 58;
 1232  0
                   jjCheckNAdd(4);
 1233  0
                   break;
 1234  
                default : break;
 1235  
             }
 1236  0
          } while(i != startsAt);
 1237  0
       }
 1238  
       else
 1239  
       {
 1240  0
          int hiByte = (int)(curChar >> 8);
 1241  0
          int i1 = hiByte >> 6;
 1242  0
          long l1 = 1L << (hiByte & 077);
 1243  0
          int i2 = (curChar & 0xff) >> 6;
 1244  0
          long l2 = 1L << (curChar & 077);
 1245  
          do
 1246  
          {
 1247  0
             switch(jjstateSet[--i])
 1248  
             {
 1249  
                case 1:
 1250  0
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 21)
 1251  0
                      kind = 21;
 1252  
                   break;
 1253  
                case 0:
 1254  
                case 4:
 1255  0
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 1256  0
                      break;
 1257  0
                   if (kind > 58)
 1258  0
                      kind = 58;
 1259  0
                   jjCheckNAdd(4);
 1260  0
                   break;
 1261  
                default : break;
 1262  
             }
 1263  0
          } while(i != startsAt);
 1264  
       }
 1265  0
       if (kind != 0x7fffffff)
 1266  
       {
 1267  0
          jjmatchedKind = kind;
 1268  0
          jjmatchedPos = curPos;
 1269  0
          kind = 0x7fffffff;
 1270  
       }
 1271  0
       ++curPos;
 1272  0
       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
 1273  0
          return curPos;
 1274  0
       try { curChar = input_stream.readChar(); }
 1275  0
       catch(java.io.IOException e) { return curPos; }
 1276  
    }
 1277  
 }
 1278  2
 static final int[] jjnextStates = {
 1279  
    2, 4, 1, 3, 4, 6, 
 1280  
 };
 1281  
 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
 1282  
 {
 1283  0
    switch(hiByte)
 1284  
    {
 1285  
       case 0:
 1286  0
          return ((jjbitVec2[i2] & l2) != 0L);
 1287  
       default : 
 1288  0
          if ((jjbitVec0[i1] & l1) != 0L)
 1289  0
             return true;
 1290  0
          return false;
 1291  
    }
 1292  
 }
 1293  
 
 1294  
 /** Token literal values. */
 1295  2
 public static final String[] jjstrLiteralImages = {
 1296  
 "", null, null, null, null, null, null, null, null, null, null, null, "\175", 
 1297  
 "\43\145\156\144", "\43\142\145\147\151\156", "\173", null, "\43\43", null, null, "\44", null, 
 1298  
 "\134", "\43", "\42", "\47", "\156\165\154\154", "\164\162\165\145", 
 1299  
 "\146\141\154\163\145", "\165\156\144\145\146\151\156\145\144", null, null, "\50", "\51", "\133", 
 1300  
 "\135", "\72", "\56", "\74", "\74\75", "\76", "\76\75", "\75\75", "\75", null, "\53", 
 1301  
 "\55", "\52", "\57", null, null, null, "\54", "\73", null, null, null, null, null, };
 1302  
 
 1303  
 /** Lexer state names. */
 1304  2
 public static final String[] lexStateNames = {
 1305  
    "SQS", 
 1306  
    "QS", 
 1307  
    "COMMENT", 
 1308  
    "WM", 
 1309  
    "DEFAULT", 
 1310  
 };
 1311  
 
 1312  
 /** Lex State array. */
 1313  2
 public static final int[] jjnewLexState = {
 1314  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 1315  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 1316  
    -1, -1, -1, -1, -1, -1, -1, -1, -1, 
 1317  
 };
 1318  2
 static final long[] jjtoToken = {
 1319  
    0x7fffffffffef801L, 
 1320  
 };
 1321  2
 static final long[] jjtoSkip = {
 1322  
    0x10000L, 
 1323  
 };
 1324  2
 static final long[] jjtoSpecial = {
 1325  
    0x10000L, 
 1326  
 };
 1327  
 protected CharStream input_stream;
 1328  228
 private final int[] jjrounds = new int[31];
 1329  228
 private final int[] jjstateSet = new int[62];
 1330  228
 private final StringBuffer jjimage = new StringBuffer();
 1331  228
 private StringBuffer image = jjimage;
 1332  
 protected char curChar;
 1333  
 /** Constructor. */
 1334  228
 public WMParser_implTokenManager(CharStream stream){
 1335  228
    input_stream = stream;
 1336  228
 }
 1337  
 
 1338  
 /** Constructor. */
 1339  
 public WMParser_implTokenManager(CharStream stream, int lexState){
 1340  0
    this(stream);
 1341  0
    SwitchTo(lexState);
 1342  0
 }
 1343  
 
 1344  
 /** Reinitialise parser. */
 1345  
 public void ReInit(CharStream stream)
 1346  
 {
 1347  0
    jjmatchedPos = jjnewStateCnt = 0;
 1348  0
    curLexState = defaultLexState;
 1349  0
    input_stream = stream;
 1350  0
    ReInitRounds();
 1351  0
 }
 1352  
 private void ReInitRounds()
 1353  
 {
 1354  
    int i;
 1355  0
    jjround = 0x80000001;
 1356  0
    for (i = 31; i-- > 0;)
 1357  0
       jjrounds[i] = 0x80000000;
 1358  0
 }
 1359  
 
 1360  
 /** Reinitialise parser. */
 1361  
 public void ReInit(CharStream stream, int lexState)
 1362  
 {
 1363  0
    ReInit(stream);
 1364  0
    SwitchTo(lexState);
 1365  0
 }
 1366  
 
 1367  
 /** Switch to specified lex state. */
 1368  
 public void SwitchTo(int lexState)
 1369  
 {
 1370  28400
    if (lexState >= 5 || lexState < 0)
 1371  0
       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 1372  
    else
 1373  28400
       curLexState = lexState;
 1374  28400
 }
 1375  
 
 1376  
 protected Token jjFillToken()
 1377  
 {
 1378  
    final Token t;
 1379  
    final String tokenImage;
 1380  
    final int beginLine;
 1381  
    final int endLine;
 1382  
    final int beginColumn;
 1383  
    final int endColumn;
 1384  79456
    if (jjmatchedPos < 0)
 1385  
    {
 1386  0
       if (image == null)
 1387  0
          tokenImage = "";
 1388  
       else
 1389  0
          tokenImage = image.toString();
 1390  0
       beginLine = endLine = input_stream.getBeginLine();
 1391  0
       beginColumn = endColumn = input_stream.getBeginColumn();
 1392  
    }
 1393  
    else
 1394  
    {
 1395  79456
       String im = jjstrLiteralImages[jjmatchedKind];
 1396  79456
       tokenImage = (im == null) ? input_stream.GetImage() : im;
 1397  79456
       beginLine = input_stream.getBeginLine();
 1398  79456
       beginColumn = input_stream.getBeginColumn();
 1399  79456
       endLine = input_stream.getEndLine();
 1400  79456
       endColumn = input_stream.getEndColumn();
 1401  
    }
 1402  79456
    t = Token.newToken(jjmatchedKind, tokenImage);
 1403  
 
 1404  79456
    t.beginLine = beginLine;
 1405  79456
    t.endLine = endLine;
 1406  79456
    t.beginColumn = beginColumn;
 1407  79456
    t.endColumn = endColumn;
 1408  
 
 1409  79456
    return t;
 1410  
 }
 1411  
 
 1412  228
 int curLexState = 4;
 1413  228
 int defaultLexState = 4;
 1414  
 int jjnewStateCnt;
 1415  
 int jjround;
 1416  
 int jjmatchedPos;
 1417  
 int jjmatchedKind;
 1418  
 
 1419  
 /** Get the next Token. */
 1420  
 public Token getNextToken() 
 1421  
 {
 1422  79428
   Token specialToken = null;
 1423  
   Token matchedToken;
 1424  79428
   int curPos = 0;
 1425  
 
 1426  
   EOFLoop :
 1427  
   for (;;)
 1428  
   {   
 1429  
    try   
 1430  
    {     
 1431  79456
       curChar = input_stream.BeginToken();
 1432  
    }     
 1433  234
    catch(java.io.IOException e)
 1434  
    {        
 1435  234
       jjmatchedKind = 0;
 1436  234
       matchedToken = jjFillToken();
 1437  234
       matchedToken.specialToken = specialToken;
 1438  234
       return matchedToken;
 1439  79222
    }
 1440  79222
    image = jjimage;
 1441  79222
    image.setLength(0);
 1442  
 
 1443  79222
    switch(curLexState)
 1444  
    {
 1445  
      case 0:
 1446  0
        jjmatchedKind = 0x7fffffff;
 1447  0
        jjmatchedPos = 0;
 1448  0
        curPos = jjMoveStringLiteralDfa0_0();
 1449  0
        break;
 1450  
      case 1:
 1451  846
        jjmatchedKind = 0x7fffffff;
 1452  846
        jjmatchedPos = 0;
 1453  846
        curPos = jjMoveStringLiteralDfa0_1();
 1454  846
        break;
 1455  
      case 2:
 1456  7204
        jjmatchedKind = 18;
 1457  7204
        jjmatchedPos = -1;
 1458  7204
        curPos = 0;
 1459  7204
        curPos = jjMoveStringLiteralDfa0_2();
 1460  7204
        if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 19))
 1461  
        {
 1462  2186
           jjmatchedKind = 19;
 1463  2186
           jjmatchedPos = 0;
 1464  
        }
 1465  
        break;
 1466  
      case 3:
 1467  43972
        jjmatchedKind = 0x7fffffff;
 1468  43972
        jjmatchedPos = 0;
 1469  43972
        curPos = jjMoveStringLiteralDfa0_3();
 1470  43972
        if (jjmatchedPos == 0 && jjmatchedKind > 56)
 1471  
        {
 1472  216
           jjmatchedKind = 56;
 1473  
        }
 1474  
        break;
 1475  
      case 4:
 1476  27200
        jjmatchedKind = 0x7fffffff;
 1477  27200
        jjmatchedPos = 0;
 1478  27200
        curPos = jjMoveStringLiteralDfa0_4();
 1479  
        break;
 1480  
    }
 1481  79222
      if (jjmatchedKind != 0x7fffffff)
 1482  
      {
 1483  79222
         if (jjmatchedPos + 1 < curPos)
 1484  39496
            input_stream.backup(curPos - jjmatchedPos - 1);
 1485  79222
         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1486  
         {
 1487  79194
            matchedToken = jjFillToken();
 1488  79194
            matchedToken.specialToken = specialToken;
 1489  79194
            TokenLexicalActions(matchedToken);
 1490  79194
        if (jjnewLexState[jjmatchedKind] != -1)
 1491  0
          curLexState = jjnewLexState[jjmatchedKind];
 1492  79194
            return matchedToken;
 1493  
         }
 1494  
         else
 1495  
         {
 1496  28
            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1497  
            {
 1498  28
               matchedToken = jjFillToken();
 1499  28
               if (specialToken == null)
 1500  28
                  specialToken = matchedToken;
 1501  
               else
 1502  
               {
 1503  0
                  matchedToken.specialToken = specialToken;
 1504  0
                  specialToken = (specialToken.next = matchedToken);
 1505  
               }
 1506  
            }
 1507  28
          if (jjnewLexState[jjmatchedKind] != -1)
 1508  0
            curLexState = jjnewLexState[jjmatchedKind];
 1509  
            continue EOFLoop;
 1510  
         }
 1511  
      }
 1512  0
      int error_line = input_stream.getEndLine();
 1513  0
      int error_column = input_stream.getEndColumn();
 1514  0
      String error_after = null;
 1515  0
      boolean EOFSeen = false;
 1516  0
      try { input_stream.readChar(); input_stream.backup(1); }
 1517  0
      catch (java.io.IOException e1) {
 1518  0
         EOFSeen = true;
 1519  0
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 1520  0
         if (curChar == '\n' || curChar == '\r') {
 1521  0
            error_line++;
 1522  0
            error_column = 0;
 1523  
         }
 1524  
         else
 1525  0
            error_column++;
 1526  0
      }
 1527  0
      if (!EOFSeen) {
 1528  0
         input_stream.backup(1);
 1529  0
         error_after = curPos <= 1 ? "" : input_stream.GetImage();
 1530  
      }
 1531  0
      throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 1532  
   }
 1533  
 }
 1534  
 
 1535  
 void TokenLexicalActions(Token matchedToken)
 1536  
 {
 1537  79194
    switch(jjmatchedKind)
 1538  
    {
 1539  
       default : 
 1540  
          break;
 1541  
    }
 1542  79194
 }
 1543  
 private void jjCheckNAdd(int state)
 1544  
 {
 1545  330980
    if (jjrounds[state] != jjround)
 1546  
    {
 1547  330980
       jjstateSet[jjnewStateCnt++] = state;
 1548  330980
       jjrounds[state] = jjround;
 1549  
    }
 1550  330980
 }
 1551  
 private void jjAddStates(int start, int end)
 1552  
 {
 1553  
    do {
 1554  0
       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 1555  0
    } while (start++ != end);
 1556  0
 }
 1557  
 
 1558  
 }