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.