001 package jtb;
002
003 /* Generated By:JavaCC: Do not edit this line. JavaParserTokenManager.java */
004 import java.io.*;
005 import jtb.syntaxtree.*;
006 import java.util.Vector;
007
008 @SuppressWarnings("cast")
009 public class JavaParserTokenManager implements JavaParserConstants
010 {
011 public java.io.PrintStream debugStream = System.out;
012 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
013 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
014 {
015 switch (pos)
016 {
017 case 0:
018 if ((active0 & 0x140L) != 0L || (active1 & 0x2010000000000L) != 0L)
019 return 2;
020 if ((active1 & 0x200000000200000L) != 0L)
021 return 8;
022 if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x3L) != 0L)
023 {
024 jjmatchedKind = 74;
025 return 32;
026 }
027 return -1;
028 case 1:
029 if ((active0 & 0x100L) != 0L)
030 return 0;
031 if ((active0 & 0xffffffeff9ffe000L) != 0L || (active1 & 0x3L) != 0L)
032 {
033 if (jjmatchedPos != 1)
034 {
035 jjmatchedKind = 74;
036 jjmatchedPos = 1;
037 }
038 return 32;
039 }
040 if ((active0 & 0x1006000000L) != 0L)
041 return 32;
042 return -1;
043 case 2:
044 if ((active0 & 0xbfffecebfdffe000L) != 0L || (active1 & 0x3L) != 0L)
045 {
046 if (jjmatchedPos != 2)
047 {
048 jjmatchedKind = 74;
049 jjmatchedPos = 2;
050 }
051 return 32;
052 }
053 if ((active0 & 0x4000130400000000L) != 0L)
054 return 32;
055 return -1;
056 case 3:
057 if ((active0 & 0x1dffcae3e5e9e000L) != 0L || (active1 & 0x3L) != 0L)
058 {
059 jjmatchedKind = 74;
060 jjmatchedPos = 3;
061 return 32;
062 }
063 if ((active0 & 0xa200240818160000L) != 0L)
064 return 32;
065 return -1;
066 case 4:
067 if ((active0 & 0x11b7cae02580e000L) != 0L || (active1 & 0x1L) != 0L)
068 {
069 if (jjmatchedPos != 4)
070 {
071 jjmatchedKind = 74;
072 jjmatchedPos = 4;
073 }
074 return 32;
075 }
076 if ((active0 & 0xc480003c0690000L) != 0L || (active1 & 0x2L) != 0L)
077 return 32;
078 return -1;
079 case 5:
080 if ((active0 & 0x1121c2a12180a000L) != 0L || (active1 & 0x1L) != 0L)
081 {
082 jjmatchedKind = 74;
083 jjmatchedPos = 5;
084 return 32;
085 }
086 if ((active0 & 0x896084004004000L) != 0L)
087 return 32;
088 return -1;
089 case 6:
090 if ((active0 & 0x112102a000802000L) != 0L || (active1 & 0x1L) != 0L)
091 {
092 jjmatchedKind = 74;
093 jjmatchedPos = 6;
094 return 32;
095 }
096 if ((active0 & 0xc00121008000L) != 0L)
097 return 32;
098 return -1;
099 case 7:
100 if ((active0 & 0x110102a000000000L) != 0L)
101 {
102 jjmatchedKind = 74;
103 jjmatchedPos = 7;
104 return 32;
105 }
106 if ((active0 & 0x20000000802000L) != 0L || (active1 & 0x1L) != 0L)
107 return 32;
108 return -1;
109 case 8:
110 if ((active0 & 0x10000a000000000L) != 0L)
111 {
112 jjmatchedKind = 74;
113 jjmatchedPos = 8;
114 return 32;
115 }
116 if ((active0 & 0x1001020000000000L) != 0L)
117 return 32;
118 return -1;
119 case 9:
120 if ((active0 & 0x100000000000000L) != 0L)
121 {
122 jjmatchedKind = 74;
123 jjmatchedPos = 9;
124 return 32;
125 }
126 if ((active0 & 0xa000000000L) != 0L)
127 return 32;
128 return -1;
129 case 10:
130 if ((active0 & 0x100000000000000L) != 0L)
131 {
132 jjmatchedKind = 74;
133 jjmatchedPos = 10;
134 return 32;
135 }
136 return -1;
137 default :
138 return -1;
139 }
140 }
141 private final int jjStartNfa_0(int pos, long active0, long active1)
142 {
143 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
144 }
145 private final int jjStopAtPos(int pos, int kind)
146 {
147 jjmatchedKind = kind;
148 jjmatchedPos = pos;
149 return pos + 1;
150 }
151 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
152 {
153 jjmatchedKind = kind;
154 jjmatchedPos = pos;
155 try { curChar = input_stream.readChar(); }
156 catch(java.io.IOException e) { return pos + 1; }
157 return jjMoveNfa_0(state, pos + 1);
158 }
159 private final int jjMoveStringLiteralDfa0_0()
160 {
161 switch(curChar)
162 {
163 case 33:
164 jjmatchedKind = 89;
165 return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000L);
166 case 37:
167 jjmatchedKind = 108;
168 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L);
169 case 38:
170 jjmatchedKind = 105;
171 return jjMoveStringLiteralDfa1_0(0x0L, 0x4000400000000L);
172 case 40:
173 return jjStopAtPos(0, 77);
174 case 41:
175 return jjStopAtPos(0, 78);
176 case 42:
177 jjmatchedKind = 103;
178 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000L);
179 case 43:
180 jjmatchedKind = 101;
181 return jjMoveStringLiteralDfa1_0(0x0L, 0x400800000000L);
182 case 44:
183 return jjStopAtPos(0, 84);
184 case 45:
185 jjmatchedKind = 102;
186 return jjMoveStringLiteralDfa1_0(0x0L, 0x801000000000L);
187 case 46:
188 jjmatchedKind = 85;
189 return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000000000L);
190 case 47:
191 jjmatchedKind = 104;
192 return jjMoveStringLiteralDfa1_0(0x140L, 0x2000000000000L);
193 case 58:
194 return jjStopAtPos(0, 92);
195 case 59:
196 return jjStopAtPos(0, 83);
197 case 60:
198 jjmatchedKind = 88;
199 return jjMoveStringLiteralDfa1_0(0x0L, 0x40200040000000L);
200 case 61:
201 jjmatchedKind = 87;
202 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000L);
203 case 62:
204 jjmatchedKind = 124;
205 return jjMoveStringLiteralDfa1_0(0x0L, 0xd80000080000000L);
206 case 63:
207 return jjStopAtPos(0, 91);
208 case 64:
209 return jjStopAtPos(0, 86);
210 case 91:
211 return jjStopAtPos(0, 81);
212 case 93:
213 return jjStopAtPos(0, 82);
214 case 94:
215 jjmatchedKind = 107;
216 return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000000000L);
217 case 97:
218 return jjMoveStringLiteralDfa1_0(0x6000L, 0x0L);
219 case 98:
220 return jjMoveStringLiteralDfa1_0(0x38000L, 0x0L);
221 case 99:
222 return jjMoveStringLiteralDfa1_0(0xfc0000L, 0x0L);
223 case 100:
224 return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L);
225 case 101:
226 return jjMoveStringLiteralDfa1_0(0x38000000L, 0x0L);
227 case 102:
228 return jjMoveStringLiteralDfa1_0(0x7c0000000L, 0x0L);
229 case 103:
230 return jjMoveStringLiteralDfa1_0(0x800000000L, 0x0L);
231 case 105:
232 return jjMoveStringLiteralDfa1_0(0x3f000000000L, 0x0L);
233 case 108:
234 return jjMoveStringLiteralDfa1_0(0x40000000000L, 0x0L);
235 case 110:
236 return jjMoveStringLiteralDfa1_0(0x380000000000L, 0x0L);
237 case 112:
238 return jjMoveStringLiteralDfa1_0(0x3c00000000000L, 0x0L);
239 case 114:
240 return jjMoveStringLiteralDfa1_0(0x4000000000000L, 0x0L);
241 case 115:
242 return jjMoveStringLiteralDfa1_0(0x1f8000000000000L, 0x0L);
243 case 116:
244 return jjMoveStringLiteralDfa1_0(0x7e00000000000000L, 0x0L);
245 case 118:
246 return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x1L);
247 case 119:
248 return jjMoveStringLiteralDfa1_0(0x0L, 0x2L);
249 case 123:
250 return jjStopAtPos(0, 79);
251 case 124:
252 jjmatchedKind = 106;
253 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000200000000L);
254 case 125:
255 return jjStopAtPos(0, 80);
256 case 126:
257 return jjStopAtPos(0, 90);
258 default :
259 return jjMoveNfa_0(3, 0);
260 }
261 }
262 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
263 {
264 try { curChar = input_stream.readChar(); }
265 catch(java.io.IOException e) {
266 jjStopStringLiteralDfa_0(0, active0, active1);
267 return 1;
268 }
269 switch(curChar)
270 {
271 case 38:
272 if ((active1 & 0x400000000L) != 0L)
273 return jjStopAtPos(1, 98);
274 break;
275 case 42:
276 if ((active0 & 0x100L) != 0L)
277 return jjStartNfaWithStates_0(1, 8, 0);
278 break;
279 case 43:
280 if ((active1 & 0x800000000L) != 0L)
281 return jjStopAtPos(1, 99);
282 break;
283 case 45:
284 if ((active1 & 0x1000000000L) != 0L)
285 return jjStopAtPos(1, 100);
286 break;
287 case 46:
288 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200000000000000L);
289 case 47:
290 if ((active0 & 0x40L) != 0L)
291 return jjStopAtPos(1, 6);
292 break;
293 case 60:
294 if ((active1 & 0x200000000000L) != 0L)
295 {
296 jjmatchedKind = 109;
297 jjmatchedPos = 1;
298 }
299 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000000000000L);
300 case 61:
301 if ((active1 & 0x20000000L) != 0L)
302 return jjStopAtPos(1, 93);
303 else if ((active1 & 0x40000000L) != 0L)
304 return jjStopAtPos(1, 94);
305 else if ((active1 & 0x80000000L) != 0L)
306 return jjStopAtPos(1, 95);
307 else if ((active1 & 0x100000000L) != 0L)
308 return jjStopAtPos(1, 96);
309 else if ((active1 & 0x400000000000L) != 0L)
310 return jjStopAtPos(1, 110);
311 else if ((active1 & 0x800000000000L) != 0L)
312 return jjStopAtPos(1, 111);
313 else if ((active1 & 0x1000000000000L) != 0L)
314 return jjStopAtPos(1, 112);
315 else if ((active1 & 0x2000000000000L) != 0L)
316 return jjStopAtPos(1, 113);
317 else if ((active1 & 0x4000000000000L) != 0L)
318 return jjStopAtPos(1, 114);
319 else if ((active1 & 0x8000000000000L) != 0L)
320 return jjStopAtPos(1, 115);
321 else if ((active1 & 0x10000000000000L) != 0L)
322 return jjStopAtPos(1, 116);
323 else if ((active1 & 0x20000000000000L) != 0L)
324 return jjStopAtPos(1, 117);
325 break;
326 case 62:
327 if ((active1 & 0x800000000000000L) != 0L)
328 {
329 jjmatchedKind = 123;
330 jjmatchedPos = 1;
331 }
332 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x580000000000000L);
333 case 97:
334 return jjMoveStringLiteralDfa2_0(active0, 0x4800400c0000L, active1, 0L);
335 case 98:
336 return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L);
337 case 101:
338 return jjMoveStringLiteralDfa2_0(active0, 0x4100001000000L, active1, 0L);
339 case 102:
340 if ((active0 & 0x1000000000L) != 0L)
341 return jjStartNfaWithStates_0(1, 36, 32);
342 break;
343 case 104:
344 return jjMoveStringLiteralDfa2_0(active0, 0xe08000000100000L, active1, 0x2L);
345 case 105:
346 return jjMoveStringLiteralDfa2_0(active0, 0x180000000L, active1, 0L);
347 case 108:
348 return jjMoveStringLiteralDfa2_0(active0, 0x208200000L, active1, 0L);
349 case 109:
350 return jjMoveStringLiteralDfa2_0(active0, 0x6000000000L, active1, 0L);
351 case 110:
352 return jjMoveStringLiteralDfa2_0(active0, 0x38010000000L, active1, 0L);
353 case 111:
354 if ((active0 & 0x2000000L) != 0L)
355 {
356 jjmatchedKind = 25;
357 jjmatchedPos = 1;
358 }
359 return jjMoveStringLiteralDfa2_0(active0, 0x8000040c04c08000L, active1, 0x1L);
360 case 114:
361 return jjMoveStringLiteralDfa2_0(active0, 0x7001800000010000L, active1, 0L);
362 case 115:
363 return jjMoveStringLiteralDfa2_0(active0, 0x4000L, active1, 0L);
364 case 116:
365 return jjMoveStringLiteralDfa2_0(active0, 0x30000000000000L, active1, 0L);
366 case 117:
367 return jjMoveStringLiteralDfa2_0(active0, 0x42200000000000L, active1, 0L);
368 case 119:
369 return jjMoveStringLiteralDfa2_0(active0, 0x80000000000000L, active1, 0L);
370 case 120:
371 return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L);
372 case 121:
373 return jjMoveStringLiteralDfa2_0(active0, 0x100000000020000L, active1, 0L);
374 case 124:
375 if ((active1 & 0x200000000L) != 0L)
376 return jjStopAtPos(1, 97);
377 break;
378 default :
379 break;
380 }
381 return jjStartNfa_0(0, active0, active1);
382 }
383 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
384 {
385 if (((active0 &= old0) | (active1 &= old1)) == 0L)
386 return jjStartNfa_0(0, old0, old1);
387 try { curChar = input_stream.readChar(); }
388 catch(java.io.IOException e) {
389 jjStopStringLiteralDfa_0(1, active0, active1);
390 return 2;
391 }
392 switch(curChar)
393 {
394 case 46:
395 if ((active1 & 0x200000000000000L) != 0L)
396 return jjStopAtPos(2, 121);
397 break;
398 case 61:
399 if ((active1 & 0x40000000000000L) != 0L)
400 return jjStopAtPos(2, 118);
401 else if ((active1 & 0x80000000000000L) != 0L)
402 return jjStopAtPos(2, 119);
403 break;
404 case 62:
405 if ((active1 & 0x400000000000000L) != 0L)
406 {
407 jjmatchedKind = 122;
408 jjmatchedPos = 2;
409 }
410 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x100000000000000L);
411 case 97:
412 return jjMoveStringLiteralDfa3_0(active0, 0x1010000000300000L, active1, 0L);
413 case 98:
414 return jjMoveStringLiteralDfa3_0(active0, 0x2000000000000L, active1, 0L);
415 case 99:
416 return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0L);
417 case 101:
418 return jjMoveStringLiteralDfa3_0(active0, 0x10000L, active1, 0L);
419 case 102:
420 return jjMoveStringLiteralDfa3_0(active0, 0x1000000L, active1, 0L);
421 case 105:
422 return jjMoveStringLiteralDfa3_0(active0, 0x8280800000000000L, active1, 0x2L);
423 case 108:
424 return jjMoveStringLiteralDfa3_0(active0, 0x200040000000L, active1, 0x1L);
425 case 110:
426 return jjMoveStringLiteralDfa3_0(active0, 0x100040180c00000L, active1, 0L);
427 case 111:
428 return jjMoveStringLiteralDfa3_0(active0, 0x9000200008000L, active1, 0L);
429 case 112:
430 return jjMoveStringLiteralDfa3_0(active0, 0x40006000000000L, active1, 0L);
431 case 114:
432 if ((active0 & 0x400000000L) != 0L)
433 return jjStartNfaWithStates_0(2, 34, 32);
434 return jjMoveStringLiteralDfa3_0(active0, 0xc20000000000000L, active1, 0L);
435 case 115:
436 return jjMoveStringLiteralDfa3_0(active0, 0x8008046000L, active1, 0L);
437 case 116:
438 if ((active0 & 0x10000000000L) != 0L)
439 {
440 jjmatchedKind = 40;
441 jjmatchedPos = 2;
442 }
443 return jjMoveStringLiteralDfa3_0(active0, 0x40a08200a0000L, active1, 0L);
444 case 117:
445 return jjMoveStringLiteralDfa3_0(active0, 0x2000000014000000L, active1, 0L);
446 case 119:
447 if ((active0 & 0x100000000000L) != 0L)
448 return jjStartNfaWithStates_0(2, 44, 32);
449 break;
450 case 121:
451 if ((active0 & 0x4000000000000000L) != 0L)
452 return jjStartNfaWithStates_0(2, 62, 32);
453 break;
454 default :
455 break;
456 }
457 return jjStartNfa_0(1, active0, active1);
458 }
459 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
460 {
461 if (((active0 &= old0) | (active1 &= old1)) == 0L)
462 return jjStartNfa_0(1, old0, old1);
463 try { curChar = input_stream.readChar(); }
464 catch(java.io.IOException e) {
465 jjStopStringLiteralDfa_0(2, active0, active1);
466 return 3;
467 }
468 switch(curChar)
469 {
470 case 61:
471 if ((active1 & 0x100000000000000L) != 0L)
472 return jjStopAtPos(3, 120);
473 break;
474 case 97:
475 return jjMoveStringLiteralDfa4_0(active0, 0x381010000L, active1, 0x1L);
476 case 98:
477 return jjMoveStringLiteralDfa4_0(active0, 0x4000000L, active1, 0L);
478 case 99:
479 return jjMoveStringLiteralDfa4_0(active0, 0x100000000080000L, active1, 0L);
480 case 100:
481 if ((active0 & 0x8000000000000000L) != 0L)
482 return jjStartNfaWithStates_0(3, 63, 32);
483 break;
484 case 101:
485 if ((active0 & 0x20000L) != 0L)
486 return jjStartNfaWithStates_0(3, 17, 32);
487 else if ((active0 & 0x40000L) != 0L)
488 return jjStartNfaWithStates_0(3, 18, 32);
489 else if ((active0 & 0x8000000L) != 0L)
490 return jjStartNfaWithStates_0(3, 27, 32);
491 else if ((active0 & 0x2000000000000000L) != 0L)
492 return jjStartNfaWithStates_0(3, 61, 32);
493 return jjMoveStringLiteralDfa4_0(active0, 0x40020020004000L, active1, 0L);
494 case 103:
495 if ((active0 & 0x40000000000L) != 0L)
496 return jjStartNfaWithStates_0(3, 42, 32);
497 break;
498 case 105:
499 return jjMoveStringLiteralDfa4_0(active0, 0x20080000000000L, active1, 0L);
500 case 107:
501 return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L);
502 case 108:
503 if ((active0 & 0x200000000000L) != 0L)
504 return jjStartNfaWithStates_0(3, 45, 32);
505 return jjMoveStringLiteralDfa4_0(active0, 0x2002000008000L, active1, 0x2L);
506 case 109:
507 if ((active0 & 0x10000000L) != 0L)
508 return jjStartNfaWithStates_0(3, 28, 32);
509 break;
510 case 110:
511 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000000L, active1, 0L);
512 case 111:
513 if ((active0 & 0x800000000L) != 0L)
514 return jjStartNfaWithStates_0(3, 35, 32);
515 return jjMoveStringLiteralDfa4_0(active0, 0xc00004000000000L, active1, 0L);
516 case 114:
517 if ((active0 & 0x100000L) != 0L)
518 return jjStartNfaWithStates_0(3, 20, 32);
519 return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L, active1, 0L);
520 case 115:
521 if ((active0 & 0x200000000000000L) != 0L)
522 return jjStartNfaWithStates_0(3, 57, 32);
523 return jjMoveStringLiteralDfa4_0(active0, 0x40600000L, active1, 0L);
524 case 116:
525 return jjMoveStringLiteralDfa4_0(active0, 0x91008000802000L, active1, 0L);
526 case 117:
527 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0L);
528 case 118:
529 return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L);
530 default :
531 break;
532 }
533 return jjStartNfa_0(2, active0, active1);
534 }
535 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
536 {
537 if (((active0 &= old0) | (active1 &= old1)) == 0L)
538 return jjStartNfa_0(2, old0, old1);
539 try { curChar = input_stream.readChar(); }
540 catch(java.io.IOException e) {
541 jjStopStringLiteralDfa_0(3, active0, active1);
542 return 4;
543 }
544 switch(curChar)
545 {
546 case 97:
547 return jjMoveStringLiteralDfa5_0(active0, 0xc08000000000L, active1, 0L);
548 case 99:
549 return jjMoveStringLiteralDfa5_0(active0, 0xa0000000000000L, active1, 0L);
550 case 101:
551 if ((active0 & 0x40000000L) != 0L)
552 return jjStartNfaWithStates_0(4, 30, 32);
553 else if ((active1 & 0x2L) != 0L)
554 return jjStartNfaWithStates_0(4, 65, 32);
555 return jjMoveStringLiteralDfa5_0(active0, 0x1002000008000L, active1, 0L);
556 case 104:
557 if ((active0 & 0x80000L) != 0L)
558 return jjStartNfaWithStates_0(4, 19, 32);
559 return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L);
560 case 105:
561 return jjMoveStringLiteralDfa5_0(active0, 0x12000000800000L, active1, 0L);
562 case 107:
563 if ((active0 & 0x10000L) != 0L)
564 return jjStartNfaWithStates_0(4, 16, 32);
565 break;
566 case 108:
567 if ((active0 & 0x80000000L) != 0L)
568 {
569 jjmatchedKind = 31;
570 jjmatchedPos = 4;
571 }
572 return jjMoveStringLiteralDfa5_0(active0, 0x104000000L, active1, 0L);
573 case 110:
574 return jjMoveStringLiteralDfa5_0(active0, 0x20000000L, active1, 0L);
575 case 114:
576 if ((active0 & 0x40000000000000L) != 0L)
577 return jjStartNfaWithStates_0(4, 54, 32);
578 return jjMoveStringLiteralDfa5_0(active0, 0x4024000006000L, active1, 0L);
579 case 115:
580 if ((active0 & 0x200000L) != 0L)
581 return jjStartNfaWithStates_0(4, 21, 32);
582 return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L, active1, 0L);
583 case 116:
584 if ((active0 & 0x400000L) != 0L)
585 return jjStartNfaWithStates_0(4, 22, 32);
586 else if ((active0 & 0x200000000L) != 0L)
587 return jjStartNfaWithStates_0(4, 33, 32);
588 else if ((active0 & 0x8000000000000L) != 0L)
589 return jjStartNfaWithStates_0(4, 51, 32);
590 return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1L);
591 case 117:
592 return jjMoveStringLiteralDfa5_0(active0, 0x1000000L, active1, 0L);
593 case 118:
594 return jjMoveStringLiteralDfa5_0(active0, 0x80000000000L, active1, 0L);
595 case 119:
596 if ((active0 & 0x400000000000000L) != 0L)
597 {
598 jjmatchedKind = 58;
599 jjmatchedPos = 4;
600 }
601 return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0L);
602 default :
603 break;
604 }
605 return jjStartNfa_0(3, active0, active1);
606 }
607 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
608 {
609 if (((active0 &= old0) | (active1 &= old1)) == 0L)
610 return jjStartNfa_0(3, old0, old1);
611 try { curChar = input_stream.readChar(); }
612 catch(java.io.IOException e) {
613 jjStopStringLiteralDfa_0(4, active0, active1);
614 return 5;
615 }
616 switch(curChar)
617 {
618 case 97:
619 return jjMoveStringLiteralDfa6_0(active0, 0xa000L, active1, 0L);
620 case 99:
621 if ((active0 & 0x2000000000000L) != 0L)
622 return jjStartNfaWithStates_0(5, 49, 32);
623 else if ((active0 & 0x10000000000000L) != 0L)
624 return jjStartNfaWithStates_0(5, 52, 32);
625 return jjMoveStringLiteralDfa6_0(active0, 0x1000000000000L, active1, 0L);
626 case 100:
627 return jjMoveStringLiteralDfa6_0(active0, 0x20000000L, active1, 0L);
628 case 101:
629 if ((active0 & 0x4000000L) != 0L)
630 return jjStartNfaWithStates_0(5, 26, 32);
631 else if ((active0 & 0x80000000000L) != 0L)
632 return jjStartNfaWithStates_0(5, 43, 32);
633 break;
634 case 102:
635 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L, active1, 0L);
636 case 103:
637 return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L);
638 case 104:
639 if ((active0 & 0x80000000000000L) != 0L)
640 return jjStartNfaWithStates_0(5, 55, 32);
641 break;
642 case 105:
643 return jjMoveStringLiteralDfa6_0(active0, 0x1000000000000000L, active1, 0x1L);
644 case 108:
645 return jjMoveStringLiteralDfa6_0(active0, 0x101000000L, active1, 0L);
646 case 109:
647 return jjMoveStringLiteralDfa6_0(active0, 0x2000000000L, active1, 0L);
648 case 110:
649 if ((active0 & 0x4000000000000L) != 0L)
650 return jjStartNfaWithStates_0(5, 50, 32);
651 return jjMoveStringLiteralDfa6_0(active0, 0x8000800000L, active1, 0L);
652 case 114:
653 return jjMoveStringLiteralDfa6_0(active0, 0x100000000000000L, active1, 0L);
654 case 115:
655 if ((active0 & 0x800000000000000L) != 0L)
656 return jjStartNfaWithStates_0(5, 59, 32);
657 break;
658 case 116:
659 if ((active0 & 0x4000L) != 0L)
660 return jjStartNfaWithStates_0(5, 14, 32);
661 else if ((active0 & 0x4000000000L) != 0L)
662 return jjStartNfaWithStates_0(5, 38, 32);
663 return jjMoveStringLiteralDfa6_0(active0, 0x20800000000000L, active1, 0L);
664 default :
665 break;
666 }
667 return jjStartNfa_0(4, active0, active1);
668 }
669 private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
670 {
671 if (((active0 &= old0) | (active1 &= old1)) == 0L)
672 return jjStartNfa_0(4, old0, old1);
673 try { curChar = input_stream.readChar(); }
674 catch(java.io.IOException e) {
675 jjStopStringLiteralDfa_0(5, active0, active1);
676 return 6;
677 }
678 switch(curChar)
679 {
680 case 97:
681 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000L, active1, 0L);
682 case 99:
683 return jjMoveStringLiteralDfa7_0(active0, 0x8000002000L, active1, 0L);
684 case 101:
685 if ((active0 & 0x400000000000L) != 0L)
686 return jjStartNfaWithStates_0(6, 46, 32);
687 else if ((active0 & 0x800000000000L) != 0L)
688 return jjStartNfaWithStates_0(6, 47, 32);
689 return jjMoveStringLiteralDfa7_0(active0, 0x1000002000000000L, active1, 0L);
690 case 102:
691 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L, active1, 0L);
692 case 108:
693 return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x1L);
694 case 110:
695 if ((active0 & 0x8000L) != 0L)
696 return jjStartNfaWithStates_0(6, 15, 32);
697 break;
698 case 111:
699 return jjMoveStringLiteralDfa7_0(active0, 0x100000000000000L, active1, 0L);
700 case 115:
701 if ((active0 & 0x20000000L) != 0L)
702 return jjStartNfaWithStates_0(6, 29, 32);
703 break;
704 case 116:
705 if ((active0 & 0x1000000L) != 0L)
706 return jjStartNfaWithStates_0(6, 24, 32);
707 return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000L, active1, 0L);
708 case 117:
709 return jjMoveStringLiteralDfa7_0(active0, 0x800000L, active1, 0L);
710 case 121:
711 if ((active0 & 0x100000000L) != 0L)
712 return jjStartNfaWithStates_0(6, 32, 32);
713 break;
714 default :
715 break;
716 }
717 return jjStartNfa_0(5, active0, active1);
718 }
719 private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1)
720 {
721 if (((active0 &= old0) | (active1 &= old1)) == 0L)
722 return jjStartNfa_0(5, old0, old1);
723 try { curChar = input_stream.readChar(); }
724 catch(java.io.IOException e) {
725 jjStopStringLiteralDfa_0(6, active0, active1);
726 return 7;
727 }
728 switch(curChar)
729 {
730 case 99:
731 return jjMoveStringLiteralDfa8_0(active0, 0x20000000000L, active1, 0L);
732 case 101:
733 if ((active0 & 0x800000L) != 0L)
734 return jjStartNfaWithStates_0(7, 23, 32);
735 else if ((active1 & 0x1L) != 0L)
736 return jjStartNfaWithStates_0(7, 64, 32);
737 return jjMoveStringLiteralDfa8_0(active0, 0x1008000000000L, active1, 0L);
738 case 110:
739 return jjMoveStringLiteralDfa8_0(active0, 0x1100002000000000L, active1, 0L);
740 case 112:
741 if ((active0 & 0x20000000000000L) != 0L)
742 return jjStartNfaWithStates_0(7, 53, 32);
743 break;
744 case 116:
745 if ((active0 & 0x2000L) != 0L)
746 return jjStartNfaWithStates_0(7, 13, 32);
747 break;
748 default :
749 break;
750 }
751 return jjStartNfa_0(6, active0, active1);
752 }
753 private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1)
754 {
755 if (((active0 &= old0) | (active1 &= old1)) == 0L)
756 return jjStartNfa_0(6, old0, old1);
757 try { curChar = input_stream.readChar(); }
758 catch(java.io.IOException e) {
759 jjStopStringLiteralDfa_0(7, active0, 0L);
760 return 8;
761 }
762 switch(curChar)
763 {
764 case 100:
765 if ((active0 & 0x1000000000000L) != 0L)
766 return jjStartNfaWithStates_0(8, 48, 32);
767 break;
768 case 101:
769 if ((active0 & 0x20000000000L) != 0L)
770 return jjStartNfaWithStates_0(8, 41, 32);
771 break;
772 case 105:
773 return jjMoveStringLiteralDfa9_0(active0, 0x100000000000000L);
774 case 111:
775 return jjMoveStringLiteralDfa9_0(active0, 0x8000000000L);
776 case 116:
777 if ((active0 & 0x1000000000000000L) != 0L)
778 return jjStartNfaWithStates_0(8, 60, 32);
779 return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L);
780 default :
781 break;
782 }
783 return jjStartNfa_0(7, active0, 0L);
784 }
785 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
786 {
787 if (((active0 &= old0)) == 0L)
788 return jjStartNfa_0(7, old0, 0L);
789 try { curChar = input_stream.readChar(); }
790 catch(java.io.IOException e) {
791 jjStopStringLiteralDfa_0(8, active0, 0L);
792 return 9;
793 }
794 switch(curChar)
795 {
796 case 102:
797 if ((active0 & 0x8000000000L) != 0L)
798 return jjStartNfaWithStates_0(9, 39, 32);
799 break;
800 case 115:
801 if ((active0 & 0x2000000000L) != 0L)
802 return jjStartNfaWithStates_0(9, 37, 32);
803 break;
804 case 122:
805 return jjMoveStringLiteralDfa10_0(active0, 0x100000000000000L);
806 default :
807 break;
808 }
809 return jjStartNfa_0(8, active0, 0L);
810 }
811 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
812 {
813 if (((active0 &= old0)) == 0L)
814 return jjStartNfa_0(8, old0, 0L);
815 try { curChar = input_stream.readChar(); }
816 catch(java.io.IOException e) {
817 jjStopStringLiteralDfa_0(9, active0, 0L);
818 return 10;
819 }
820 switch(curChar)
821 {
822 case 101:
823 return jjMoveStringLiteralDfa11_0(active0, 0x100000000000000L);
824 default :
825 break;
826 }
827 return jjStartNfa_0(9, active0, 0L);
828 }
829 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
830 {
831 if (((active0 &= old0)) == 0L)
832 return jjStartNfa_0(9, old0, 0L);
833 try { curChar = input_stream.readChar(); }
834 catch(java.io.IOException e) {
835 jjStopStringLiteralDfa_0(10, active0, 0L);
836 return 11;
837 }
838 switch(curChar)
839 {
840 case 100:
841 if ((active0 & 0x100000000000000L) != 0L)
842 return jjStartNfaWithStates_0(11, 56, 32);
843 break;
844 default :
845 break;
846 }
847 return jjStartNfa_0(10, active0, 0L);
848 }
849 private final void jjCheckNAdd(int state)
850 {
851 if (jjrounds[state] != jjround)
852 {
853 jjstateSet[jjnewStateCnt++] = state;
854 jjrounds[state] = jjround;
855 }
856 }
857 private final void jjAddStates(int start, int end)
858 {
859 do {
860 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
861 } while (start++ != end);
862 }
863 private final void jjCheckNAddTwoStates(int state1, int state2)
864 {
865 jjCheckNAdd(state1);
866 jjCheckNAdd(state2);
867 }
868 private final void jjCheckNAddStates(int start, int end)
869 {
870 do {
871 jjCheckNAdd(jjnextStates[start]);
872 } while (start++ != end);
873 }
874 private final void jjCheckNAddStates(int start)
875 {
876 jjCheckNAdd(jjnextStates[start]);
877 jjCheckNAdd(jjnextStates[start + 1]);
878 }
879 static final long[] jjbitVec0 = {
880 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
881 };
882 static final long[] jjbitVec2 = {
883 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
884 };
885 static final long[] jjbitVec3 = {
886 0xfff0000000200002L, 0xffffffffffffdfffL, 0xfffff00f7fffffffL, 0x12000000007fffffL
887 };
888 static final long[] jjbitVec4 = {
889 0x0L, 0x0L, 0x420043c00000000L, 0xff7fffffff7fffffL
890 };
891 static final long[] jjbitVec5 = {
892 0xffffcffffffffL, 0xffffffffffff0000L, 0xf9ff3fffffffffffL, 0x401f00030003L
893 };
894 static final long[] jjbitVec6 = {
895 0x0L, 0x400000000000000L, 0xfffffffbffffd740L, 0xffffffcff7fffL
896 };
897 static final long[] jjbitVec7 = {
898 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff003L, 0x33fffffffff199fL
899 };
900 static final long[] jjbitVec8 = {
901 0xfffe000000000000L, 0xfffffffe027fffffL, 0xffL, 0x707ffffff0000L
902 };
903 static final long[] jjbitVec9 = {
904 0x7fffffe00000000L, 0xfffe0000000007ffL, 0xffffffffffffffffL, 0x1c000060002fffffL
905 };
906 static final long[] jjbitVec10 = {
907 0x1ffffffd0000L, 0x0L, 0x3fffffffffL, 0x0L
908 };
909 static final long[] jjbitVec11 = {
910 0x23ffffffffffffe0L, 0x3ff010000L, 0x3c5fdfffff99fe0L, 0xf0003b0000000L
911 };
912 static final long[] jjbitVec12 = {
913 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100010000L
914 };
915 static final long[] jjbitVec13 = {
916 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
917 };
918 static final long[] jjbitVec14 = {
919 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
920 };
921 static final long[] jjbitVec15 = {
922 0x3fffdfffffddfe0L, 0x300000000L, 0x2ffbfffffc7fffe0L, 0x7fL
923 };
924 static final long[] jjbitVec16 = {
925 0x800dfffffffffffeL, 0x7fL, 0x200decaefef02596L, 0x3000005fL
926 };
927 static final long[] jjbitVec17 = {
928 0x1L, 0x7fffffffeffL, 0xf00L, 0x0L
929 };
930 static final long[] jjbitVec18 = {
931 0x6fbffffffffL, 0x3f0000L, 0xffffffff00000000L, 0x7fffffffff003fL
932 };
933 static final long[] jjbitVec19 = {
934 0xffffffffffffffffL, 0xffffffff83ffffffL, 0xffffff07ffffffffL, 0x3ffffffffffffffL
935 };
936 static final long[] jjbitVec20 = {
937 0xffffffffffffff7fL, 0xffffffff3d7f3d7fL, 0x7f3d7fffffff3d7fL, 0xffff7fffff7f7f3dL
938 };
939 static final long[] jjbitVec21 = {
940 0xffffffff7f3d7fffL, 0x7ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
941 };
942 static final long[] jjbitVec22 = {
943 0xffffffffffffffffL, 0x7f9fffffffffffL, 0xffffffff07fffffeL, 0x7ffffffffffL
944 };
945 static final long[] jjbitVec23 = {
946 0x0L, 0x0L, 0xfffffffffffffL, 0x8000000L
947 };
948 static final long[] jjbitVec24 = {
949 0xffffffff00000000L, 0xffffffffffffffL, 0x1ffffffffffL, 0x0L
950 };
951 static final long[] jjbitVec25 = {
952 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
953 };
954 static final long[] jjbitVec26 = {
955 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
956 };
957 static final long[] jjbitVec27 = {
958 0x8000000000000000L, 0x8000000000000001L, 0xffff00000000L, 0x0L
959 };
960 static final long[] jjbitVec28 = {
961 0x3fbbd503e2ffc84L, 0xffffffff00000000L, 0xfL, 0x0L
962 };
963 static final long[] jjbitVec29 = {
964 0x73e03fe000000e0L, 0xfffffffffffffffeL, 0xfffffffe601fffffL, 0x7fffffffffffffffL
965 };
966 static final long[] jjbitVec30 = {
967 0xfffe1fffffffffe0L, 0xffffffffffffffffL, 0xffffff00007fffL, 0x0L
968 };
969 static final long[] jjbitVec31 = {
970 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffffffL, 0x0L
971 };
972 static final long[] jjbitVec32 = {
973 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
974 };
975 static final long[] jjbitVec33 = {
976 0xffffffffffffffffL, 0xffffffffffffffffL, 0x1fffL, 0x0L
977 };
978 static final long[] jjbitVec34 = {
979 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
980 };
981 static final long[] jjbitVec35 = {
982 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
983 };
984 static final long[] jjbitVec36 = {
985 0x5f7ffdffa0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
986 };
987 static final long[] jjbitVec37 = {
988 0x3fffffffffffffffL, 0xffffffffffff0000L, 0xfffffffffffcffffL, 0xfff0000000000ffL
989 };
990 static final long[] jjbitVec38 = {
991 0x18000000000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x1fffffffffffffffL
992 };
993 static final long[] jjbitVec39 = {
994 0x87fffffe00000010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0x631cfcfcfcL
995 };
996 static final long[] jjbitVec40 = {
997 0x0L, 0x0L, 0x420043cffffffffL, 0xff7fffffff7fffffL
998 };
999 static final long[] jjbitVec41 = {
1000 0xffffffffffffffffL, 0x400000700007fffL, 0xfffffffbffffd740L, 0xffffffcff7fffL
1001 };
1002 static final long[] jjbitVec42 = {
1003 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffffff07bL, 0x33fffffffff199fL
1004 };
1005 static final long[] jjbitVec43 = {
1006 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe00ffL, 0x707ffffff0016L
1007 };
1008 static final long[] jjbitVec44 = {
1009 0x7fffffe00000000L, 0xffff03ff003fffffL, 0xffffffffffffffffL, 0x1fff3dff9fefffffL
1010 };
1011 static final long[] jjbitVec45 = {
1012 0xffff1fffffff8000L, 0x7ffL, 0x1ffffffffffffL, 0x0L
1013 };
1014 static final long[] jjbitVec46 = {
1015 0xf3ffffffffffffeeL, 0xffcfff1f3fffL, 0xd3c5fdfffff99feeL, 0xfffcfb080399fL
1016 };
1017 static final long[] jjbitVec47 = {
1018 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100013bbfL
1019 };
1020 static final long[] jjbitVec48 = {
1021 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
1022 };
1023 static final long[] jjbitVec49 = {
1024 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
1025 };
1026 static final long[] jjbitVec50 = {
1027 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x2ffbfffffc7fffecL, 0xc0000ff5f847fL
1028 };
1029 static final long[] jjbitVec51 = {
1030 0x87fffffffffffffeL, 0x3ff7fffL, 0x3bffecaefef02596L, 0x33ff3f5fL
1031 };
1032 static final long[] jjbitVec52 = {
1033 0xc2a003ff03000001L, 0xfffe07fffffffeffL, 0x1ffffffffeff0fdfL, 0x40L
1034 };
1035 static final long[] jjbitVec53 = {
1036 0x3c7f6fbffffffffL, 0x3ff03ffL, 0xffffffff00000000L, 0x7fffffffff003fL
1037 };
1038 static final long[] jjbitVec54 = {
1039 0xffffffff7f3d7fffL, 0x3fe0007ffff7fL, 0xffffffff00000000L, 0x1fffffffffffffL
1040 };
1041 static final long[] jjbitVec55 = {
1042 0x0L, 0x0L, 0xffffffffffffffffL, 0x3ff080fffffL
1043 };
1044 static final long[] jjbitVec56 = {
1045 0xffffffff03ff7800L, 0xffffffffffffffL, 0x3ffffffffffL, 0x0L
1046 };
1047 static final long[] jjbitVec57 = {
1048 0x80007c000000f000L, 0x8000fc0000000001L, 0xffff00000000L, 0x21fff0000L
1049 };
1050 static final long[] jjbitVec58 = {
1051 0x73efffe000000e0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x7fffffffffffffffL
1052 };
1053 static final long[] jjbitVec59 = {
1054 0x5f7ffdffe0f8007fL, 0xffffffffffffffdbL, 0x3ffffffffffffL, 0xfffffffffff80000L
1055 };
1056 static final long[] jjbitVec60 = {
1057 0x18000f00000000L, 0xffd702000000e000L, 0xffffffffffffffffL, 0x9fffffffffffffffL
1058 };
1059 static final long[] jjbitVec61 = {
1060 0x87fffffe03ff0010L, 0xffffffe007fffffeL, 0x7fffffffffffffffL, 0xe0000631cfcfcfcL
1061 };
1062 private final int jjMoveNfa_0(int startState, int curPos)
1063 {
1064 int[] nextStates;
1065 int startsAt = 0;
1066 jjnewStateCnt = 52;
1067 int i = 1;
1068 jjstateSet[0] = startState;
1069 int j, kind = 0x7fffffff;
1070 for (;;)
1071 {
1072 if (++jjround == 0x7fffffff)
1073 ReInitRounds();
1074 if (curChar < 64)
1075 {
1076 long l = 1L << curChar;
1077 MatchLoop: do
1078 {
1079 switch(jjstateSet[--i])
1080 {
1081 case 3:
1082 if ((0x3ff000000000000L & l) != 0L)
1083 jjCheckNAddStates(0, 6);
1084 else if (curChar == 36)
1085 {
1086 if (kind > 74)
1087 kind = 74;
1088 jjCheckNAdd(32);
1089 }
1090 else if (curChar == 34)
1091 jjCheckNAddStates(7, 9);
1092 else if (curChar == 39)
1093 jjAddStates(10, 11);
1094 else if (curChar == 46)
1095 jjCheckNAdd(8);
1096 else if (curChar == 47)
1097 jjstateSet[jjnewStateCnt++] = 2;
1098 if ((0x3fe000000000000L & l) != 0L)
1099 {
1100 if (kind > 66)
1101 kind = 66;
1102 jjCheckNAddTwoStates(5, 6);
1103 }
1104 else if (curChar == 48)
1105 {
1106 if (kind > 66)
1107 kind = 66;
1108 jjCheckNAddStates(12, 14);
1109 }
1110 break;
1111 case 0:
1112 if (curChar == 42)
1113 jjstateSet[jjnewStateCnt++] = 1;
1114 break;
1115 case 1:
1116 if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
1117 kind = 7;
1118 break;
1119 case 2:
1120 if (curChar == 42)
1121 jjstateSet[jjnewStateCnt++] = 0;
1122 break;
1123 case 4:
1124 if ((0x3fe000000000000L & l) == 0L)
1125 break;
1126 if (kind > 66)
1127 kind = 66;
1128 jjCheckNAddTwoStates(5, 6);
1129 break;
1130 case 5:
1131 if ((0x3ff000000000000L & l) == 0L)
1132 break;
1133 if (kind > 66)
1134 kind = 66;
1135 jjCheckNAddTwoStates(5, 6);
1136 break;
1137 case 7:
1138 if (curChar == 46)
1139 jjCheckNAdd(8);
1140 break;
1141 case 8:
1142 if ((0x3ff000000000000L & l) == 0L)
1143 break;
1144 if (kind > 70)
1145 kind = 70;
1146 jjCheckNAddStates(15, 17);
1147 break;
1148 case 10:
1149 if ((0x280000000000L & l) != 0L)
1150 jjCheckNAdd(11);
1151 break;
1152 case 11:
1153 if ((0x3ff000000000000L & l) == 0L)
1154 break;
1155 if (kind > 70)
1156 kind = 70;
1157 jjCheckNAddTwoStates(11, 12);
1158 break;
1159 case 13:
1160 if (curChar == 39)
1161 jjAddStates(10, 11);
1162 break;
1163 case 14:
1164 if ((0xffffff7fffffdbffL & l) != 0L)
1165 jjCheckNAdd(15);
1166 break;
1167 case 15:
1168 if (curChar == 39 && kind > 72)
1169 kind = 72;
1170 break;
1171 case 17:
1172 if ((0x8400000000L & l) != 0L)
1173 jjCheckNAdd(15);
1174 break;
1175 case 18:
1176 if ((0xff000000000000L & l) != 0L)
1177 jjCheckNAddTwoStates(19, 15);
1178 break;
1179 case 19:
1180 if ((0xff000000000000L & l) != 0L)
1181 jjCheckNAdd(15);
1182 break;
1183 case 20:
1184 if ((0xf000000000000L & l) != 0L)
1185 jjstateSet[jjnewStateCnt++] = 21;
1186 break;
1187 case 21:
1188 if ((0xff000000000000L & l) != 0L)
1189 jjCheckNAdd(19);
1190 break;
1191 case 22:
1192 if (curChar == 34)
1193 jjCheckNAddStates(7, 9);
1194 break;
1195 case 23:
1196 if ((0xfffffffbffffdbffL & l) != 0L)
1197 jjCheckNAddStates(7, 9);
1198 break;
1199 case 25:
1200 if ((0x8400000000L & l) != 0L)
1201 jjCheckNAddStates(7, 9);
1202 break;
1203 case 26:
1204 if (curChar == 34 && kind > 73)
1205 kind = 73;
1206 break;
1207 case 27:
1208 if ((0xff000000000000L & l) != 0L)
1209 jjCheckNAddStates(18, 21);
1210 break;
1211 case 28:
1212 if ((0xff000000000000L & l) != 0L)
1213 jjCheckNAddStates(7, 9);
1214 break;
1215 case 29:
1216 if ((0xf000000000000L & l) != 0L)
1217 jjstateSet[jjnewStateCnt++] = 30;
1218 break;
1219 case 30:
1220 if ((0xff000000000000L & l) != 0L)
1221 jjCheckNAdd(28);
1222 break;
1223 case 31:
1224 if (curChar != 36)
1225 break;
1226 if (kind > 74)
1227 kind = 74;
1228 jjCheckNAdd(32);
1229 break;
1230 case 32:
1231 if ((0x3ff00100fffc1ffL & l) == 0L)
1232 break;
1233 if (kind > 74)
1234 kind = 74;
1235 jjCheckNAdd(32);
1236 break;
1237 case 33:
1238 if ((0x3ff000000000000L & l) != 0L)
1239 jjCheckNAddStates(0, 6);
1240 break;
1241 case 34:
1242 if ((0x3ff000000000000L & l) != 0L)
1243 jjCheckNAddTwoStates(34, 35);
1244 break;
1245 case 35:
1246 if (curChar != 46)
1247 break;
1248 if (kind > 70)
1249 kind = 70;
1250 jjCheckNAddStates(22, 24);
1251 break;
1252 case 36:
1253 if ((0x3ff000000000000L & l) == 0L)
1254 break;
1255 if (kind > 70)
1256 kind = 70;
1257 jjCheckNAddStates(22, 24);
1258 break;
1259 case 38:
1260 if ((0x280000000000L & l) != 0L)
1261 jjCheckNAdd(39);
1262 break;
1263 case 39:
1264 if ((0x3ff000000000000L & l) == 0L)
1265 break;
1266 if (kind > 70)
1267 kind = 70;
1268 jjCheckNAddTwoStates(39, 12);
1269 break;
1270 case 40:
1271 if ((0x3ff000000000000L & l) != 0L)
1272 jjCheckNAddTwoStates(40, 41);
1273 break;
1274 case 42:
1275 if ((0x280000000000L & l) != 0L)
1276 jjCheckNAdd(43);
1277 break;
1278 case 43:
1279 if ((0x3ff000000000000L & l) == 0L)
1280 break;
1281 if (kind > 70)
1282 kind = 70;
1283 jjCheckNAddTwoStates(43, 12);
1284 break;
1285 case 44:
1286 if ((0x3ff000000000000L & l) != 0L)
1287 jjCheckNAddStates(25, 27);
1288 break;
1289 case 46:
1290 if ((0x280000000000L & l) != 0L)
1291 jjCheckNAdd(47);
1292 break;
1293 case 47:
1294 if ((0x3ff000000000000L & l) != 0L)
1295 jjCheckNAddTwoStates(47, 12);
1296 break;
1297 case 48:
1298 if (curChar != 48)
1299 break;
1300 if (kind > 66)
1301 kind = 66;
1302 jjCheckNAddStates(12, 14);
1303 break;
1304 case 50:
1305 if ((0x3ff000000000000L & l) == 0L)
1306 break;
1307 if (kind > 66)
1308 kind = 66;
1309 jjCheckNAddTwoStates(50, 6);
1310 break;
1311 case 51:
1312 if ((0xff000000000000L & l) == 0L)
1313 break;
1314 if (kind > 66)
1315 kind = 66;
1316 jjCheckNAddTwoStates(51, 6);
1317 break;
1318 default : break;
1319 }
1320 } while(i != startsAt);
1321 }
1322 else if (curChar < 128)
1323 {
1324 long l = 1L << (curChar & 077);
1325 MatchLoop: do
1326 {
1327 switch(jjstateSet[--i])
1328 {
1329 case 3:
1330 if ((0x7fffffe87fffffeL & l) == 0L)
1331 break;
1332 if (kind > 74)
1333 kind = 74;
1334 jjCheckNAdd(32);
1335 break;
1336 case 1:
1337 if (kind > 7)
1338 kind = 7;
1339 break;
1340 case 6:
1341 if ((0x100000001000L & l) != 0L && kind > 66)
1342 kind = 66;
1343 break;
1344 case 9:
1345 if ((0x2000000020L & l) != 0L)
1346 jjAddStates(28, 29);
1347 break;
1348 case 12:
1349 if ((0x5000000050L & l) != 0L && kind > 70)
1350 kind = 70;
1351 break;
1352 case 14:
1353 if ((0xffffffffefffffffL & l) != 0L)
1354 jjCheckNAdd(15);
1355 break;
1356 case 16:
1357 if (curChar == 92)
1358 jjAddStates(30, 32);
1359 break;
1360 case 17:
1361 if ((0x14404410000000L & l) != 0L)
1362 jjCheckNAdd(15);
1363 break;
1364 case 23:
1365 if ((0xffffffffefffffffL & l) != 0L)
1366 jjCheckNAddStates(7, 9);
1367 break;
1368 case 24:
1369 if (curChar == 92)
1370 jjAddStates(33, 35);
1371 break;
1372 case 25:
1373 if ((0x14404410000000L & l) != 0L)
1374 jjCheckNAddStates(7, 9);
1375 break;
1376 case 32:
1377 if ((0x87fffffe87fffffeL & l) == 0L)
1378 break;
1379 if (kind > 74)
1380 kind = 74;
1381 jjCheckNAdd(32);
1382 break;
1383 case 37:
1384 if ((0x2000000020L & l) != 0L)
1385 jjAddStates(36, 37);
1386 break;
1387 case 41:
1388 if ((0x2000000020L & l) != 0L)
1389 jjAddStates(38, 39);
1390 break;
1391 case 45:
1392 if ((0x2000000020L & l) != 0L)
1393 jjAddStates(40, 41);
1394 break;
1395 case 49:
1396 if ((0x100000001000000L & l) != 0L)
1397 jjCheckNAdd(50);
1398 break;
1399 case 50:
1400 if ((0x7e0000007eL & l) == 0L)
1401 break;
1402 if (kind > 66)
1403 kind = 66;
1404 jjCheckNAddTwoStates(50, 6);
1405 break;
1406 default : break;
1407 }
1408 } while(i != startsAt);
1409 }
1410 else
1411 {
1412 int hiByte = (int)(curChar >> 8);
1413 int i1 = hiByte >> 6;
1414 long l1 = 1L << (hiByte & 077);
1415 int i2 = (curChar & 0xff) >> 6;
1416 long l2 = 1L << (curChar & 077);
1417 MatchLoop: do
1418 {
1419 switch(jjstateSet[--i])
1420 {
1421 case 3:
1422 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1423 break;
1424 if (kind > 74)
1425 kind = 74;
1426 jjCheckNAdd(32);
1427 break;
1428 case 1:
1429 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 7)
1430 kind = 7;
1431 break;
1432 case 14:
1433 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1434 jjstateSet[jjnewStateCnt++] = 15;
1435 break;
1436 case 23:
1437 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1438 jjAddStates(7, 9);
1439 break;
1440 case 32:
1441 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1442 break;
1443 if (kind > 74)
1444 kind = 74;
1445 jjCheckNAdd(32);
1446 break;
1447 default : break;
1448 }
1449 } while(i != startsAt);
1450 }
1451 if (kind != 0x7fffffff)
1452 {
1453 jjmatchedKind = kind;
1454 jjmatchedPos = curPos;
1455 kind = 0x7fffffff;
1456 }
1457 ++curPos;
1458 if ((i = jjnewStateCnt) == (startsAt = 52 - (jjnewStateCnt = startsAt)))
1459 return curPos;
1460 try { curChar = input_stream.readChar(); }
1461 catch(java.io.IOException e) { return curPos; }
1462 }
1463 }
1464 private final int jjMoveStringLiteralDfa0_3()
1465 {
1466 switch(curChar)
1467 {
1468 case 42:
1469 return jjMoveStringLiteralDfa1_3(0x800L);
1470 default :
1471 return 1;
1472 }
1473 }
1474 private final int jjMoveStringLiteralDfa1_3(long active0)
1475 {
1476 try { curChar = input_stream.readChar(); }
1477 catch(java.io.IOException e) {
1478 return 1;
1479 }
1480 switch(curChar)
1481 {
1482 case 47:
1483 if ((active0 & 0x800L) != 0L)
1484 return jjStopAtPos(1, 11);
1485 break;
1486 default :
1487 return 2;
1488 }
1489 return 2;
1490 }
1491 private final int jjMoveStringLiteralDfa0_1()
1492 {
1493 return jjMoveNfa_1(0, 0);
1494 }
1495 private final int jjMoveNfa_1(int startState, int curPos)
1496 {
1497 int[] nextStates;
1498 int startsAt = 0;
1499 jjnewStateCnt = 3;
1500 int i = 1;
1501 jjstateSet[0] = startState;
1502 int j, kind = 0x7fffffff;
1503 for (;;)
1504 {
1505 if (++jjround == 0x7fffffff)
1506 ReInitRounds();
1507 if (curChar < 64)
1508 {
1509 long l = 1L << curChar;
1510 MatchLoop: do
1511 {
1512 switch(jjstateSet[--i])
1513 {
1514 case 0:
1515 if ((0x2400L & l) != 0L)
1516 {
1517 if (kind > 9)
1518 kind = 9;
1519 }
1520 if (curChar == 13)
1521 jjstateSet[jjnewStateCnt++] = 1;
1522 break;
1523 case 1:
1524 if (curChar == 10 && kind > 9)
1525 kind = 9;
1526 break;
1527 case 2:
1528 if (curChar == 13)
1529 jjstateSet[jjnewStateCnt++] = 1;
1530 break;
1531 default : break;
1532 }
1533 } while(i != startsAt);
1534 }
1535 else if (curChar < 128)
1536 {
1537 long l = 1L << (curChar & 077);
1538 MatchLoop: do
1539 {
1540 switch(jjstateSet[--i])
1541 {
1542 default : break;
1543 }
1544 } while(i != startsAt);
1545 }
1546 else
1547 {
1548 int hiByte = (int)(curChar >> 8);
1549 int i1 = hiByte >> 6;
1550 long l1 = 1L << (hiByte & 077);
1551 int i2 = (curChar & 0xff) >> 6;
1552 long l2 = 1L << (curChar & 077);
1553 MatchLoop: do
1554 {
1555 switch(jjstateSet[--i])
1556 {
1557 default : break;
1558 }
1559 } while(i != startsAt);
1560 }
1561 if (kind != 0x7fffffff)
1562 {
1563 jjmatchedKind = kind;
1564 jjmatchedPos = curPos;
1565 kind = 0x7fffffff;
1566 }
1567 ++curPos;
1568 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1569 return curPos;
1570 try { curChar = input_stream.readChar(); }
1571 catch(java.io.IOException e) { return curPos; }
1572 }
1573 }
1574 private final int jjMoveStringLiteralDfa0_2()
1575 {
1576 switch(curChar)
1577 {
1578 case 42:
1579 return jjMoveStringLiteralDfa1_2(0x400L);
1580 default :
1581 return 1;
1582 }
1583 }
1584 private final int jjMoveStringLiteralDfa1_2(long active0)
1585 {
1586 try { curChar = input_stream.readChar(); }
1587 catch(java.io.IOException e) {
1588 return 1;
1589 }
1590 switch(curChar)
1591 {
1592 case 47:
1593 if ((active0 & 0x400L) != 0L)
1594 return jjStopAtPos(1, 10);
1595 break;
1596 default :
1597 return 2;
1598 }
1599 return 2;
1600 }
1601 static final int[] jjnextStates = {
1602 34, 35, 40, 41, 44, 45, 12, 23, 24, 26, 14, 16, 49, 51, 6, 8,
1603 9, 12, 23, 24, 28, 26, 36, 37, 12, 44, 45, 12, 10, 11, 17, 18,
1604 20, 25, 27, 29, 38, 39, 42, 43, 46, 47,
1605 };
1606 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1607 {
1608 switch(hiByte)
1609 {
1610 case 0:
1611 return ((jjbitVec2[i2] & l2) != 0L);
1612 default :
1613 if ((jjbitVec0[i1] & l1) != 0L)
1614 return true;
1615 return false;
1616 }
1617 }
1618 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1619 {
1620 switch(hiByte)
1621 {
1622 case 0:
1623 return ((jjbitVec4[i2] & l2) != 0L);
1624 case 2:
1625 return ((jjbitVec5[i2] & l2) != 0L);
1626 case 3:
1627 return ((jjbitVec6[i2] & l2) != 0L);
1628 case 4:
1629 return ((jjbitVec7[i2] & l2) != 0L);
1630 case 5:
1631 return ((jjbitVec8[i2] & l2) != 0L);
1632 case 6:
1633 return ((jjbitVec9[i2] & l2) != 0L);
1634 case 7:
1635 return ((jjbitVec10[i2] & l2) != 0L);
1636 case 9:
1637 return ((jjbitVec11[i2] & l2) != 0L);
1638 case 10:
1639 return ((jjbitVec12[i2] & l2) != 0L);
1640 case 11:
1641 return ((jjbitVec13[i2] & l2) != 0L);
1642 case 12:
1643 return ((jjbitVec14[i2] & l2) != 0L);
1644 case 13:
1645 return ((jjbitVec15[i2] & l2) != 0L);
1646 case 14:
1647 return ((jjbitVec16[i2] & l2) != 0L);
1648 case 15:
1649 return ((jjbitVec17[i2] & l2) != 0L);
1650 case 16:
1651 return ((jjbitVec18[i2] & l2) != 0L);
1652 case 17:
1653 return ((jjbitVec19[i2] & l2) != 0L);
1654 case 18:
1655 return ((jjbitVec20[i2] & l2) != 0L);
1656 case 19:
1657 return ((jjbitVec21[i2] & l2) != 0L);
1658 case 20:
1659 return ((jjbitVec0[i2] & l2) != 0L);
1660 case 22:
1661 return ((jjbitVec22[i2] & l2) != 0L);
1662 case 23:
1663 return ((jjbitVec23[i2] & l2) != 0L);
1664 case 24:
1665 return ((jjbitVec24[i2] & l2) != 0L);
1666 case 30:
1667 return ((jjbitVec25[i2] & l2) != 0L);
1668 case 31:
1669 return ((jjbitVec26[i2] & l2) != 0L);
1670 case 32:
1671 return ((jjbitVec27[i2] & l2) != 0L);
1672 case 33:
1673 return ((jjbitVec28[i2] & l2) != 0L);
1674 case 48:
1675 return ((jjbitVec29[i2] & l2) != 0L);
1676 case 49:
1677 return ((jjbitVec30[i2] & l2) != 0L);
1678 case 77:
1679 return ((jjbitVec31[i2] & l2) != 0L);
1680 case 159:
1681 return ((jjbitVec32[i2] & l2) != 0L);
1682 case 164:
1683 return ((jjbitVec33[i2] & l2) != 0L);
1684 case 215:
1685 return ((jjbitVec34[i2] & l2) != 0L);
1686 case 250:
1687 return ((jjbitVec35[i2] & l2) != 0L);
1688 case 251:
1689 return ((jjbitVec36[i2] & l2) != 0L);
1690 case 253:
1691 return ((jjbitVec37[i2] & l2) != 0L);
1692 case 254:
1693 return ((jjbitVec38[i2] & l2) != 0L);
1694 case 255:
1695 return ((jjbitVec39[i2] & l2) != 0L);
1696 default :
1697 if ((jjbitVec3[i1] & l1) != 0L)
1698 return true;
1699 return false;
1700 }
1701 }
1702 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1703 {
1704 switch(hiByte)
1705 {
1706 case 0:
1707 return ((jjbitVec40[i2] & l2) != 0L);
1708 case 2:
1709 return ((jjbitVec5[i2] & l2) != 0L);
1710 case 3:
1711 return ((jjbitVec41[i2] & l2) != 0L);
1712 case 4:
1713 return ((jjbitVec42[i2] & l2) != 0L);
1714 case 5:
1715 return ((jjbitVec43[i2] & l2) != 0L);
1716 case 6:
1717 return ((jjbitVec44[i2] & l2) != 0L);
1718 case 7:
1719 return ((jjbitVec45[i2] & l2) != 0L);
1720 case 9:
1721 return ((jjbitVec46[i2] & l2) != 0L);
1722 case 10:
1723 return ((jjbitVec47[i2] & l2) != 0L);
1724 case 11:
1725 return ((jjbitVec48[i2] & l2) != 0L);
1726 case 12:
1727 return ((jjbitVec49[i2] & l2) != 0L);
1728 case 13:
1729 return ((jjbitVec50[i2] & l2) != 0L);
1730 case 14:
1731 return ((jjbitVec51[i2] & l2) != 0L);
1732 case 15:
1733 return ((jjbitVec52[i2] & l2) != 0L);
1734 case 16:
1735 return ((jjbitVec53[i2] & l2) != 0L);
1736 case 17:
1737 return ((jjbitVec19[i2] & l2) != 0L);
1738 case 18:
1739 return ((jjbitVec20[i2] & l2) != 0L);
1740 case 19:
1741 return ((jjbitVec54[i2] & l2) != 0L);
1742 case 20:
1743 return ((jjbitVec0[i2] & l2) != 0L);
1744 case 22:
1745 return ((jjbitVec22[i2] & l2) != 0L);
1746 case 23:
1747 return ((jjbitVec55[i2] & l2) != 0L);
1748 case 24:
1749 return ((jjbitVec56[i2] & l2) != 0L);
1750 case 30:
1751 return ((jjbitVec25[i2] & l2) != 0L);
1752 case 31:
1753 return ((jjbitVec26[i2] & l2) != 0L);
1754 case 32:
1755 return ((jjbitVec57[i2] & l2) != 0L);
1756 case 33:
1757 return ((jjbitVec28[i2] & l2) != 0L);
1758 case 48:
1759 return ((jjbitVec58[i2] & l2) != 0L);
1760 case 49:
1761 return ((jjbitVec30[i2] & l2) != 0L);
1762 case 77:
1763 return ((jjbitVec31[i2] & l2) != 0L);
1764 case 159:
1765 return ((jjbitVec32[i2] & l2) != 0L);
1766 case 164:
1767 return ((jjbitVec33[i2] & l2) != 0L);
1768 case 215:
1769 return ((jjbitVec34[i2] & l2) != 0L);
1770 case 250:
1771 return ((jjbitVec35[i2] & l2) != 0L);
1772 case 251:
1773 return ((jjbitVec59[i2] & l2) != 0L);
1774 case 253:
1775 return ((jjbitVec37[i2] & l2) != 0L);
1776 case 254:
1777 return ((jjbitVec60[i2] & l2) != 0L);
1778 case 255:
1779 return ((jjbitVec61[i2] & l2) != 0L);
1780 default :
1781 if ((jjbitVec3[i1] & l1) != 0L)
1782 return true;
1783 return false;
1784 }
1785 }
1786 public static final String[] jjstrLiteralImages = {
1787 "", null, null, null, null, null, null, null, null, null, null, null, null,
1788 "\141\142\163\164\162\141\143\164", "\141\163\163\145\162\164", "\142\157\157\154\145\141\156",
1789 "\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150",
1790 "\143\150\141\162", "\143\154\141\163\163", "\143\157\156\163\164",
1791 "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145",
1792 "\145\154\163\145", "\145\156\165\155", "\145\170\164\145\156\144\163", "\146\141\154\163\145",
1793 "\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162",
1794 "\147\157\164\157", "\151\146", "\151\155\160\154\145\155\145\156\164\163",
1795 "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
1796 "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145", "\156\145\167",
1797 "\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145",
1798 "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156",
1799 "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160",
1800 "\163\165\160\145\162", "\163\167\151\164\143\150",
1801 "\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", "\164\150\162\157\167", "\164\150\162\157\167\163",
1802 "\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171", "\166\157\151\144",
1803 "\166\157\154\141\164\151\154\145", "\167\150\151\154\145", null, null, null, null, null, null, null, null, null,
1804 null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56",
1805 "\100", "\75", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", "\76\75",
1806 "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", "\57", "\46",
1807 "\174", "\136", "\45", "\74\74", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75",
1808 "\174\75", "\136\75", "\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75", "\56\56\56",
1809 "\76\76\76", "\76\76", "\76", };
1810 public static final String[] lexStateNames = {
1811 "DEFAULT",
1812 "IN_SINGLE_LINE_COMMENT",
1813 "IN_FORMAL_COMMENT",
1814 "IN_MULTI_LINE_COMMENT",
1815 };
1816 public static final int[] jjnewLexState = {
1817 -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1818 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1819 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1820 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1821 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1822 };
1823 static final long[] jjtoToken = {
1824 0xffffffffffffe001L, 0x1fffffffffffe747L,
1825 };
1826 static final long[] jjtoSkip = {
1827 0xe3eL, 0x0L,
1828 };
1829 static final long[] jjtoSpecial = {
1830 0xe00L, 0x0L,
1831 };
1832 static final long[] jjtoMore = {
1833 0x11c0L, 0x0L,
1834 };
1835 protected JavaCharStream input_stream;
1836 private final int[] jjrounds = new int[52];
1837 private final int[] jjstateSet = new int[104];
1838 StringBuffer image;
1839 int jjimageLen;
1840 int lengthOfMatch;
1841 protected char curChar;
1842 public JavaParserTokenManager(JavaCharStream stream)
1843 {
1844 if (JavaCharStream.staticFlag)
1845 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1846 input_stream = stream;
1847 }
1848 public JavaParserTokenManager(JavaCharStream stream, int lexState)
1849 {
1850 this(stream);
1851 SwitchTo(lexState);
1852 }
1853 public void ReInit(JavaCharStream stream)
1854 {
1855 jjmatchedPos = jjnewStateCnt = 0;
1856 curLexState = defaultLexState;
1857 input_stream = stream;
1858 ReInitRounds();
1859 }
1860 private final void ReInitRounds()
1861 {
1862 int i;
1863 jjround = 0x80000001;
1864 for (i = 52; i-- > 0;)
1865 jjrounds[i] = 0x80000000;
1866 }
1867 public void ReInit(JavaCharStream stream, int lexState)
1868 {
1869 ReInit(stream);
1870 SwitchTo(lexState);
1871 }
1872 public void SwitchTo(int lexState)
1873 {
1874 if (lexState >= 4 || lexState < 0)
1875 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1876 else
1877 curLexState = lexState;
1878 }
1879
1880 protected Token jjFillToken()
1881 {
1882 Token t = Token.newToken(jjmatchedKind);
1883 t.kind = jjmatchedKind;
1884 String im = jjstrLiteralImages[jjmatchedKind];
1885 t.image = (im == null) ? input_stream.GetImage() : im;
1886 t.beginLine = input_stream.getBeginLine();
1887 t.beginColumn = input_stream.getBeginColumn();
1888 t.endLine = input_stream.getEndLine();
1889 t.endColumn = input_stream.getEndColumn();
1890 return t;
1891 }
1892
1893 int curLexState = 0;
1894 int defaultLexState = 0;
1895 int jjnewStateCnt;
1896 int jjround;
1897 int jjmatchedPos;
1898 int jjmatchedKind;
1899
1900 public Token getNextToken()
1901 {
1902 int kind;
1903 Token specialToken = null;
1904 Token matchedToken;
1905 int curPos = 0;
1906
1907 EOFLoop :
1908 for (;;)
1909 {
1910 try
1911 {
1912 curChar = input_stream.BeginToken();
1913 }
1914 catch(java.io.IOException e)
1915 {
1916 jjmatchedKind = 0;
1917 matchedToken = jjFillToken();
1918 matchedToken.specialToken = specialToken;
1919 return matchedToken;
1920 }
1921 image = null;
1922 jjimageLen = 0;
1923
1924 for (;;)
1925 {
1926 switch(curLexState)
1927 {
1928 case 0:
1929 try { input_stream.backup(0);
1930 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
1931 curChar = input_stream.BeginToken();
1932 }
1933 catch (java.io.IOException e1) { continue EOFLoop; }
1934 jjmatchedKind = 0x7fffffff;
1935 jjmatchedPos = 0;
1936 curPos = jjMoveStringLiteralDfa0_0();
1937 break;
1938 case 1:
1939 jjmatchedKind = 0x7fffffff;
1940 jjmatchedPos = 0;
1941 curPos = jjMoveStringLiteralDfa0_1();
1942 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1943 {
1944 jjmatchedKind = 12;
1945 }
1946 break;
1947 case 2:
1948 jjmatchedKind = 0x7fffffff;
1949 jjmatchedPos = 0;
1950 curPos = jjMoveStringLiteralDfa0_2();
1951 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1952 {
1953 jjmatchedKind = 12;
1954 }
1955 break;
1956 case 3:
1957 jjmatchedKind = 0x7fffffff;
1958 jjmatchedPos = 0;
1959 curPos = jjMoveStringLiteralDfa0_3();
1960 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1961 {
1962 jjmatchedKind = 12;
1963 }
1964 break;
1965 }
1966 if (jjmatchedKind != 0x7fffffff)
1967 {
1968 if (jjmatchedPos + 1 < curPos)
1969 input_stream.backup(curPos - jjmatchedPos - 1);
1970 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1971 {
1972 matchedToken = jjFillToken();
1973 matchedToken.specialToken = specialToken;
1974 TokenLexicalActions(matchedToken);
1975 if (jjnewLexState[jjmatchedKind] != -1)
1976 curLexState = jjnewLexState[jjmatchedKind];
1977 return matchedToken;
1978 }
1979 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1980 {
1981 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1982 {
1983 matchedToken = jjFillToken();
1984 if (specialToken == null)
1985 specialToken = matchedToken;
1986 else
1987 {
1988 matchedToken.specialToken = specialToken;
1989 specialToken = (specialToken.next = matchedToken);
1990 }
1991 SkipLexicalActions(matchedToken);
1992 }
1993 else
1994 SkipLexicalActions(null);
1995 if (jjnewLexState[jjmatchedKind] != -1)
1996 curLexState = jjnewLexState[jjmatchedKind];
1997 continue EOFLoop;
1998 }
1999 MoreLexicalActions();
2000 if (jjnewLexState[jjmatchedKind] != -1)
2001 curLexState = jjnewLexState[jjmatchedKind];
2002 curPos = 0;
2003 jjmatchedKind = 0x7fffffff;
2004 try {
2005 curChar = input_stream.readChar();
2006 continue;
2007 }
2008 catch (java.io.IOException e1) { }
2009 }
2010 int error_line = input_stream.getEndLine();
2011 int error_column = input_stream.getEndColumn();
2012 String error_after = null;
2013 boolean EOFSeen = false;
2014 try { input_stream.readChar(); input_stream.backup(1); }
2015 catch (java.io.IOException e1) {
2016 EOFSeen = true;
2017 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2018 if (curChar == '\n' || curChar == '\r') {
2019 error_line++;
2020 error_column = 0;
2021 }
2022 else
2023 error_column++;
2024 }
2025 if (!EOFSeen) {
2026 input_stream.backup(1);
2027 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2028 }
2029 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2030 }
2031 }
2032 }
2033
2034 void SkipLexicalActions(Token matchedToken)
2035 {
2036 switch(jjmatchedKind)
2037 {
2038 default :
2039 break;
2040 }
2041 }
2042 void MoreLexicalActions()
2043 {
2044 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2045 switch(jjmatchedKind)
2046 {
2047 case 7 :
2048 if (image == null)
2049 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
2050 else
2051 image.append(input_stream.GetSuffix(jjimageLen));
2052 jjimageLen = 0;
2053 input_stream.backup(1);
2054 break;
2055 default :
2056 break;
2057 }
2058 }
2059 void TokenLexicalActions(Token matchedToken)
2060 {
2061 switch(jjmatchedKind)
2062 {
2063 case 122 :
2064 if (image == null)
2065 image = new StringBuffer(jjstrLiteralImages[122]);
2066 else
2067 image.append(jjstrLiteralImages[122]);
2068 matchedToken.kind = GT;
2069 ((Token.GTToken)matchedToken).realKind = RUNSIGNEDSHIFT;
2070 input_stream.backup(2);
2071 break;
2072 case 123 :
2073 if (image == null)
2074 image = new StringBuffer(jjstrLiteralImages[123]);
2075 else
2076 image.append(jjstrLiteralImages[123]);
2077 matchedToken.kind = GT;
2078 ((Token.GTToken)matchedToken).realKind = RSIGNEDSHIFT;
2079 input_stream.backup(1);
2080 break;
2081 default :
2082 break;
2083 }
2084 }
2085 }