001 /* Generated By:JavaCC: Do not edit this line. JavaParserTokenManager.java */
002
003 /*
004 * Cobertura - http://cobertura.sourceforge.net/
005 *
006 * This file was taken from JavaNCSS
007 * http://www.kclee.com/clemens/java/javancss/
008 * Copyright (C) 2000 Chr. Clemens Lee <clemens a.t kclee d.o.t com>
009 *
010 * Cobertura is free software; you can redistribute it and/or modify
011 * it under the terms of the GNU General Public License as published
012 * by the Free Software Foundation; either version 2 of the License,
013 * or (at your option) any later version.
014 *
015 * Cobertura is distributed in the hope that it will be useful, but
016 * WITHOUT ANY WARRANTY; without even the implied warranty of
017 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
018 * General Public License for more details.
019 *
020 * You should have received a copy of the GNU General Public License
021 * along with Cobertura; if not, write to the Free Software
022 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
023 * USA
024 */
025 package net.sourceforge.cobertura.javancss;
026
027 public class JavaParserTokenManager implements JavaParserConstants
028 {
029 // added by SMS
030
031 static int _iSingleComments = 0;
032 static int _iMultiComments = 0;
033 static int _iFormalComments = 0;
034
035 static int _iMultiCommentsLast = 0;
036 private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
037 {
038 switch (pos)
039 {
040 case 0:
041 if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x3L) != 0L)
042 {
043 jjmatchedKind = 74;
044 return 28;
045 }
046 if ((active1 & 0x1000000000200000L) != 0L)
047 return 4;
048 return -1;
049 case 1:
050 if ((active0 & 0x1006000000L) != 0L)
051 return 28;
052 if ((active0 & 0xffffffeff9ffe000L) != 0L || (active1 & 0x3L) != 0L)
053 {
054 if (jjmatchedPos != 1)
055 {
056 jjmatchedKind = 74;
057 jjmatchedPos = 1;
058 }
059 return 28;
060 }
061 return -1;
062 case 2:
063 if ((active0 & 0x4000130400000000L) != 0L)
064 return 28;
065 if ((active0 & 0xbfffecebfdffe000L) != 0L || (active1 & 0x3L) != 0L)
066 {
067 if (jjmatchedPos != 2)
068 {
069 jjmatchedKind = 74;
070 jjmatchedPos = 2;
071 }
072 return 28;
073 }
074 return -1;
075 case 3:
076 if ((active0 & 0x1dffcae3e5e9e000L) != 0L || (active1 & 0x3L) != 0L)
077 {
078 jjmatchedKind = 74;
079 jjmatchedPos = 3;
080 return 28;
081 }
082 if ((active0 & 0xa200240818160000L) != 0L)
083 return 28;
084 return -1;
085 case 4:
086 if ((active0 & 0xc480003c0690000L) != 0L || (active1 & 0x2L) != 0L)
087 return 28;
088 if ((active0 & 0x11b7cae02580e000L) != 0L || (active1 & 0x1L) != 0L)
089 {
090 if (jjmatchedPos != 4)
091 {
092 jjmatchedKind = 74;
093 jjmatchedPos = 4;
094 }
095 return 28;
096 }
097 return -1;
098 case 5:
099 if ((active0 & 0x896084004004000L) != 0L)
100 return 28;
101 if ((active0 & 0x1121c2a12180a000L) != 0L || (active1 & 0x1L) != 0L)
102 {
103 jjmatchedKind = 74;
104 jjmatchedPos = 5;
105 return 28;
106 }
107 return -1;
108 case 6:
109 if ((active0 & 0xc00121008000L) != 0L)
110 return 28;
111 if ((active0 & 0x112102a000802000L) != 0L || (active1 & 0x1L) != 0L)
112 {
113 jjmatchedKind = 74;
114 jjmatchedPos = 6;
115 return 28;
116 }
117 return -1;
118 case 7:
119 if ((active0 & 0x20000000802000L) != 0L || (active1 & 0x1L) != 0L)
120 return 28;
121 if ((active0 & 0x110102a000000000L) != 0L)
122 {
123 jjmatchedKind = 74;
124 jjmatchedPos = 7;
125 return 28;
126 }
127 return -1;
128 case 8:
129 if ((active0 & 0x1001020000000000L) != 0L)
130 return 28;
131 if ((active0 & 0x10000a000000000L) != 0L)
132 {
133 jjmatchedKind = 74;
134 jjmatchedPos = 8;
135 return 28;
136 }
137 return -1;
138 case 9:
139 if ((active0 & 0xa000000000L) != 0L)
140 return 28;
141 if ((active0 & 0x100000000000000L) != 0L)
142 {
143 jjmatchedKind = 74;
144 jjmatchedPos = 9;
145 return 28;
146 }
147 return -1;
148 case 10:
149 if ((active0 & 0x100000000000000L) != 0L)
150 {
151 jjmatchedKind = 74;
152 jjmatchedPos = 10;
153 return 28;
154 }
155 return -1;
156 default :
157 return -1;
158 }
159 }
160 private final int jjStartNfa_0(int pos, long active0, long active1)
161 {
162 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
163 }
164 private final int jjStopAtPos(int pos, int kind)
165 {
166 jjmatchedKind = kind;
167 jjmatchedPos = pos;
168 return pos + 1;
169 }
170 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
171 {
172 jjmatchedKind = kind;
173 jjmatchedPos = pos;
174 try { curChar = input_stream.readChar(); }
175 catch(java.io.IOException e) { return pos + 1; }
176 return jjMoveNfa_0(state, pos + 1);
177 }
178 private final int jjMoveStringLiteralDfa0_0()
179 {
180 switch(curChar)
181 {
182 case 33:
183 jjmatchedKind = 90;
184 return jjMoveStringLiteralDfa1_0(0x0L, 0x200000000L);
185 case 37:
186 jjmatchedKind = 109;
187 return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000000L);
188 case 38:
189 jjmatchedKind = 106;
190 return jjMoveStringLiteralDfa1_0(0x0L, 0x20000800000000L);
191 case 40:
192 return jjStopAtPos(0, 77);
193 case 41:
194 return jjStopAtPos(0, 78);
195 case 42:
196 jjmatchedKind = 104;
197 return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000000000L);
198 case 43:
199 jjmatchedKind = 102;
200 return jjMoveStringLiteralDfa1_0(0x0L, 0x2001000000000L);
201 case 44:
202 return jjStopAtPos(0, 84);
203 case 45:
204 jjmatchedKind = 103;
205 return jjMoveStringLiteralDfa1_0(0x0L, 0x4002000000000L);
206 case 46:
207 jjmatchedKind = 85;
208 return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000000L);
209 case 47:
210 jjmatchedKind = 105;
211 return jjMoveStringLiteralDfa1_0(0x180L, 0x10000000000000L);
212 case 58:
213 return jjStopAtPos(0, 93);
214 case 59:
215 return jjStopAtPos(0, 83);
216 case 60:
217 jjmatchedKind = 89;
218 return jjMoveStringLiteralDfa1_0(0x0L, 0x200400080000000L);
219 case 61:
220 jjmatchedKind = 87;
221 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000L);
222 case 62:
223 jjmatchedKind = 88;
224 return jjMoveStringLiteralDfa1_0(0x0L, 0xc01800100000000L);
225 case 63:
226 return jjStopAtPos(0, 92);
227 case 64:
228 return jjStopAtPos(0, 86);
229 case 91:
230 return jjStopAtPos(0, 81);
231 case 93:
232 return jjStopAtPos(0, 82);
233 case 94:
234 jjmatchedKind = 108;
235 return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000000000L);
236 case 97:
237 return jjMoveStringLiteralDfa1_0(0x6000L, 0x0L);
238 case 98:
239 return jjMoveStringLiteralDfa1_0(0x38000L, 0x0L);
240 case 99:
241 return jjMoveStringLiteralDfa1_0(0xfc0000L, 0x0L);
242 case 100:
243 return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L);
244 case 101:
245 return jjMoveStringLiteralDfa1_0(0x38000000L, 0x0L);
246 case 102:
247 return jjMoveStringLiteralDfa1_0(0x7c0000000L, 0x0L);
248 case 103:
249 return jjMoveStringLiteralDfa1_0(0x800000000L, 0x0L);
250 case 105:
251 return jjMoveStringLiteralDfa1_0(0x3f000000000L, 0x0L);
252 case 108:
253 return jjMoveStringLiteralDfa1_0(0x40000000000L, 0x0L);
254 case 110:
255 return jjMoveStringLiteralDfa1_0(0x380000000000L, 0x0L);
256 case 112:
257 return jjMoveStringLiteralDfa1_0(0x3c00000000000L, 0x0L);
258 case 114:
259 return jjMoveStringLiteralDfa1_0(0x4000000000000L, 0x0L);
260 case 115:
261 return jjMoveStringLiteralDfa1_0(0x1f8000000000000L, 0x0L);
262 case 116:
263 return jjMoveStringLiteralDfa1_0(0x7e00000000000000L, 0x0L);
264 case 118:
265 return jjMoveStringLiteralDfa1_0(0x8000000000000000L, 0x1L);
266 case 119:
267 return jjMoveStringLiteralDfa1_0(0x0L, 0x2L);
268 case 123:
269 return jjStopAtPos(0, 79);
270 case 124:
271 jjmatchedKind = 107;
272 return jjMoveStringLiteralDfa1_0(0x0L, 0x40000400000000L);
273 case 125:
274 return jjStopAtPos(0, 80);
275 case 126:
276 return jjStopAtPos(0, 91);
277 default :
278 return jjMoveNfa_0(0, 0);
279 }
280 }
281 private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
282 {
283 try { curChar = input_stream.readChar(); }
284 catch(java.io.IOException e) {
285 jjStopStringLiteralDfa_0(0, active0, active1);
286 return 1;
287 }
288 switch(curChar)
289 {
290 case 38:
291 if ((active1 & 0x800000000L) != 0L)
292 return jjStopAtPos(1, 99);
293 break;
294 case 42:
295 if ((active0 & 0x80L) != 0L)
296 return jjStopAtPos(1, 7);
297 break;
298 case 43:
299 if ((active1 & 0x1000000000L) != 0L)
300 return jjStopAtPos(1, 100);
301 break;
302 case 45:
303 if ((active1 & 0x2000000000L) != 0L)
304 return jjStopAtPos(1, 101);
305 break;
306 case 46:
307 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x1000000000000000L);
308 case 47:
309 if ((active0 & 0x100L) != 0L)
310 return jjStopAtPos(1, 8);
311 break;
312 case 60:
313 if ((active1 & 0x400000000000L) != 0L)
314 {
315 jjmatchedKind = 110;
316 jjmatchedPos = 1;
317 }
318 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x200000000000000L);
319 case 61:
320 if ((active1 & 0x40000000L) != 0L)
321 return jjStopAtPos(1, 94);
322 else if ((active1 & 0x80000000L) != 0L)
323 return jjStopAtPos(1, 95);
324 else if ((active1 & 0x100000000L) != 0L)
325 return jjStopAtPos(1, 96);
326 else if ((active1 & 0x200000000L) != 0L)
327 return jjStopAtPos(1, 97);
328 else if ((active1 & 0x2000000000000L) != 0L)
329 return jjStopAtPos(1, 113);
330 else if ((active1 & 0x4000000000000L) != 0L)
331 return jjStopAtPos(1, 114);
332 else if ((active1 & 0x8000000000000L) != 0L)
333 return jjStopAtPos(1, 115);
334 else if ((active1 & 0x10000000000000L) != 0L)
335 return jjStopAtPos(1, 116);
336 else if ((active1 & 0x20000000000000L) != 0L)
337 return jjStopAtPos(1, 117);
338 else if ((active1 & 0x40000000000000L) != 0L)
339 return jjStopAtPos(1, 118);
340 else if ((active1 & 0x80000000000000L) != 0L)
341 return jjStopAtPos(1, 119);
342 else if ((active1 & 0x100000000000000L) != 0L)
343 return jjStopAtPos(1, 120);
344 break;
345 case 62:
346 if ((active1 & 0x800000000000L) != 0L)
347 {
348 jjmatchedKind = 111;
349 jjmatchedPos = 1;
350 }
351 return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0xc01000000000000L);
352 case 97:
353 return jjMoveStringLiteralDfa2_0(active0, 0x4800400c0000L, active1, 0L);
354 case 98:
355 return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L);
356 case 101:
357 return jjMoveStringLiteralDfa2_0(active0, 0x4100001000000L, active1, 0L);
358 case 102:
359 if ((active0 & 0x1000000000L) != 0L)
360 return jjStartNfaWithStates_0(1, 36, 28);
361 break;
362 case 104:
363 return jjMoveStringLiteralDfa2_0(active0, 0xe08000000100000L, active1, 0x2L);
364 case 105:
365 return jjMoveStringLiteralDfa2_0(active0, 0x180000000L, active1, 0L);
366 case 108:
367 return jjMoveStringLiteralDfa2_0(active0, 0x208200000L, active1, 0L);
368 case 109:
369 return jjMoveStringLiteralDfa2_0(active0, 0x6000000000L, active1, 0L);
370 case 110:
371 return jjMoveStringLiteralDfa2_0(active0, 0x38010000000L, active1, 0L);
372 case 111:
373 if ((active0 & 0x2000000L) != 0L)
374 {
375 jjmatchedKind = 25;
376 jjmatchedPos = 1;
377 }
378 return jjMoveStringLiteralDfa2_0(active0, 0x8000040c04c08000L, active1, 0x1L);
379 case 114:
380 return jjMoveStringLiteralDfa2_0(active0, 0x7001800000010000L, active1, 0L);
381 case 115:
382 return jjMoveStringLiteralDfa2_0(active0, 0x4000L, active1, 0L);
383 case 116:
384 return jjMoveStringLiteralDfa2_0(active0, 0x30000000000000L, active1, 0L);
385 case 117:
386 return jjMoveStringLiteralDfa2_0(active0, 0x42200000000000L, active1, 0L);
387 case 119:
388 return jjMoveStringLiteralDfa2_0(active0, 0x80000000000000L, active1, 0L);
389 case 120:
390 return jjMoveStringLiteralDfa2_0(active0, 0x20000000L, active1, 0L);
391 case 121:
392 return jjMoveStringLiteralDfa2_0(active0, 0x100000000020000L, active1, 0L);
393 case 124:
394 if ((active1 & 0x400000000L) != 0L)
395 return jjStopAtPos(1, 98);
396 break;
397 default :
398 break;
399 }
400 return jjStartNfa_0(0, active0, active1);
401 }
402 private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
403 {
404 if (((active0 &= old0) | (active1 &= old1)) == 0L)
405 return jjStartNfa_0(0, old0, old1);
406 try { curChar = input_stream.readChar(); }
407 catch(java.io.IOException e) {
408 jjStopStringLiteralDfa_0(1, active0, active1);
409 return 2;
410 }
411 switch(curChar)
412 {
413 case 46:
414 if ((active1 & 0x1000000000000000L) != 0L)
415 return jjStopAtPos(2, 124);
416 break;
417 case 61:
418 if ((active1 & 0x200000000000000L) != 0L)
419 return jjStopAtPos(2, 121);
420 else if ((active1 & 0x400000000000000L) != 0L)
421 return jjStopAtPos(2, 122);
422 break;
423 case 62:
424 if ((active1 & 0x1000000000000L) != 0L)
425 {
426 jjmatchedKind = 112;
427 jjmatchedPos = 2;
428 }
429 return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x800000000000000L);
430 case 97:
431 return jjMoveStringLiteralDfa3_0(active0, 0x1010000000300000L, active1, 0L);
432 case 98:
433 return jjMoveStringLiteralDfa3_0(active0, 0x2000000000000L, active1, 0L);
434 case 99:
435 return jjMoveStringLiteralDfa3_0(active0, 0x400000000000L, active1, 0L);
436 case 101:
437 return jjMoveStringLiteralDfa3_0(active0, 0x10000L, active1, 0L);
438 case 102:
439 return jjMoveStringLiteralDfa3_0(active0, 0x1000000L, active1, 0L);
440 case 105:
441 return jjMoveStringLiteralDfa3_0(active0, 0x8280800000000000L, active1, 0x2L);
442 case 108:
443 return jjMoveStringLiteralDfa3_0(active0, 0x200040000000L, active1, 0x1L);
444 case 110:
445 return jjMoveStringLiteralDfa3_0(active0, 0x100040180c00000L, active1, 0L);
446 case 111:
447 return jjMoveStringLiteralDfa3_0(active0, 0x9000200008000L, active1, 0L);
448 case 112:
449 return jjMoveStringLiteralDfa3_0(active0, 0x40006000000000L, active1, 0L);
450 case 114:
451 if ((active0 & 0x400000000L) != 0L)
452 return jjStartNfaWithStates_0(2, 34, 28);
453 return jjMoveStringLiteralDfa3_0(active0, 0xc20000000000000L, active1, 0L);
454 case 115:
455 return jjMoveStringLiteralDfa3_0(active0, 0x8008046000L, active1, 0L);
456 case 116:
457 if ((active0 & 0x10000000000L) != 0L)
458 {
459 jjmatchedKind = 40;
460 jjmatchedPos = 2;
461 }
462 return jjMoveStringLiteralDfa3_0(active0, 0x40a08200a0000L, active1, 0L);
463 case 117:
464 return jjMoveStringLiteralDfa3_0(active0, 0x2000000014000000L, active1, 0L);
465 case 119:
466 if ((active0 & 0x100000000000L) != 0L)
467 return jjStartNfaWithStates_0(2, 44, 28);
468 break;
469 case 121:
470 if ((active0 & 0x4000000000000000L) != 0L)
471 return jjStartNfaWithStates_0(2, 62, 28);
472 break;
473 default :
474 break;
475 }
476 return jjStartNfa_0(1, active0, active1);
477 }
478 private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
479 {
480 if (((active0 &= old0) | (active1 &= old1)) == 0L)
481 return jjStartNfa_0(1, old0, old1);
482 try { curChar = input_stream.readChar(); }
483 catch(java.io.IOException e) {
484 jjStopStringLiteralDfa_0(2, active0, active1);
485 return 3;
486 }
487 switch(curChar)
488 {
489 case 61:
490 if ((active1 & 0x800000000000000L) != 0L)
491 return jjStopAtPos(3, 123);
492 break;
493 case 97:
494 return jjMoveStringLiteralDfa4_0(active0, 0x381010000L, active1, 0x1L);
495 case 98:
496 return jjMoveStringLiteralDfa4_0(active0, 0x4000000L, active1, 0L);
497 case 99:
498 return jjMoveStringLiteralDfa4_0(active0, 0x100000000080000L, active1, 0L);
499 case 100:
500 if ((active0 & 0x8000000000000000L) != 0L)
501 return jjStartNfaWithStates_0(3, 63, 28);
502 break;
503 case 101:
504 if ((active0 & 0x20000L) != 0L)
505 return jjStartNfaWithStates_0(3, 17, 28);
506 else if ((active0 & 0x40000L) != 0L)
507 return jjStartNfaWithStates_0(3, 18, 28);
508 else if ((active0 & 0x8000000L) != 0L)
509 return jjStartNfaWithStates_0(3, 27, 28);
510 else if ((active0 & 0x2000000000000000L) != 0L)
511 return jjStartNfaWithStates_0(3, 61, 28);
512 return jjMoveStringLiteralDfa4_0(active0, 0x40020020004000L, active1, 0L);
513 case 103:
514 if ((active0 & 0x40000000000L) != 0L)
515 return jjStartNfaWithStates_0(3, 42, 28);
516 break;
517 case 105:
518 return jjMoveStringLiteralDfa4_0(active0, 0x20080000000000L, active1, 0L);
519 case 107:
520 return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L);
521 case 108:
522 if ((active0 & 0x200000000000L) != 0L)
523 return jjStartNfaWithStates_0(3, 45, 28);
524 return jjMoveStringLiteralDfa4_0(active0, 0x2002000008000L, active1, 0x2L);
525 case 109:
526 if ((active0 & 0x10000000L) != 0L)
527 return jjStartNfaWithStates_0(3, 28, 28);
528 break;
529 case 110:
530 return jjMoveStringLiteralDfa4_0(active0, 0x1000000000000000L, active1, 0L);
531 case 111:
532 if ((active0 & 0x800000000L) != 0L)
533 return jjStartNfaWithStates_0(3, 35, 28);
534 return jjMoveStringLiteralDfa4_0(active0, 0xc00004000000000L, active1, 0L);
535 case 114:
536 if ((active0 & 0x100000L) != 0L)
537 return jjStartNfaWithStates_0(3, 20, 28);
538 return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L, active1, 0L);
539 case 115:
540 if ((active0 & 0x200000000000000L) != 0L)
541 return jjStartNfaWithStates_0(3, 57, 28);
542 return jjMoveStringLiteralDfa4_0(active0, 0x40600000L, active1, 0L);
543 case 116:
544 return jjMoveStringLiteralDfa4_0(active0, 0x91008000802000L, active1, 0L);
545 case 117:
546 return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0L);
547 case 118:
548 return jjMoveStringLiteralDfa4_0(active0, 0x800000000000L, active1, 0L);
549 default :
550 break;
551 }
552 return jjStartNfa_0(2, active0, active1);
553 }
554 private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
555 {
556 if (((active0 &= old0) | (active1 &= old1)) == 0L)
557 return jjStartNfa_0(2, old0, old1);
558 try { curChar = input_stream.readChar(); }
559 catch(java.io.IOException e) {
560 jjStopStringLiteralDfa_0(3, active0, active1);
561 return 4;
562 }
563 switch(curChar)
564 {
565 case 97:
566 return jjMoveStringLiteralDfa5_0(active0, 0xc08000000000L, active1, 0L);
567 case 99:
568 return jjMoveStringLiteralDfa5_0(active0, 0xa0000000000000L, active1, 0L);
569 case 101:
570 if ((active0 & 0x40000000L) != 0L)
571 return jjStartNfaWithStates_0(4, 30, 28);
572 else if ((active1 & 0x2L) != 0L)
573 return jjStartNfaWithStates_0(4, 65, 28);
574 return jjMoveStringLiteralDfa5_0(active0, 0x1002000008000L, active1, 0L);
575 case 104:
576 if ((active0 & 0x80000L) != 0L)
577 return jjStartNfaWithStates_0(4, 19, 28);
578 return jjMoveStringLiteralDfa5_0(active0, 0x100000000000000L, active1, 0L);
579 case 105:
580 return jjMoveStringLiteralDfa5_0(active0, 0x12000000800000L, active1, 0L);
581 case 107:
582 if ((active0 & 0x10000L) != 0L)
583 return jjStartNfaWithStates_0(4, 16, 28);
584 break;
585 case 108:
586 if ((active0 & 0x80000000L) != 0L)
587 {
588 jjmatchedKind = 31;
589 jjmatchedPos = 4;
590 }
591 return jjMoveStringLiteralDfa5_0(active0, 0x104000000L, active1, 0L);
592 case 110:
593 return jjMoveStringLiteralDfa5_0(active0, 0x20000000L, active1, 0L);
594 case 114:
595 if ((active0 & 0x40000000000000L) != 0L)
596 return jjStartNfaWithStates_0(4, 54, 28);
597 return jjMoveStringLiteralDfa5_0(active0, 0x4024000006000L, active1, 0L);
598 case 115:
599 if ((active0 & 0x200000L) != 0L)
600 return jjStartNfaWithStates_0(4, 21, 28);
601 return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000000L, active1, 0L);
602 case 116:
603 if ((active0 & 0x400000L) != 0L)
604 return jjStartNfaWithStates_0(4, 22, 28);
605 else if ((active0 & 0x200000000L) != 0L)
606 return jjStartNfaWithStates_0(4, 33, 28);
607 else if ((active0 & 0x8000000000000L) != 0L)
608 return jjStartNfaWithStates_0(4, 51, 28);
609 return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1L);
610 case 117:
611 return jjMoveStringLiteralDfa5_0(active0, 0x1000000L, active1, 0L);
612 case 118:
613 return jjMoveStringLiteralDfa5_0(active0, 0x80000000000L, active1, 0L);
614 case 119:
615 if ((active0 & 0x400000000000000L) != 0L)
616 {
617 jjmatchedKind = 58;
618 jjmatchedPos = 4;
619 }
620 return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0L);
621 default :
622 break;
623 }
624 return jjStartNfa_0(3, active0, active1);
625 }
626 private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
627 {
628 if (((active0 &= old0) | (active1 &= old1)) == 0L)
629 return jjStartNfa_0(3, old0, old1);
630 try { curChar = input_stream.readChar(); }
631 catch(java.io.IOException e) {
632 jjStopStringLiteralDfa_0(4, active0, active1);
633 return 5;
634 }
635 switch(curChar)
636 {
637 case 97:
638 return jjMoveStringLiteralDfa6_0(active0, 0xa000L, active1, 0L);
639 case 99:
640 if ((active0 & 0x2000000000000L) != 0L)
641 return jjStartNfaWithStates_0(5, 49, 28);
642 else if ((active0 & 0x10000000000000L) != 0L)
643 return jjStartNfaWithStates_0(5, 52, 28);
644 return jjMoveStringLiteralDfa6_0(active0, 0x1000000000000L, active1, 0L);
645 case 100:
646 return jjMoveStringLiteralDfa6_0(active0, 0x20000000L, active1, 0L);
647 case 101:
648 if ((active0 & 0x4000000L) != 0L)
649 return jjStartNfaWithStates_0(5, 26, 28);
650 else if ((active0 & 0x80000000000L) != 0L)
651 return jjStartNfaWithStates_0(5, 43, 28);
652 break;
653 case 102:
654 return jjMoveStringLiteralDfa6_0(active0, 0x20000000000L, active1, 0L);
655 case 103:
656 return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L);
657 case 104:
658 if ((active0 & 0x80000000000000L) != 0L)
659 return jjStartNfaWithStates_0(5, 55, 28);
660 break;
661 case 105:
662 return jjMoveStringLiteralDfa6_0(active0, 0x1000000000000000L, active1, 0x1L);
663 case 108:
664 return jjMoveStringLiteralDfa6_0(active0, 0x101000000L, active1, 0L);
665 case 109:
666 return jjMoveStringLiteralDfa6_0(active0, 0x2000000000L, active1, 0L);
667 case 110:
668 if ((active0 & 0x4000000000000L) != 0L)
669 return jjStartNfaWithStates_0(5, 50, 28);
670 return jjMoveStringLiteralDfa6_0(active0, 0x8000800000L, active1, 0L);
671 case 114:
672 return jjMoveStringLiteralDfa6_0(active0, 0x100000000000000L, active1, 0L);
673 case 115:
674 if ((active0 & 0x800000000000000L) != 0L)
675 return jjStartNfaWithStates_0(5, 59, 28);
676 break;
677 case 116:
678 if ((active0 & 0x4000L) != 0L)
679 return jjStartNfaWithStates_0(5, 14, 28);
680 else if ((active0 & 0x4000000000L) != 0L)
681 return jjStartNfaWithStates_0(5, 38, 28);
682 return jjMoveStringLiteralDfa6_0(active0, 0x20800000000000L, active1, 0L);
683 default :
684 break;
685 }
686 return jjStartNfa_0(4, active0, active1);
687 }
688 private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
689 {
690 if (((active0 &= old0) | (active1 &= old1)) == 0L)
691 return jjStartNfa_0(4, old0, old1);
692 try { curChar = input_stream.readChar(); }
693 catch(java.io.IOException e) {
694 jjStopStringLiteralDfa_0(5, active0, active1);
695 return 6;
696 }
697 switch(curChar)
698 {
699 case 97:
700 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000L, active1, 0L);
701 case 99:
702 return jjMoveStringLiteralDfa7_0(active0, 0x8000002000L, active1, 0L);
703 case 101:
704 if ((active0 & 0x400000000000L) != 0L)
705 return jjStartNfaWithStates_0(6, 46, 28);
706 else if ((active0 & 0x800000000000L) != 0L)
707 return jjStartNfaWithStates_0(6, 47, 28);
708 return jjMoveStringLiteralDfa7_0(active0, 0x1000002000000000L, active1, 0L);
709 case 102:
710 return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L, active1, 0L);
711 case 108:
712 return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x1L);
713 case 110:
714 if ((active0 & 0x8000L) != 0L)
715 return jjStartNfaWithStates_0(6, 15, 28);
716 break;
717 case 111:
718 return jjMoveStringLiteralDfa7_0(active0, 0x100000000000000L, active1, 0L);
719 case 115:
720 if ((active0 & 0x20000000L) != 0L)
721 return jjStartNfaWithStates_0(6, 29, 28);
722 break;
723 case 116:
724 if ((active0 & 0x1000000L) != 0L)
725 return jjStartNfaWithStates_0(6, 24, 28);
726 return jjMoveStringLiteralDfa7_0(active0, 0x1000000000000L, active1, 0L);
727 case 117:
728 return jjMoveStringLiteralDfa7_0(active0, 0x800000L, active1, 0L);
729 case 121:
730 if ((active0 & 0x100000000L) != 0L)
731 return jjStartNfaWithStates_0(6, 32, 28);
732 break;
733 default :
734 break;
735 }
736 return jjStartNfa_0(5, active0, active1);
737 }
738 private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1)
739 {
740 if (((active0 &= old0) | (active1 &= old1)) == 0L)
741 return jjStartNfa_0(5, old0, old1);
742 try { curChar = input_stream.readChar(); }
743 catch(java.io.IOException e) {
744 jjStopStringLiteralDfa_0(6, active0, active1);
745 return 7;
746 }
747 switch(curChar)
748 {
749 case 99:
750 return jjMoveStringLiteralDfa8_0(active0, 0x20000000000L, active1, 0L);
751 case 101:
752 if ((active0 & 0x800000L) != 0L)
753 return jjStartNfaWithStates_0(7, 23, 28);
754 else if ((active1 & 0x1L) != 0L)
755 return jjStartNfaWithStates_0(7, 64, 28);
756 return jjMoveStringLiteralDfa8_0(active0, 0x1008000000000L, active1, 0L);
757 case 110:
758 return jjMoveStringLiteralDfa8_0(active0, 0x1100002000000000L, active1, 0L);
759 case 112:
760 if ((active0 & 0x20000000000000L) != 0L)
761 return jjStartNfaWithStates_0(7, 53, 28);
762 break;
763 case 116:
764 if ((active0 & 0x2000L) != 0L)
765 return jjStartNfaWithStates_0(7, 13, 28);
766 break;
767 default :
768 break;
769 }
770 return jjStartNfa_0(6, active0, active1);
771 }
772 private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1)
773 {
774 if (((active0 &= old0) | (active1 &= old1)) == 0L)
775 return jjStartNfa_0(6, old0, old1);
776 try { curChar = input_stream.readChar(); }
777 catch(java.io.IOException e) {
778 jjStopStringLiteralDfa_0(7, active0, 0L);
779 return 8;
780 }
781 switch(curChar)
782 {
783 case 100:
784 if ((active0 & 0x1000000000000L) != 0L)
785 return jjStartNfaWithStates_0(8, 48, 28);
786 break;
787 case 101:
788 if ((active0 & 0x20000000000L) != 0L)
789 return jjStartNfaWithStates_0(8, 41, 28);
790 break;
791 case 105:
792 return jjMoveStringLiteralDfa9_0(active0, 0x100000000000000L);
793 case 111:
794 return jjMoveStringLiteralDfa9_0(active0, 0x8000000000L);
795 case 116:
796 if ((active0 & 0x1000000000000000L) != 0L)
797 return jjStartNfaWithStates_0(8, 60, 28);
798 return jjMoveStringLiteralDfa9_0(active0, 0x2000000000L);
799 default :
800 break;
801 }
802 return jjStartNfa_0(7, active0, 0L);
803 }
804 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
805 {
806 if (((active0 &= old0)) == 0L)
807 return jjStartNfa_0(7, old0, 0L);
808 try { curChar = input_stream.readChar(); }
809 catch(java.io.IOException e) {
810 jjStopStringLiteralDfa_0(8, active0, 0L);
811 return 9;
812 }
813 switch(curChar)
814 {
815 case 102:
816 if ((active0 & 0x8000000000L) != 0L)
817 return jjStartNfaWithStates_0(9, 39, 28);
818 break;
819 case 115:
820 if ((active0 & 0x2000000000L) != 0L)
821 return jjStartNfaWithStates_0(9, 37, 28);
822 break;
823 case 122:
824 return jjMoveStringLiteralDfa10_0(active0, 0x100000000000000L);
825 default :
826 break;
827 }
828 return jjStartNfa_0(8, active0, 0L);
829 }
830 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
831 {
832 if (((active0 &= old0)) == 0L)
833 return jjStartNfa_0(8, old0, 0L);
834 try { curChar = input_stream.readChar(); }
835 catch(java.io.IOException e) {
836 jjStopStringLiteralDfa_0(9, active0, 0L);
837 return 10;
838 }
839 switch(curChar)
840 {
841 case 101:
842 return jjMoveStringLiteralDfa11_0(active0, 0x100000000000000L);
843 default :
844 break;
845 }
846 return jjStartNfa_0(9, active0, 0L);
847 }
848 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
849 {
850 if (((active0 &= old0)) == 0L)
851 return jjStartNfa_0(9, old0, 0L);
852 try { curChar = input_stream.readChar(); }
853 catch(java.io.IOException e) {
854 jjStopStringLiteralDfa_0(10, active0, 0L);
855 return 11;
856 }
857 switch(curChar)
858 {
859 case 100:
860 if ((active0 & 0x100000000000000L) != 0L)
861 return jjStartNfaWithStates_0(11, 56, 28);
862 break;
863 default :
864 break;
865 }
866 return jjStartNfa_0(10, active0, 0L);
867 }
868 private final void jjCheckNAdd(int state)
869 {
870 if (jjrounds[state] != jjround)
871 {
872 jjstateSet[jjnewStateCnt++] = state;
873 jjrounds[state] = jjround;
874 }
875 }
876 private final void jjAddStates(int start, int end)
877 {
878 do {
879 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
880 } while (start++ != end);
881 }
882 private final void jjCheckNAddTwoStates(int state1, int state2)
883 {
884 jjCheckNAdd(state1);
885 jjCheckNAdd(state2);
886 }
887 private final void jjCheckNAddStates(int start, int end)
888 {
889 do {
890 jjCheckNAdd(jjnextStates[start]);
891 } while (start++ != end);
892 }
893 private final void jjCheckNAddStates(int start)
894 {
895 jjCheckNAdd(jjnextStates[start]);
896 jjCheckNAdd(jjnextStates[start + 1]);
897 }
898 static final long[] jjbitVec0 = {
899 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
900 };
901 static final long[] jjbitVec2 = {
902 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
903 };
904 static final long[] jjbitVec3 = {
905 0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
906 };
907 static final long[] jjbitVec4 = {
908 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
909 };
910 static final long[] jjbitVec5 = {
911 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
912 };
913 static final long[] jjbitVec6 = {
914 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
915 };
916 static final long[] jjbitVec7 = {
917 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
918 };
919 static final long[] jjbitVec8 = {
920 0x3fffffffffffL, 0x0L, 0x0L, 0x0L
921 };
922 private final int jjMoveNfa_0(int startState, int curPos)
923 {
924 int[] nextStates;
925 int startsAt = 0;
926 jjnewStateCnt = 48;
927 int i = 1;
928 jjstateSet[0] = startState;
929 int j, kind = 0x7fffffff;
930 for (;;)
931 {
932 if (++jjround == 0x7fffffff)
933 ReInitRounds();
934 if (curChar < 64)
935 {
936 long l = 1L << curChar;
937 MatchLoop: do
938 {
939 switch(jjstateSet[--i])
940 {
941 case 0:
942 if ((0x3ff000000000000L & l) != 0L)
943 jjCheckNAddStates(0, 6);
944 else if (curChar == 36)
945 {
946 if (kind > 74)
947 kind = 74;
948 jjCheckNAdd(28);
949 }
950 else if (curChar == 34)
951 jjCheckNAddStates(7, 9);
952 else if (curChar == 39)
953 jjAddStates(10, 11);
954 else if (curChar == 46)
955 jjCheckNAdd(4);
956 if ((0x3fe000000000000L & l) != 0L)
957 {
958 if (kind > 66)
959 kind = 66;
960 jjCheckNAddTwoStates(1, 2);
961 }
962 else if (curChar == 48)
963 {
964 if (kind > 66)
965 kind = 66;
966 jjCheckNAddStates(12, 14);
967 }
968 break;
969 case 1:
970 if ((0x3ff000000000000L & l) == 0L)
971 break;
972 if (kind > 66)
973 kind = 66;
974 jjCheckNAddTwoStates(1, 2);
975 break;
976 case 3:
977 if (curChar == 46)
978 jjCheckNAdd(4);
979 break;
980 case 4:
981 if ((0x3ff000000000000L & l) == 0L)
982 break;
983 if (kind > 70)
984 kind = 70;
985 jjCheckNAddStates(15, 17);
986 break;
987 case 6:
988 if ((0x280000000000L & l) != 0L)
989 jjCheckNAdd(7);
990 break;
991 case 7:
992 if ((0x3ff000000000000L & l) == 0L)
993 break;
994 if (kind > 70)
995 kind = 70;
996 jjCheckNAddTwoStates(7, 8);
997 break;
998 case 9:
999 if (curChar == 39)
1000 jjAddStates(10, 11);
1001 break;
1002 case 10:
1003 if ((0xfffffffffffffbffL & l) != 0L)
1004 jjCheckNAdd(11);
1005 break;
1006 case 11:
1007 if (curChar == 39 && kind > 72)
1008 kind = 72;
1009 break;
1010 case 13:
1011 if ((0x8400000000L & l) != 0L)
1012 jjCheckNAdd(11);
1013 break;
1014 case 14:
1015 if ((0xff000000000000L & l) != 0L)
1016 jjCheckNAddTwoStates(15, 11);
1017 break;
1018 case 15:
1019 if ((0xff000000000000L & l) != 0L)
1020 jjCheckNAdd(11);
1021 break;
1022 case 16:
1023 if ((0xf000000000000L & l) != 0L)
1024 jjstateSet[jjnewStateCnt++] = 17;
1025 break;
1026 case 17:
1027 if ((0xff000000000000L & l) != 0L)
1028 jjCheckNAdd(15);
1029 break;
1030 case 18:
1031 if (curChar == 34)
1032 jjCheckNAddStates(7, 9);
1033 break;
1034 case 19:
1035 if ((0xfffffffbffffdbffL & l) != 0L)
1036 jjCheckNAddStates(7, 9);
1037 break;
1038 case 21:
1039 if ((0x8400000000L & l) != 0L)
1040 jjCheckNAddStates(7, 9);
1041 break;
1042 case 22:
1043 if (curChar == 34 && kind > 73)
1044 kind = 73;
1045 break;
1046 case 23:
1047 if ((0xff000000000000L & l) != 0L)
1048 jjCheckNAddStates(18, 21);
1049 break;
1050 case 24:
1051 if ((0xff000000000000L & l) != 0L)
1052 jjCheckNAddStates(7, 9);
1053 break;
1054 case 25:
1055 if ((0xf000000000000L & l) != 0L)
1056 jjstateSet[jjnewStateCnt++] = 26;
1057 break;
1058 case 26:
1059 if ((0xff000000000000L & l) != 0L)
1060 jjCheckNAdd(24);
1061 break;
1062 case 27:
1063 if (curChar != 36)
1064 break;
1065 if (kind > 74)
1066 kind = 74;
1067 jjCheckNAdd(28);
1068 break;
1069 case 28:
1070 if ((0x3ff001000000000L & l) == 0L)
1071 break;
1072 if (kind > 74)
1073 kind = 74;
1074 jjCheckNAdd(28);
1075 break;
1076 case 29:
1077 if ((0x3ff000000000000L & l) != 0L)
1078 jjCheckNAddStates(0, 6);
1079 break;
1080 case 30:
1081 if ((0x3ff000000000000L & l) != 0L)
1082 jjCheckNAddTwoStates(30, 31);
1083 break;
1084 case 31:
1085 if (curChar != 46)
1086 break;
1087 if (kind > 70)
1088 kind = 70;
1089 jjCheckNAddStates(22, 24);
1090 break;
1091 case 32:
1092 if ((0x3ff000000000000L & l) == 0L)
1093 break;
1094 if (kind > 70)
1095 kind = 70;
1096 jjCheckNAddStates(22, 24);
1097 break;
1098 case 34:
1099 if ((0x280000000000L & l) != 0L)
1100 jjCheckNAdd(35);
1101 break;
1102 case 35:
1103 if ((0x3ff000000000000L & l) == 0L)
1104 break;
1105 if (kind > 70)
1106 kind = 70;
1107 jjCheckNAddTwoStates(35, 8);
1108 break;
1109 case 36:
1110 if ((0x3ff000000000000L & l) != 0L)
1111 jjCheckNAddTwoStates(36, 37);
1112 break;
1113 case 38:
1114 if ((0x280000000000L & l) != 0L)
1115 jjCheckNAdd(39);
1116 break;
1117 case 39:
1118 if ((0x3ff000000000000L & l) == 0L)
1119 break;
1120 if (kind > 70)
1121 kind = 70;
1122 jjCheckNAddTwoStates(39, 8);
1123 break;
1124 case 40:
1125 if ((0x3ff000000000000L & l) != 0L)
1126 jjCheckNAddStates(25, 27);
1127 break;
1128 case 42:
1129 if ((0x280000000000L & l) != 0L)
1130 jjCheckNAdd(43);
1131 break;
1132 case 43:
1133 if ((0x3ff000000000000L & l) != 0L)
1134 jjCheckNAddTwoStates(43, 8);
1135 break;
1136 case 44:
1137 if (curChar != 48)
1138 break;
1139 if (kind > 66)
1140 kind = 66;
1141 jjCheckNAddStates(12, 14);
1142 break;
1143 case 46:
1144 if ((0x3ff000000000000L & l) == 0L)
1145 break;
1146 if (kind > 66)
1147 kind = 66;
1148 jjCheckNAddTwoStates(46, 2);
1149 break;
1150 case 47:
1151 if ((0xff000000000000L & l) == 0L)
1152 break;
1153 if (kind > 66)
1154 kind = 66;
1155 jjCheckNAddTwoStates(47, 2);
1156 break;
1157 default : break;
1158 }
1159 } while(i != startsAt);
1160 }
1161 else if (curChar < 128)
1162 {
1163 long l = 1L << (curChar & 077);
1164 MatchLoop: do
1165 {
1166 switch(jjstateSet[--i])
1167 {
1168 case 0:
1169 case 28:
1170 if ((0x7fffffe87fffffeL & l) == 0L)
1171 break;
1172 if (kind > 74)
1173 kind = 74;
1174 jjCheckNAdd(28);
1175 break;
1176 case 2:
1177 if ((0x100000001000L & l) != 0L && kind > 66)
1178 kind = 66;
1179 break;
1180 case 5:
1181 if ((0x2000000020L & l) != 0L)
1182 jjAddStates(28, 29);
1183 break;
1184 case 8:
1185 if ((0x5000000050L & l) != 0L && kind > 70)
1186 kind = 70;
1187 break;
1188 case 10:
1189 if ((0xffffffffefffffffL & l) != 0L)
1190 jjCheckNAdd(11);
1191 break;
1192 case 12:
1193 if (curChar == 92)
1194 jjAddStates(30, 32);
1195 break;
1196 case 13:
1197 if ((0x14404410000000L & l) != 0L)
1198 jjCheckNAdd(11);
1199 break;
1200 case 19:
1201 if ((0xffffffffefffffffL & l) != 0L)
1202 jjCheckNAddStates(7, 9);
1203 break;
1204 case 20:
1205 if (curChar == 92)
1206 jjAddStates(33, 35);
1207 break;
1208 case 21:
1209 if ((0x14404410000000L & l) != 0L)
1210 jjCheckNAddStates(7, 9);
1211 break;
1212 case 33:
1213 if ((0x2000000020L & l) != 0L)
1214 jjAddStates(36, 37);
1215 break;
1216 case 37:
1217 if ((0x2000000020L & l) != 0L)
1218 jjAddStates(38, 39);
1219 break;
1220 case 41:
1221 if ((0x2000000020L & l) != 0L)
1222 jjAddStates(40, 41);
1223 break;
1224 case 45:
1225 if ((0x100000001000000L & l) != 0L)
1226 jjCheckNAdd(46);
1227 break;
1228 case 46:
1229 if ((0x7e0000007eL & l) == 0L)
1230 break;
1231 if (kind > 66)
1232 kind = 66;
1233 jjCheckNAddTwoStates(46, 2);
1234 break;
1235 default : break;
1236 }
1237 } while(i != startsAt);
1238 }
1239 else
1240 {
1241 int hiByte = (int)(curChar >> 8);
1242 int i1 = hiByte >> 6;
1243 long l1 = 1L << (hiByte & 077);
1244 int i2 = (curChar & 0xff) >> 6;
1245 long l2 = 1L << (curChar & 077);
1246 MatchLoop: do
1247 {
1248 switch(jjstateSet[--i])
1249 {
1250 case 0:
1251 case 28:
1252 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1253 break;
1254 if (kind > 74)
1255 kind = 74;
1256 jjCheckNAdd(28);
1257 break;
1258 case 10:
1259 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1260 jjstateSet[jjnewStateCnt++] = 11;
1261 break;
1262 case 19:
1263 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1264 jjAddStates(7, 9);
1265 break;
1266 default : break;
1267 }
1268 } while(i != startsAt);
1269 }
1270 if (kind != 0x7fffffff)
1271 {
1272 jjmatchedKind = kind;
1273 jjmatchedPos = curPos;
1274 kind = 0x7fffffff;
1275 }
1276 ++curPos;
1277 if ((i = jjnewStateCnt) == (startsAt = 48 - (jjnewStateCnt = startsAt)))
1278 return curPos;
1279 try { curChar = input_stream.readChar(); }
1280 catch(java.io.IOException e) { return curPos; }
1281 }
1282 }
1283 private final int jjStopStringLiteralDfa_2(int pos, long active0)
1284 {
1285 switch (pos)
1286 {
1287 default :
1288 return -1;
1289 }
1290 }
1291 private final int jjStartNfa_2(int pos, long active0)
1292 {
1293 return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos, active0), pos + 1);
1294 }
1295 private final int jjStartNfaWithStates_2(int pos, int kind, int state)
1296 {
1297 jjmatchedKind = kind;
1298 jjmatchedPos = pos;
1299 try { curChar = input_stream.readChar(); }
1300 catch(java.io.IOException e) { return pos + 1; }
1301 return jjMoveNfa_2(state, pos + 1);
1302 }
1303 private final int jjMoveStringLiteralDfa0_2()
1304 {
1305 switch(curChar)
1306 {
1307 case 42:
1308 return jjMoveStringLiteralDfa1_2(0x800L);
1309 default :
1310 return jjMoveNfa_2(0, 0);
1311 }
1312 }
1313 private final int jjMoveStringLiteralDfa1_2(long active0)
1314 {
1315 try { curChar = input_stream.readChar(); }
1316 catch(java.io.IOException e) {
1317 jjStopStringLiteralDfa_2(0, active0);
1318 return 1;
1319 }
1320 switch(curChar)
1321 {
1322 case 47:
1323 if ((active0 & 0x800L) != 0L)
1324 return jjStopAtPos(1, 11);
1325 break;
1326 default :
1327 break;
1328 }
1329 return jjStartNfa_2(0, active0);
1330 }
1331 private final int jjMoveNfa_2(int startState, int curPos)
1332 {
1333 int[] nextStates;
1334 int startsAt = 0;
1335 jjnewStateCnt = 3;
1336 int i = 1;
1337 jjstateSet[0] = startState;
1338 int j, kind = 0x7fffffff;
1339 for (;;)
1340 {
1341 if (++jjround == 0x7fffffff)
1342 ReInitRounds();
1343 if (curChar < 64)
1344 {
1345 long l = 1L << curChar;
1346 MatchLoop: do
1347 {
1348 switch(jjstateSet[--i])
1349 {
1350 case 0:
1351 if ((0x2400L & l) != 0L)
1352 {
1353 if (kind > 10)
1354 kind = 10;
1355 }
1356 if (curChar == 13)
1357 jjstateSet[jjnewStateCnt++] = 1;
1358 break;
1359 case 1:
1360 if (curChar == 10 && kind > 10)
1361 kind = 10;
1362 break;
1363 case 2:
1364 if (curChar == 13)
1365 jjstateSet[jjnewStateCnt++] = 1;
1366 break;
1367 default : break;
1368 }
1369 } while(i != startsAt);
1370 }
1371 else if (curChar < 128)
1372 {
1373 long l = 1L << (curChar & 077);
1374 MatchLoop: do
1375 {
1376 switch(jjstateSet[--i])
1377 {
1378 default : break;
1379 }
1380 } while(i != startsAt);
1381 }
1382 else
1383 {
1384 int hiByte = (int)(curChar >> 8);
1385 int i1 = hiByte >> 6;
1386 long l1 = 1L << (hiByte & 077);
1387 int i2 = (curChar & 0xff) >> 6;
1388 long l2 = 1L << (curChar & 077);
1389 MatchLoop: do
1390 {
1391 switch(jjstateSet[--i])
1392 {
1393 default : break;
1394 }
1395 } while(i != startsAt);
1396 }
1397 if (kind != 0x7fffffff)
1398 {
1399 jjmatchedKind = kind;
1400 jjmatchedPos = curPos;
1401 kind = 0x7fffffff;
1402 }
1403 ++curPos;
1404 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1405 return curPos;
1406 try { curChar = input_stream.readChar(); }
1407 catch(java.io.IOException e) { return curPos; }
1408 }
1409 }
1410 private final int jjMoveStringLiteralDfa0_1()
1411 {
1412 return jjMoveNfa_1(4, 0);
1413 }
1414 private final int jjMoveNfa_1(int startState, int curPos)
1415 {
1416 int[] nextStates;
1417 int startsAt = 0;
1418 jjnewStateCnt = 4;
1419 int i = 1;
1420 jjstateSet[0] = startState;
1421 int j, kind = 0x7fffffff;
1422 for (;;)
1423 {
1424 if (++jjround == 0x7fffffff)
1425 ReInitRounds();
1426 if (curChar < 64)
1427 {
1428 long l = 1L << curChar;
1429 MatchLoop: do
1430 {
1431 switch(jjstateSet[--i])
1432 {
1433 case 4:
1434 if ((0xffffffffffffdbffL & l) != 0L)
1435 {
1436 if (kind > 9)
1437 kind = 9;
1438 jjCheckNAddStates(42, 44);
1439 }
1440 else if ((0x2400L & l) != 0L)
1441 {
1442 if (kind > 9)
1443 kind = 9;
1444 }
1445 if (curChar == 13)
1446 jjstateSet[jjnewStateCnt++] = 2;
1447 break;
1448 case 0:
1449 if ((0xffffffffffffdbffL & l) == 0L)
1450 break;
1451 kind = 9;
1452 jjCheckNAddStates(42, 44);
1453 break;
1454 case 1:
1455 if ((0x2400L & l) != 0L && kind > 9)
1456 kind = 9;
1457 break;
1458 case 2:
1459 if (curChar == 10 && kind > 9)
1460 kind = 9;
1461 break;
1462 case 3:
1463 if (curChar == 13)
1464 jjstateSet[jjnewStateCnt++] = 2;
1465 break;
1466 default : break;
1467 }
1468 } while(i != startsAt);
1469 }
1470 else if (curChar < 128)
1471 {
1472 long l = 1L << (curChar & 077);
1473 MatchLoop: do
1474 {
1475 switch(jjstateSet[--i])
1476 {
1477 case 4:
1478 case 0:
1479 kind = 9;
1480 jjCheckNAddStates(42, 44);
1481 break;
1482 default : break;
1483 }
1484 } while(i != startsAt);
1485 }
1486 else
1487 {
1488 int hiByte = (int)(curChar >> 8);
1489 int i1 = hiByte >> 6;
1490 long l1 = 1L << (hiByte & 077);
1491 int i2 = (curChar & 0xff) >> 6;
1492 long l2 = 1L << (curChar & 077);
1493 MatchLoop: do
1494 {
1495 switch(jjstateSet[--i])
1496 {
1497 case 4:
1498 case 0:
1499 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1500 break;
1501 if (kind > 9)
1502 kind = 9;
1503 jjCheckNAddStates(42, 44);
1504 break;
1505 default : break;
1506 }
1507 } while(i != startsAt);
1508 }
1509 if (kind != 0x7fffffff)
1510 {
1511 jjmatchedKind = kind;
1512 jjmatchedPos = curPos;
1513 kind = 0x7fffffff;
1514 }
1515 ++curPos;
1516 if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1517 return curPos;
1518 try { curChar = input_stream.readChar(); }
1519 catch(java.io.IOException e) { return curPos; }
1520 }
1521 }
1522 static final int[] jjnextStates = {
1523 30, 31, 36, 37, 40, 41, 8, 19, 20, 22, 10, 12, 45, 47, 2, 4,
1524 5, 8, 19, 20, 24, 22, 32, 33, 8, 40, 41, 8, 6, 7, 13, 14,
1525 16, 21, 23, 25, 34, 35, 38, 39, 42, 43, 0, 1, 3,
1526 };
1527 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1528 {
1529 switch(hiByte)
1530 {
1531 case 0:
1532 return ((jjbitVec2[i2] & l2) != 0L);
1533 default :
1534 if ((jjbitVec0[i1] & l1) != 0L)
1535 return true;
1536 return false;
1537 }
1538 }
1539 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1540 {
1541 switch(hiByte)
1542 {
1543 case 0:
1544 return ((jjbitVec4[i2] & l2) != 0L);
1545 case 48:
1546 return ((jjbitVec5[i2] & l2) != 0L);
1547 case 49:
1548 return ((jjbitVec6[i2] & l2) != 0L);
1549 case 51:
1550 return ((jjbitVec7[i2] & l2) != 0L);
1551 case 61:
1552 return ((jjbitVec8[i2] & l2) != 0L);
1553 default :
1554 if ((jjbitVec3[i1] & l1) != 0L)
1555 return true;
1556 return false;
1557 }
1558 }
1559 public static final String[] jjstrLiteralImages = {
1560 "", null, null, null, null, null, null, null, null, null, null, null, null,
1561 "\141\142\163\164\162\141\143\164", "\141\163\163\145\162\164", "\142\157\157\154\145\141\156",
1562 "\142\162\145\141\153", "\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150",
1563 "\143\150\141\162", "\143\154\141\163\163", "\143\157\156\163\164",
1564 "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145",
1565 "\145\154\163\145", "\145\156\165\155", "\145\170\164\145\156\144\163", "\146\141\154\163\145",
1566 "\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162",
1567 "\147\157\164\157", "\151\146", "\151\155\160\154\145\155\145\156\164\163",
1568 "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
1569 "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145", "\156\145\167",
1570 "\156\165\154\154", "\160\141\143\153\141\147\145", "\160\162\151\166\141\164\145",
1571 "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", "\162\145\164\165\162\156",
1572 "\163\150\157\162\164", "\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160",
1573 "\163\165\160\145\162", "\163\167\151\164\143\150",
1574 "\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",
1575 "\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171", "\166\157\151\144",
1576 "\166\157\154\141\164\151\154\145", "\167\150\151\154\145", null, null, null, null, null, null, null, null, null,
1577 null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56",
1578 "\100", "\75", "\76", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75",
1579 "\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52",
1580 "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76", "\53\75",
1581 "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75",
1582 "\76\76\75", "\76\76\76\75", "\56\56\56", };
1583 public static final String[] lexStateNames = {
1584 "DEFAULT",
1585 "IN_SINGLE_LINE_COMMENT",
1586 "IN_MULTI_LINE_COMMENT",
1587 };
1588 public static final int[] jjnewLexState = {
1589 -1, -1, -1, -1, -1, -1, -1, 2, 1, 0, -1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1590 -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,
1591 -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,
1592 -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,
1593 -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,
1594 };
1595 static final long[] jjtoToken = {
1596 0xffffffffffffe001L, 0x1fffffffffffe747L,
1597 };
1598 static final long[] jjtoSkip = {
1599 0xf7eL, 0x0L,
1600 };
1601 static final long[] jjtoSpecial = {
1602 0xf00L, 0x0L,
1603 };
1604 static final long[] jjtoMore = {
1605 0x1080L, 0x0L,
1606 };
1607 private ASCII_UCodeESC_CharStream input_stream;
1608 private final int[] jjrounds = new int[48];
1609 private final int[] jjstateSet = new int[96];
1610 StringBuffer image;
1611 int jjimageLen;
1612 int lengthOfMatch;
1613 protected char curChar;
1614 public JavaParserTokenManager(ASCII_UCodeESC_CharStream stream)
1615 {
1616 if (ASCII_UCodeESC_CharStream.staticFlag)
1617 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1618 input_stream = stream;
1619 }
1620 public JavaParserTokenManager(ASCII_UCodeESC_CharStream stream, int lexState)
1621 {
1622 this(stream);
1623 SwitchTo(lexState);
1624 }
1625 public void ReInit(ASCII_UCodeESC_CharStream stream)
1626 {
1627 jjmatchedPos = jjnewStateCnt = 0;
1628 curLexState = defaultLexState;
1629 input_stream = stream;
1630 ReInitRounds();
1631 }
1632 private final void ReInitRounds()
1633 {
1634 int i;
1635 jjround = 0x80000001;
1636 for (i = 48; i-- > 0;)
1637 jjrounds[i] = 0x80000000;
1638 }
1639 public void ReInit(ASCII_UCodeESC_CharStream stream, int lexState)
1640 {
1641 ReInit(stream);
1642 SwitchTo(lexState);
1643 }
1644 public void SwitchTo(int lexState)
1645 {
1646 if (lexState >= 3 || lexState < 0)
1647 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1648 else
1649 curLexState = lexState;
1650 }
1651
1652 private final Token jjFillToken()
1653 {
1654 Token t = Token.newToken(jjmatchedKind);
1655 t.kind = jjmatchedKind;
1656 if (jjmatchedPos < 0)
1657 {
1658 t.image = "";
1659 t.beginLine = t.endLine = input_stream.getBeginLine();
1660 t.beginColumn = t.endColumn = input_stream.getBeginColumn();
1661 }
1662 else
1663 {
1664 String im = jjstrLiteralImages[jjmatchedKind];
1665 t.image = (im == null) ? input_stream.GetImage() : im;
1666 t.beginLine = input_stream.getBeginLine();
1667 t.beginColumn = input_stream.getBeginColumn();
1668 t.endLine = input_stream.getEndLine();
1669 t.endColumn = input_stream.getEndColumn();
1670 }
1671 return t;
1672 }
1673
1674 int curLexState = 0;
1675 int defaultLexState = 0;
1676 int jjnewStateCnt;
1677 int jjround;
1678 int jjmatchedPos;
1679 int jjmatchedKind;
1680
1681 public final Token getNextToken()
1682 {
1683 int kind;
1684 Token specialToken = null;
1685 Token matchedToken;
1686 int curPos = 0;
1687
1688 EOFLoop :
1689 for (;;)
1690 {
1691 try
1692 {
1693 curChar = input_stream.BeginToken();
1694 }
1695 catch(java.io.IOException e)
1696 {
1697 jjmatchedKind = 0;
1698 matchedToken = jjFillToken();
1699 matchedToken.specialToken = specialToken;
1700 return matchedToken;
1701 }
1702 image = null;
1703 jjimageLen = 0;
1704
1705 for (;;)
1706 {
1707 switch(curLexState)
1708 {
1709 case 0:
1710 try { input_stream.backup(0);
1711 while (curChar <= 32 && (0x104003600L & (1L << curChar)) != 0L)
1712 curChar = input_stream.BeginToken();
1713 }
1714 catch (java.io.IOException e1) { continue EOFLoop; }
1715 jjmatchedKind = 0x7fffffff;
1716 jjmatchedPos = 0;
1717 curPos = jjMoveStringLiteralDfa0_0();
1718 break;
1719 case 1:
1720 jjmatchedKind = 9;
1721 jjmatchedPos = -1;
1722 curPos = 0;
1723 curPos = jjMoveStringLiteralDfa0_1();
1724 if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 12))
1725 {
1726 jjmatchedKind = 12;
1727 jjmatchedPos = 0;
1728 }
1729 break;
1730 case 2:
1731 jjmatchedKind = 0x7fffffff;
1732 jjmatchedPos = 0;
1733 curPos = jjMoveStringLiteralDfa0_2();
1734 if (jjmatchedPos == 0 && jjmatchedKind > 12)
1735 {
1736 jjmatchedKind = 12;
1737 }
1738 break;
1739 }
1740 if (jjmatchedKind != 0x7fffffff)
1741 {
1742 if (jjmatchedPos + 1 < curPos)
1743 input_stream.backup(curPos - jjmatchedPos - 1);
1744 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1745 {
1746 matchedToken = jjFillToken();
1747 matchedToken.specialToken = specialToken;
1748 if (jjnewLexState[jjmatchedKind] != -1)
1749 curLexState = jjnewLexState[jjmatchedKind];
1750 return matchedToken;
1751 }
1752 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1753 {
1754 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1755 {
1756 matchedToken = jjFillToken();
1757 if (specialToken == null)
1758 specialToken = matchedToken;
1759 else
1760 {
1761 matchedToken.specialToken = specialToken;
1762 specialToken = (specialToken.next = matchedToken);
1763 }
1764 SkipLexicalActions(matchedToken);
1765 }
1766 else
1767 SkipLexicalActions(null);
1768 if (jjnewLexState[jjmatchedKind] != -1)
1769 curLexState = jjnewLexState[jjmatchedKind];
1770 continue EOFLoop;
1771 }
1772 MoreLexicalActions();
1773 if (jjnewLexState[jjmatchedKind] != -1)
1774 curLexState = jjnewLexState[jjmatchedKind];
1775 curPos = 0;
1776 jjmatchedKind = 0x7fffffff;
1777 try {
1778 curChar = input_stream.readChar();
1779 continue;
1780 }
1781 catch (java.io.IOException e1) { }
1782 }
1783 int error_line = input_stream.getEndLine();
1784 int error_column = input_stream.getEndColumn();
1785 String error_after = null;
1786 boolean EOFSeen = false;
1787 try { input_stream.readChar(); input_stream.backup(1); }
1788 catch (java.io.IOException e1) {
1789 EOFSeen = true;
1790 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1791 if (curChar == '\n' || curChar == '\r') {
1792 error_line++;
1793 error_column = 0;
1794 }
1795 else
1796 error_column++;
1797 }
1798 if (!EOFSeen) {
1799 input_stream.backup(1);
1800 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1801 }
1802 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1803 }
1804 }
1805 }
1806
1807 final void SkipLexicalActions(Token matchedToken)
1808 {
1809 switch(jjmatchedKind)
1810 {
1811 case 8 :
1812 if (image == null)
1813 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
1814 else
1815 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
1816 _iSingleComments++;
1817 break;
1818 case 10 :
1819 if (image == null)
1820 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
1821 else
1822 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
1823 _iMultiComments++; _iMultiCommentsLast++;
1824 break;
1825 case 11 :
1826 if (image == null)
1827 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
1828 else
1829 image.append(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
1830 _iMultiComments++; _iMultiCommentsLast++;
1831 break;
1832 default :
1833 break;
1834 }
1835 }
1836 final void MoreLexicalActions()
1837 {
1838 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
1839 switch(jjmatchedKind)
1840 {
1841 case 7 :
1842 if (image == null)
1843 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
1844 else
1845 image.append(input_stream.GetSuffix(jjimageLen));
1846 jjimageLen = 0;
1847 _iMultiCommentsLast = 0;
1848 break;
1849 default :
1850 break;
1851 }
1852 }
1853 }