1 /*
2 * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /* Generated By:JavaCC: Do not edit this line. ExpressionParserTokenManager.java */
27 package com.sun.tools.example.debug.expr;
28 import com.sun.jdi.*;
29 import java.util.Stack;
30 import java.util.List;
31 import java.util.ArrayList;
32
33 /** Token Manager. */
34 public class ExpressionParserTokenManager implements ExpressionParserConstants
35 {
36
37 /** Debug output. */
38 public java.io.PrintStream debugStream = System.out;
39 /** Set debug output. */
40 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
41 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
42 {
43 switch (pos)
44 {
45 case 0:
46 if ((active1 & 0x100200000000L) != 0L)
47 return 49;
48 if ((active1 & 0x4000L) != 0L)
49 return 4;
50 if ((active0 & 0x7fffffffffffe00L) != 0L)
51 {
52 jjmatchedKind = 67;
53 return 28;
54 }
55 return -1;
56 case 1:
57 if ((active0 & 0x40300000L) != 0L)
58 return 28;
59 if ((active0 & 0x7ffffffbfcffe00L) != 0L)
60 {
61 if (jjmatchedPos != 1)
62 {
63 jjmatchedKind = 67;
64 jjmatchedPos = 1;
65 }
66 return 28;
67 }
68 return -1;
69 case 2:
70 if ((active0 & 0x80004c10000000L) != 0L)
71 return 28;
72 if ((active0 & 0x77fffb3afeffe00L) != 0L)
73 {
74 if (jjmatchedPos != 2)
75 {
76 jjmatchedKind = 67;
77 jjmatchedPos = 2;
78 }
79 return 28;
80 }
81 return -1;
82 case 3:
83 if ((active0 & 0x63bff2b8faf4e00L) != 0L)
84 {
85 jjmatchedKind = 67;
86 jjmatchedPos = 3;
87 return 28;
88 }
89 if ((active0 & 0x14400902040b000L) != 0L)
90 return 28;
91 return -1;
92 case 4:
93 if ((active0 & 0x418a0000f034800L) != 0L)
94 return 28;
95 if ((active0 & 0x2235f2b80ac0600L) != 0L)
96 {
97 if (jjmatchedPos != 4)
98 {
99 jjmatchedKind = 67;
100 jjmatchedPos = 4;
101 }
102 return 28;
103 }
104 return -1;
105 case 5:
106 if ((active0 & 0x11582100200000L) != 0L)
107 return 28;
108 if ((active0 & 0x222070a848c0600L) != 0L)
109 {
110 jjmatchedKind = 67;
111 jjmatchedPos = 5;
112 return 28;
113 }
114 return -1;
115 case 6:
116 if ((active0 & 0x222040a80040200L) != 0L)
117 {
118 jjmatchedKind = 67;
119 jjmatchedPos = 6;
120 return 28;
121 }
122 if ((active0 & 0x30004880400L) != 0L)
123 return 28;
124 return -1;
125 case 7:
126 if ((active0 & 0x200000000040200L) != 0L)
127 return 28;
128 if ((active0 & 0x22040a80000000L) != 0L)
129 {
130 jjmatchedKind = 67;
131 jjmatchedPos = 7;
132 return 28;
133 }
134 return -1;
135 case 8:
136 if ((active0 & 0x20040800000000L) != 0L)
137 return 28;
138 if ((active0 & 0x2000280000000L) != 0L)
139 {
140 jjmatchedKind = 67;
141 jjmatchedPos = 8;
142 return 28;
143 }
144 return -1;
145 case 9:
146 if ((active0 & 0x2000000000000L) != 0L)
147 {
148 jjmatchedKind = 67;
149 jjmatchedPos = 9;
150 return 28;
151 }
152 if ((active0 & 0x280000000L) != 0L)
153 return 28;
154 return -1;
155 case 10:
156 if ((active0 & 0x2000000000000L) != 0L)
157 {
158 jjmatchedKind = 67;
159 jjmatchedPos = 10;
160 return 28;
161 }
162 return -1;
163 default :
164 return -1;
165 }
166 }
167 private final int jjStartNfa_0(int pos, long active0, long active1)
168 {
169 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
170 }
171 private int jjStopAtPos(int pos, int kind)
172 {
173 jjmatchedKind = kind;
174 jjmatchedPos = pos;
175 return pos + 1;
176 }
177 private int jjMoveStringLiteralDfa0_0()
178 {
179 switch(curChar)
180 {
181 case 33:
182 jjmatchedKind = 82;
183 return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000L);
184 case 37:
185 jjmatchedKind = 101;
186 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L);
187 case 38:
188 jjmatchedKind = 98;
189 return jjMoveStringLiteralDfa1_0(0x0L, 0x200008000000L);
190 case 40:
191 return jjStopAtPos(0, 70);
192 case 41:
193 return jjStopAtPos(0, 71);
194 case 42:
195 jjmatchedKind = 96;
196 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000L);
197 case 43:
198 jjmatchedKind = 94;
199 return jjMoveStringLiteralDfa1_0(0x0L, 0x20010000000L);
200 case 44:
201 return jjStopAtPos(0, 77);
202 case 45:
203 jjmatchedKind = 95;
204 return jjMoveStringLiteralDfa1_0(0x0L, 0x40020000000L);
205 case 46:
206 return jjStartNfaWithStates_0(0, 78, 4);
207 case 47:
208 jjmatchedKind = 97;
209 return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000L);
210 case 58:
211 return jjStopAtPos(0, 85);
212 case 59:
213 return jjStopAtPos(0, 76);
214 case 60:
215 jjmatchedKind = 81;
216 return jjMoveStringLiteralDfa1_0(0x0L, 0x2004000800000L);
217 case 61:
218 jjmatchedKind = 79;
219 return jjMoveStringLiteralDfa1_0(0x0L, 0x400000L);
220 case 62:
221 jjmatchedKind = 80;
222 return jjMoveStringLiteralDfa1_0(0x0L, 0xc018001000000L);
223 case 63:
224 return jjStopAtPos(0, 84);
225 case 91:
226 return jjStopAtPos(0, 74);
227 case 93:
228 return jjStopAtPos(0, 75);
229 case 94:
230 jjmatchedKind = 100;
231 return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000000L);
232 case 97:
233 return jjMoveStringLiteralDfa1_0(0x200L, 0x0L);
234 case 98:
235 return jjMoveStringLiteralDfa1_0(0x1c00L, 0x0L);
236 case 99:
237 return jjMoveStringLiteralDfa1_0(0x7e000L, 0x0L);
238 case 100:
239 return jjMoveStringLiteralDfa1_0(0x380000L, 0x0L);
240 case 101:
241 return jjMoveStringLiteralDfa1_0(0xc00000L, 0x0L);
242 case 102:
243 return jjMoveStringLiteralDfa1_0(0x1f000000L, 0x0L);
244 case 103:
245 return jjMoveStringLiteralDfa1_0(0x20000000L, 0x0L);
246 case 105:
247 return jjMoveStringLiteralDfa1_0(0xfc0000000L, 0x0L);
248 case 108:
249 return jjMoveStringLiteralDfa1_0(0x1000000000L, 0x0L);
250 case 110:
251 return jjMoveStringLiteralDfa1_0(0xe000000000L, 0x0L);
252 case 112:
253 return jjMoveStringLiteralDfa1_0(0xf0000000000L, 0x0L);
254 case 114:
255 return jjMoveStringLiteralDfa1_0(0x100000000000L, 0x0L);
256 case 115:
257 return jjMoveStringLiteralDfa1_0(0x3e00000000000L, 0x0L);
258 case 116:
259 return jjMoveStringLiteralDfa1_0(0xfc000000000000L, 0x0L);
260 case 118:
261 return jjMoveStringLiteralDfa1_0(0x300000000000000L, 0x0L);
262 case 119:
263 return jjMoveStringLiteralDfa1_0(0x400000000000000L, 0x0L);
264 case 123:
265 return jjStopAtPos(0, 72);
266 case 124:
267 jjmatchedKind = 99;
268 return jjMoveStringLiteralDfa1_0(0x0L, 0x400004000000L);
269 case 125:
270 return jjStopAtPos(0, 73);
271 case 126:
272 return jjStopAtPos(0, 83);
273 default :
274 return jjMoveNfa_0(0, 0);
275 }
276 }
277 private int jjMoveStringLiteralDfa1_0(long active0, long active1)
278 {
279 try { curChar = input_stream.readChar(); }
280 catch(java.io.IOException e) {
281 jjStopStringLiteralDfa_0(0, active0, active1);
282 return 1;
283 }
284 switch(curChar)
285 {
286 case 38:
287 if ((active1 & 0x8000000L) != 0L)
288 return jjStopAtPos(1, 91);
289 break;
290 case 43:
291 if ((active1 & 0x10000000L) != 0L)
292 return jjStopAtPos(1, 92);
293 break;
294 case 45:
295 if ((active1 & 0x20000000L) != 0L)
296 return jjStopAtPos(1, 93);
297 break;
298 case 60:
299 if ((active1 & 0x4000000000L) != 0L)
300 {
301 jjmatchedKind = 102;
302 jjmatchedPos = 1;
303 }
304 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x2000000000000L);
305 case 61:
306 if ((active1 & 0x400000L) != 0L)
307 return jjStopAtPos(1, 86);
308 else if ((active1 & 0x800000L) != 0L)
309 return jjStopAtPos(1, 87);
310 else if ((active1 & 0x1000000L) != 0L)
311 return jjStopAtPos(1, 88);
312 else if ((active1 & 0x2000000L) != 0L)
313 return jjStopAtPos(1, 89);
314 else if ((active1 & 0x20000000000L) != 0L)
315 return jjStopAtPos(1, 105);
316 else if ((active1 & 0x40000000000L) != 0L)
317 return jjStopAtPos(1, 106);
318 else if ((active1 & 0x80000000000L) != 0L)
319 return jjStopAtPos(1, 107);
320 else if ((active1 & 0x100000000000L) != 0L)
321 return jjStopAtPos(1, 108);
322 else if ((active1 & 0x200000000000L) != 0L)
323 return jjStopAtPos(1, 109);
324 else if ((active1 & 0x400000000000L) != 0L)
325 return jjStopAtPos(1, 110);
326 else if ((active1 & 0x800000000000L) != 0L)
327 return jjStopAtPos(1, 111);
328 else if ((active1 & 0x1000000000000L) != 0L)
329 return jjStopAtPos(1, 112);
330 break;
331 case 62:
332 if ((active1 & 0x8000000000L) != 0L)
333 {
334 jjmatchedKind = 103;
335 jjmatchedPos = 1;
336 }
337 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0xc010000000000L);
338 case 97:
339 return jjMoveStringLiteralDfa2_0(active0, 0x12001006000L, active1, 0L);
340 case 98:
341 return jjMoveStringLiteralDfa2_0(active0, 0x200L, active1, 0L);
342 case 101:
343 return jjMoveStringLiteralDfa2_0(active0, 0x104000080000L, active1, 0L);
344 case 102:
345 if ((active0 & 0x40000000L) != 0L)
346 return jjStartNfaWithStates_0(1, 30, 28);
347 break;
348 case 104:
349 return jjMoveStringLiteralDfa2_0(active0, 0x41c200000008000L, active1, 0L);
350 case 105:
351 return jjMoveStringLiteralDfa2_0(active0, 0x6000000L, active1, 0L);
352 case 108:
353 return jjMoveStringLiteralDfa2_0(active0, 0x8410000L, active1, 0L);
354 case 109:
355 return jjMoveStringLiteralDfa2_0(active0, 0x180000000L, active1, 0L);
356 case 110:
357 return jjMoveStringLiteralDfa2_0(active0, 0xe00000000L, active1, 0L);
358 case 111:
359 if ((active0 & 0x100000L) != 0L)
360 {
361 jjmatchedKind = 20;
362 jjmatchedPos = 1;
363 }
364 return jjMoveStringLiteralDfa2_0(active0, 0x300001030260400L, active1, 0L);
365 case 114:
366 return jjMoveStringLiteralDfa2_0(active0, 0xe0060000000800L, active1, 0L);
367 case 116:
368 return jjMoveStringLiteralDfa2_0(active0, 0x400000000000L, active1, 0L);
369 case 117:
370 return jjMoveStringLiteralDfa2_0(active0, 0x888000000000L, active1, 0L);
371 case 119:
372 return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000L, active1, 0L);
373 case 120:
374 return jjMoveStringLiteralDfa2_0(active0, 0x800000L, active1, 0L);
375 case 121:
376 return jjMoveStringLiteralDfa2_0(active0, 0x2000000001000L, active1, 0L);
377 case 124:
378 if ((active1 & 0x4000000L) != 0L)
379 return jjStopAtPos(1, 90);
380 break;
381 default :
382 break;
383 }
384 return jjStartNfa_0(0, active0, active1);
385 }
386 private int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
387 {
388 if (((active0 &= old0) | (active1 &= old1)) == 0L)
389 return jjStartNfa_0(0, old0, old1);
390 try { curChar = input_stream.readChar(); }
391 catch(java.io.IOException e) {
392 jjStopStringLiteralDfa_0(1, active0, active1);
393 return 2;
394 }
395 switch(curChar)
396 {
397 case 61:
398 if ((active1 & 0x2000000000000L) != 0L)
399 return jjStopAtPos(2, 113);
400 else if ((active1 & 0x4000000000000L) != 0L)
401 return jjStopAtPos(2, 114);
402 break;
403 case 62:
404 if ((active1 & 0x10000000000L) != 0L)
405 {
406 jjmatchedKind = 104;
407 jjmatchedPos = 2;
408 }
409 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x8000000000000L);
410 case 97:
411 return jjMoveStringLiteralDfa3_0(active0, 0x20400000018000L, active1, 0L);
412 case 98:
413 return jjMoveStringLiteralDfa3_0(active0, 0x80000000000L, active1, 0L);
414 case 99:
415 return jjMoveStringLiteralDfa3_0(active0, 0x10000000000L, active1, 0L);
416 case 101:
417 return jjMoveStringLiteralDfa3_0(active0, 0x800L, active1, 0L);
418 case 102:
419 return jjMoveStringLiteralDfa3_0(active0, 0x80000L, active1, 0L);
420 case 105:
421 return jjMoveStringLiteralDfa3_0(active0, 0x505020000000000L, active1, 0L);
422 case 108:
423 return jjMoveStringLiteralDfa3_0(active0, 0x200008001000000L, active1, 0L);
424 case 110:
425 return jjMoveStringLiteralDfa3_0(active0, 0x2001006060000L, active1, 0L);
426 case 111:
427 return jjMoveStringLiteralDfa3_0(active0, 0x240008000400L, active1, 0L);
428 case 112:
429 return jjMoveStringLiteralDfa3_0(active0, 0x800180000000L, active1, 0L);
430 case 114:
431 if ((active0 & 0x10000000L) != 0L)
432 return jjStartNfaWithStates_0(2, 28, 28);
433 return jjMoveStringLiteralDfa3_0(active0, 0x18000000000000L, active1, 0L);
434 case 115:
435 return jjMoveStringLiteralDfa3_0(active0, 0x200402200L, active1, 0L);
436 case 116:
437 if ((active0 & 0x400000000L) != 0L)
438 {
439 jjmatchedKind = 34;
440 jjmatchedPos = 2;
441 }
442 return jjMoveStringLiteralDfa3_0(active0, 0x102820805000L, active1, 0L);
443 case 117:
444 return jjMoveStringLiteralDfa3_0(active0, 0x40000000200000L, active1, 0L);
445 case 119:
446 if ((active0 & 0x4000000000L) != 0L)
447 return jjStartNfaWithStates_0(2, 38, 28);
448 break;
449 case 121:
450 if ((active0 & 0x80000000000000L) != 0L)
451 return jjStartNfaWithStates_0(2, 55, 28);
452 break;
453 default :
454 break;
455 }
456 return jjStartNfa_0(1, active0, active1);
457 }
458 private int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
459 {
460 if (((active0 &= old0) | (active1 &= old1)) == 0L)
461 return jjStartNfa_0(1, old0, old1);
462 try { curChar = input_stream.readChar(); }
463 catch(java.io.IOException e) {
464 jjStopStringLiteralDfa_0(2, active0, active1);
465 return 3;
466 }
467 switch(curChar)
468 {
469 case 61:
470 if ((active1 & 0x8000000000000L) != 0L)
471 return jjStopAtPos(3, 115);
472 break;
473 case 97:
474 return jjMoveStringLiteralDfa4_0(active0, 0x20000000e080800L, active1, 0L);
475 case 98:
476 return jjMoveStringLiteralDfa4_0(active0, 0x200000L, active1, 0L);
477 case 99:
478 return jjMoveStringLiteralDfa4_0(active0, 0x2000000004000L, active1, 0L);
479 case 100:
480 if ((active0 & 0x100000000000000L) != 0L)
481 return jjStartNfaWithStates_0(3, 56, 28);
482 break;
483 case 101:
484 if ((active0 & 0x1000L) != 0L)
485 return jjStartNfaWithStates_0(3, 12, 28);
486 else if ((active0 & 0x2000L) != 0L)
487 return jjStartNfaWithStates_0(3, 13, 28);
488 else if ((active0 & 0x400000L) != 0L)
489 return jjStartNfaWithStates_0(3, 22, 28);
490 else if ((active0 & 0x40000000000000L) != 0L)
491 return jjStartNfaWithStates_0(3, 54, 28);
492 return jjMoveStringLiteralDfa4_0(active0, 0x800800800000L, active1, 0L);
493 case 103:
494 if ((active0 & 0x1000000000L) != 0L)
495 return jjStartNfaWithStates_0(3, 36, 28);
496 break;
497 case 105:
498 return jjMoveStringLiteralDfa4_0(active0, 0x2000000000L, active1, 0L);
499 case 107:
500 return jjMoveStringLiteralDfa4_0(active0, 0x10000000000L, active1, 0L);
501 case 108:
502 if ((active0 & 0x8000000000L) != 0L)
503 return jjStartNfaWithStates_0(3, 39, 28);
504 return jjMoveStringLiteralDfa4_0(active0, 0x400080080000400L, active1, 0L);
505 case 110:
506 return jjMoveStringLiteralDfa4_0(active0, 0x20000000000000L, active1, 0L);
507 case 111:
508 if ((active0 & 0x20000000L) != 0L)
509 return jjStartNfaWithStates_0(3, 29, 28);
510 return jjMoveStringLiteralDfa4_0(active0, 0x18000100000000L, active1, 0L);
511 case 114:
512 if ((active0 & 0x8000L) != 0L)
513 return jjStartNfaWithStates_0(3, 15, 28);
514 return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
515 case 115:
516 if ((active0 & 0x4000000000000L) != 0L)
517 return jjStartNfaWithStates_0(3, 50, 28);
518 return jjMoveStringLiteralDfa4_0(active0, 0x1030000L, active1, 0L);
519 case 116:
520 return jjMoveStringLiteralDfa4_0(active0, 0x1440200040200L, active1, 0L);
521 case 117:
522 return jjMoveStringLiteralDfa4_0(active0, 0x100000000000L, active1, 0L);
523 case 118:
524 return jjMoveStringLiteralDfa4_0(active0, 0x20000000000L, active1, 0L);
525 default :
526 break;
527 }
528 return jjStartNfa_0(2, active0, active1);
529 }
530 private int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
531 {
532 if (((active0 &= old0) | (active1 &= old1)) == 0L)
533 return jjStartNfa_0(2, old0, old1);
534 try { curChar = input_stream.readChar(); }
535 catch(java.io.IOException e) {
536 jjStopStringLiteralDfa_0(3, active0, 0L);
537 return 4;
538 }
539 switch(curChar)
540 {
541 case 97:
542 return jjMoveStringLiteralDfa5_0(active0, 0x30200000000L);
543 case 99:
544 return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000L);
545 case 101:
546 if ((active0 & 0x1000000L) != 0L)
547 return jjStartNfaWithStates_0(4, 24, 28);
548 else if ((active0 & 0x400000000000000L) != 0L)
549 return jjStartNfaWithStates_0(4, 58, 28);
550 return jjMoveStringLiteralDfa5_0(active0, 0x40080000400L);
551 case 104:
552 if ((active0 & 0x4000L) != 0L)
553 return jjStartNfaWithStates_0(4, 14, 28);
554 return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000L);
555 case 105:
556 return jjMoveStringLiteralDfa5_0(active0, 0x480000040000L);
557 case 107:
558 if ((active0 & 0x800L) != 0L)
559 return jjStartNfaWithStates_0(4, 11, 28);
560 break;
561 case 108:
562 if ((active0 & 0x2000000L) != 0L)
563 {
564 jjmatchedKind = 25;
565 jjmatchedPos = 4;
566 }
567 return jjMoveStringLiteralDfa5_0(active0, 0x4200000L);
568 case 110:
569 return jjMoveStringLiteralDfa5_0(active0, 0x800000L);
570 case 114:
571 if ((active0 & 0x800000000000L) != 0L)
572 return jjStartNfaWithStates_0(4, 47, 28);
573 return jjMoveStringLiteralDfa5_0(active0, 0x100900000200L);
574 case 115:
575 if ((active0 & 0x10000L) != 0L)
576 return jjStartNfaWithStates_0(4, 16, 28);
577 return jjMoveStringLiteralDfa5_0(active0, 0x20000000000000L);
578 case 116:
579 if ((active0 & 0x20000L) != 0L)
580 return jjStartNfaWithStates_0(4, 17, 28);
581 else if ((active0 & 0x8000000L) != 0L)
582 return jjStartNfaWithStates_0(4, 27, 28);
583 else if ((active0 & 0x200000000000L) != 0L)
584 return jjStartNfaWithStates_0(4, 45, 28);
585 return jjMoveStringLiteralDfa5_0(active0, 0x200000000000000L);
586 case 117:
587 return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
588 case 118:
589 return jjMoveStringLiteralDfa5_0(active0, 0x2000000000L);
590 case 119:
591 if ((active0 & 0x8000000000000L) != 0L)
592 {
593 jjmatchedKind = 51;
594 jjmatchedPos = 4;
595 }
596 return jjMoveStringLiteralDfa5_0(active0, 0x10000000000000L);
597 default :
598 break;
599 }
600 return jjStartNfa_0(3, active0, 0L);
601 }
602 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
603 {
604 if (((active0 &= old0)) == 0L)
605 return jjStartNfa_0(3, old0, 0L);
606 try { curChar = input_stream.readChar(); }
607 catch(java.io.IOException e) {
608 jjStopStringLiteralDfa_0(4, active0, 0L);
609 return 5;
610 }
611 switch(curChar)
612 {
613 case 97:
614 return jjMoveStringLiteralDfa6_0(active0, 0x600L);
615 case 99:
616 if ((active0 & 0x80000000000L) != 0L)
617 return jjStartNfaWithStates_0(5, 43, 28);
618 else if ((active0 & 0x400000000000L) != 0L)
619 return jjStartNfaWithStates_0(5, 46, 28);
620 return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L);
621 case 100:
622 return jjMoveStringLiteralDfa6_0(active0, 0x800000L);
623 case 101:
624 if ((active0 & 0x200000L) != 0L)
625 return jjStartNfaWithStates_0(5, 21, 28);
626 else if ((active0 & 0x2000000000L) != 0L)
627 return jjStartNfaWithStates_0(5, 37, 28);
628 break;
629 case 102:
630 return jjMoveStringLiteralDfa6_0(active0, 0x800000000L);
631 case 103:
632 return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L);
633 case 104:
634 if ((active0 & 0x1000000000000L) != 0L)
635 return jjStartNfaWithStates_0(5, 48, 28);
636 break;
637 case 105:
638 return jjMoveStringLiteralDfa6_0(active0, 0x220000000000000L);
639 case 108:
640 return jjMoveStringLiteralDfa6_0(active0, 0x4080000L);
641 case 109:
642 return jjMoveStringLiteralDfa6_0(active0, 0x80000000L);
643 case 110:
644 if ((active0 & 0x100000000000L) != 0L)
645 return jjStartNfaWithStates_0(5, 44, 28);
646 return jjMoveStringLiteralDfa6_0(active0, 0x200040000L);
647 case 114:
648 return jjMoveStringLiteralDfa6_0(active0, 0x2000000000000L);
649 case 115:
650 if ((active0 & 0x10000000000000L) != 0L)
651 return jjStartNfaWithStates_0(5, 52, 28);
652 break;
653 case 116:
654 if ((active0 & 0x100000000L) != 0L)
655 return jjStartNfaWithStates_0(5, 32, 28);
656 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L);
657 default :
658 break;
659 }
660 return jjStartNfa_0(4, active0, 0L);
661 }
662 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
663 {
664 if (((active0 &= old0)) == 0L)
665 return jjStartNfa_0(4, old0, 0L);
666 try { curChar = input_stream.readChar(); }
667 catch(java.io.IOException e) {
668 jjStopStringLiteralDfa_0(5, active0, 0L);
669 return 6;
670 }
671 switch(curChar)
672 {
673 case 97:
674 return jjMoveStringLiteralDfa7_0(active0, 0x800000000L);
675 case 99:
676 return jjMoveStringLiteralDfa7_0(active0, 0x200000200L);
677 case 101:
678 if ((active0 & 0x10000000000L) != 0L)
679 return jjStartNfaWithStates_0(6, 40, 28);
680 else if ((active0 & 0x20000000000L) != 0L)
681 return jjStartNfaWithStates_0(6, 41, 28);
682 return jjMoveStringLiteralDfa7_0(active0, 0x20000080000000L);
683 case 108:
684 return jjMoveStringLiteralDfa7_0(active0, 0x200000000000000L);
685 case 110:
686 if ((active0 & 0x400L) != 0L)
687 return jjStartNfaWithStates_0(6, 10, 28);
688 break;
689 case 111:
690 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000L);
691 case 115:
692 if ((active0 & 0x800000L) != 0L)
693 return jjStartNfaWithStates_0(6, 23, 28);
694 break;
695 case 116:
696 if ((active0 & 0x80000L) != 0L)
697 return jjStartNfaWithStates_0(6, 19, 28);
698 return jjMoveStringLiteralDfa7_0(active0, 0x40000000000L);
699 case 117:
700 return jjMoveStringLiteralDfa7_0(active0, 0x40000L);
701 case 121:
702 if ((active0 & 0x4000000L) != 0L)
703 return jjStartNfaWithStates_0(6, 26, 28);
704 break;
705 default :
706 break;
707 }
708 return jjStartNfa_0(5, active0, 0L);
709 }
710 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
711 {
712 if (((active0 &= old0)) == 0L)
713 return jjStartNfa_0(5, old0, 0L);
714 try { curChar = input_stream.readChar(); }
715 catch(java.io.IOException e) {
716 jjStopStringLiteralDfa_0(6, active0, 0L);
717 return 7;
718 }
719 switch(curChar)
720 {
721 case 99:
722 return jjMoveStringLiteralDfa8_0(active0, 0x800000000L);
723 case 101:
724 if ((active0 & 0x40000L) != 0L)
725 return jjStartNfaWithStates_0(7, 18, 28);
726 else if ((active0 & 0x200000000000000L) != 0L)
727 return jjStartNfaWithStates_0(7, 57, 28);
728 return jjMoveStringLiteralDfa8_0(active0, 0x40200000000L);
729 case 110:
730 return jjMoveStringLiteralDfa8_0(active0, 0x22000080000000L);
731 case 116:
732 if ((active0 & 0x200L) != 0L)
733 return jjStartNfaWithStates_0(7, 9, 28);
734 break;
735 default :
736 break;
737 }
738 return jjStartNfa_0(6, active0, 0L);
739 }
740 private int jjMoveStringLiteralDfa8_0(long old0, long active0)
741 {
742 if (((active0 &= old0)) == 0L)
743 return jjStartNfa_0(6, old0, 0L);
744 try { curChar = input_stream.readChar(); }
745 catch(java.io.IOException e) {
746 jjStopStringLiteralDfa_0(7, active0, 0L);
747 return 8;
748 }
749 switch(curChar)
750 {
751 case 100:
752 if ((active0 & 0x40000000000L) != 0L)
753 return jjStartNfaWithStates_0(8, 42, 28);
754 break;
755 case 101:
756 if ((active0 & 0x800000000L) != 0L)
757 return jjStartNfaWithStates_0(8, 35, 28);
758 break;
759 case 105:
760 return jjMoveStringLiteralDfa9_0(active0, 0x2000000000000L);
761 case 111:
762 return jjMoveStringLiteralDfa9_0(active0, 0x200000000L);
763 case 116:
764 if ((active0 & 0x20000000000000L) != 0L)
765 return jjStartNfaWithStates_0(8, 53, 28);
766 return jjMoveStringLiteralDfa9_0(active0, 0x80000000L);
767 default :
768 break;
769 }
770 return jjStartNfa_0(7, active0, 0L);
771 }
772 private int jjMoveStringLiteralDfa9_0(long old0, long active0)
773 {
774 if (((active0 &= old0)) == 0L)
775 return jjStartNfa_0(7, old0, 0L);
776 try { curChar = input_stream.readChar(); }
777 catch(java.io.IOException e) {
778 jjStopStringLiteralDfa_0(8, active0, 0L);
779 return 9;
780 }
781 switch(curChar)
782 {
783 case 102:
784 if ((active0 & 0x200000000L) != 0L)
785 return jjStartNfaWithStates_0(9, 33, 28);
786 break;
787 case 115:
788 if ((active0 & 0x80000000L) != 0L)
789 return jjStartNfaWithStates_0(9, 31, 28);
790 break;
791 case 122:
792 return jjMoveStringLiteralDfa10_0(active0, 0x2000000000000L);
793 default :
794 break;
795 }
796 return jjStartNfa_0(8, active0, 0L);
797 }
798 private int jjMoveStringLiteralDfa10_0(long old0, long active0)
799 {
800 if (((active0 &= old0)) == 0L)
801 return jjStartNfa_0(8, old0, 0L);
802 try { curChar = input_stream.readChar(); }
803 catch(java.io.IOException e) {
804 jjStopStringLiteralDfa_0(9, active0, 0L);
805 return 10;
806 }
807 switch(curChar)
808 {
809 case 101:
810 return jjMoveStringLiteralDfa11_0(active0, 0x2000000000000L);
811 default :
812 break;
813 }
814 return jjStartNfa_0(9, active0, 0L);
815 }
816 private int jjMoveStringLiteralDfa11_0(long old0, long active0)
817 {
818 if (((active0 &= old0)) == 0L)
819 return jjStartNfa_0(9, old0, 0L);
820 try { curChar = input_stream.readChar(); }
821 catch(java.io.IOException e) {
822 jjStopStringLiteralDfa_0(10, active0, 0L);
823 return 11;
824 }
825 switch(curChar)
826 {
827 case 100:
828 if ((active0 & 0x2000000000000L) != 0L)
829 return jjStartNfaWithStates_0(11, 49, 28);
830 break;
831 default :
832 break;
833 }
834 return jjStartNfa_0(10, active0, 0L);
835 }
836 private int jjStartNfaWithStates_0(int pos, int kind, int state)
837 {
838 jjmatchedKind = kind;
839 jjmatchedPos = pos;
840 try { curChar = input_stream.readChar(); }
841 catch(java.io.IOException e) { return pos + 1; }
842 return jjMoveNfa_0(state, pos + 1);
843 }
844 static final long[] jjbitVec0 = {
845 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
846 };
847 static final long[] jjbitVec2 = {
848 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
849 };
850 static final long[] jjbitVec3 = {
851 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
852 };
853 static final long[] jjbitVec4 = {
854 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
855 };
856 static final long[] jjbitVec5 = {
857 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
858 };
859 static final long[] jjbitVec6 = {
860 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
861 };
862 static final long[] jjbitVec7 = {
863 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
864 };
865 static final long[] jjbitVec8 = {
866 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
867 };
868 private int jjMoveNfa_0(int startState, int curPos)
869 {
870 int startsAt = 0;
871 jjnewStateCnt = 67;
872 int i = 1;
873 jjstateSet[0] = startState;
874 int kind = 0x7fffffff;
875 for (;;)
876 {
877 if (++jjround == 0x7fffffff)
878 ReInitRounds();
879 if (curChar < 64)
880 {
881 long l = 1L << curChar;
882 do
883 {
884 switch(jjstateSet[--i])
885 {
886 case 49:
887 if (curChar == 42)
888 jjCheckNAddTwoStates(62, 63);
889 else if (curChar == 47)
890 jjCheckNAddStates(0, 2);
891 if (curChar == 42)
892 jjstateSet[jjnewStateCnt++] = 54;
893 break;
894 case 0:
895 if ((0x3ff000000000000L & l) != 0L)
896 jjCheckNAddStates(3, 9);
897 else if (curChar == 47)
898 jjAddStates(10, 12);
899 else if (curChar == 36)
900 {
901 if (kind > 67)
902 kind = 67;
903 jjCheckNAdd(28);
904 }
905 else if (curChar == 34)
906 jjCheckNAddStates(13, 15);
907 else if (curChar == 39)
908 jjAddStates(16, 17);
909 else if (curChar == 46)
910 jjCheckNAdd(4);
911 if ((0x3fe000000000000L & l) != 0L)
912 {
913 if (kind > 59)
914 kind = 59;
915 jjCheckNAddTwoStates(1, 2);
916 }
917 else if (curChar == 48)
918 {
919 if (kind > 59)
920 kind = 59;
921 jjCheckNAddStates(18, 20);
922 }
923 break;
924 case 1:
925 if ((0x3ff000000000000L & l) == 0L)
926 break;
927 if (kind > 59)
928 kind = 59;
929 jjCheckNAddTwoStates(1, 2);
930 break;
931 case 3:
932 if (curChar == 46)
933 jjCheckNAdd(4);
934 break;
935 case 4:
936 if ((0x3ff000000000000L & l) == 0L)
937 break;
938 if (kind > 63)
939 kind = 63;
940 jjCheckNAddStates(21, 23);
941 break;
942 case 6:
943 if ((0x280000000000L & l) != 0L)
944 jjCheckNAdd(7);
945 break;
946 case 7:
947 if ((0x3ff000000000000L & l) == 0L)
948 break;
949 if (kind > 63)
950 kind = 63;
951 jjCheckNAddTwoStates(7, 8);
952 break;
953 case 9:
954 if (curChar == 39)
955 jjAddStates(16, 17);
956 break;
957 case 10:
958 if ((0xffffff7fffffdbffL & l) != 0L)
959 jjCheckNAdd(11);
960 break;
961 case 11:
962 if (curChar == 39 && kind > 65)
963 kind = 65;
964 break;
965 case 13:
966 if ((0x8400000000L & l) != 0L)
967 jjCheckNAdd(11);
968 break;
969 case 14:
970 if ((0xff000000000000L & l) != 0L)
971 jjCheckNAddTwoStates(15, 11);
972 break;
973 case 15:
974 if ((0xff000000000000L & l) != 0L)
975 jjCheckNAdd(11);
976 break;
977 case 16:
978 if ((0xf000000000000L & l) != 0L)
979 jjstateSet[jjnewStateCnt++] = 17;
980 break;
981 case 17:
982 if ((0xff000000000000L & l) != 0L)
983 jjCheckNAdd(15);
984 break;
985 case 18:
986 if (curChar == 34)
987 jjCheckNAddStates(13, 15);
988 break;
989 case 19:
990 if ((0xfffffffbffffdbffL & l) != 0L)
991 jjCheckNAddStates(13, 15);
992 break;
993 case 21:
994 if ((0x8400000000L & l) != 0L)
995 jjCheckNAddStates(13, 15);
996 break;
997 case 22:
998 if (curChar == 34 && kind > 66)
999 kind = 66;
1000 break;
1001 case 23:
1002 if ((0xff000000000000L & l) != 0L)
1003 jjCheckNAddStates(24, 27);
1004 break;
1005 case 24:
1006 if ((0xff000000000000L & l) != 0L)
1007 jjCheckNAddStates(13, 15);
1008 break;
1009 case 25:
1010 if ((0xf000000000000L & l) != 0L)
1011 jjstateSet[jjnewStateCnt++] = 26;
1012 break;
1013 case 26:
1014 if ((0xff000000000000L & l) != 0L)
1015 jjCheckNAdd(24);
1016 break;
1017 case 27:
1018 if (curChar != 36)
1019 break;
1020 if (kind > 67)
1021 kind = 67;
1022 jjCheckNAdd(28);
1023 break;
1024 case 28:
1025 if ((0x3ff001000000000L & l) == 0L)
1026 break;
1027 if (kind > 67)
1028 kind = 67;
1029 jjCheckNAdd(28);
1030 break;
1031 case 29:
1032 if ((0x3ff000000000000L & l) != 0L)
1033 jjCheckNAddStates(3, 9);
1034 break;
1035 case 30:
1036 if ((0x3ff000000000000L & l) != 0L)
1037 jjCheckNAddTwoStates(30, 31);
1038 break;
1039 case 31:
1040 if (curChar != 46)
1041 break;
1042 if (kind > 63)
1043 kind = 63;
1044 jjCheckNAddStates(28, 30);
1045 break;
1046 case 32:
1047 if ((0x3ff000000000000L & l) == 0L)
1048 break;
1049 if (kind > 63)
1050 kind = 63;
1051 jjCheckNAddStates(28, 30);
1052 break;
1053 case 34:
1054 if ((0x280000000000L & l) != 0L)
1055 jjCheckNAdd(35);
1056 break;
1057 case 35:
1058 if ((0x3ff000000000000L & l) == 0L)
1059 break;
1060 if (kind > 63)
1061 kind = 63;
1062 jjCheckNAddTwoStates(35, 8);
1063 break;
1064 case 36:
1065 if ((0x3ff000000000000L & l) != 0L)
1066 jjCheckNAddTwoStates(36, 37);
1067 break;
1068 case 38:
1069 if ((0x280000000000L & l) != 0L)
1070 jjCheckNAdd(39);
1071 break;
1072 case 39:
1073 if ((0x3ff000000000000L & l) == 0L)
1074 break;
1075 if (kind > 63)
1076 kind = 63;
1077 jjCheckNAddTwoStates(39, 8);
1078 break;
1079 case 40:
1080 if ((0x3ff000000000000L & l) != 0L)
1081 jjCheckNAddStates(31, 33);
1082 break;
1083 case 42:
1084 if ((0x280000000000L & l) != 0L)
1085 jjCheckNAdd(43);
1086 break;
1087 case 43:
1088 if ((0x3ff000000000000L & l) != 0L)
1089 jjCheckNAddTwoStates(43, 8);
1090 break;
1091 case 44:
1092 if (curChar != 48)
1093 break;
1094 if (kind > 59)
1095 kind = 59;
1096 jjCheckNAddStates(18, 20);
1097 break;
1098 case 46:
1099 if ((0x3ff000000000000L & l) == 0L)
1100 break;
1101 if (kind > 59)
1102 kind = 59;
1103 jjCheckNAddTwoStates(46, 2);
1104 break;
1105 case 47:
1106 if ((0xff000000000000L & l) == 0L)
1107 break;
1108 if (kind > 59)
1109 kind = 59;
1110 jjCheckNAddTwoStates(47, 2);
1111 break;
1112 case 48:
1113 if (curChar == 47)
1114 jjAddStates(10, 12);
1115 break;
1116 case 50:
1117 if ((0xffffffffffffdbffL & l) != 0L)
1118 jjCheckNAddStates(0, 2);
1119 break;
1120 case 51:
1121 if ((0x2400L & l) != 0L && kind > 6)
1122 kind = 6;
1123 break;
1124 case 52:
1125 if (curChar == 10 && kind > 6)
1126 kind = 6;
1127 break;
1128 case 53:
1129 if (curChar == 13)
1130 jjstateSet[jjnewStateCnt++] = 52;
1131 break;
1132 case 54:
1133 if (curChar == 42)
1134 jjCheckNAddTwoStates(55, 56);
1135 break;
1136 case 55:
1137 if ((0xfffffbffffffffffL & l) != 0L)
1138 jjCheckNAddTwoStates(55, 56);
1139 break;
1140 case 56:
1141 if (curChar == 42)
1142 jjCheckNAddStates(34, 36);
1143 break;
1144 case 57:
1145 if ((0xffff7bffffffffffL & l) != 0L)
1146 jjCheckNAddTwoStates(58, 56);
1147 break;
1148 case 58:
1149 if ((0xfffffbffffffffffL & l) != 0L)
1150 jjCheckNAddTwoStates(58, 56);
1151 break;
1152 case 59:
1153 if (curChar == 47 && kind > 7)
1154 kind = 7;
1155 break;
1156 case 60:
1157 if (curChar == 42)
1158 jjstateSet[jjnewStateCnt++] = 54;
1159 break;
1160 case 61:
1161 if (curChar == 42)
1162 jjCheckNAddTwoStates(62, 63);
1163 break;
1164 case 62:
1165 if ((0xfffffbffffffffffL & l) != 0L)
1166 jjCheckNAddTwoStates(62, 63);
1167 break;
1168 case 63:
1169 if (curChar == 42)
1170 jjCheckNAddStates(37, 39);
1171 break;
1172 case 64:
1173 if ((0xffff7bffffffffffL & l) != 0L)
1174 jjCheckNAddTwoStates(65, 63);
1175 break;
1176 case 65:
1177 if ((0xfffffbffffffffffL & l) != 0L)
1178 jjCheckNAddTwoStates(65, 63);
1179 break;
1180 case 66:
1181 if (curChar == 47 && kind > 8)
1182 kind = 8;
1183 break;
1184 default : break;
1185 }
1186 } while(i != startsAt);
1187 }
1188 else if (curChar < 128)
1189 {
1190 long l = 1L << (curChar & 077);
1191 do
1192 {
1193 switch(jjstateSet[--i])
1194 {
1195 case 0:
1196 case 28:
1197 if ((0x7fffffe87fffffeL & l) == 0L)
1198 break;
1199 if (kind > 67)
1200 kind = 67;
1201 jjCheckNAdd(28);
1202 break;
1203 case 2:
1204 if ((0x100000001000L & l) != 0L && kind > 59)
1205 kind = 59;
1206 break;
1207 case 5:
1208 if ((0x2000000020L & l) != 0L)
1209 jjAddStates(40, 41);
1210 break;
1211 case 8:
1212 if ((0x5000000050L & l) != 0L && kind > 63)
1213 kind = 63;
1214 break;
1215 case 10:
1216 if ((0xffffffffefffffffL & l) != 0L)
1217 jjCheckNAdd(11);
1218 break;
1219 case 12:
1220 if (curChar == 92)
1221 jjAddStates(42, 44);
1222 break;
1223 case 13:
1224 if ((0x14404410000000L & l) != 0L)
1225 jjCheckNAdd(11);
1226 break;
1227 case 19:
1228 if ((0xffffffffefffffffL & l) != 0L)
1229 jjCheckNAddStates(13, 15);
1230 break;
1231 case 20:
1232 if (curChar == 92)
1233 jjAddStates(45, 47);
1234 break;
1235 case 21:
1236 if ((0x14404410000000L & l) != 0L)
1237 jjCheckNAddStates(13, 15);
1238 break;
1239 case 33:
1240 if ((0x2000000020L & l) != 0L)
1241 jjAddStates(48, 49);
1242 break;
1243 case 37:
1244 if ((0x2000000020L & l) != 0L)
1245 jjAddStates(50, 51);
1246 break;
1247 case 41:
1248 if ((0x2000000020L & l) != 0L)
1249 jjAddStates(52, 53);
1250 break;
1251 case 45:
1252 if ((0x100000001000000L & l) != 0L)
1253 jjCheckNAdd(46);
1254 break;
1255 case 46:
1256 if ((0x7e0000007eL & l) == 0L)
1257 break;
1258 if (kind > 59)
1259 kind = 59;
1260 jjCheckNAddTwoStates(46, 2);
1261 break;
1262 case 50:
1263 jjAddStates(0, 2);
1264 break;
1265 case 55:
1266 jjCheckNAddTwoStates(55, 56);
1267 break;
1268 case 57:
1269 case 58:
1270 jjCheckNAddTwoStates(58, 56);
1271 break;
1272 case 62:
1273 jjCheckNAddTwoStates(62, 63);
1274 break;
1275 case 64:
1276 case 65:
1277 jjCheckNAddTwoStates(65, 63);
1278 break;
1279 default : break;
1280 }
1281 } while(i != startsAt);
1282 }
1283 else
1284 {
1285 int hiByte = (curChar >> 8);
1286 int i1 = hiByte >> 6;
1287 long l1 = 1L << (hiByte & 077);
1288 int i2 = (curChar & 0xff) >> 6;
1289 long l2 = 1L << (curChar & 077);
1290 do
1291 {
1292 switch(jjstateSet[--i])
1293 {
1294 case 0:
1295 case 28:
1296 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1297 break;
1298 if (kind > 67)
1299 kind = 67;
1300 jjCheckNAdd(28);
1301 break;
1302 case 10:
1303 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1304 jjstateSet[jjnewStateCnt++] = 11;
1305 break;
1306 case 19:
1307 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1308 jjAddStates(13, 15);
1309 break;
1310 case 50:
1311 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1312 jjAddStates(0, 2);
1313 break;
1314 case 55:
1315 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1316 jjCheckNAddTwoStates(55, 56);
1317 break;
1318 case 57:
1319 case 58:
1320 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1321 jjCheckNAddTwoStates(58, 56);
1322 break;
1323 case 62:
1324 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1325 jjCheckNAddTwoStates(62, 63);
1326 break;
1327 case 64:
1328 case 65:
1329 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1330 jjCheckNAddTwoStates(65, 63);
1331 break;
1332 default : break;
1333 }
1334 } while(i != startsAt);
1335 }
1336 if (kind != 0x7fffffff)
1337 {
1338 jjmatchedKind = kind;
1339 jjmatchedPos = curPos;
1340 kind = 0x7fffffff;
1341 }
1342 ++curPos;
1343 if ((i = jjnewStateCnt) == (startsAt = 67 - (jjnewStateCnt = startsAt)))
1344 return curPos;
1345 try { curChar = input_stream.readChar(); }
1346 catch(java.io.IOException e) { return curPos; }
1347 }
1348 }
1349 static final int[] jjnextStates = {
1350 50, 51, 53, 30, 31, 36, 37, 40, 41, 8, 49, 60, 61, 19, 20, 22,
1351 10, 12, 45, 47, 2, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8, 40,
1352 41, 8, 56, 57, 59, 63, 64, 66, 6, 7, 13, 14, 16, 21, 23, 25,
1353 34, 35, 38, 39, 42, 43,
1354 };
1355 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1356 {
1357 switch(hiByte)
1358 {
1359 case 0:
1360 return ((jjbitVec2[i2] & l2) != 0L);
1361 default :
1362 if ((jjbitVec0[i1] & l1) != 0L)
1363 return true;
1364 return false;
1365 }
1366 }
1367 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1368 {
1369 switch(hiByte)
1370 {
1371 case 0:
1372 return ((jjbitVec4[i2] & l2) != 0L);
1373 case 48:
1374 return ((jjbitVec5[i2] & l2) != 0L);
1375 case 49:
1376 return ((jjbitVec6[i2] & l2) != 0L);
1377 case 51:
1378 return ((jjbitVec7[i2] & l2) != 0L);
1379 case 61:
1380 return ((jjbitVec8[i2] & l2) != 0L);
1381 default :
1382 if ((jjbitVec3[i1] & l1) != 0L)
1383 return true;
1384 return false;
1385 }
1386 }
1387
1388 /** Token literal values. */
1389 public static final String[] jjstrLiteralImages = {
1390 "", null, null, null, null, null, null, null, null,
1391 "\141\142\163\164\162\141\143\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145",
1392 "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163",
1393 "\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164",
1394 "\144\157", "\144\157\165\142\154\145", "\145\154\163\145",
1395 "\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154",
1396 "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146",
1397 "\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146",
1398 "\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147",
1399 "\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145",
1400 "\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143",
1401 "\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\165\160\145\162",
1402 "\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163",
1403 "\164\150\162\157\167", "\164\150\162\157\167\163", "\164\162\141\156\163\151\145\156\164",
1404 "\164\162\165\145", "\164\162\171", "\166\157\151\144", "\166\157\154\141\164\151\154\145",
1405 "\167\150\151\154\145", null, null, null, null, null, null, null, null, null, null, null, "\50",
1406 "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", "\74",
1407 "\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75", "\41\75", "\174\174",
1408 "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46", "\174", "\136", "\45",
1409 "\74\74", "\76\76", "\76\76\76", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75",
1410 "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75", };
1411
1412 /** Lexer state names. */
1413 public static final String[] lexStateNames = {
1414 "DEFAULT",
1415 };
1416 static final long[] jjtoToken = {
1417 0x8ffffffffffffe01L, 0xfffffffffffceL,
1418 };
1419 static final long[] jjtoSkip = {
1420 0x1feL, 0x0L,
1421 };
1422 static final long[] jjtoSpecial = {
1423 0x1c0L, 0x0L,
1424 };
1425 protected JavaCharStream input_stream;
1426 private final int[] jjrounds = new int[67];
1427 private final int[] jjstateSet = new int[134];
1428 protected char curChar;
1429 /** Constructor. */
1430 public ExpressionParserTokenManager(JavaCharStream stream){
1431 if (JavaCharStream.staticFlag)
1432 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1433 input_stream = stream;
1434 }
1435
1436 /** Constructor. */
1437 public ExpressionParserTokenManager(JavaCharStream stream, int lexState){
1438 this(stream);
1439 SwitchTo(lexState);
1440 }
1441
1442 /** Reinitialise parser. */
1443 public void ReInit(JavaCharStream stream)
1444 {
1445 jjmatchedPos = jjnewStateCnt = 0;
1446 curLexState = defaultLexState;
1447 input_stream = stream;
1448 ReInitRounds();
1449 }
1450 private void ReInitRounds()
1451 {
1452 int i;
1453 jjround = 0x80000001;
1454 for (i = 67; i-- > 0;)
1455 jjrounds[i] = 0x80000000;
1456 }
1457
1458 /** Reinitialise parser. */
1459 public void ReInit(JavaCharStream stream, int lexState)
1460 {
1461 ReInit(stream);
1462 SwitchTo(lexState);
1463 }
1464
1465 /** Switch to specified lex state. */
1466 public void SwitchTo(int lexState)
1467 {
1468 if (lexState >= 1 || lexState < 0)
1469 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1470 else
1471 curLexState = lexState;
1472 }
1473
1474 protected Token jjFillToken()
1475 {
1476 final Token t;
1477 final String curTokenImage;
1478 final int beginLine;
1479 final int endLine;
1480 final int beginColumn;
1481 final int endColumn;
1482 String im = jjstrLiteralImages[jjmatchedKind];
1483 curTokenImage = (im == null) ? input_stream.GetImage() : im;
1484 beginLine = input_stream.getBeginLine();
1485 beginColumn = input_stream.getBeginColumn();
1486 endLine = input_stream.getEndLine();
1487 endColumn = input_stream.getEndColumn();
1488 t = Token.newToken(jjmatchedKind, curTokenImage);
1489
1490 t.beginLine = beginLine;
1491 t.endLine = endLine;
1492 t.beginColumn = beginColumn;
1493 t.endColumn = endColumn;
1494
1495 return t;
1496 }
1497
1498 int curLexState = 0;
1499 int defaultLexState = 0;
1500 int jjnewStateCnt;
1501 int jjround;
1502 int jjmatchedPos;
1503 int jjmatchedKind;
1504
1505 /** Get the next Token. */
1506 public Token getNextToken()
1507 {
1508 Token specialToken = null;
1509 Token matchedToken;
1510 int curPos = 0;
1511
1512 EOFLoop :
1513 for (;;)
1514 {
1515 try
1516 {
1517 curChar = input_stream.BeginToken();
1518 }
1519 catch(java.io.IOException e)
1520 {
1521 jjmatchedKind = 0;
1522 matchedToken = jjFillToken();
1523 matchedToken.specialToken = specialToken;
1524 return matchedToken;
1525 }
1526
1527 try { input_stream.backup(0);
1528 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1529 curChar = input_stream.BeginToken();
1530 }
1531 catch (java.io.IOException e1) { continue EOFLoop; }
1532 jjmatchedKind = 0x7fffffff;
1533 jjmatchedPos = 0;
1534 curPos = jjMoveStringLiteralDfa0_0();
1535 if (jjmatchedKind != 0x7fffffff)
1536 {
1537 if (jjmatchedPos + 1 < curPos)
1538 input_stream.backup(curPos - jjmatchedPos - 1);
1539 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1540 {
1541 matchedToken = jjFillToken();
1542 matchedToken.specialToken = specialToken;
1543 return matchedToken;
1544 }
1545 else
1546 {
1547 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1548 {
1549 matchedToken = jjFillToken();
1550 if (specialToken == null)
1551 specialToken = matchedToken;
1552 else
1553 {
1554 matchedToken.specialToken = specialToken;
1555 specialToken = (specialToken.next = matchedToken);
1556 }
1557 }
1558 continue EOFLoop;
1559 }
1560 }
1561 int error_line = input_stream.getEndLine();
1562 int error_column = input_stream.getEndColumn();
1563 String error_after = null;
1564 boolean EOFSeen = false;
1565 try { input_stream.readChar(); input_stream.backup(1); }
1566 catch (java.io.IOException e1) {
1567 EOFSeen = true;
1568 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1569 if (curChar == '\n' || curChar == '\r') {
1570 error_line++;
1571 error_column = 0;
1572 }
1573 else
1574 error_column++;
1575 }
1576 if (!EOFSeen) {
1577 input_stream.backup(1);
1578 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1579 }
1580 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1581 }
1582 }
1583
1584 private void jjCheckNAdd(int state)
1585 {
1586 if (jjrounds[state] != jjround)
1587 {
1588 jjstateSet[jjnewStateCnt++] = state;
1589 jjrounds[state] = jjround;
1590 }
1591 }
1592 private void jjAddStates(int start, int end)
1593 {
1594 do {
1595 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1596 } while (start++ != end);
1597 }
1598 private void jjCheckNAddTwoStates(int state1, int state2)
1599 {
1600 jjCheckNAdd(state1);
1601 jjCheckNAdd(state2);
1602 }
1603
1604 private void jjCheckNAddStates(int start, int end)
1605 {
1606 do {
1607 jjCheckNAdd(jjnextStates[start]);
1608 } while (start++ != end);
1609 }
1610
1611 }