Coverage Report - org.webmacro.parser.WMParser_implTokenManager
 
Classes in this File Line Coverage Branch Coverage Complexity
WMParser_implTokenManager
67%
584/864
45%
352/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  13642
   void backup(int n) { input_stream.backup(n); }
 9  
 
 10  
   /** Debug output. */
 11  1678
   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  5486
    switch (pos)
 17  
    {
 18  
       case 0:
 19  5365
          if ((active0 & 0x400000L) != 0L)
 20  0
             return 2;
 21  5365
          return -1;
 22  
       default :
 23  121
          return -1;
 24  
    }
 25  
 }
 26  
 private final int jjStartNfa_4(int pos, long active0)
 27  
 {
 28  5486
    return jjMoveNfa_4(jjStopStringLiteralDfa_4(pos, active0), pos + 1);
 29  
 }
 30  
 private int jjStopAtPos(int pos, int kind)
 31  
 {
 32  40332
    jjmatchedKind = kind;
 33  40332
    jjmatchedPos = pos;
 34  40332
    return pos + 1;
 35  
 }
 36  
 private int jjMoveStringLiteralDfa0_4()
 37  
 {
 38  24275
    switch(curChar)
 39  
    {
 40  
       case 35:
 41  7777
          jjmatchedKind = 23;
 42  7777
          return jjMoveStringLiteralDfa1_4(0x26000L);
 43  
       case 36:
 44  1534
          return jjStopAtPos(0, 20);
 45  
       case 92:
 46  128
          return jjStartNfaWithStates_4(0, 22, 2);
 47  
       case 123:
 48  3045
          return jjStopAtPos(0, 15);
 49  
       case 125:
 50  3196
          return jjStopAtPos(0, 12);
 51  
       default :
 52  8595
          return jjMoveNfa_4(1, 0);
 53  
    }
 54  
 }
 55  
 private int jjMoveStringLiteralDfa1_4(long active0)
 56  
 {
 57  7777
    try { curChar = input_stream.readChar(); }
 58  0
    catch(java.io.IOException e) {
 59  0
       jjStopStringLiteralDfa_4(0, active0);
 60  0
       return 1;
 61  7777
    }
 62  7777
    switch(curChar)
 63  
    {
 64  
       case 35:
 65  2118
          if ((active0 & 0x20000L) != 0L)
 66  2118
             return jjStopAtPos(1, 17);
 67  
          break;
 68  
       case 98:
 69  144
          return jjMoveStringLiteralDfa2_4(active0, 0x4000L);
 70  
       case 101:
 71  150
          return jjMoveStringLiteralDfa2_4(active0, 0x2000L);
 72  
       default :
 73  
          break;
 74  
    }
 75  5365
    return jjStartNfa_4(0, active0);
 76  
 }
 77  
 private int jjMoveStringLiteralDfa2_4(long old0, long active0)
 78  
 {
 79  294
    if (((active0 &= old0)) == 0L)
 80  0
       return jjStartNfa_4(0, old0); 
 81  294
    try { curChar = input_stream.readChar(); }
 82  0
    catch(java.io.IOException e) {
 83  0
       jjStopStringLiteralDfa_4(1, active0);
 84  0
       return 2;
 85  294
    }
 86  294
    switch(curChar)
 87  
    {
 88  
       case 101:
 89  142
          return jjMoveStringLiteralDfa3_4(active0, 0x4000L);
 90  
       case 110:
 91  108
          return jjMoveStringLiteralDfa3_4(active0, 0x2000L);
 92  
       default :
 93  
          break;
 94  
    }
 95  44
    return jjStartNfa_4(1, active0);
 96  
 }
 97  
 private int jjMoveStringLiteralDfa3_4(long old0, long active0)
 98  
 {
 99  250
    if (((active0 &= old0)) == 0L)
 100  0
       return jjStartNfa_4(1, old0); 
 101  250
    try { curChar = input_stream.readChar(); }
 102  0
    catch(java.io.IOException e) {
 103  0
       jjStopStringLiteralDfa_4(2, active0);
 104  0
       return 3;
 105  250
    }
 106  250
    switch(curChar)
 107  
    {
 108  
       case 100:
 109  108
          if ((active0 & 0x2000L) != 0L)
 110  108
             return jjStopAtPos(3, 13);
 111  
          break;
 112  
       case 103:
 113  65
          return jjMoveStringLiteralDfa4_4(active0, 0x4000L);
 114  
       default :
 115  
          break;
 116  
    }
 117  77
    return jjStartNfa_4(2, active0);
 118  
 }
 119  
 private int jjMoveStringLiteralDfa4_4(long old0, long active0)
 120  
 {
 121  65
    if (((active0 &= old0)) == 0L)
 122  0
       return jjStartNfa_4(2, old0); 
 123  65
    try { curChar = input_stream.readChar(); }
 124  0
    catch(java.io.IOException e) {
 125  0
       jjStopStringLiteralDfa_4(3, active0);
 126  0
       return 4;
 127  65
    }
 128  65
    switch(curChar)
 129  
    {
 130  
       case 105:
 131  65
          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  65
    if (((active0 &= old0)) == 0L)
 140  0
       return jjStartNfa_4(3, old0); 
 141  65
    try { curChar = input_stream.readChar(); }
 142  0
    catch(java.io.IOException e) {
 143  0
       jjStopStringLiteralDfa_4(4, active0);
 144  0
       return 5;
 145  65
    }
 146  65
    switch(curChar)
 147  
    {
 148  
       case 110:
 149  65
          if ((active0 & 0x4000L) != 0L)
 150  65
             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  128
    jjmatchedKind = kind;
 160  128
    jjmatchedPos = pos;
 161  128
    try { curChar = input_stream.readChar(); }
 162  128
    catch(java.io.IOException e) { return pos + 1; }
 163  128
    return jjMoveNfa_4(state, pos + 1);
 164  
 }
 165  37
 static final long[] jjbitVec0 = {
 166  
    0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 167  
 };
 168  37
 static final long[] jjbitVec2 = {
 169  
    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 170  
 };
 171  
 private int jjMoveNfa_4(int startState, int curPos)
 172  
 {
 173  14209
    int startsAt = 0;
 174  14209
    jjnewStateCnt = 5;
 175  14209
    int i = 1;
 176  14209
    jjstateSet[0] = startState;
 177  14209
    int kind = 0x7fffffff;
 178  
    for (;;)
 179  
    {
 180  210760
       if (++jjround == 0x7fffffff)
 181  0
          ReInitRounds();
 182  210760
       if (curChar < 64)
 183  
       {
 184  53471
          long l = 1L << curChar;
 185  
          do
 186  
          {
 187  53471
             switch(jjstateSet[--i])
 188  
             {
 189  
                case 1:
 190  
                case 0:
 191  53360
                   if ((0xffffffe7ffffffffL & l) == 0L)
 192  5845
                      break;
 193  47515
                   if (kind > 11)
 194  47515
                      kind = 11;
 195  47515
                   jjCheckNAdd(0);
 196  47515
                   break;
 197  
                case 2:
 198  105
                   if ((0xfc00ffffffffffffL & l) != 0L)
 199  
                   {
 200  105
                      if (kind > 21)
 201  105
                         kind = 21;
 202  
                   }
 203  105
                   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  53471
          } while(i != startsAt);
 217  53471
       }
 218  157289
       else if (curChar < 128)
 219  
       {
 220  157257
          long l = 1L << (curChar & 077);
 221  
          do
 222  
          {
 223  157257
             switch(jjstateSet[--i])
 224  
             {
 225  
                case 1:
 226  1841
                   if ((0xd7ffffffefffffffL & l) != 0L)
 227  
                   {
 228  1841
                      if (kind > 11)
 229  1841
                         kind = 11;
 230  1841
                      jjCheckNAdd(0);
 231  
                   }
 232  0
                   else if (curChar == 92)
 233  0
                      jjAddStates(0, 1);
 234  
                   break;
 235  
                case 2:
 236  23
                   if ((0xf8000001f8000001L & l) != 0L && kind > 21)
 237  23
                      kind = 21;
 238  
                   break;
 239  
                case 0:
 240  149913
                   if ((0xd7ffffffefffffffL & l) == 0L)
 241  2649
                      break;
 242  147264
                   if (kind > 11)
 243  147264
                      kind = 11;
 244  147264
                   jjCheckNAdd(0);
 245  147264
                   break;
 246  
                default : break;
 247  
             }
 248  157257
          } while(i != startsAt);
 249  157257
       }
 250  
       else
 251  
       {
 252  32
          int hiByte = (int)(curChar >> 8);
 253  32
          int i1 = hiByte >> 6;
 254  32
          long l1 = 1L << (hiByte & 077);
 255  32
          int i2 = (curChar & 0xff) >> 6;
 256  32
          long l2 = 1L << (curChar & 077);
 257  
          do
 258  
          {
 259  32
             switch(jjstateSet[--i])
 260  
             {
 261  
                case 1:
 262  
                case 0:
 263  32
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 264  0
                      break;
 265  32
                   if (kind > 11)
 266  32
                      kind = 11;
 267  32
                   jjCheckNAdd(0);
 268  32
                   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  32
          } while(i != startsAt);
 276  
       }
 277  210760
       if (kind != 0x7fffffff)
 278  
       {
 279  196780
          jjmatchedKind = kind;
 280  196780
          jjmatchedPos = curPos;
 281  196780
          kind = 0x7fffffff;
 282  
       }
 283  210760
       ++curPos;
 284  210760
       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
 285  14108
          return curPos;
 286  196652
       try { curChar = input_stream.readChar(); }
 287  196551
       catch(java.io.IOException e) { return curPos; }
 288  
    }
 289  
 }
 290  
 private int jjMoveStringLiteralDfa0_1()
 291  
 {
 292  7237
    switch(curChar)
 293  
    {
 294  
       case 34:
 295  3097
          return jjStopAtPos(0, 24);
 296  
       case 36:
 297  1167
          return jjStopAtPos(0, 20);
 298  
       case 92:
 299  1
          return jjStartNfaWithStates_1(0, 22, 1);
 300  
       default :
 301  2972
          return jjMoveNfa_1(0, 0);
 302  
    }
 303  
 }
 304  
 private int jjStartNfaWithStates_1(int pos, int kind, int state)
 305  
 {
 306  1
    jjmatchedKind = kind;
 307  1
    jjmatchedPos = pos;
 308  1
    try { curChar = input_stream.readChar(); }
 309  1
    catch(java.io.IOException e) { return pos + 1; }
 310  1
    return jjMoveNfa_1(state, pos + 1);
 311  
 }
 312  
 private int jjMoveNfa_1(int startState, int curPos)
 313  
 {
 314  2973
    int startsAt = 0;
 315  2973
    jjnewStateCnt = 5;
 316  2973
    int i = 1;
 317  2973
    jjstateSet[0] = startState;
 318  2973
    int kind = 0x7fffffff;
 319  
    for (;;)
 320  
    {
 321  33672
       if (++jjround == 0x7fffffff)
 322  0
          ReInitRounds();
 323  33672
       if (curChar < 64)
 324  
       {
 325  8129
          long l = 1L << curChar;
 326  
          do
 327  
          {
 328  8129
             switch(jjstateSet[--i])
 329  
             {
 330  
                case 1:
 331  1
                   if ((0xfc00ffffffffffffL & l) != 0L)
 332  
                   {
 333  1
                      if (kind > 21)
 334  1
                         kind = 21;
 335  
                   }
 336  1
                   if (curChar == 13)
 337  0
                      jjstateSet[jjnewStateCnt++] = 2;
 338  
                   break;
 339  
                case 0:
 340  
                case 4:
 341  8128
                   if ((0xffffffebffffdbffL & l) == 0L)
 342  2972
                      break;
 343  5156
                   if (kind > 57)
 344  5156
                      kind = 57;
 345  5156
                   jjCheckNAdd(4);
 346  5156
                   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  8129
          } while(i != startsAt);
 358  8129
       }
 359  25543
       else if (curChar < 128)
 360  
       {
 361  25543
          long l = 1L << (curChar & 077);
 362  
          do
 363  
          {
 364  25543
             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  2208
                   if ((0xffffffffefffffffL & l) != 0L)
 372  
                   {
 373  2208
                      if (kind > 57)
 374  2208
                         kind = 57;
 375  2208
                      jjCheckNAdd(4);
 376  
                   }
 377  0
                   else if (curChar == 92)
 378  0
                      jjAddStates(2, 3);
 379  
                   break;
 380  
                case 4:
 381  23335
                   if ((0xffffffffefffffffL & l) == 0L)
 382  0
                      break;
 383  23335
                   if (kind > 57)
 384  23335
                      kind = 57;
 385  23335
                   jjCheckNAdd(4);
 386  23335
                   break;
 387  
                default : break;
 388  
             }
 389  25543
          } while(i != startsAt);
 390  25543
       }
 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  33672
       if (kind != 0x7fffffff)
 419  
       {
 420  30700
          jjmatchedKind = kind;
 421  30700
          jjmatchedPos = curPos;
 422  30700
          kind = 0x7fffffff;
 423  
       }
 424  33672
       ++curPos;
 425  33672
       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
 426  2973
          return curPos;
 427  30699
       try { curChar = input_stream.readChar(); }
 428  30699
       catch(java.io.IOException e) { return curPos; }
 429  
    }
 430  
 }
 431  
 private int jjMoveStringLiteralDfa0_2()
 432  
 {
 433  2118
    return jjMoveNfa_2(0, 0);
 434  
 }
 435  
 private int jjMoveNfa_2(int startState, int curPos)
 436  
 {
 437  2118
    int startsAt = 0;
 438  2118
    jjnewStateCnt = 1;
 439  2118
    int i = 1;
 440  2118
    jjstateSet[0] = startState;
 441  2118
    int kind = 0x7fffffff;
 442  
    for (;;)
 443  
    {
 444  54253
       if (++jjround == 0x7fffffff)
 445  0
          ReInitRounds();
 446  54253
       if (curChar < 64)
 447  
       {
 448  10971
          long l = 1L << curChar;
 449  
          do
 450  
          {
 451  10971
             switch(jjstateSet[--i])
 452  
             {
 453  
                case 0:
 454  10971
                   if ((0xffffffffffffdbffL & l) == 0L)
 455  2116
                      break;
 456  8855
                   kind = 18;
 457  8855
                   jjstateSet[jjnewStateCnt++] = 0;
 458  8855
                   break;
 459  
                default : break;
 460  
             }
 461  10971
          } while(i != startsAt);
 462  10971
       }
 463  43282
       else if (curChar < 128)
 464  
       {
 465  
          //long l = 1L << (curChar & 077);
 466  
          do
 467  
          {
 468  43282
             switch(jjstateSet[--i])
 469  
             {
 470  
                case 0:
 471  43282
                   kind = 18;
 472  43282
                   jjstateSet[jjnewStateCnt++] = 0;
 473  43282
                   break;
 474  
                default : break;
 475  
             }
 476  43282
          } 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  54253
       if (kind != 0x7fffffff)
 501  
       {
 502  52137
          jjmatchedKind = kind;
 503  52137
          jjmatchedPos = curPos;
 504  52137
          kind = 0x7fffffff;
 505  
       }
 506  54253
       ++curPos;
 507  54253
       if ((i = jjnewStateCnt) == (startsAt = 1 - (jjnewStateCnt = startsAt)))
 508  2116
          return curPos;
 509  52137
       try { curChar = input_stream.readChar(); }
 510  52135
       catch(java.io.IOException e) { return curPos; }
 511  
    }
 512  
 }
 513  
 private final int jjStopStringLiteralDfa_3(int pos, long active0)
 514  
 {
 515  6529
    switch (pos)
 516  
    {
 517  
       case 0:
 518  6458
          if ((active0 & 0x400000L) != 0L)
 519  0
             return 4;
 520  6458
          if ((active0 & 0x804000L) != 0L)
 521  1529
             return 0;
 522  4929
          if ((active0 & 0x3c000000L) != 0L)
 523  
          {
 524  2471
             jjmatchedKind = 54;
 525  2471
             return 29;
 526  
          }
 527  2458
          if ((active0 & 0xc000000000L) != 0L)
 528  191
             return 13;
 529  2267
          return -1;
 530  
       case 1:
 531  71
          if ((active0 & 0x3c000000L) != 0L)
 532  
          {
 533  71
             jjmatchedKind = 54;
 534  71
             jjmatchedPos = 1;
 535  71
             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  6528
    return jjMoveNfa_3(jjStopStringLiteralDfa_3(pos, active0), pos + 1);
 597  
 }
 598  
 private int jjMoveStringLiteralDfa0_3()
 599  
 {
 600  79861
    switch(curChar)
 601  
    {
 602  
       case 34:
 603  3603
          return jjStopAtPos(0, 24);
 604  
       case 35:
 605  1594
          jjmatchedKind = 23;
 606  1594
          return jjMoveStringLiteralDfa1_3(0x4000L);
 607  
       case 36:
 608  9705
          return jjStopAtPos(0, 20);
 609  
       case 39:
 610  58
          return jjStopAtPos(0, 25);
 611  
       case 40:
 612  2548
          return jjStopAtPos(0, 32);
 613  
       case 41:
 614  2590
          return jjStopAtPos(0, 33);
 615  
       case 42:
 616  56
          return jjStopAtPos(0, 47);
 617  
       case 43:
 618  287
          return jjStopAtPos(0, 45);
 619  
       case 44:
 620  758
          return jjStopAtPos(0, 52);
 621  
       case 45:
 622  61
          return jjStopAtPos(0, 46);
 623  
       case 46:
 624  1324
          return jjStopAtPos(0, 37);
 625  
       case 47:
 626  363
          return jjStopAtPos(0, 48);
 627  
       case 58:
 628  292
          return jjStopAtPos(0, 36);
 629  
       case 59:
 630  2
          return jjStopAtPos(0, 53);
 631  
       case 60:
 632  240
          jjmatchedKind = 38;
 633  240
          return jjMoveStringLiteralDfa1_3(0x8000000000L);
 634  
       case 61:
 635  2676
          jjmatchedKind = 43;
 636  2676
          return jjMoveStringLiteralDfa1_3(0x40000000000L);
 637  
       case 62:
 638  127
          jjmatchedKind = 40;
 639  127
          return jjMoveStringLiteralDfa1_3(0x20000000000L);
 640  
       case 91:
 641  244
          return jjStopAtPos(0, 34);
 642  
       case 92:
 643  0
          return jjStartNfaWithStates_3(0, 22, 4);
 644  
       case 93:
 645  244
          return jjStopAtPos(0, 35);
 646  
       case 102:
 647  1486
          return jjMoveStringLiteralDfa1_3(0x10000000L);
 648  
       case 110:
 649  124
          return jjMoveStringLiteralDfa1_3(0x4000000L);
 650  
       case 116:
 651  1011
          return jjMoveStringLiteralDfa1_3(0x8000000L);
 652  
       case 117:
 653  49
          return jjMoveStringLiteralDfa1_3(0x20000000L);
 654  
       case 123:
 655  3165
          return jjStopAtPos(0, 15);
 656  
       default :
 657  47254
          return jjMoveNfa_3(2, 0);
 658  
    }
 659  
 }
 660  
 private int jjMoveStringLiteralDfa1_3(long active0)
 661  
 {
 662  7307
    try { curChar = input_stream.readChar(); }
 663  1
    catch(java.io.IOException e) {
 664  1
       jjStopStringLiteralDfa_3(0, active0);
 665  1
       return 1;
 666  7306
    }
 667  7306
    switch(curChar)
 668  
    {
 669  
       case 61:
 670  585
          if ((active0 & 0x8000000000L) != 0L)
 671  49
             return jjStopAtPos(1, 39);
 672  536
          else if ((active0 & 0x20000000000L) != 0L)
 673  49
             return jjStopAtPos(1, 41);
 674  487
          else if ((active0 & 0x40000000000L) != 0L)
 675  487
             return jjStopAtPos(1, 42);
 676  
          break;
 677  
       case 97:
 678  201
          return jjMoveStringLiteralDfa2_3(active0, 0x10000000L);
 679  
       case 98:
 680  69
          return jjMoveStringLiteralDfa2_3(active0, 0x4000L);
 681  
       case 110:
 682  4
          return jjMoveStringLiteralDfa2_3(active0, 0x20000000L);
 683  
       case 114:
 684  380
          return jjMoveStringLiteralDfa2_3(active0, 0x8000000L);
 685  
       case 117:
 686  66
          return jjMoveStringLiteralDfa2_3(active0, 0x4000000L);
 687  
       default :
 688  
          break;
 689  
    }
 690  6001
    return jjStartNfa_3(0, active0);
 691  
 }
 692  
 private int jjMoveStringLiteralDfa2_3(long old0, long active0)
 693  
 {
 694  720
    if (((active0 &= old0)) == 0L)
 695  456
       return jjStartNfa_3(0, old0); 
 696  264
    try { curChar = input_stream.readChar(); }
 697  0
    catch(java.io.IOException e) {
 698  0
       jjStopStringLiteralDfa_3(1, active0);
 699  0
       return 2;
 700  264
    }
 701  264
    switch(curChar)
 702  
    {
 703  
       case 100:
 704  4
          return jjMoveStringLiteralDfa3_3(active0, 0x20000000L);
 705  
       case 101:
 706  65
          return jjMoveStringLiteralDfa3_3(active0, 0x4000L);
 707  
       case 108:
 708  32
          return jjMoveStringLiteralDfa3_3(active0, 0x14000000L);
 709  
       case 117:
 710  92
          return jjMoveStringLiteralDfa3_3(active0, 0x8000000L);
 711  
       default :
 712  
          break;
 713  
    }
 714  71
    return jjStartNfa_3(1, active0);
 715  
 }
 716  
 private int jjMoveStringLiteralDfa3_3(long old0, long active0)
 717  
 {
 718  193
    if (((active0 &= old0)) == 0L)
 719  0
       return jjStartNfa_3(1, old0); 
 720  193
    try { curChar = input_stream.readChar(); }
 721  0
    catch(java.io.IOException e) {
 722  0
       jjStopStringLiteralDfa_3(2, active0);
 723  0
       return 3;
 724  193
    }
 725  193
    switch(curChar)
 726  
    {
 727  
       case 101:
 728  96
          if ((active0 & 0x8000000L) != 0L)
 729  92
             return jjStartNfaWithStates_3(3, 27, 29);
 730  4
          return jjMoveStringLiteralDfa4_3(active0, 0x20000000L);
 731  
       case 103:
 732  65
          return jjMoveStringLiteralDfa4_3(active0, 0x4000L);
 733  
       case 108:
 734  23
          if ((active0 & 0x4000000L) != 0L)
 735  23
             return jjStartNfaWithStates_3(3, 26, 29);
 736  
          break;
 737  
       case 115:
 738  9
          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  78
    if (((active0 &= old0)) == 0L)
 747  0
       return jjStartNfa_3(2, old0); 
 748  78
    try { curChar = input_stream.readChar(); }
 749  0
    catch(java.io.IOException e) {
 750  0
       jjStopStringLiteralDfa_3(3, active0);
 751  0
       return 4;
 752  78
    }
 753  78
    switch(curChar)
 754  
    {
 755  
       case 101:
 756  9
          if ((active0 & 0x10000000L) != 0L)
 757  9
             return jjStartNfaWithStates_3(4, 28, 29);
 758  
          break;
 759  
       case 102:
 760  4
          return jjMoveStringLiteralDfa5_3(active0, 0x20000000L);
 761  
       case 105:
 762  65
          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  69
    if (((active0 &= old0)) == 0L)
 771  0
       return jjStartNfa_3(3, old0); 
 772  69
    try { curChar = input_stream.readChar(); }
 773  0
    catch(java.io.IOException e) {
 774  0
       jjStopStringLiteralDfa_3(4, active0);
 775  0
       return 5;
 776  69
    }
 777  69
    switch(curChar)
 778  
    {
 779  
       case 105:
 780  4
          return jjMoveStringLiteralDfa6_3(active0, 0x20000000L);
 781  
       case 110:
 782  65
          if ((active0 & 0x4000L) != 0L)
 783  65
             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  4
    if (((active0 &= old0)) == 0L)
 793  0
       return jjStartNfa_3(4, old0); 
 794  4
    try { curChar = input_stream.readChar(); }
 795  0
    catch(java.io.IOException e) {
 796  0
       jjStopStringLiteralDfa_3(5, active0);
 797  0
       return 6;
 798  4
    }
 799  4
    switch(curChar)
 800  
    {
 801  
       case 110:
 802  4
          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  4
    if (((active0 &= old0)) == 0L)
 811  0
       return jjStartNfa_3(5, old0); 
 812  4
    try { curChar = input_stream.readChar(); }
 813  0
    catch(java.io.IOException e) {
 814  0
       jjStopStringLiteralDfa_3(6, active0);
 815  0
       return 7;
 816  4
    }
 817  4
    switch(curChar)
 818  
    {
 819  
       case 101:
 820  4
          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  4
    if (((active0 &= old0)) == 0L)
 829  0
       return jjStartNfa_3(6, old0); 
 830  4
    try { curChar = input_stream.readChar(); }
 831  0
    catch(java.io.IOException e) {
 832  0
       jjStopStringLiteralDfa_3(7, active0);
 833  0
       return 8;
 834  4
    }
 835  4
    switch(curChar)
 836  
    {
 837  
       case 100:
 838  4
          if ((active0 & 0x20000000L) != 0L)
 839  4
             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  128
    jjmatchedKind = kind;
 849  128
    jjmatchedPos = pos;
 850  128
    try { curChar = input_stream.readChar(); }
 851  126
    catch(java.io.IOException e) { return pos + 1; }
 852  126
    return jjMoveNfa_3(state, pos + 1);
 853  
 }
 854  
 private int jjMoveNfa_3(int startState, int curPos)
 855  
 {
 856  53908
    int startsAt = 0;
 857  53908
    jjnewStateCnt = 31;
 858  53908
    int i = 1;
 859  53908
    jjstateSet[0] = startState;
 860  53908
    int kind = 0x7fffffff;
 861  
    for (;;)
 862  
    {
 863  171667
       if (++jjround == 0x7fffffff)
 864  0
          ReInitRounds();
 865  171667
       if (curChar < 64)
 866  
       {
 867  70406
          long l = 1L << curChar;
 868  
          do
 869  
          {
 870  70409
             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  28987
                   if ((0x3ff000000000000L & l) != 0L)
 883  
                   {
 884  1496
                      if (kind > 55)
 885  1496
                         kind = 55;
 886  1496
                      jjCheckNAdd(30);
 887  
                   }
 888  27491
                   else if ((0x2400L & l) != 0L)
 889  
                   {
 890  6434
                      if (kind > 31)
 891  6434
                         kind = 31;
 892  
                   }
 893  21057
                   else if ((0x100000200L & l) != 0L)
 894  
                   {
 895  20486
                      if (kind > 30)
 896  20486
                         kind = 30;
 897  20486
                      jjCheckNAdd(7);
 898  
                   }
 899  571
                   else if (curChar == 33)
 900  
                   {
 901  534
                      if (kind > 51)
 902  534
                         kind = 51;
 903  
                   }
 904  37
                   else if (curChar == 38)
 905  37
                      jjstateSet[jjnewStateCnt++] = 15;
 906  0
                   else if (curChar == 60)
 907  0
                      jjstateSet[jjnewStateCnt++] = 13;
 908  0
                   else if (curChar == 35)
 909  0
                      jjstateSet[jjnewStateCnt++] = 0;
 910  28987
                   if (curChar == 33)
 911  534
                      jjstateSet[jjnewStateCnt++] = 11;
 912  28453
                   else if (curChar == 13)
 913  163
                      jjstateSet[jjnewStateCnt++] = 8;
 914  
                   break;
 915  
                case 0:
 916  321
                   if (curChar != 35)
 917  1
                      break;
 918  320
                   if (kind > 16)
 919  320
                      kind = 16;
 920  320
                   jjCheckNAdd(1);
 921  320
                   break;
 922  
                case 1:
 923  865
                   if ((0xffffffffffffdbffL & l) == 0L)
 924  320
                      break;
 925  545
                   if (kind > 16)
 926  545
                      kind = 16;
 927  545
                   jjCheckNAdd(1);
 928  545
                   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  15165
                   if ((0x100000200L & l) == 0L)
 939  14724
                      break;
 940  441
                   if (kind > 30)
 941  441
                      kind = 30;
 942  441
                   jjCheckNAdd(7);
 943  441
                   break;
 944  
                case 8:
 945  163
                   if (curChar == 10 && kind > 31)
 946  129
                      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  534
                   if (curChar == 61 && kind > 44)
 958  477
                      kind = 44;
 959  
                   break;
 960  
                case 12:
 961  0
                   if (curChar == 33)
 962  0
                      jjstateSet[jjnewStateCnt++] = 11;
 963  
                   break;
 964  
                case 13:
 965  154
                   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  31
                   if (curChar == 38 && kind > 49)
 974  31
                      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  20421
                   if ((0x3ff000000000000L & l) == 0L)
 986  18755
                      break;
 987  1666
                   if (kind > 54)
 988  1666
                      kind = 54;
 989  1666
                   jjstateSet[jjnewStateCnt++] = 29;
 990  1666
                   break;
 991  
                case 30:
 992  1572
                   if ((0x3ff000000000000L & l) == 0L)
 993  1483
                      break;
 994  89
                   if (kind > 55)
 995  89
                      kind = 55;
 996  89
                   jjCheckNAdd(30);
 997  89
                   break;
 998  
                default : break;
 999  
             }
 1000  70409
          } while(i != startsAt);
 1001  70406
       }
 1002  101261
       else if (curChar < 128)
 1003  
       {
 1004  101261
          long l = 1L << (curChar & 077);
 1005  
          do
 1006  
          {
 1007  102217
             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  18267
                   if ((0x7fffffe07fffffeL & l) != 0L)
 1015  
                   {
 1016  17771
                      if (kind > 54)
 1017  17771
                         kind = 54;
 1018  17771
                      jjCheckNAdd(29);
 1019  
                   }
 1020  496
                   else if (curChar == 124)
 1021  178
                      jjstateSet[jjnewStateCnt++] = 20;
 1022  318
                   else if (curChar == 92)
 1023  0
                      jjAddStates(4, 5);
 1024  18267
                   if (curChar == 78)
 1025  808
                      jjstateSet[jjnewStateCnt++] = 26;
 1026  17459
                   else if (curChar == 79)
 1027  41
                      jjstateSet[jjnewStateCnt++] = 22;
 1028  17418
                   else if (curChar == 65)
 1029  107
                      jjstateSet[jjnewStateCnt++] = 18;
 1030  
                   break;
 1031  
                case 1:
 1032  3224
                   if (kind > 16)
 1033  3224
                      kind = 16;
 1034  3224
                   jjstateSet[jjnewStateCnt++] = 1;
 1035  3224
                   break;
 1036  
                case 3:
 1037  0
                   if (curChar == 92)
 1038  0
                      jjAddStates(4, 5);
 1039  
                   break;
 1040  
                case 17:
 1041  4
                   if (curChar == 68 && kind > 49)
 1042  4
                      kind = 49;
 1043  
                   break;
 1044  
                case 18:
 1045  103
                   if (curChar == 78)
 1046  4
                      jjstateSet[jjnewStateCnt++] = 17;
 1047  
                   break;
 1048  
                case 19:
 1049  0
                   if (curChar == 65)
 1050  0
                      jjstateSet[jjnewStateCnt++] = 18;
 1051  
                   break;
 1052  
                case 20:
 1053  178
                   if (curChar == 124 && kind > 50)
 1054  178
                      kind = 50;
 1055  
                   break;
 1056  
                case 21:
 1057  0
                   if (curChar == 124)
 1058  0
                      jjstateSet[jjnewStateCnt++] = 20;
 1059  
                   break;
 1060  
                case 22:
 1061  41
                   if (curChar == 82 && kind > 50)
 1062  4
                      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  808
                   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  72511
                   if ((0x7fffffe87fffffeL & l) == 0L)
 1089  1298
                      break;
 1090  71213
                   if (kind > 54)
 1091  71209
                      kind = 54;
 1092  71213
                   jjCheckNAdd(29);
 1093  71213
                   break;
 1094  
                default : break;
 1095  
             }
 1096  102217
          } while(i != startsAt);
 1097  101261
       }
 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  171667
       if (kind != 0x7fffffff)
 1125  
       {
 1126  125034
          jjmatchedKind = kind;
 1127  125034
          jjmatchedPos = curPos;
 1128  125034
          kind = 0x7fffffff;
 1129  
       }
 1130  171667
       ++curPos;
 1131  171667
       if ((i = jjnewStateCnt) == (startsAt = 31 - (jjnewStateCnt = startsAt)))
 1132  53504
          return curPos;
 1133  118163
       try { curChar = input_stream.readChar(); }
 1134  117759
       catch(java.io.IOException e) { return curPos; }
 1135  
    }
 1136  
 }
 1137  
 private int jjMoveStringLiteralDfa0_0()
 1138  
 {
 1139  104
    switch(curChar)
 1140  
    {
 1141  
       case 36:
 1142  1
          return jjStopAtPos(0, 20);
 1143  
       case 39:
 1144  51
          return jjStopAtPos(0, 25);
 1145  
       case 92:
 1146  3
          return jjStartNfaWithStates_0(0, 22, 1);
 1147  
       default :
 1148  49
          return jjMoveNfa_0(0, 0);
 1149  
    }
 1150  
 }
 1151  
 private int jjStartNfaWithStates_0(int pos, int kind, int state)
 1152  
 {
 1153  3
    jjmatchedKind = kind;
 1154  3
    jjmatchedPos = pos;
 1155  3
    try { curChar = input_stream.readChar(); }
 1156  3
    catch(java.io.IOException e) { return pos + 1; }
 1157  3
    return jjMoveNfa_0(state, pos + 1);
 1158  
 }
 1159  
 private int jjMoveNfa_0(int startState, int curPos)
 1160  
 {
 1161  52
    int startsAt = 0;
 1162  52
    jjnewStateCnt = 5;
 1163  52
    int i = 1;
 1164  52
    jjstateSet[0] = startState;
 1165  52
    int kind = 0x7fffffff;
 1166  
    for (;;)
 1167  
    {
 1168  272
       if (++jjround == 0x7fffffff)
 1169  0
          ReInitRounds();
 1170  272
       if (curChar < 64)
 1171  
       {
 1172  66
          long l = 1L << curChar;
 1173  
          do
 1174  
          {
 1175  66
             switch(jjstateSet[--i])
 1176  
             {
 1177  
                case 1:
 1178  3
                   if ((0xfc00ffffffffffffL & l) != 0L)
 1179  
                   {
 1180  3
                      if (kind > 21)
 1181  3
                         kind = 21;
 1182  
                   }
 1183  3
                   if (curChar == 13)
 1184  0
                      jjstateSet[jjnewStateCnt++] = 2;
 1185  
                   break;
 1186  
                case 0:
 1187  
                case 4:
 1188  63
                   if ((0xffffff6fffffdbffL & l) == 0L)
 1189  47
                      break;
 1190  16
                   if (kind > 58)
 1191  16
                      kind = 58;
 1192  16
                   jjCheckNAdd(4);
 1193  16
                   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  66
          } while(i != startsAt);
 1205  66
       }
 1206  206
       else if (curChar < 128)
 1207  
       {
 1208  206
          long l = 1L << (curChar & 077);
 1209  
          do
 1210  
          {
 1211  206
             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  46
                   if ((0xffffffffefffffffL & l) != 0L)
 1219  
                   {
 1220  46
                      if (kind > 58)
 1221  46
                         kind = 58;
 1222  46
                      jjCheckNAdd(4);
 1223  
                   }
 1224  0
                   else if (curChar == 92)
 1225  0
                      jjAddStates(2, 3);
 1226  
                   break;
 1227  
                case 4:
 1228  160
                   if ((0xffffffffefffffffL & l) == 0L)
 1229  2
                      break;
 1230  158
                   if (kind > 58)
 1231  158
                      kind = 58;
 1232  158
                   jjCheckNAdd(4);
 1233  158
                   break;
 1234  
                default : break;
 1235  
             }
 1236  206
          } while(i != startsAt);
 1237  206
       }
 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  272
       if (kind != 0x7fffffff)
 1266  
       {
 1267  223
          jjmatchedKind = kind;
 1268  223
          jjmatchedPos = curPos;
 1269  223
          kind = 0x7fffffff;
 1270  
       }
 1271  272
       ++curPos;
 1272  272
       if ((i = jjnewStateCnt) == (startsAt = 5 - (jjnewStateCnt = startsAt)))
 1273  52
          return curPos;
 1274  220
       try { curChar = input_stream.readChar(); }
 1275  220
       catch(java.io.IOException e) { return curPos; }
 1276  
    }
 1277  
 }
 1278  37
 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  32
    switch(hiByte)
 1284  
    {
 1285  
       case 0:
 1286  8
          return ((jjbitVec2[i2] & l2) != 0L);
 1287  
       default : 
 1288  24
          if ((jjbitVec0[i1] & l1) != 0L)
 1289  24
             return true;
 1290  0
          return false;
 1291  
    }
 1292  
 }
 1293  
 
 1294  
 /** Token literal values. */
 1295  37
 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  37
 public static final String[] lexStateNames = {
 1305  
    "SQS", 
 1306  
    "QS", 
 1307  
    "COMMENT", 
 1308  
    "WM", 
 1309  
    "DEFAULT", 
 1310  
 };
 1311  
 
 1312  
 /** Lex State array. */
 1313  37
 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  37
 static final long[] jjtoToken = {
 1319  
    0x7fffffffffef801L, 
 1320  
 };
 1321  37
 static final long[] jjtoSkip = {
 1322  
    0x10000L, 
 1323  
 };
 1324  37
 static final long[] jjtoSpecial = {
 1325  
    0x10000L, 
 1326  
 };
 1327  
 protected CharStream input_stream;
 1328  1678
 private final int[] jjrounds = new int[31];
 1329  1678
 private final int[] jjstateSet = new int[62];
 1330  1678
 private final StringBuffer jjimage = new StringBuffer();
 1331  1678
 private StringBuffer image = jjimage;
 1332  
 protected char curChar;
 1333  
 /** Constructor. */
 1334  1678
 public WMParser_implTokenManager(CharStream stream){
 1335  1678
    input_stream = stream;
 1336  1678
 }
 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  38640
    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  38640
       curLexState = lexState;
 1374  38640
 }
 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  116830
    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  116830
       String im = jjstrLiteralImages[jjmatchedKind];
 1396  116830
       tokenImage = (im == null) ? input_stream.GetImage() : im;
 1397  116830
       beginLine = input_stream.getBeginLine();
 1398  116830
       beginColumn = input_stream.getBeginColumn();
 1399  116830
       endLine = input_stream.getEndLine();
 1400  116830
       endColumn = input_stream.getEndColumn();
 1401  
    }
 1402  116830
    t = Token.newToken(jjmatchedKind, tokenImage);
 1403  
 
 1404  116830
    t.beginLine = beginLine;
 1405  116830
    t.endLine = endLine;
 1406  116830
    t.beginColumn = beginColumn;
 1407  116830
    t.endColumn = endColumn;
 1408  
 
 1409  116830
    return t;
 1410  
 }
 1411  
 
 1412  1678
 int curLexState = 4;
 1413  1678
 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  116510
   Token specialToken = null;
 1423  
   Token matchedToken;
 1424  116510
   int curPos = 0;
 1425  
 
 1426  
   EOFLoop :
 1427  
   for (;;)
 1428  
   {   
 1429  
    try   
 1430  
    {     
 1431  116830
       curChar = input_stream.BeginToken();
 1432  
    }     
 1433  3235
    catch(java.io.IOException e)
 1434  
    {        
 1435  3235
       jjmatchedKind = 0;
 1436  3235
       matchedToken = jjFillToken();
 1437  3235
       matchedToken.specialToken = specialToken;
 1438  3235
       return matchedToken;
 1439  113595
    }
 1440  113595
    image = jjimage;
 1441  113595
    image.setLength(0);
 1442  
 
 1443  113595
    switch(curLexState)
 1444  
    {
 1445  
      case 0:
 1446  104
        jjmatchedKind = 0x7fffffff;
 1447  104
        jjmatchedPos = 0;
 1448  104
        curPos = jjMoveStringLiteralDfa0_0();
 1449  104
        break;
 1450  
      case 1:
 1451  7237
        jjmatchedKind = 0x7fffffff;
 1452  7237
        jjmatchedPos = 0;
 1453  7237
        curPos = jjMoveStringLiteralDfa0_1();
 1454  7237
        break;
 1455  
      case 2:
 1456  2118
        jjmatchedKind = 18;
 1457  2118
        jjmatchedPos = -1;
 1458  2118
        curPos = 0;
 1459  2118
        curPos = jjMoveStringLiteralDfa0_2();
 1460  2118
        if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 19))
 1461  
        {
 1462  707
           jjmatchedKind = 19;
 1463  707
           jjmatchedPos = 0;
 1464  
        }
 1465  
        break;
 1466  
      case 3:
 1467  79861
        jjmatchedKind = 0x7fffffff;
 1468  79861
        jjmatchedPos = 0;
 1469  79861
        curPos = jjMoveStringLiteralDfa0_3();
 1470  79861
        if (jjmatchedPos == 0 && jjmatchedKind > 56)
 1471  
        {
 1472  324
           jjmatchedKind = 56;
 1473  
        }
 1474  
        break;
 1475  
      case 4:
 1476  24275
        jjmatchedKind = 0x7fffffff;
 1477  24275
        jjmatchedPos = 0;
 1478  24275
        curPos = jjMoveStringLiteralDfa0_4();
 1479  
        break;
 1480  
    }
 1481  113595
      if (jjmatchedKind != 0x7fffffff)
 1482  
      {
 1483  113595
         if (jjmatchedPos + 1 < curPos)
 1484  64510
            input_stream.backup(curPos - jjmatchedPos - 1);
 1485  113595
         if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1486  
         {
 1487  113275
            matchedToken = jjFillToken();
 1488  113275
            matchedToken.specialToken = specialToken;
 1489  113275
            TokenLexicalActions(matchedToken);
 1490  113275
        if (jjnewLexState[jjmatchedKind] != -1)
 1491  0
          curLexState = jjnewLexState[jjmatchedKind];
 1492  113275
            return matchedToken;
 1493  
         }
 1494  
         else
 1495  
         {
 1496  320
            if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 1497  
            {
 1498  320
               matchedToken = jjFillToken();
 1499  320
               if (specialToken == null)
 1500  320
                  specialToken = matchedToken;
 1501  
               else
 1502  
               {
 1503  0
                  matchedToken.specialToken = specialToken;
 1504  0
                  specialToken = (specialToken.next = matchedToken);
 1505  
               }
 1506  
            }
 1507  320
          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  113275
    switch(jjmatchedKind)
 1538  
    {
 1539  
       default : 
 1540  
          break;
 1541  
    }
 1542  113275
 }
 1543  
 private void jjCheckNAdd(int state)
 1544  
 {
 1545  339932
    if (jjrounds[state] != jjround)
 1546  
    {
 1547  339932
       jjstateSet[jjnewStateCnt++] = state;
 1548  339932
       jjrounds[state] = jjround;
 1549  
    }
 1550  339932
 }
 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  
 }