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.