Coverage report

  %line %branch
org.apache.commons.jexl.parser.ParserTokenManager
63% 
76% 

 1  
 /* Generated By:JJTree&JavaCC: Do not edit this line. ParserTokenManager.java */
 2  
 package org.apache.commons.jexl.parser;
 3  
 
 4  3
 public class ParserTokenManager implements ParserConstants
 5  
 {
 6  75
   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  3057
    switch (pos)
 11  
    {
 12  
       case 0:
 13  1743
          if ((active0 & 0x3ef285550a4800L) != 0L)
 14  
          {
 15  1446
             jjmatchedKind = 58;
 16  1446
             return 5;
 17  
          }
 18  297
          return -1;
 19  
       case 1:
 20  1314
          if ((active0 & 0x1cf28000084800L) != 0L)
 21  
          {
 22  1314
             jjmatchedKind = 58;
 23  1314
             jjmatchedPos = 1;
 24  1314
             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  3057
    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  7989
    jjmatchedKind = kind;
 78  7989
    jjmatchedPos = pos;
 79  7989
    return pos + 1;
 80  
 }
 81  
 private final int jjStartNfaWithStates_0(class="keyword">int pos, class="keyword">int kind, class="keyword">int state)
 82  
 {
 83  1368
    jjmatchedKind = kind;
 84  1368
    jjmatchedPos = pos;
 85  1368
    try { curChar = input_stream.readChar(); }
 86  369
    catch(java.io.IOException e) { return pos + 1; }
 87  1368
    return jjMoveNfa_0(state, pos + 1);
 88  
 }
 89  
 private final int jjMoveStringLiteralDfa0_0()
 90  
 {
 91  15486
    switch(curChar)
 92  
    {
 93  
       case 33:
 94  282
          jjmatchedKind = 43;
 95  282
          return jjMoveStringLiteralDfa1_0(0x2000000L);
 96  
       case 37:
 97  30
          return jjStopAtPos(0, 40);
 98  
       case 38:
 99  30
          jjmatchedKind = 22;
 100  30
          return jjMoveStringLiteralDfa1_0(0x40000L);
 101  
       case 40:
 102  933
          return jjStopAtPos(0, 12);
 103  
       case 41:
 104  933
          return jjStopAtPos(0, 13);
 105  
       case 42:
 106  75
          return jjStopAtPos(0, 37);
 107  
       case 43:
 108  207
          return jjStopAtPos(0, 35);
 109  
       case 44:
 110  60
          return jjStopAtPos(0, 54);
 111  
       case 45:
 112  165
          return jjStopAtPos(0, 36);
 113  
       case 46:
 114  1137
          return jjStopAtPos(0, 57);
 115  
       case 47:
 116  60
          return jjStopAtPos(0, 38);
 117  
       case 59:
 118  2793
          return jjStopAtPos(0, 48);
 119  
       case 60:
 120  135
          jjmatchedKind = 27;
 121  135
          return jjMoveStringLiteralDfa1_0(0x80000000L);
 122  
       case 61:
 123  786
          jjmatchedKind = 15;
 124  786
          return jjMoveStringLiteralDfa1_0(0x800000L);
 125  
       case 62:
 126  150
          jjmatchedKind = 29;
 127  150
          return jjMoveStringLiteralDfa1_0(0x200000000L);
 128  
       case 91:
 129  240
          return jjStopAtPos(0, 55);
 130  
       case 93:
 131  240
          return jjStopAtPos(0, 56);
 132  
       case 94:
 133  0
          return jjStopAtPos(0, 21);
 134  
       case 97:
 135  657
          return jjMoveStringLiteralDfa1_0(0x80000L);
 136  
       case 100:
 137  0
          return jjMoveStringLiteralDfa1_0(0x8000000000L);
 138  
       case 101:
 139  351
          return jjMoveStringLiteralDfa1_0(0x4000001000800L);
 140  
       case 102:
 141  1359
          return jjMoveStringLiteralDfa1_0(0x10800000000000L);
 142  
       case 103:
 143  105
          return jjMoveStringLiteralDfa1_0(0x440000000L);
 144  
       case 105:
 145  150
          return jjMoveStringLiteralDfa1_0(0x22000000000000L);
 146  
       case 108:
 147  291
          return jjMoveStringLiteralDfa1_0(0x110000000L);
 148  
       case 109:
 149  114
          return jjMoveStringLiteralDfa1_0(0x20000000000L);
 150  
       case 110:
 151  255
          return jjMoveStringLiteralDfa1_0(0x300004000000L);
 152  
       case 111:
 153  45
          return jjMoveStringLiteralDfa1_0(0x20000L);
 154  
       case 115:
 155  621
          return jjMoveStringLiteralDfa1_0(0x4000L);
 156  
       case 116:
 157  180
          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  30
          jjmatchedKind = 20;
 164  30
          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  3072
          return jjMoveNfa_0(3, 0);
 171  
    }
 172  
 }
 173  
 private final int jjMoveStringLiteralDfa1_0(long active0)
 174  
 {
 175  5541
    try { curChar = input_stream.readChar(); }
 176  
    catch(java.io.IOException e) {
 177  0
       jjStopStringLiteralDfa_0(0, active0);
 178  0
       return 1;
 179  1500
    }
 180  5541
    switch(curChar)
 181  
    {
 182  
       case 38:
 183  30
          if ((active0 & 0x40000L) != 0L)
 184  30
             return jjStopAtPos(1, 18);
 185  
          break;
 186  
       case 61:
 187  1131
          if ((active0 & 0x800000L) != 0L)
 188  726
             return jjStopAtPos(1, 23);
 189  405
          else if ((active0 & 0x2000000L) != 0L)
 190  165
             return jjStopAtPos(1, 25);
 191  240
          else if ((active0 & 0x80000000L) != 0L)
 192  75
             return jjStopAtPos(1, 31);
 193  165
          else if ((active0 & 0x200000000L) != 0L)
 194  90
             return jjStopAtPos(1, 33);
 195  
          break;
 196  
       case 97:
 197  204
          return jjMoveStringLiteralDfa2_0(active0, 0x800000000000L);
 198  
       case 101:
 199  291
          if ((active0 & 0x4000000L) != 0L)
 200  30
             return jjStartNfaWithStates_0(1, 26, 5);
 201  261
          else if ((active0 & 0x100000000L) != 0L)
 202  66
             return jjStartNfaWithStates_0(1, 32, 5);
 203  195
          else if ((active0 & 0x400000000L) != 0L)
 204  105
             return jjStartNfaWithStates_0(1, 34, 5);
 205  
          break;
 206  
       case 102:
 207  30
          if ((active0 & 0x2000000000000L) != 0L)
 208  0
             return jjStartNfaWithStates_0(1, 49, 5);
 209  
          break;
 210  
       case 104:
 211  45
          return jjMoveStringLiteralDfa2_0(active0, 0x8000000000000L);
 212  
       case 105:
 213  546
          return jjMoveStringLiteralDfa2_0(active0, 0x8000004000L);
 214  
       case 108:
 215  0
          return jjMoveStringLiteralDfa2_0(active0, 0x4000000000000L);
 216  
       case 109:
 217  366
          return jjMoveStringLiteralDfa2_0(active0, 0x800L);
 218  
       case 110:
 219  105
          if ((active0 & 0x20000000000000L) != 0L)
 220  60
             return jjStartNfaWithStates_0(1, 53, 5);
 221  45
          return jjMoveStringLiteralDfa2_0(active0, 0x80000L);
 222  
       case 111:
 223  1359
          return jjMoveStringLiteralDfa2_0(active0, 0x10120000000000L);
 224  
       case 113:
 225  60
          if ((active0 & 0x1000000L) != 0L)
 226  30
             return jjStartNfaWithStates_0(1, 24, 5);
 227  
          break;
 228  
       case 114:
 229  300
          if ((active0 & 0x20000L) != 0L)
 230  45
             return jjStartNfaWithStates_0(1, 17, 5);
 231  255
          return jjMoveStringLiteralDfa2_0(active0, 0x400000000000L);
 232  
       case 116:
 233  120
          if ((active0 & 0x10000000L) != 0L)
 234  0
             return jjStartNfaWithStates_0(1, 28, 5);
 235  120
          else if ((active0 & 0x40000000L) != 0L)
 236  0
             return jjStartNfaWithStates_0(1, 30, 5);
 237  
          break;
 238  
       case 117:
 239  210
          return jjMoveStringLiteralDfa2_0(active0, 0x200000000000L);
 240  
       case 124:
 241  30
          if ((active0 & 0x10000L) != 0L)
 242  30
             return jjStopAtPos(1, 16);
 243  
          break;
 244  
       default :
 245  
          break;
 246  
    }
 247  1059
    return jjStartNfa_0(0, active0);
 248  
 }
 249  
 private final int jjMoveStringLiteralDfa2_0(long old0, class="keyword">long active0)
 250  
 {
 251  3030
    if (((active0 &= old0)) == 0L)
 252  684
       return jjStartNfa_0(0, old0); 
 253  2346
    try { curChar = input_stream.readChar(); }
 254  
    catch(java.io.IOException e) {
 255  0
       jjStopStringLiteralDfa_0(1, active0);
 256  0
       return 2;
 257  634
    }
 258  2346
    switch(curChar)
 259  
    {
 260  
       case 100:
 261  45
          if ((active0 & 0x80000L) != 0L)
 262  45
             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  165
          return jjMoveStringLiteralDfa3_0(active0, 0xa00000000000L);
 270  
       case 112:
 271  321
          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  90
          if ((active0 & 0x100000000000L) != 0L)
 278  90
             return jjStartNfaWithStates_0(2, 44, 5);
 279  
          break;
 280  
       case 117:
 281  120
          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  291
          return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
 288  
       default :
 289  
          break;
 290  
    }
 291  1314
    return jjStartNfa_0(1, active0);
 292  
 }
 293  
 private final int jjMoveStringLiteralDfa3_0(long old0, class="keyword">long active0)
 294  
 {
 295  897
    if (((active0 &= old0)) == 0L)
 296  0
       return jjStartNfa_0(1, old0); 
 297  897
    try { curChar = input_stream.readChar(); }
 298  
    catch(java.io.IOException e) {
 299  0
       jjStopStringLiteralDfa_0(2, active0);
 300  0
       return 3;
 301  242
    }
 302  897
    switch(curChar)
 303  
    {
 304  
       case 101:
 305  411
          if ((active0 & 0x4000L) != 0L)
 306  291
             return jjStartNfaWithStates_0(3, 14, 5);
 307  120
          else if ((active0 & 0x400000000000L) != 0L)
 308  120
             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  75
          if ((active0 & 0x200000000000L) != 0L)
 314  75
             return jjStartNfaWithStates_0(3, 45, 5);
 315  0
          return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L);
 316  
       case 115:
 317  90
          return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L);
 318  
       case 116:
 319  321
          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  411
    if (((active0 &= old0)) == 0L)
 328  0
       return jjStartNfa_0(2, old0); 
 329  411
    try { curChar = input_stream.readChar(); }
 330  
    catch(java.io.IOException e) {
 331  0
       jjStopStringLiteralDfa_0(3, active0);
 332  0
       return 4;
 333  111
    }
 334  411
    switch(curChar)
 335  
    {
 336  
       case 97:
 337  0
          return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
 338  
       case 101:
 339  90
          if ((active0 & 0x800000000000L) != 0L)
 340  90
             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  321
          if ((active0 & 0x800L) != 0L)
 346  321
             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  18996
    if (jjrounds[state] != jjround)
 394  
    {
 395  18996
       jjstateSet[jjnewStateCnt++] = state;
 396  18996
       jjrounds[state] = jjround;
 397  
    }
 398  18996
 }
 399  
 private final void jjAddStates(int start, class="keyword">int end)
 400  
 {
 401  
    do {
 402  4326
       jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 403  4326
    } while (start++ != end);
 404  2163
 }
 405  
 private final void jjCheckNAddTwoStates(int state1, class="keyword">int state2)
 406  
 {
 407  1131
    jjCheckNAdd(state1);
 408  1131
    jjCheckNAdd(state2);
 409  1131
 }
 410  
 private final void jjCheckNAddStates(int start, class="keyword">int end)
 411  
 {
 412  
    do {
 413  4185
       jjCheckNAdd(jjnextStates[start]);
 414  4185
    } while (start++ != end);
 415  1395
 }
 416  
 private final void jjCheckNAddStates(int start)
 417  
 {
 418  0
    jjCheckNAdd(jjnextStates[start]);
 419  0
    jjCheckNAdd(jjnextStates[start + 1]);
 420  0
 }
 421  78
 static final long[] jjbitVec0 = {
 422  3
    0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 423  
 };
 424  
 private final int jjMoveNfa_0(class="keyword">int startState, class="keyword">int curPos)
 425  
 {
 426  
    int[] nextStates;
 427  7497
    int startsAt = 0;
 428  7497
    jjnewStateCnt = 17;
 429  7497
    int i = 1;
 430  7497
    jjstateSet[0] = startState;
 431  7497
    int j, kind = 0x7fffffff;
 432  6135
    for (;;)
 433  
    {
 434  24750
       if (++jjround == 0x7fffffff)
 435  0
          ReInitRounds();
 436  24750
       if (curChar < 64)
 437  
       {
 438  9666
          long l = 1L << curChar;
 439  
          MatchLoop: do
 440  
          {
 441  13257
             switch(jjstateSet[--i])
 442  
             {
 443  
                case 3:
 444  2229
                   if ((0x3ff000000000000L & l) != 0L)
 445  
                   {
 446  1395
                      if (kind > 7)
 447  1395
                         kind = 7;
 448  1395
                      jjCheckNAddStates(0, 2);
 449  
                   }
 450  834
                   else if (curChar == 39)
 451  696
                      jjCheckNAddTwoStates(10, 11);
 452  138
                   else if (curChar == 34)
 453  123
                      jjCheckNAddTwoStates(7, 8);
 454  15
                   else if (curChar == 36)
 455  
                   {
 456  0
                      if (kind > 58)
 457  0
                         kind = 58;
 458  0
                      jjCheckNAdd(5);
 459  
                   }
 460  15
                   else if (curChar == 35)
 461  15
                      jjstateSet[jjnewStateCnt++] = 0;
 462  1
                   break;
 463  
                case 0:
 464  15
                   if (curChar == 35)
 465  15
                      jjCheckNAddTwoStates(1, 2);
 466  1
                   break;
 467  
                case 1:
 468  60
                   if ((0xfffffffbffffdbffL & l) != 0L)
 469  45
                      jjCheckNAddTwoStates(1, 2);
 470  3
                   break;
 471  
                case 2:
 472  60
                   if ((0x2400L & l) != 0L)
 473  15
                      kind = 1;
 474  1
                   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  4761
                   if ((0x3ff001000000000L & l) == 0L)
 484  4746
                      break;
 485  15
                   if (kind > 58)
 486  15
                      kind = 58;
 487  15
                   jjCheckNAdd(5);
 488  15
                   break;
 489  
                case 6:
 490  0
                   if (curChar == 34)
 491  0
                      jjCheckNAddTwoStates(7, 8);
 492  
                   break;
 493  
                case 7:
 494  168
                   if ((0xfffffffbffffdbffL & l) != 0L)
 495  45
                      jjCheckNAddTwoStates(7, 8);
 496  3
                   break;
 497  
                case 8:
 498  168
                   if (curChar == 34 && kind > 61)
 499  123
                      kind = 61;
 500  10
                   break;
 501  
                case 9:
 502  0
                   if (curChar == 39)
 503  0
                      jjCheckNAddTwoStates(10, 11);
 504  
                   break;
 505  
                case 10:
 506  903
                   if ((0xffffff7fffffdbffL & l) != 0L)
 507  207
                      jjCheckNAddTwoStates(10, 11);
 508  15
                   break;
 509  
                case 11:
 510  903
                   if (curChar == 39 && kind > 61)
 511  696
                      kind = 61;
 512  47
                   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  1230
                   if ((0x3ff000000000000L & l) == 0L)
 522  1230
                      break;
 523  0
                   if (kind > 7)
 524  0
                      kind = 7;
 525  0
                   jjCheckNAdd(13);
 526  0
                   break;
 527  
                case 14:
 528  1230
                   if ((0x3ff000000000000L & l) != 0L)
 529  0
                      jjCheckNAddTwoStates(14, 15);
 530  
                   break;
 531  
                case 15:
 532  1230
                   if (curChar == 46)
 533  45
                      jjCheckNAdd(16);
 534  3
                   break;
 535  
                case 16:
 536  90
                   if ((0x3ff000000000000L & l) == 0L)
 537  45
                      break;
 538  45
                   if (kind > 8)
 539  45
                      kind = 8;
 540  45
                   jjCheckNAdd(16);
 541  45
                   break;
 542  
                default : break;
 543  
             }
 544  13257
          } while(i != startsAt);
 545  
       }
 546  15084
       else if (curChar < 128)
 547  
       {
 548  15084
          long l = 1L << (curChar & 077);
 549  
          MatchLoop: do
 550  
          {
 551  17577
             switch(jjstateSet[--i])
 552  
             {
 553  
                case 3:
 554  
                case 5:
 555  12669
                   if ((0x7fffffe87fffffeL & l) == 0L)
 556  225
                      break;
 557  12444
                   if (kind > 58)
 558  12444
                      kind = 58;
 559  12444
                   jjCheckNAdd(5);
 560  12444
                   break;
 561  
                case 1:
 562  225
                   jjAddStates(3, 4);
 563  225
                   break;
 564  
                case 7:
 565  387
                   jjAddStates(5, 6);
 566  387
                   break;
 567  
                case 10:
 568  1551
                   jjAddStates(7, 8);
 569  1551
                   break;
 570  
                default : break;
 571  
             }
 572  17577
          } 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  24750
       if (kind != 0x7fffffff)
 599  
       {
 600  14733
          jjmatchedKind = kind;
 601  14733
          jjmatchedPos = curPos;
 602  14733
          kind = 0x7fffffff;
 603  
       }
 604  24750
       ++curPos;
 605  24750
       if ((i = jjnewStateCnt) == (startsAt = 17 - (jjnewStateCnt = startsAt)))
 606  7497
          return curPos;
 607  17253
       try { curChar = input_stream.readChar(); }
 608  4696
       catch(java.io.IOException e) { return curPos; }
 609  
    }
 610  
 }
 611  48
 static final int[] jjnextStates = {
 612  3
    13, 14, 15, 1, 2, 7, 8, 10, 11, 
 613  
 };
 614  48
 public static final String[] jjstrLiteralImages = {
 615  3
 "", 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  3
 "\145\155\160\164\171", "\50", "\51", "\163\151\172\145", "\75", "\174\174", "\157\162", "\46\46", 
 617  3
 "\141\156\144", "\174", "\136", "\46", "\75\75", "\145\161", "\41\75", "\156\145", "\74", 
 618  3
 "\154\164", "\76", "\147\164", "\74\75", "\154\145", "\76\75", "\147\145", "\53", "\55", 
 619  3
 "\52", "\57", "\144\151\166", "\45", "\155\157\144", "\176", "\41", "\156\157\164", 
 620  3
 "\156\165\154\154", "\164\162\165\145", "\146\141\154\163\145", "\73", "\151\146", 
 621  3
 "\145\154\163\145", "\167\150\151\154\145", "\146\157\162\145\141\143\150", "\151\156", "\54", 
 622  3
 "\133", "\135", "\56", null, class="keyword">null, class="keyword">null, class="keyword">null, };
 623  48
 public static final String[] lexStateNames = {
 624  3
    "DEFAULT", 
 625  
 };
 626  48
 static final long[] jjtoToken = {
 627  3
    0x27ffffffffffff81L, 
 628  
 };
 629  48
 static final long[] jjtoSkip = {
 630  3
    0x7eL, 
 631  
 };
 632  
 private SimpleCharStream input_stream;
 633  75
 private final int[] jjrounds = new class="keyword">int[17];
 634  75
 private final int[] jjstateSet = new class="keyword">int[34];
 635  
 protected char curChar;
 636  5
 public ParserTokenManager(SimpleCharStream stream)
 637  70
 {
 638  
    if (SimpleCharStream.staticFlag)
 639  
       throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 640  75
    input_stream = stream;
 641  70
 }
 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  2808
    jjmatchedPos = jjnewStateCnt = 0;
 650  2808
    curLexState = defaultLexState;
 651  2808
    input_stream = stream;
 652  2808
    ReInitRounds();
 653  2808
 }
 654  
 private final void ReInitRounds()
 655  
 {
 656  
    int i;
 657  2808
    jjround = 0x80000001;
 658  39672
    for (i = 17; i-- > 0;)
 659  47736
       jjrounds[i] = 0x80000000;
 660  2808
 }
 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  18264
    Token t = Token.newToken(jjmatchedKind);
 677  18264
    t.kind = jjmatchedKind;
 678  18264
    String im = jjstrLiteralImages[jjmatchedKind];
 679  18264
    t.image = (im == null) ? input_stream.GetImage() : im;
 680  18264
    t.beginLine = input_stream.getBeginLine();
 681  18264
    t.beginColumn = input_stream.getBeginColumn();
 682  18264
    t.endLine = input_stream.getEndLine();
 683  18264
    t.endColumn = input_stream.getEndColumn();
 684  18264
    return t;
 685  
 }
 686  
 
 687  75
 int curLexState = 0;
 688  75
 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  18264
   Token specialToken = null;
 698  
   Token matchedToken;
 699  18264
   int curPos = 0;
 700  
 
 701  
   EOFLoop :
 702  12049
   for (;;)
 703  
   {   
 704  
    try   
 705  
    {     
 706  18279
       curChar = input_stream.BeginToken();
 707  10212
    }     
 708  947
    catch(java.io.IOException e)
 709  
    {        
 710  2793
       jjmatchedKind = 0;
 711  2793
       matchedToken = jjFillToken();
 712  2793
       return matchedToken;
 713  4208
    }
 714  
 
 715  15486
    try { input_stream.backup(0);
 716  30565
       while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
 717  3801
          curChar = input_stream.BeginToken();
 718  10212
    }
 719  4208
    catch (java.io.IOException e1) { continue EOFLoop; }
 720  15486
    jjmatchedKind = 0x7fffffff;
 721  15486
    jjmatchedPos = 0;
 722  15486
    curPos = jjMoveStringLiteralDfa0_0();
 723  15486
    if (jjmatchedKind != 0x7fffffff)
 724  
    {
 725  15486
       if (jjmatchedPos + 1 < curPos)
 726  6663
          input_stream.backup(curPos - jjmatchedPos - 1);
 727  15486
       if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 728  
       {
 729  15471
          matchedToken = jjFillToken();
 730  15471
          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.