Coverage report

  %line %branch
org.apache.commons.jexl.parser.ParserTokenManager
66% 
78% 

 1  
 /* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */
 2  
 package org.apache.commons.jexl.parser;
 3  
 
 4  
 public class ParserTokenManager implements ParserConstants
 5  
 {
 6  45
   public  java.io.PrintStream debugStream = System.out;
 7  0
   public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
 8  
 private final int jjStopStringLiteralDfa_0(class="keyword">int pos, long active0)
 9  
 {
 10  1791
    switch (pos)
 11  
    {
 12  
       case 0:
 13  1017
          if ((active0 & 0x3ef285550a4800L) != 0L)
 14  
          {
 15  846
             jjmatchedKind = 58;
 16  846
             return 5;
 17  
          }
 18  171
          return -1;
 19  
       case 1:
 20  774
          if ((active0 & 0x1cf28000084800L) != 0L)
 21  
          {
 22  774
             jjmatchedKind = 58;
 23  774
             jjmatchedPos = 1;
 24  774
             return 5;
 25  
          }
 26  0
          if ((active0 & 0x22000555020000L) != 0L)
 27  0
             return 5;
 28  0
          return -1;
 29  
       case 2:
 30  0
          if ((active0 & 0x1ce00000004800L) != 0L)
 31  
          {
 32  0
             jjmatchedKind = 58;
 33  0
             jjmatchedPos = 2;
 34  0
             return 5;
 35  
          }
 36  0
          if ((active0 & 0x128000080000L) != 0L)
 37  0
             return 5;
 38  0
          return -1;
 39  
       case 3:
 40  0
          if ((active0 & 0x18800000000800L) != 0L)
 41  
          {
 42  0
             jjmatchedKind = 58;
 43  0
             jjmatchedPos = 3;
 44  0
             return 5;
 45  
          }
 46  0
          if ((active0 & 0x4600000004000L) != 0L)
 47  0
             return 5;
 48  0
          return -1;
 49  
       case 4:
 50  0
          if ((active0 & 0x10000000000000L) != 0L)
 51  
          {
 52  0
             jjmatchedKind = 58;
 53  0
             jjmatchedPos = 4;
 54  0
             return 5;
 55  
          }
 56  0
          if ((active0 & 0x8800000000800L) != 0L)
 57  0
             return 5;
 58  0
          return -1;
 59  
       case 5:
 60  0
          if ((active0 & 0x10000000000000L) != 0L)
 61  
          {
 62  0
             jjmatchedKind = 58;
 63  0
             jjmatchedPos = 5;
 64  0
             return 5;
 65  
          }
 66  0
          return -1;
 67  
       default :
 68  0
          return -1;
 69  
    }
 70  
 }
 71  
 private final int jjStartNfa_0(class="keyword">int pos, long active0)
 72  
 {
 73  1791
    return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
 74  
 }
 75  
 private final int jjStopAtPos(class="keyword">int pos, class="keyword">int kind)
 76  
 {
 77  4689
    jjmatchedKind = kind;
 78  4689
    jjmatchedPos = pos;
 79  4689
    return pos + 1;
 80  
 }
 81  
 private final int jjStartNfaWithStates_0(class="keyword">int pos, class="keyword">int kind, class="keyword">int state)
 82  
 {
 83  810
    jjmatchedKind = kind;
 84  810
    jjmatchedPos = pos;
 85  810
    try { curChar = input_stream.readChar(); }
 86  90
    catch(java.io.IOException e) { return pos + 1; }
 87  810
    return jjMoveNfa_0(state, pos + 1);
 88  
 }
 89  
 private final int jjMoveStringLiteralDfa0_0()
 90  
 {
 91  9090
    switch(curChar)
 92  
    {
 93  
       case 33:
 94  162
          jjmatchedKind = 43;
 95  162
          return jjMoveStringLiteralDfa1_0(0x2000000L);
 96  
       case 37:
 97  18
          return jjStopAtPos(0, 40);
 98  
       case 38:
 99  18
          jjmatchedKind = 22;
 100  18
          return jjMoveStringLiteralDfa1_0(0x40000L);
 101  
       case 40:
 102  549
          return jjStopAtPos(0, 12);
 103  
       case 41:
 104  549
          return jjStopAtPos(0, 13);
 105  
       case 42:
 106  45
          return jjStopAtPos(0, 37);
 107  
       case 43:
 108  117
          return jjStopAtPos(0, 35);
 109  
       case 44:
 110  36
          return jjStopAtPos(0, 54);
 111  
       case 45:
 112  99
          return jjStopAtPos(0, 36);
 113  
       case 46:
 114  639
          return jjStopAtPos(0, 57);
 115  
       case 47:
 116  36
          return jjStopAtPos(0, 38);
 117  
       case 59:
 118  1647
          return jjStopAtPos(0, 48);
 119  
       case 60:
 120  81
          jjmatchedKind = 27;
 121  81
          return jjMoveStringLiteralDfa1_0(0x80000000L);
 122  
       case 61:
 123  468
          jjmatchedKind = 15;
 124  468
          return jjMoveStringLiteralDfa1_0(0x800000L);
 125  
       case 62:
 126  90
          jjmatchedKind = 29;
 127  90
          return jjMoveStringLiteralDfa1_0(0x200000000L);
 128  
       case 91:
 129  144
          return jjStopAtPos(0, 55);
 130  
       case 93:
 131  144
          return jjStopAtPos(0, 56);
 132  
       case 94:
 133  0
          return jjStopAtPos(0, 21);
 134  
       case 97:
 135  387
          return jjMoveStringLiteralDfa1_0(0x80000L);
 136  
       case 100:
 137  0
          return jjMoveStringLiteralDfa1_0(0x8000000000L);
 138  
       case 101:
 139  207
          return jjMoveStringLiteralDfa1_0(0x4000001000800L);
 140  
       case 102:
 141  801
          return jjMoveStringLiteralDfa1_0(0x10800000000000L);
 142  
       case 103:
 143  63
          return jjMoveStringLiteralDfa1_0(0x440000000L);
 144  
       case 105:
 145  90
          return jjMoveStringLiteralDfa1_0(0x22000000000000L);
 146  
       case 108:
 147  171
          return jjMoveStringLiteralDfa1_0(0x110000000L);
 148  
       case 109:
 149  54
          return jjMoveStringLiteralDfa1_0(0x20000000000L);
 150  
       case 110:
 151  153
          return jjMoveStringLiteralDfa1_0(0x300004000000L);
 152  
       case 111:
 153  27
          return jjMoveStringLiteralDfa1_0(0x20000L);
 154  
       case 115:
 155  369
          return jjMoveStringLiteralDfa1_0(0x4000L);
 156  
       case 116:
 157  108
          return jjMoveStringLiteralDfa1_0(0x400000000000L);
 158  
       case 119:
 159  0
          return jjMoveStringLiteralDfa1_0(0x8000000000000L);
 160  
       case 123:
 161  0
          return jjStopAtPos(0, 9);
 162  
       case 124:
 163  18
          jjmatchedKind = 20;
 164  18
          return jjMoveStringLiteralDfa1_0(0x10000L);
 165  
       case 125:
 166  0
          return jjStopAtPos(0, 10);
 167  
       case 126:
 168  0
          return jjStopAtPos(0, 42);
 169  
       default :
 170  1800
          return jjMoveNfa_0(3, 0);
 171  
    }
 172  
 }
 173  
 private final int jjMoveStringLiteralDfa1_0(long active0)
 174  
 {
 175  3267
    try { curChar = input_stream.readChar(); }
 176  
    catch(java.io.IOException e) {
 177  0
       jjStopStringLiteralDfa_0(0, active0);
 178  0
       return 1;
 179  363
    }
 180  3267
    switch(curChar)
 181  
    {
 182  
       case 38:
 183  18
          if ((active0 & 0x40000L) != 0L)
 184  18
             return jjStopAtPos(1, 18);
 185  
          break;
 186  
       case 61:
 187  675
          if ((active0 & 0x800000L) != 0L)
 188  432
             return jjStopAtPos(1, 23);
 189  243
          else if ((active0 & 0x2000000L) != 0L)
 190  99
             return jjStopAtPos(1, 25);
 191  144
          else if ((active0 & 0x80000000L) != 0L)
 192  45
             return jjStopAtPos(1, 31);
 193  99
          else if ((active0 & 0x200000000L) != 0L)
 194  54
             return jjStopAtPos(1, 33);
 195  
          break;
 196  
       case 97:
 197  108
          return jjMoveStringLiteralDfa2_0(active0, 0x800000000000L);
 198  
       case 101:
 199  171
          if ((active0 & 0x4000000L) != 0L)
 200  18
             return jjStartNfaWithStates_0(1, 26, 5);
 201  153
          else if ((active0 & 0x100000000L) != 0L)
 202  36
             return jjStartNfaWithStates_0(1, 32, 5);
 203  117
          else if ((active0 & 0x400000000L) != 0L)
 204  63
             return jjStartNfaWithStates_0(1, 34, 5);
 205  
          break;
 206  
       case 102:
 207  18
          if ((active0 & 0x2000000000000L) != 0L)
 208  0
             return jjStartNfaWithStates_0(1, 49, 5);
 209  
          break;
 210  
       case 104:
 211  27
          return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L);
 212  
       case 105:
 213  324
          return jjMoveStringLiteralDfa2_0(active0, 0x8000004000L);
 214  
       case 108:
 215  0
          return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000L);
 216  
       case 109:
 217  216
          return jjMoveStringLiteralDfa2_0(active0, 0x800L);
 218  
       case 110:
 219  63
          if ((active0 & 0x20000000000000L) != 0L)
 220  36
             return jjStartNfaWithStates_0(1, 53, 5);
 221  27
          return jjMoveStringLiteralDfa2_0(active0, 0x80000L);
 222  
       case 111:
 223  801
          return jjMoveStringLiteralDfa2_0(active0, 0x10120000000000L);
 224  
       case 113:
 225  36
          if ((active0 & 0x1000000L) != 0L)
 226  18
             return jjStartNfaWithStates_0(1, 24, 5);
 227  
          break;
 228  
       case 114:
 229  180
          if ((active0 & 0x20000L) != 0L)
 230  27
             return jjStartNfaWithStates_0(1, 17, 5);
 231  153
          return jjMoveStringLiteralDfa2_0(active0, 0x400000000000L);
 232  
       case 116:
 233  72
          if ((active0 & 0x10000000L) != 0L)
 234  0
             return jjStartNfaWithStates_0(1, 28, 5);
 235  72
          else if ((active0 & 0x40000000L) != 0L)
 236  0
             return jjStartNfaWithStates_0(1, 30, 5);
 237  
          break;
 238  
       case 117:
 239  126
          return jjMoveStringLiteralDfa2_0(active0, 0x200000000000L);
 240  
       case 124:
 241  18
          if ((active0 & 0x10000L) != 0L)
 242  18
             return jjStopAtPos(1, 16);
 243  
          break;
 244  
       default :
 245  
          break;
 246  
    }
 247  621
    return jjStartNfa_0(0, active0);
 248  
 }
 249  
 private final int jjMoveStringLiteralDfa2_0(long old0, class="keyword">long active0)
 250  
 {
 251  1782
    if (((active0 &= old0)) == 0L)
 252  396
       return jjStartNfa_0(0, old0); 
 253  1386
    try { curChar = input_stream.readChar(); }
 254  
    catch(java.io.IOException e) {
 255  0
       jjStopStringLiteralDfa_0(1, active0);
 256  0
       return 2;
 257  154
    }
 258  1386
    switch(curChar)
 259  
    {
 260  
       case 100:
 261  27
          if ((active0 & 0x80000L) != 0L)
 262  27
             return jjStartNfaWithStates_0(2, 19, 5);
 263  0
          else if ((active0 & 0x20000000000L) != 0L)
 264  0
             return jjStartNfaWithStates_0(2, 41, 5);
 265  
          break;
 266  
       case 105:
 267  0
          return jjMoveStringLiteralDfa3_0(active0, 0x8000000000000L);
 268  
       case 108:
 269  99
          return jjMoveStringLiteralDfa3_0(active0, 0xa00000000000L);
 270  
       case 112:
 271  189
          return jjMoveStringLiteralDfa3_0(active0, 0x800L);
 272  
       case 114:
 273  0
          return jjMoveStringLiteralDfa3_0(active0, 0x10000000000000L);
 274  
       case 115:
 275  0
          return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000L);
 276  
       case 116:
 277  54
          if ((active0 & 0x100000000000L) != 0L)
 278  54
             return jjStartNfaWithStates_0(2, 44, 5);
 279  
          break;
 280  
       case 117:
 281  72
          return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L);
 282  
       case 118:
 283  0
          if ((active0 & 0x8000000000L) != 0L)
 284  0
             return jjStartNfaWithStates_0(2, 39, 5);
 285  
          break;
 286  
       case 122:
 287  171
          return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
 288  
       default :
 289  
          break;
 290  
    }
 291  774
    return jjStartNfa_0(1, active0);
 292  
 }
 293  
 private final int jjMoveStringLiteralDfa3_0(long old0, class="keyword">long active0)
 294  
 {
 295  531
    if (((active0 &= old0)) == 0L)
 296  0
       return jjStartNfa_0(1, old0); 
 297  531
    try { curChar = input_stream.readChar(); }
 298  
    catch(java.io.IOException e) {
 299  0
       jjStopStringLiteralDfa_0(2, active0);
 300  0
       return 3;
 301  59
    }
 302  531
    switch(curChar)
 303  
    {
 304  
       case 101:
 305  243
          if ((active0 & 0x4000L) != 0L)
 306  171
             return jjStartNfaWithStates_0(3, 14, 5);
 307  72
          else if ((active0 & 0x400000000000L) != 0L)
 308  72
             return jjStartNfaWithStates_0(3, 46, 5);
 309  0
          else if ((active0 & 0x4000000000000L) != 0L)
 310  0
             return jjStartNfaWithStates_0(3, 50, 5);
 311  0
          return jjMoveStringLiteralDfa4_0(active0, 0x10000000000000L);
 312  
       case 108:
 313  45
          if ((active0 & 0x200000000000L) != 0L)
 314  45
             return jjStartNfaWithStates_0(3, 45, 5);
 315  0
          return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L);
 316  
       case 115:
 317  54
          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L);
 318  
       case 116:
 319  189
          return jjMoveStringLiteralDfa4_0(active0, 0x800L);
 320  
       default :
 321  
          break;
 322  
    }
 323  0
    return jjStartNfa_0(2, active0);
 324  
 }
 325  
 private final int jjMoveStringLiteralDfa4_0(long old0, class="keyword">long active0)
 326  
 {
 327  243
    if (((active0 &= old0)) == 0L)
 328  0
       return jjStartNfa_0(2, old0); 
 329  243
    try { curChar = input_stream.readChar(); }
 330  
    catch(java.io.IOException e) {
 331  0
       jjStopStringLiteralDfa_0(3, active0);
 332  0
       return 4;
 333  27
    }
 334  243
    switch(curChar)
 335  
    {
 336  
       case 97:
 337  0
          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
 338  
       case 101:
 339  54
          if ((active0 & 0x800000000000L) != 0L)
 340  54
             return jjStartNfaWithStates_0(4, 47, 5);
 341  0
          else if ((active0 & 0x8000000000000L) != 0L)
 342  0
             return jjStartNfaWithStates_0(4, 51, 5);
 343  
          break;
 344  
       case 121:
 345  189
          if ((active0 & 0x800L) != 0L)
 346  189
             return jjStartNfaWithStates_0(4, 11, 5);
 347  
          break;
 348  
       default :
 349  
          break;
 350  
    }
 351  0
    return jjStartNfa_0(3, active0);
 352  
 }
 353  
 private final int jjMoveStringLiteralDfa5_0(long old0, class="keyword">long active0)
 354  
 {
 355  0
    if (((active0 &= old0)) == 0L)
 356  0
       return jjStartNfa_0(3, old0); 
 357  0
    try { curChar = input_stream.readChar(); }
 358  
    catch(java.io.IOException e) {
 359  0
       jjStopStringLiteralDfa_0(4, active0);
 360  0
       return 5;
 361  
    }
 362  0
    switch(curChar)
 363  
    {
 364  
       case 99:
 365  0
          return jjMoveStringLiteralDfa6_0(active0, 0x10000000000000L);
 366  
       default :
 367  
          break;
 368  
    }
 369  0
    return jjStartNfa_0(4, active0);
 370  
 }
 371  
 private final int jjMoveStringLiteralDfa6_0(long old0, class="keyword">long active0)
 372  
 {
 373  0
    if (((active0 &= old0)) == 0L)
 374  0
       return jjStartNfa_0(4, old0); 
 375  0
    try { curChar = input_stream.readChar(); }
 376  
    catch(java.io.IOException e) {
 377  0
       jjStopStringLiteralDfa_0(5, active0);
 378  0
       return 6;
 379  
    }
 380  0
    switch(curChar)
 381  
    {
 382  
       case 104:
 383  0
          if ((active0 & 0x10000000000000L) != 0L)
 384  0
             return jjStartNfaWithStates_0(6, 52, 5);
 385  
          break;
 386  
       default :
 387  
          break;
 388  
    }
 389  0
    return jjStartNfa_0(5, active0);
 390  
 }
 391  
 private final void jjCheckNAdd(int state)
 392  
 {
 393  11196
    if (jjrounds[state] != jjround)
 394  
    {
 395  11196
       jjstateSet[jjnewStateCnt++] = state;
 396  11196
       jjrounds[state] = jjround;
 397  
    }
 398  11196
 }
 399  
 private final void jjAddStates(int start, class="keyword">int end)
 400  
 {
 401  
    do {
 402  2466
       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 403  2466
    } while (start++ != end);
 404  1233
 }
 405  
 private final void jjCheckNAddTwoStates(int state1, class="keyword">int state2)
 406  
 {
 407  657
    jjCheckNAdd(state1);
 408  657
    jjCheckNAdd(state2);
 409  657
 }
 410  
 private final void jjCheckNAddStates(int start, class="keyword">int end)
 411  
 {
 412  
    do {
 413  2511
       jjCheckNAdd(jjnextStates[start]);
 414  2511
    } while (start++ != end);
 415  837
 }
 416  
 private final void jjCheckNAddStates(int start)
 417  
 {
 418  0
    jjCheckNAdd(jjnextStates[start]);
 419  0
    jjCheckNAdd(jjnextStates[start + 1]);
 420  0
 }
 421  51
 static final long[] jjbitVec0 = {
 422  
    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 423  
 };
 424  
 private final int jjMoveNfa_0(class="keyword">int startState, class="keyword">int curPos)
 425  
 {
 426  
    int[] nextStates;
 427  4401
    int startsAt = 0;
 428  4401
    jjnewStateCnt = 17;
 429  4401
    int i = 1;
 430  4401
    jjstateSet[0] = startState;
 431  4401
    int j, kind = 0x7fffffff;
 432  3912
    for (;;)
 433  
    {
 434  14508
       if (++jjround == 0x7fffffff)
 435  0
          ReInitRounds();
 436  14508
       if (curChar < 64)
 437  
       {
 438  5688
          long l = 1L << curChar;
 439  
          MatchLoop: do
 440  
          {
 441  7821
             switch(jjstateSet[--i])
 442  
             {
 443  
                case 3:
 444  1323
                   if ((0x3ff000000000000L & l) != 0L)
 445  
                   {
 446  837
                      if (kind > 7)
 447  837
                         kind = 7;
 448  837
                      jjCheckNAddStates(0, 2);
 449  
                   }
 450  486
                   else if (curChar == 39)
 451  414
                      jjCheckNAddTwoStates(10, 11);
 452  72
                   else if (curChar == 34)
 453  63
                      jjCheckNAddTwoStates(7, 8);
 454  9
                   else if (curChar == 36)
 455  
                   {
 456  0
                      if (kind > 58)
 457  0
                         kind = 58;
 458  0
                      jjCheckNAdd(5);
 459  
                   }
 460  9
                   else if (curChar == 35)
 461  9
                      jjstateSet[jjnewStateCnt++] = 0;
 462  
                   break;
 463  
                case 0:
 464  9
                   if (curChar == 35)
 465  9
                      jjCheckNAddTwoStates(1, 2);
 466  
                   break;
 467  
                case 1:
 468  36
                   if ((0xfffffffbffffdbffL & l) != 0L)
 469  27
                      jjCheckNAddTwoStates(1, 2);
 470  
                   break;
 471  
                case 2:
 472  36
                   if ((0x2400L & l) != 0L)
 473  9
                      kind = 1;
 474  
                   break;
 475  
                case 4:
 476  0
                   if (curChar != 36)
 477  0
                      break;
 478  0
                   if (kind > 58)
 479  0
                      kind = 58;
 480  0
                   jjCheckNAdd(5);
 481  0
                   break;
 482  
                case 5:
 483  2781
                   if ((0x3ff001000000000L & l) == 0L)
 484  2772
                      break;
 485  9
                   if (kind > 58)
 486  9
                      kind = 58;
 487  9
                   jjCheckNAdd(5);
 488  9
                   break;
 489  
                case 6:
 490  0
                   if (curChar == 34)
 491  0
                      jjCheckNAddTwoStates(7, 8);
 492  
                   break;
 493  
                case 7:
 494  90
                   if ((0xfffffffbffffdbffL & l) != 0L)
 495  27
                      jjCheckNAddTwoStates(7, 8);
 496  
                   break;
 497  
                case 8:
 498  90
                   if (curChar == 34 && kind > 61)
 499  63
                      kind = 61;
 500  
                   break;
 501  
                case 9:
 502  0
                   if (curChar == 39)
 503  0
                      jjCheckNAddTwoStates(10, 11);
 504  
                   break;
 505  
                case 10:
 506  531
                   if ((0xffffff7fffffdbffL & l) != 0L)
 507  117
                      jjCheckNAddTwoStates(10, 11);
 508  
                   break;
 509  
                case 11:
 510  531
                   if (curChar == 39 && kind > 61)
 511  414
                      kind = 61;
 512  
                   break;
 513  
                case 12:
 514  0
                   if ((0x3ff000000000000L & l) == 0L)
 515  0
                      break;
 516  0
                   if (kind > 7)
 517  0
                      kind = 7;
 518  0
                   jjCheckNAddStates(0, 2);
 519  0
                   break;
 520  
                case 13:
 521  738
                   if ((0x3ff000000000000L & l) == 0L)
 522  738
                      break;
 523  0
                   if (kind > 7)
 524  0
                      kind = 7;
 525  0
                   jjCheckNAdd(13);
 526  0
                   break;
 527  
                case 14:
 528  738
                   if ((0x3ff000000000000L & l) != 0L)
 529  0
                      jjCheckNAddTwoStates(14, 15);
 530  
                   break;
 531  
                case 15:
 532  738
                   if (curChar == 46)
 533  27
                      jjCheckNAdd(16);
 534  
                   break;
 535  
                case 16:
 536  54
                   if ((0x3ff000000000000L & l) == 0L)
 537  27
                      break;
 538  27
                   if (kind > 8)
 539  27
                      kind = 8;
 540  27
                   jjCheckNAdd(16);
 541  27
                   break;
 542  
                default : break;
 543  
             }
 544  7821
          } while(i != startsAt);
 545  
       }
 546  8820
       else if (curChar < 128)
 547  
       {
 548  8820
          long l = 1L << (curChar & 077);
 549  
          MatchLoop: do
 550  
          {
 551  10251
             switch(jjstateSet[--i])
 552  
             {
 553  
                case 3:
 554  
                case 5:
 555  7443
                   if ((0x7fffffe87fffffeL & l) == 0L)
 556  135
                      break;
 557  7308
                   if (kind > 58)
 558  7308
                      kind = 58;
 559  7308
                   jjCheckNAdd(5);
 560  7308
                   break;
 561  
                case 1:
 562  135
                   jjAddStates(3, 4);
 563  135
                   break;
 564  
                case 7:
 565  189
                   jjAddStates(5, 6);
 566  189
                   break;
 567  
                case 10:
 568  909
                   jjAddStates(7, 8);
 569  909
                   break;
 570  
                default : break;
 571  
             }
 572  10251
          } while(i != startsAt);
 573  
       }
 574  
       else
 575  
       {
 576  0
          int i2 = (curChar & 0xff) >> 6;
 577  0
          long l2 = 1L << (curChar & 077);
 578  
          MatchLoop: do
 579  
          {
 580  0
             switch(jjstateSet[--i])
 581  
             {
 582  
                case 1:
 583  0
                   if ((jjbitVec0[i2] & l2) != 0L)
 584  0
                      jjAddStates(3, 4);
 585  
                   break;
 586  
                case 7:
 587  0
                   if ((jjbitVec0[i2] & l2) != 0L)
 588  0
                      jjAddStates(5, 6);
 589  
                   break;
 590  
                case 10:
 591  0
                   if ((jjbitVec0[i2] & l2) != 0L)
 592  0
                      jjAddStates(7, 8);
 593  
                   break;
 594  
                default : break;
 595  
             }
 596  0
          } while(i != startsAt);
 597  
       }
 598  14508
       if (kind != 0x7fffffff)
 599  
       {
 600  8667
          jjmatchedKind = kind;
 601  8667
          jjmatchedPos = curPos;
 602  8667
          kind = 0x7fffffff;
 603  
       }
 604  14508
       ++curPos;
 605  14508
       if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt)))
 606  4401
          return curPos;
 607  10107
       try { curChar = input_stream.readChar(); }
 608  1123
       catch(java.io.IOException e) { return curPos; }
 609  
    }
 610  
 }
 611  27
 static final int[] jjnextStates = {
 612  
    13, 14, 15, 1, 2, 7, 8, 10, 11, 
 613  
 };
 614  27
 public static final String[] jjstrLiteralImages = {
 615  
 "", null, class="keyword">null, class="keyword">null, class="keyword">null, class="keyword">null, class="keyword">null, class="keyword">null, class="keyword">null, "\173", "\175", 
 616  
 "\145\155\160\164\171", "\50", "\51", "\163\151\172\145", "\75", "\174\174", "\157\162", "\46\46", 
 617  
 "\141\156\144", "\174", "\136", "\46", "\75\75", "\145\161", "\41\75", "\156\145", "\74", 
 618  
 "\154\164", "\76", "\147\164", "\74\75", "\154\145", "\76\75", "\147\145", "\53", "\55", 
 619  
 "\52", "\57", "\144\151\166", "\45", "\155\157\144", "\176", "\41", "\156\157\164", 
 620  
 "\156\165\154\154", "\164\162\165\145", "\146\141\154\163\145", "\73", "\151\146", 
 621  
 "\145\154\163\145", "\167\150\151\154\145", "\146\157\162\145\141\143\150", "\151\156", "\54", 
 622  
 "\133", "\135", "\56", null, class="keyword">null, class="keyword">null, class="keyword">null, };
 623  27
 public static final String[] lexStateNames = {
 624  
    "DEFAULT", 
 625  
 };
 626  27
 static final long[] jjtoToken = {
 627  
    0x27ffffffffffff81L, 
 628  
 };
 629  27
 static final long[] jjtoSkip = {
 630  
    0x7eL, 
 631  
 };
 632  
 private SimpleCharStream input_stream;
 633  45
 private final int[] jjrounds = new class="keyword">int[17];
 634  45
 private final int[] jjstateSet = new class="keyword">int[34];
 635  
 protected char curChar;
 636  
 public ParserTokenManager(SimpleCharStream stream)
 637  45
 {
 638  
    if (SimpleCharStream.staticFlag)
 639  
       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 640  45
    input_stream = stream;
 641  45
 }
 642  
 public ParserTokenManager(SimpleCharStream stream, int lexState)
 643  
 {
 644  0
    this(stream);
 645  0
    SwitchTo(lexState);
 646  0
 }
 647  
 public void ReInit(SimpleCharStream stream)
 648  
 {
 649  1656
    jjmatchedPos = jjnewStateCnt = 0;
 650  1656
    curLexState = defaultLexState;
 651  1656
    input_stream = stream;
 652  1656
    ReInitRounds();
 653  1656
 }
 654  
 private final void ReInitRounds()
 655  
 {
 656  
    int i;
 657  1656
    jjround = 0x80000001;
 658  28152
    for (i = 17; i-- > 0;)
 659  28152
       jjrounds[i] = 0x80000000;
 660  1656
 }
 661  
 public void ReInit(SimpleCharStream stream, int lexState)
 662  
 {
 663  0
    ReInit(stream);
 664  0
    SwitchTo(lexState);
 665  0
 }
 666  
 public void SwitchTo(int lexState)
 667  
 {
 668  0
    if (lexState >= 1 || lexState < 0)
 669  0
       throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 670  
    else
 671  0
       curLexState = lexState;
 672  0
 }
 673  
 
 674  
 private final Token jjFillToken()
 675  
 {
 676  10728
    Token t = Token.newToken(jjmatchedKind);
 677  10728
    t.kind = jjmatchedKind;
 678  10728
    String im = jjstrLiteralImages[jjmatchedKind];
 679  10728
    t.image = (im == null) ? input_stream.GetImage() : im;
 680  10728
    t.beginLine = input_stream.getBeginLine();
 681  10728
    t.beginColumn = input_stream.getBeginColumn();
 682  10728
    t.endLine = input_stream.getEndLine();
 683  10728
    t.endColumn = input_stream.getEndColumn();
 684  10728
    return t;
 685  
 }
 686  
 
 687  45
 int curLexState = 0;
 688  45
 int defaultLexState = 0;
 689  
 int jjnewStateCnt;
 690  
 int jjround;
 691  
 int jjmatchedPos;
 692  
 int jjmatchedKind;
 693  
 
 694  
 public final Token getNextToken() 
 695  
 {
 696  
   int kind;
 697  10728
   Token specialToken = null;
 698  
   Token matchedToken;
 699  10728
   int curPos = 0;
 700  
 
 701  
   EOFLoop :
 702  9536
   for (;;)
 703  
   {   
 704  
    try   
 705  
    {     
 706  10737
       curChar = input_stream.BeginToken();
 707  8080
    }     
 708  183
    catch(java.io.IOException e)
 709  
    {        
 710  1647
       jjmatchedKind = 0;
 711  1647
       matchedToken = jjFillToken();
 712  1647
       return matchedToken;
 713  1010
    }
 714  
 
 715  9090
    try { input_stream.backup(0);
 716  19429
       while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
 717  2259
          curChar = input_stream.BeginToken();
 718  8080
    }
 719  1010
    catch (java.io.IOException e1) { continue EOFLoop; }
 720  9090
    jjmatchedKind = 0x7fffffff;
 721  9090
    jjmatchedPos = 0;
 722  9090
    curPos = jjMoveStringLiteralDfa0_0();
 723  9090
    if (jjmatchedKind != 0x7fffffff)
 724  
    {
 725  9090
       if (jjmatchedPos + 1 < curPos)
 726  3915
          input_stream.backup(curPos - jjmatchedPos - 1);
 727  9090
       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 728  
       {
 729  9081
          matchedToken = jjFillToken();
 730  9081
          return matchedToken;
 731  
       }
 732  
       else
 733  
       {
 734  
          continue EOFLoop;
 735  
       }
 736  
    }
 737  0
    int error_line = input_stream.getEndLine();
 738  0
    int error_column = input_stream.getEndColumn();
 739  0
    String error_after = null;
 740  0
    boolean EOFSeen = false;
 741  0
    try { input_stream.readChar(); input_stream.backup(1); }
 742  
    catch (java.io.IOException e1) {
 743  0
       EOFSeen = true;
 744  0
       error_after = curPos <= 1 ? "" : input_stream.GetImage();
 745  0
       if (curChar == '\n' || curChar == '\r') {
 746  0
          error_line++;
 747  0
          error_column = 0;
 748  
       }
 749  
       else
 750  0
          error_column++;
 751  
    }
 752  0
    if (!EOFSeen) {
 753  0
       input_stream.backup(1);
 754  0
       error_after = curPos <= 1 ? "" : input_stream.GetImage();
 755  
    }
 756  0
    throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 757  
   }
 758  
 }
 759  
 
 760  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.