Coverage report

  %line %branch
org.apache.commons.jexl.parser.ParserTokenManager
74% 
86% 

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

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