001 /* Generated By:JavaCC: Do not edit this line. CompactSyntaxTokenManager.java */
002 package com.thaiopensource.relaxng.parse.compact;
003 import com.thaiopensource.relaxng.parse.SchemaBuilder;
004 import com.thaiopensource.relaxng.parse.Annotations;
005 import com.thaiopensource.relaxng.parse.DataPatternBuilder;
006 import com.thaiopensource.relaxng.parse.ParsedElementAnnotation;
007 import com.thaiopensource.relaxng.parse.ElementAnnotationBuilder;
008 import com.thaiopensource.relaxng.parse.CommentList;
009 import com.thaiopensource.relaxng.parse.ParsedPattern;
010 import com.thaiopensource.relaxng.parse.ParsedNameClass;
011 import com.thaiopensource.relaxng.parse.Scope;
012 import com.thaiopensource.relaxng.parse.GrammarSection;
013 import com.thaiopensource.relaxng.parse.Div;
014 import com.thaiopensource.relaxng.parse.Grammar;
015 import com.thaiopensource.relaxng.parse.Include;
016 import com.thaiopensource.relaxng.parse.IncludedGrammar;
017 import com.thaiopensource.relaxng.parse.IllegalSchemaException;
018 import com.thaiopensource.relaxng.parse.BuildException;
019 import com.thaiopensource.relaxng.parse.Location;
020 import com.thaiopensource.relaxng.parse.Context;
021 import com.thaiopensource.xml.util.WellKnownNamespaces;
022 import com.thaiopensource.util.Localizer;
023 import org.xml.sax.ErrorHandler;
024 import org.xml.sax.SAXException;
025 import org.xml.sax.SAXParseException;
026 import org.xml.sax.Locator;
027 import org.xml.sax.helpers.LocatorImpl;
028 import java.util.Hashtable;
029 import java.util.Enumeration;
030 import java.io.Reader;
031 import java.net.MalformedURLException;
032 import java.net.URL;
033
034 public class CompactSyntaxTokenManager implements CompactSyntaxConstants
035 {
036 private final int jjStopStringLiteralDfa_0(int pos, long active0)
037 {
038 switch (pos)
039 {
040 case 0:
041 if ((active0 & 0x1f8c0fe4e0L) != 0L)
042 {
043 jjmatchedKind = 54;
044 return 43;
045 }
046 if ((active0 & 0x800000000000000L) != 0L)
047 {
048 jjmatchedKind = 60;
049 return -1;
050 }
051 return -1;
052 case 1:
053 if ((active0 & 0x1f8c0fe4e0L) != 0L)
054 {
055 jjmatchedKind = 54;
056 jjmatchedPos = 1;
057 return 43;
058 }
059 if ((active0 & 0x800000000000000L) != 0L)
060 {
061 if (jjmatchedPos == 0)
062 {
063 jjmatchedKind = 60;
064 jjmatchedPos = 0;
065 }
066 return -1;
067 }
068 return -1;
069 case 2:
070 if ((active0 & 0x1f8c0fe4a0L) != 0L)
071 {
072 jjmatchedKind = 54;
073 jjmatchedPos = 2;
074 return 43;
075 }
076 if ((active0 & 0x40L) != 0L)
077 return 43;
078 return -1;
079 case 3:
080 if ((active0 & 0x1f0c0be4a0L) != 0L)
081 {
082 jjmatchedKind = 54;
083 jjmatchedPos = 3;
084 return 43;
085 }
086 if ((active0 & 0x80040000L) != 0L)
087 return 43;
088 return -1;
089 case 4:
090 if ((active0 & 0xe0c09e480L) != 0L)
091 {
092 jjmatchedKind = 54;
093 jjmatchedPos = 4;
094 return 43;
095 }
096 if ((active0 & 0x1100020020L) != 0L)
097 return 43;
098 return -1;
099 case 5:
100 if ((active0 & 0x20c09e480L) != 0L)
101 {
102 jjmatchedKind = 54;
103 jjmatchedPos = 5;
104 return 43;
105 }
106 if ((active0 & 0xc00000000L) != 0L)
107 return 43;
108 return -1;
109 case 6:
110 if ((active0 & 0x208092000L) != 0L)
111 {
112 jjmatchedKind = 54;
113 jjmatchedPos = 6;
114 return 43;
115 }
116 if ((active0 & 0x400c480L) != 0L)
117 return 43;
118 return -1;
119 case 7:
120 if ((active0 & 0x8092000L) != 0L)
121 {
122 jjmatchedKind = 54;
123 jjmatchedPos = 7;
124 return 43;
125 }
126 if ((active0 & 0x200000000L) != 0L)
127 return 43;
128 return -1;
129 case 8:
130 if ((active0 & 0x80000L) != 0L)
131 {
132 jjmatchedKind = 54;
133 jjmatchedPos = 8;
134 return 43;
135 }
136 if ((active0 & 0x8012000L) != 0L)
137 return 43;
138 return -1;
139 default :
140 return -1;
141 }
142 }
143 private final int jjStartNfa_0(int pos, long active0)
144 {
145 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
146 }
147 private final int jjStopAtPos(int pos, int kind)
148 {
149 jjmatchedKind = kind;
150 jjmatchedPos = pos;
151 return pos + 1;
152 }
153 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
154 {
155 jjmatchedKind = kind;
156 jjmatchedPos = pos;
157 try { curChar = input_stream.readChar(); }
158 catch(EOFException e) { return pos + 1; }
159 return jjMoveNfa_0(state, pos + 1);
160 }
161 private final int jjMoveStringLiteralDfa0_0()
162 {
163 switch(curChar)
164 {
165 case 38:
166 jjmatchedKind = 21;
167 return jjMoveStringLiteralDfa1_0(0x8L);
168 case 40:
169 return jjStopAtPos(0, 28);
170 case 41:
171 return jjStopAtPos(0, 29);
172 case 42:
173 return jjStopAtPos(0, 25);
174 case 43:
175 return jjStopAtPos(0, 23);
176 case 44:
177 return jjStopAtPos(0, 22);
178 case 45:
179 return jjStopAtPos(0, 30);
180 case 61:
181 return jjStopAtPos(0, 2);
182 case 62:
183 return jjMoveStringLiteralDfa1_0(0x800000000000000L);
184 case 63:
185 return jjStopAtPos(0, 24);
186 case 91:
187 return jjStopAtPos(0, 1);
188 case 93:
189 return jjStopAtPos(0, 9);
190 case 97:
191 return jjMoveStringLiteralDfa1_0(0x8000000L);
192 case 100:
193 return jjMoveStringLiteralDfa1_0(0x14040L);
194 case 101:
195 return jjMoveStringLiteralDfa1_0(0x204020000L);
196 case 103:
197 return jjMoveStringLiteralDfa1_0(0x400L);
198 case 105:
199 return jjMoveStringLiteralDfa1_0(0x8080L);
200 case 108:
201 return jjMoveStringLiteralDfa1_0(0x80000000L);
202 case 109:
203 return jjMoveStringLiteralDfa1_0(0x100000000L);
204 case 110:
205 return jjMoveStringLiteralDfa1_0(0x82000L);
206 case 112:
207 return jjMoveStringLiteralDfa1_0(0x400000000L);
208 case 115:
209 return jjMoveStringLiteralDfa1_0(0x800000020L);
210 case 116:
211 return jjMoveStringLiteralDfa1_0(0x1000040000L);
212 case 123:
213 return jjStopAtPos(0, 11);
214 case 124:
215 jjmatchedKind = 20;
216 return jjMoveStringLiteralDfa1_0(0x10L);
217 case 125:
218 return jjStopAtPos(0, 12);
219 case 126:
220 return jjStopAtPos(0, 8);
221 default :
222 return jjMoveNfa_0(3, 0);
223 }
224 }
225 private final int jjMoveStringLiteralDfa1_0(long active0)
226 {
227 try { curChar = input_stream.readChar(); }
228 catch(EOFException e) {
229 jjStopStringLiteralDfa_0(0, active0);
230 return 1;
231 }
232 switch(curChar)
233 {
234 case 61:
235 if ((active0 & 0x8L) != 0L)
236 return jjStopAtPos(1, 3);
237 else if ((active0 & 0x10L) != 0L)
238 return jjStopAtPos(1, 4);
239 break;
240 case 62:
241 if ((active0 & 0x800000000000000L) != 0L)
242 return jjStopAtPos(1, 59);
243 break;
244 case 97:
245 return jjMoveStringLiteralDfa2_0(active0, 0x400012000L);
246 case 101:
247 return jjMoveStringLiteralDfa2_0(active0, 0x44000L);
248 case 105:
249 return jjMoveStringLiteralDfa2_0(active0, 0x180000040L);
250 case 108:
251 return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
252 case 109:
253 return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
254 case 110:
255 return jjMoveStringLiteralDfa2_0(active0, 0x8080L);
256 case 111:
257 return jjMoveStringLiteralDfa2_0(active0, 0x1000080000L);
258 case 114:
259 return jjMoveStringLiteralDfa2_0(active0, 0x400L);
260 case 116:
261 return jjMoveStringLiteralDfa2_0(active0, 0x808000020L);
262 case 120:
263 return jjMoveStringLiteralDfa2_0(active0, 0x200000000L);
264 default :
265 break;
266 }
267 return jjStartNfa_0(0, active0);
268 }
269 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
270 {
271 if (((active0 &= old0)) == 0L)
272 return jjStartNfa_0(0, old0);
273 try { curChar = input_stream.readChar(); }
274 catch(EOFException e) {
275 jjStopStringLiteralDfa_0(1, active0);
276 return 2;
277 }
278 switch(curChar)
279 {
280 case 97:
281 return jjMoveStringLiteralDfa3_0(active0, 0x420L);
282 case 99:
283 return jjMoveStringLiteralDfa3_0(active0, 0x80L);
284 case 101:
285 return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
286 case 102:
287 return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
288 case 104:
289 return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
290 case 107:
291 return jjMoveStringLiteralDfa3_0(active0, 0x1000000000L);
292 case 109:
293 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
294 case 112:
295 return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
296 case 114:
297 return jjMoveStringLiteralDfa3_0(active0, 0xc00000000L);
298 case 115:
299 return jjMoveStringLiteralDfa3_0(active0, 0x80000000L);
300 case 116:
301 return jjMoveStringLiteralDfa3_0(active0, 0x208090000L);
302 case 118:
303 if ((active0 & 0x40L) != 0L)
304 return jjStartNfaWithStates_0(2, 6, 43);
305 break;
306 case 120:
307 return jjMoveStringLiteralDfa3_0(active0, 0x100040000L);
308 default :
309 break;
310 }
311 return jjStartNfa_0(1, active0);
312 }
313 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
314 {
315 if (((active0 &= old0)) == 0L)
316 return jjStartNfa_0(1, old0);
317 try { curChar = input_stream.readChar(); }
318 catch(EOFException e) {
319 jjStopStringLiteralDfa_0(2, active0);
320 return 3;
321 }
322 switch(curChar)
323 {
324 case 65:
325 return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
326 case 97:
327 return jjMoveStringLiteralDfa4_0(active0, 0x14000L);
328 case 101:
329 return jjMoveStringLiteralDfa4_0(active0, 0x170000a000L);
330 case 105:
331 return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
332 case 108:
333 return jjMoveStringLiteralDfa4_0(active0, 0x80L);
334 case 109:
335 return jjMoveStringLiteralDfa4_0(active0, 0x4000400L);
336 case 114:
337 return jjMoveStringLiteralDfa4_0(active0, 0x8000020L);
338 case 116:
339 if ((active0 & 0x40000L) != 0L)
340 return jjStartNfaWithStates_0(3, 18, 43);
341 else if ((active0 & 0x80000000L) != 0L)
342 return jjStartNfaWithStates_0(3, 31, 43);
343 return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
344 default :
345 break;
346 }
347 return jjStartNfa_0(2, active0);
348 }
349 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
350 {
351 if (((active0 &= old0)) == 0L)
352 return jjStartNfa_0(2, old0);
353 try { curChar = input_stream.readChar(); }
354 catch(EOFException e) {
355 jjStopStringLiteralDfa_0(3, active0);
356 return 4;
357 }
358 switch(curChar)
359 {
360 case 100:
361 if ((active0 & 0x100000000L) != 0L)
362 return jjStartNfaWithStates_0(4, 32, 43);
363 break;
364 case 101:
365 return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
366 case 105:
367 return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
368 case 108:
369 return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
370 case 109:
371 return jjMoveStringLiteralDfa5_0(active0, 0x400L);
372 case 110:
373 if ((active0 & 0x1000000000L) != 0L)
374 return jjStartNfaWithStates_0(4, 36, 43);
375 return jjMoveStringLiteralDfa5_0(active0, 0xc00000000L);
376 case 114:
377 return jjMoveStringLiteralDfa5_0(active0, 0x200008000L);
378 case 115:
379 return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
380 case 116:
381 if ((active0 & 0x20L) != 0L)
382 return jjStartNfaWithStates_0(4, 5, 43);
383 return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
384 case 117:
385 return jjMoveStringLiteralDfa5_0(active0, 0x4080L);
386 case 121:
387 if ((active0 & 0x20000L) != 0L)
388 return jjStartNfaWithStates_0(4, 17, 43);
389 break;
390 default :
391 break;
392 }
393 return jjStartNfa_0(3, active0);
394 }
395 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
396 {
397 if (((active0 &= old0)) == 0L)
398 return jjStartNfa_0(3, old0);
399 try { curChar = input_stream.readChar(); }
400 catch(EOFException e) {
401 jjStopStringLiteralDfa_0(4, active0);
402 return 5;
403 }
404 switch(curChar)
405 {
406 case 97:
407 return jjMoveStringLiteralDfa6_0(active0, 0x400L);
408 case 98:
409 return jjMoveStringLiteralDfa6_0(active0, 0x8000000L);
410 case 100:
411 return jjMoveStringLiteralDfa6_0(active0, 0x80L);
412 case 103:
413 if ((active0 & 0x800000000L) != 0L)
414 return jjStartNfaWithStates_0(5, 35, 43);
415 break;
416 case 105:
417 return jjMoveStringLiteralDfa6_0(active0, 0x8000L);
418 case 108:
419 return jjMoveStringLiteralDfa6_0(active0, 0x84000L);
420 case 110:
421 return jjMoveStringLiteralDfa6_0(active0, 0x204000000L);
422 case 112:
423 return jjMoveStringLiteralDfa6_0(active0, 0x2000L);
424 case 116:
425 if ((active0 & 0x400000000L) != 0L)
426 return jjStartNfaWithStates_0(5, 34, 43);
427 break;
428 case 121:
429 return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
430 default :
431 break;
432 }
433 return jjStartNfa_0(4, active0);
434 }
435 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
436 {
437 if (((active0 &= old0)) == 0L)
438 return jjStartNfa_0(4, old0);
439 try { curChar = input_stream.readChar(); }
440 catch(EOFException e) {
441 jjStopStringLiteralDfa_0(5, active0);
442 return 6;
443 }
444 switch(curChar)
445 {
446 case 97:
447 return jjMoveStringLiteralDfa7_0(active0, 0x200002000L);
448 case 101:
449 if ((active0 & 0x80L) != 0L)
450 return jjStartNfaWithStates_0(6, 7, 43);
451 break;
452 case 111:
453 return jjMoveStringLiteralDfa7_0(active0, 0x80000L);
454 case 112:
455 return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
456 case 114:
457 if ((active0 & 0x400L) != 0L)
458 return jjStartNfaWithStates_0(6, 10, 43);
459 break;
460 case 116:
461 if ((active0 & 0x4000L) != 0L)
462 return jjStartNfaWithStates_0(6, 14, 43);
463 else if ((active0 & 0x8000L) != 0L)
464 return jjStartNfaWithStates_0(6, 15, 43);
465 else if ((active0 & 0x4000000L) != 0L)
466 return jjStartNfaWithStates_0(6, 26, 43);
467 break;
468 case 117:
469 return jjMoveStringLiteralDfa7_0(active0, 0x8000000L);
470 default :
471 break;
472 }
473 return jjStartNfa_0(5, active0);
474 }
475 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
476 {
477 if (((active0 &= old0)) == 0L)
478 return jjStartNfa_0(5, old0);
479 try { curChar = input_stream.readChar(); }
480 catch(EOFException e) {
481 jjStopStringLiteralDfa_0(6, active0);
482 return 7;
483 }
484 switch(curChar)
485 {
486 case 99:
487 return jjMoveStringLiteralDfa8_0(active0, 0x2000L);
488 case 101:
489 return jjMoveStringLiteralDfa8_0(active0, 0x10000L);
490 case 108:
491 if ((active0 & 0x200000000L) != 0L)
492 return jjStartNfaWithStates_0(7, 33, 43);
493 break;
494 case 116:
495 return jjMoveStringLiteralDfa8_0(active0, 0x8000000L);
496 case 119:
497 return jjMoveStringLiteralDfa8_0(active0, 0x80000L);
498 default :
499 break;
500 }
501 return jjStartNfa_0(6, active0);
502 }
503 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
504 {
505 if (((active0 &= old0)) == 0L)
506 return jjStartNfa_0(6, old0);
507 try { curChar = input_stream.readChar(); }
508 catch(EOFException e) {
509 jjStopStringLiteralDfa_0(7, active0);
510 return 8;
511 }
512 switch(curChar)
513 {
514 case 101:
515 if ((active0 & 0x2000L) != 0L)
516 return jjStartNfaWithStates_0(8, 13, 43);
517 else if ((active0 & 0x8000000L) != 0L)
518 return jjStartNfaWithStates_0(8, 27, 43);
519 return jjMoveStringLiteralDfa9_0(active0, 0x80000L);
520 case 115:
521 if ((active0 & 0x10000L) != 0L)
522 return jjStartNfaWithStates_0(8, 16, 43);
523 break;
524 default :
525 break;
526 }
527 return jjStartNfa_0(7, active0);
528 }
529 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
530 {
531 if (((active0 &= old0)) == 0L)
532 return jjStartNfa_0(7, old0);
533 try { curChar = input_stream.readChar(); }
534 catch(EOFException e) {
535 jjStopStringLiteralDfa_0(8, active0);
536 return 9;
537 }
538 switch(curChar)
539 {
540 case 100:
541 if ((active0 & 0x80000L) != 0L)
542 return jjStartNfaWithStates_0(9, 19, 43);
543 break;
544 default :
545 break;
546 }
547 return jjStartNfa_0(8, active0);
548 }
549 private final void jjCheckNAdd(int state)
550 {
551 if (jjrounds[state] != jjround)
552 {
553 jjstateSet[jjnewStateCnt++] = state;
554 jjrounds[state] = jjround;
555 }
556 }
557 private final void jjAddStates(int start, int end)
558 {
559 do {
560 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
561 } while (start++ != end);
562 }
563 private final void jjCheckNAddTwoStates(int state1, int state2)
564 {
565 jjCheckNAdd(state1);
566 jjCheckNAdd(state2);
567 }
568 private final void jjCheckNAddStates(int start, int end)
569 {
570 do {
571 jjCheckNAdd(jjnextStates[start]);
572 } while (start++ != end);
573 }
574 private final void jjCheckNAddStates(int start)
575 {
576 jjCheckNAdd(jjnextStates[start]);
577 jjCheckNAdd(jjnextStates[start + 1]);
578 }
579 static final long[] jjbitVec0 = {
580 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
581 };
582 static final long[] jjbitVec2 = {
583 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
584 };
585 static final long[] jjbitVec3 = {
586 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
587 };
588 static final long[] jjbitVec4 = {
589 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
590 };
591 static final long[] jjbitVec5 = {
592 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
593 };
594 static final long[] jjbitVec6 = {
595 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
596 };
597 static final long[] jjbitVec7 = {
598 0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
599 };
600 static final long[] jjbitVec8 = {
601 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
602 };
603 static final long[] jjbitVec9 = {
604 0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
605 };
606 static final long[] jjbitVec10 = {
607 0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
608 };
609 static final long[] jjbitVec11 = {
610 0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
611 };
612 static final long[] jjbitVec12 = {
613 0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
614 };
615 static final long[] jjbitVec13 = {
616 0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
617 };
618 static final long[] jjbitVec14 = {
619 0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
620 };
621 static final long[] jjbitVec15 = {
622 0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
623 };
624 static final long[] jjbitVec16 = {
625 0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
626 };
627 static final long[] jjbitVec17 = {
628 0x0L, 0x3fffffffeffL, 0x0L, 0x0L
629 };
630 static final long[] jjbitVec18 = {
631 0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
632 };
633 static final long[] jjbitVec19 = {
634 0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
635 };
636 static final long[] jjbitVec20 = {
637 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
638 };
639 static final long[] jjbitVec21 = {
640 0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
641 };
642 static final long[] jjbitVec22 = {
643 0x4c4000000000L, 0x0L, 0x7L, 0x0L
644 };
645 static final long[] jjbitVec23 = {
646 0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
647 };
648 static final long[] jjbitVec24 = {
649 0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
650 };
651 static final long[] jjbitVec25 = {
652 0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
653 };
654 static final long[] jjbitVec26 = {
655 0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
656 };
657 static final long[] jjbitVec27 = {
658 0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
659 };
660 static final long[] jjbitVec28 = {
661 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
662 };
663 static final long[] jjbitVec29 = {
664 0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
665 };
666 static final long[] jjbitVec30 = {
667 0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
668 };
669 static final long[] jjbitVec31 = {
670 0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
671 };
672 static final long[] jjbitVec32 = {
673 0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
674 };
675 static final long[] jjbitVec33 = {
676 0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
677 };
678 static final long[] jjbitVec34 = {
679 0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
680 };
681 static final long[] jjbitVec35 = {
682 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
683 };
684 static final long[] jjbitVec36 = {
685 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
686 };
687 static final long[] jjbitVec37 = {
688 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
689 };
690 static final long[] jjbitVec38 = {
691 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
692 };
693 static final long[] jjbitVec39 = {
694 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
695 };
696 static final long[] jjbitVec40 = {
697 0x0L, 0x0L, 0x0L, 0x21fff0000L
698 };
699 static final long[] jjbitVec41 = {
700 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
701 };
702 private final int jjMoveNfa_0(int startState, int curPos)
703 {
704 int[] nextStates;
705 int startsAt = 0;
706 jjnewStateCnt = 43;
707 int i = 1;
708 jjstateSet[0] = startState;
709 int j, kind = 0x7fffffff;
710 for (;;)
711 {
712 if (++jjround == 0x7fffffff)
713 ReInitRounds();
714 if (curChar < 64)
715 {
716 long l = 1L << curChar;
717 MatchLoop: do
718 {
719 switch(jjstateSet[--i])
720 {
721 case 3:
722 if ((0xfffffffffffff9ffL & l) != 0L)
723 {
724 if (kind > 60)
725 kind = 60;
726 }
727 if ((0x100000601L & l) != 0L)
728 {
729 if (kind > 39)
730 kind = 39;
731 jjCheckNAdd(0);
732 }
733 else if (curChar == 39)
734 jjstateSet[jjnewStateCnt++] = 31;
735 else if (curChar == 34)
736 jjstateSet[jjnewStateCnt++] = 22;
737 else if (curChar == 35)
738 {
739 if (kind > 42)
740 kind = 42;
741 jjCheckNAdd(5);
742 }
743 if (curChar == 39)
744 jjCheckNAddTwoStates(13, 14);
745 else if (curChar == 34)
746 jjCheckNAddTwoStates(10, 11);
747 else if (curChar == 35)
748 jjstateSet[jjnewStateCnt++] = 1;
749 break;
750 case 43:
751 if ((0x3ff600000000000L & l) != 0L)
752 jjCheckNAddTwoStates(39, 40);
753 else if (curChar == 58)
754 jjstateSet[jjnewStateCnt++] = 41;
755 if ((0x3ff600000000000L & l) != 0L)
756 jjCheckNAddTwoStates(36, 38);
757 else if (curChar == 58)
758 jjstateSet[jjnewStateCnt++] = 37;
759 if ((0x3ff600000000000L & l) != 0L)
760 {
761 if (kind > 54)
762 kind = 54;
763 jjCheckNAdd(35);
764 }
765 break;
766 case 0:
767 if ((0x100000601L & l) == 0L)
768 break;
769 if (kind > 39)
770 kind = 39;
771 jjCheckNAdd(0);
772 break;
773 case 1:
774 if (curChar != 35)
775 break;
776 if (kind > 40)
777 kind = 40;
778 jjCheckNAdd(2);
779 break;
780 case 2:
781 if ((0xfffffffffffffbfeL & l) == 0L)
782 break;
783 if (kind > 40)
784 kind = 40;
785 jjCheckNAdd(2);
786 break;
787 case 4:
788 if (curChar != 35)
789 break;
790 if (kind > 42)
791 kind = 42;
792 jjCheckNAdd(5);
793 break;
794 case 5:
795 if ((0xfffffffffffffbfeL & l) == 0L)
796 break;
797 if (kind > 42)
798 kind = 42;
799 jjCheckNAdd(5);
800 break;
801 case 8:
802 if ((0x3ff600000000000L & l) == 0L)
803 break;
804 if (kind > 55)
805 kind = 55;
806 jjstateSet[jjnewStateCnt++] = 8;
807 break;
808 case 9:
809 if (curChar == 34)
810 jjCheckNAddTwoStates(10, 11);
811 break;
812 case 10:
813 if ((0xfffffffbfffffffeL & l) != 0L)
814 jjCheckNAddTwoStates(10, 11);
815 break;
816 case 11:
817 case 20:
818 if (curChar == 34 && kind > 58)
819 kind = 58;
820 break;
821 case 12:
822 if (curChar == 39)
823 jjCheckNAddTwoStates(13, 14);
824 break;
825 case 13:
826 if ((0xffffff7ffffffffeL & l) != 0L)
827 jjCheckNAddTwoStates(13, 14);
828 break;
829 case 14:
830 case 29:
831 if (curChar == 39 && kind > 58)
832 kind = 58;
833 break;
834 case 15:
835 if (curChar == 34)
836 jjCheckNAddStates(0, 2);
837 break;
838 case 16:
839 if ((0xfffffffbffffffffL & l) != 0L)
840 jjCheckNAddStates(0, 2);
841 break;
842 case 17:
843 case 19:
844 if (curChar == 34)
845 jjCheckNAdd(16);
846 break;
847 case 18:
848 if (curChar == 34)
849 jjAddStates(3, 4);
850 break;
851 case 21:
852 if (curChar == 34)
853 jjstateSet[jjnewStateCnt++] = 20;
854 break;
855 case 22:
856 if (curChar == 34)
857 jjstateSet[jjnewStateCnt++] = 15;
858 break;
859 case 23:
860 if (curChar == 34)
861 jjstateSet[jjnewStateCnt++] = 22;
862 break;
863 case 24:
864 if (curChar == 39)
865 jjCheckNAddStates(5, 7);
866 break;
867 case 25:
868 if ((0xffffff7fffffffffL & l) != 0L)
869 jjCheckNAddStates(5, 7);
870 break;
871 case 26:
872 case 28:
873 if (curChar == 39)
874 jjCheckNAdd(25);
875 break;
876 case 27:
877 if (curChar == 39)
878 jjAddStates(8, 9);
879 break;
880 case 30:
881 if (curChar == 39)
882 jjstateSet[jjnewStateCnt++] = 29;
883 break;
884 case 31:
885 if (curChar == 39)
886 jjstateSet[jjnewStateCnt++] = 24;
887 break;
888 case 32:
889 if (curChar == 39)
890 jjstateSet[jjnewStateCnt++] = 31;
891 break;
892 case 33:
893 if ((0xfffffffffffff9ffL & l) != 0L && kind > 60)
894 kind = 60;
895 break;
896 case 35:
897 if ((0x3ff600000000000L & l) == 0L)
898 break;
899 if (kind > 54)
900 kind = 54;
901 jjCheckNAdd(35);
902 break;
903 case 36:
904 if ((0x3ff600000000000L & l) != 0L)
905 jjCheckNAddTwoStates(36, 38);
906 break;
907 case 37:
908 if (curChar == 42 && kind > 56)
909 kind = 56;
910 break;
911 case 38:
912 if (curChar == 58)
913 jjstateSet[jjnewStateCnt++] = 37;
914 break;
915 case 39:
916 if ((0x3ff600000000000L & l) != 0L)
917 jjCheckNAddTwoStates(39, 40);
918 break;
919 case 40:
920 if (curChar == 58)
921 jjstateSet[jjnewStateCnt++] = 41;
922 break;
923 case 42:
924 if ((0x3ff600000000000L & l) == 0L)
925 break;
926 if (kind > 57)
927 kind = 57;
928 jjstateSet[jjnewStateCnt++] = 42;
929 break;
930 default : break;
931 }
932 } while(i != startsAt);
933 }
934 else if (curChar < 128)
935 {
936 long l = 1L << (curChar & 077);
937 MatchLoop: do
938 {
939 switch(jjstateSet[--i])
940 {
941 case 3:
942 if (kind > 60)
943 kind = 60;
944 if ((0x7fffffe87fffffeL & l) != 0L)
945 {
946 if (kind > 54)
947 kind = 54;
948 jjCheckNAddStates(10, 14);
949 }
950 else if (curChar == 92)
951 jjstateSet[jjnewStateCnt++] = 7;
952 break;
953 case 43:
954 if ((0x7fffffe87fffffeL & l) != 0L)
955 jjCheckNAddTwoStates(39, 40);
956 if ((0x7fffffe87fffffeL & l) != 0L)
957 jjCheckNAddTwoStates(36, 38);
958 if ((0x7fffffe87fffffeL & l) != 0L)
959 {
960 if (kind > 54)
961 kind = 54;
962 jjCheckNAdd(35);
963 }
964 break;
965 case 2:
966 if (kind > 40)
967 kind = 40;
968 jjstateSet[jjnewStateCnt++] = 2;
969 break;
970 case 5:
971 if (kind > 42)
972 kind = 42;
973 jjstateSet[jjnewStateCnt++] = 5;
974 break;
975 case 6:
976 if (curChar == 92)
977 jjstateSet[jjnewStateCnt++] = 7;
978 break;
979 case 7:
980 case 8:
981 if ((0x7fffffe87fffffeL & l) == 0L)
982 break;
983 if (kind > 55)
984 kind = 55;
985 jjCheckNAdd(8);
986 break;
987 case 10:
988 jjAddStates(15, 16);
989 break;
990 case 13:
991 jjAddStates(17, 18);
992 break;
993 case 16:
994 jjAddStates(0, 2);
995 break;
996 case 25:
997 jjAddStates(5, 7);
998 break;
999 case 33:
1000 if (kind > 60)
1001 kind = 60;
1002 break;
1003 case 34:
1004 if ((0x7fffffe87fffffeL & l) == 0L)
1005 break;
1006 if (kind > 54)
1007 kind = 54;
1008 jjCheckNAddStates(10, 14);
1009 break;
1010 case 35:
1011 if ((0x7fffffe87fffffeL & l) == 0L)
1012 break;
1013 if (kind > 54)
1014 kind = 54;
1015 jjCheckNAdd(35);
1016 break;
1017 case 36:
1018 if ((0x7fffffe87fffffeL & l) != 0L)
1019 jjCheckNAddTwoStates(36, 38);
1020 break;
1021 case 39:
1022 if ((0x7fffffe87fffffeL & l) != 0L)
1023 jjCheckNAddTwoStates(39, 40);
1024 break;
1025 case 41:
1026 case 42:
1027 if ((0x7fffffe87fffffeL & l) == 0L)
1028 break;
1029 if (kind > 57)
1030 kind = 57;
1031 jjCheckNAdd(42);
1032 break;
1033 default : break;
1034 }
1035 } while(i != startsAt);
1036 }
1037 else
1038 {
1039 int hiByte = (int)(curChar >> 8);
1040 int i1 = hiByte >> 6;
1041 long l1 = 1L << (hiByte & 077);
1042 int i2 = (curChar & 0xff) >> 6;
1043 long l2 = 1L << (curChar & 077);
1044 MatchLoop: do
1045 {
1046 switch(jjstateSet[--i])
1047 {
1048 case 3:
1049 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1050 {
1051 if (kind > 60)
1052 kind = 60;
1053 }
1054 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1055 {
1056 if (kind > 54)
1057 kind = 54;
1058 jjCheckNAddStates(10, 14);
1059 }
1060 break;
1061 case 43:
1062 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1063 {
1064 if (kind > 54)
1065 kind = 54;
1066 jjCheckNAdd(35);
1067 }
1068 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1069 jjCheckNAddTwoStates(36, 38);
1070 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1071 jjCheckNAddTwoStates(39, 40);
1072 break;
1073 case 2:
1074 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1075 break;
1076 if (kind > 40)
1077 kind = 40;
1078 jjstateSet[jjnewStateCnt++] = 2;
1079 break;
1080 case 5:
1081 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1082 break;
1083 if (kind > 42)
1084 kind = 42;
1085 jjstateSet[jjnewStateCnt++] = 5;
1086 break;
1087 case 7:
1088 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1089 break;
1090 if (kind > 55)
1091 kind = 55;
1092 jjCheckNAdd(8);
1093 break;
1094 case 8:
1095 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1096 break;
1097 if (kind > 55)
1098 kind = 55;
1099 jjCheckNAdd(8);
1100 break;
1101 case 10:
1102 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1103 jjAddStates(15, 16);
1104 break;
1105 case 13:
1106 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1107 jjAddStates(17, 18);
1108 break;
1109 case 16:
1110 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1111 jjAddStates(0, 2);
1112 break;
1113 case 25:
1114 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1115 jjAddStates(5, 7);
1116 break;
1117 case 33:
1118 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1119 kind = 60;
1120 break;
1121 case 34:
1122 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1123 break;
1124 if (kind > 54)
1125 kind = 54;
1126 jjCheckNAddStates(10, 14);
1127 break;
1128 case 35:
1129 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1130 break;
1131 if (kind > 54)
1132 kind = 54;
1133 jjCheckNAdd(35);
1134 break;
1135 case 36:
1136 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1137 jjCheckNAddTwoStates(36, 38);
1138 break;
1139 case 39:
1140 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1141 jjCheckNAddTwoStates(39, 40);
1142 break;
1143 case 41:
1144 if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1145 break;
1146 if (kind > 57)
1147 kind = 57;
1148 jjCheckNAdd(42);
1149 break;
1150 case 42:
1151 if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1152 break;
1153 if (kind > 57)
1154 kind = 57;
1155 jjCheckNAdd(42);
1156 break;
1157 default : break;
1158 }
1159 } while(i != startsAt);
1160 }
1161 if (kind != 0x7fffffff)
1162 {
1163 jjmatchedKind = kind;
1164 jjmatchedPos = curPos;
1165 kind = 0x7fffffff;
1166 }
1167 ++curPos;
1168 if ((i = jjnewStateCnt) == (startsAt = 43 - (jjnewStateCnt = startsAt)))
1169 return curPos;
1170 try { curChar = input_stream.readChar(); }
1171 catch(EOFException e) { return curPos; }
1172 }
1173 }
1174 private final int jjMoveStringLiteralDfa0_1()
1175 {
1176 return jjMoveNfa_1(1, 0);
1177 }
1178 private final int jjMoveNfa_1(int startState, int curPos)
1179 {
1180 int[] nextStates;
1181 int startsAt = 0;
1182 jjnewStateCnt = 10;
1183 int i = 1;
1184 jjstateSet[0] = startState;
1185 int j, kind = 0x7fffffff;
1186 for (;;)
1187 {
1188 if (++jjround == 0x7fffffff)
1189 ReInitRounds();
1190 if (curChar < 64)
1191 {
1192 long l = 1L << curChar;
1193 MatchLoop: do
1194 {
1195 switch(jjstateSet[--i])
1196 {
1197 case 1:
1198 if ((0xfffffffffffff9ffL & l) != 0L)
1199 {
1200 if (kind > 60)
1201 kind = 60;
1202 }
1203 if ((0x100000601L & l) != 0L)
1204 {
1205 if (kind > 39)
1206 kind = 39;
1207 jjCheckNAdd(0);
1208 }
1209 if ((0x401L & l) != 0L)
1210 jjCheckNAddStates(19, 22);
1211 break;
1212 case 0:
1213 if ((0x100000601L & l) == 0L)
1214 break;
1215 if (kind > 39)
1216 kind = 39;
1217 jjCheckNAdd(0);
1218 break;
1219 case 2:
1220 if ((0x401L & l) != 0L)
1221 jjCheckNAddStates(19, 22);
1222 break;
1223 case 3:
1224 if ((0x100000200L & l) != 0L)
1225 jjCheckNAddTwoStates(3, 6);
1226 break;
1227 case 4:
1228 if (curChar != 35)
1229 break;
1230 if (kind > 43)
1231 kind = 43;
1232 jjCheckNAdd(5);
1233 break;
1234 case 5:
1235 if ((0xfffffffffffffbfeL & l) == 0L)
1236 break;
1237 if (kind > 43)
1238 kind = 43;
1239 jjCheckNAdd(5);
1240 break;
1241 case 6:
1242 if (curChar == 35)
1243 jjstateSet[jjnewStateCnt++] = 4;
1244 break;
1245 case 7:
1246 if ((0x100000200L & l) != 0L)
1247 jjCheckNAddTwoStates(7, 8);
1248 break;
1249 case 8:
1250 if (curChar != 35)
1251 break;
1252 if (kind > 44)
1253 kind = 44;
1254 jjCheckNAdd(9);
1255 break;
1256 case 9:
1257 if ((0xfffffffffffffbfeL & l) == 0L)
1258 break;
1259 if (kind > 44)
1260 kind = 44;
1261 jjCheckNAdd(9);
1262 break;
1263 default : break;
1264 }
1265 } while(i != startsAt);
1266 }
1267 else if (curChar < 128)
1268 {
1269 long l = 1L << (curChar & 077);
1270 MatchLoop: do
1271 {
1272 switch(jjstateSet[--i])
1273 {
1274 case 1:
1275 if (kind > 60)
1276 kind = 60;
1277 break;
1278 case 5:
1279 if (kind > 43)
1280 kind = 43;
1281 jjstateSet[jjnewStateCnt++] = 5;
1282 break;
1283 case 9:
1284 if (kind > 44)
1285 kind = 44;
1286 jjstateSet[jjnewStateCnt++] = 9;
1287 break;
1288 default : break;
1289 }
1290 } while(i != startsAt);
1291 }
1292 else
1293 {
1294 int hiByte = (int)(curChar >> 8);
1295 int i1 = hiByte >> 6;
1296 long l1 = 1L << (hiByte & 077);
1297 int i2 = (curChar & 0xff) >> 6;
1298 long l2 = 1L << (curChar & 077);
1299 MatchLoop: do
1300 {
1301 switch(jjstateSet[--i])
1302 {
1303 case 1:
1304 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1305 kind = 60;
1306 break;
1307 case 5:
1308 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1309 break;
1310 if (kind > 43)
1311 kind = 43;
1312 jjstateSet[jjnewStateCnt++] = 5;
1313 break;
1314 case 9:
1315 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1316 break;
1317 if (kind > 44)
1318 kind = 44;
1319 jjstateSet[jjnewStateCnt++] = 9;
1320 break;
1321 default : break;
1322 }
1323 } while(i != startsAt);
1324 }
1325 if (kind != 0x7fffffff)
1326 {
1327 jjmatchedKind = kind;
1328 jjmatchedPos = curPos;
1329 kind = 0x7fffffff;
1330 }
1331 ++curPos;
1332 if ((i = jjnewStateCnt) == (startsAt = 10 - (jjnewStateCnt = startsAt)))
1333 return curPos;
1334 try { curChar = input_stream.readChar(); }
1335 catch(EOFException e) { return curPos; }
1336 }
1337 }
1338 private final int jjMoveStringLiteralDfa0_2()
1339 {
1340 return jjMoveNfa_2(1, 0);
1341 }
1342 private final int jjMoveNfa_2(int startState, int curPos)
1343 {
1344 int[] nextStates;
1345 int startsAt = 0;
1346 jjnewStateCnt = 7;
1347 int i = 1;
1348 jjstateSet[0] = startState;
1349 int j, kind = 0x7fffffff;
1350 for (;;)
1351 {
1352 if (++jjround == 0x7fffffff)
1353 ReInitRounds();
1354 if (curChar < 64)
1355 {
1356 long l = 1L << curChar;
1357 MatchLoop: do
1358 {
1359 switch(jjstateSet[--i])
1360 {
1361 case 1:
1362 if ((0xfffffffffffff9ffL & l) != 0L)
1363 {
1364 if (kind > 60)
1365 kind = 60;
1366 }
1367 if ((0x100000601L & l) != 0L)
1368 {
1369 if (kind > 39)
1370 kind = 39;
1371 jjCheckNAdd(0);
1372 }
1373 if ((0x401L & l) != 0L)
1374 jjCheckNAddTwoStates(2, 5);
1375 break;
1376 case 0:
1377 if ((0x100000601L & l) == 0L)
1378 break;
1379 if (kind > 39)
1380 kind = 39;
1381 jjCheckNAdd(0);
1382 break;
1383 case 2:
1384 if ((0x100000200L & l) != 0L)
1385 jjCheckNAddTwoStates(2, 5);
1386 break;
1387 case 3:
1388 if (curChar != 35)
1389 break;
1390 if (kind > 41)
1391 kind = 41;
1392 jjCheckNAdd(4);
1393 break;
1394 case 4:
1395 if ((0xfffffffffffffbfeL & l) == 0L)
1396 break;
1397 if (kind > 41)
1398 kind = 41;
1399 jjCheckNAdd(4);
1400 break;
1401 case 5:
1402 if (curChar == 35)
1403 jjstateSet[jjnewStateCnt++] = 3;
1404 break;
1405 case 6:
1406 if ((0xfffffffffffff9ffL & l) != 0L && kind > 60)
1407 kind = 60;
1408 break;
1409 default : break;
1410 }
1411 } while(i != startsAt);
1412 }
1413 else if (curChar < 128)
1414 {
1415 long l = 1L << (curChar & 077);
1416 MatchLoop: do
1417 {
1418 switch(jjstateSet[--i])
1419 {
1420 case 1:
1421 if (kind > 60)
1422 kind = 60;
1423 break;
1424 case 4:
1425 if (kind > 41)
1426 kind = 41;
1427 jjstateSet[jjnewStateCnt++] = 4;
1428 break;
1429 default : break;
1430 }
1431 } while(i != startsAt);
1432 }
1433 else
1434 {
1435 int hiByte = (int)(curChar >> 8);
1436 int i1 = hiByte >> 6;
1437 long l1 = 1L << (hiByte & 077);
1438 int i2 = (curChar & 0xff) >> 6;
1439 long l2 = 1L << (curChar & 077);
1440 MatchLoop: do
1441 {
1442 switch(jjstateSet[--i])
1443 {
1444 case 1:
1445 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1446 kind = 60;
1447 break;
1448 case 4:
1449 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1450 break;
1451 if (kind > 41)
1452 kind = 41;
1453 jjstateSet[jjnewStateCnt++] = 4;
1454 break;
1455 default : break;
1456 }
1457 } while(i != startsAt);
1458 }
1459 if (kind != 0x7fffffff)
1460 {
1461 jjmatchedKind = kind;
1462 jjmatchedPos = curPos;
1463 kind = 0x7fffffff;
1464 }
1465 ++curPos;
1466 if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
1467 return curPos;
1468 try { curChar = input_stream.readChar(); }
1469 catch(EOFException e) { return curPos; }
1470 }
1471 }
1472 static final int[] jjnextStates = {
1473 16, 17, 18, 19, 21, 25, 26, 27, 28, 30, 35, 36, 38, 39, 40, 10,
1474 11, 13, 14, 3, 6, 7, 8,
1475 };
1476 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1477 {
1478 switch(hiByte)
1479 {
1480 case 0:
1481 return ((jjbitVec2[i2] & l2) != 0L);
1482 default :
1483 if ((jjbitVec0[i1] & l1) != 0L)
1484 return true;
1485 return false;
1486 }
1487 }
1488 private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1489 {
1490 switch(hiByte)
1491 {
1492 case 0:
1493 return ((jjbitVec4[i2] & l2) != 0L);
1494 case 1:
1495 return ((jjbitVec5[i2] & l2) != 0L);
1496 case 2:
1497 return ((jjbitVec6[i2] & l2) != 0L);
1498 case 3:
1499 return ((jjbitVec7[i2] & l2) != 0L);
1500 case 4:
1501 return ((jjbitVec8[i2] & l2) != 0L);
1502 case 5:
1503 return ((jjbitVec9[i2] & l2) != 0L);
1504 case 6:
1505 return ((jjbitVec10[i2] & l2) != 0L);
1506 case 9:
1507 return ((jjbitVec11[i2] & l2) != 0L);
1508 case 10:
1509 return ((jjbitVec12[i2] & l2) != 0L);
1510 case 11:
1511 return ((jjbitVec13[i2] & l2) != 0L);
1512 case 12:
1513 return ((jjbitVec14[i2] & l2) != 0L);
1514 case 13:
1515 return ((jjbitVec15[i2] & l2) != 0L);
1516 case 14:
1517 return ((jjbitVec16[i2] & l2) != 0L);
1518 case 15:
1519 return ((jjbitVec17[i2] & l2) != 0L);
1520 case 16:
1521 return ((jjbitVec18[i2] & l2) != 0L);
1522 case 17:
1523 return ((jjbitVec19[i2] & l2) != 0L);
1524 case 30:
1525 return ((jjbitVec20[i2] & l2) != 0L);
1526 case 31:
1527 return ((jjbitVec21[i2] & l2) != 0L);
1528 case 33:
1529 return ((jjbitVec22[i2] & l2) != 0L);
1530 case 48:
1531 return ((jjbitVec23[i2] & l2) != 0L);
1532 case 49:
1533 return ((jjbitVec24[i2] & l2) != 0L);
1534 case 159:
1535 return ((jjbitVec25[i2] & l2) != 0L);
1536 case 215:
1537 return ((jjbitVec26[i2] & l2) != 0L);
1538 default :
1539 if ((jjbitVec3[i1] & l1) != 0L)
1540 return true;
1541 return false;
1542 }
1543 }
1544 private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1545 {
1546 switch(hiByte)
1547 {
1548 case 0:
1549 return ((jjbitVec27[i2] & l2) != 0L);
1550 case 1:
1551 return ((jjbitVec5[i2] & l2) != 0L);
1552 case 2:
1553 return ((jjbitVec28[i2] & l2) != 0L);
1554 case 3:
1555 return ((jjbitVec29[i2] & l2) != 0L);
1556 case 4:
1557 return ((jjbitVec30[i2] & l2) != 0L);
1558 case 5:
1559 return ((jjbitVec31[i2] & l2) != 0L);
1560 case 6:
1561 return ((jjbitVec32[i2] & l2) != 0L);
1562 case 9:
1563 return ((jjbitVec33[i2] & l2) != 0L);
1564 case 10:
1565 return ((jjbitVec34[i2] & l2) != 0L);
1566 case 11:
1567 return ((jjbitVec35[i2] & l2) != 0L);
1568 case 12:
1569 return ((jjbitVec36[i2] & l2) != 0L);
1570 case 13:
1571 return ((jjbitVec37[i2] & l2) != 0L);
1572 case 14:
1573 return ((jjbitVec38[i2] & l2) != 0L);
1574 case 15:
1575 return ((jjbitVec39[i2] & l2) != 0L);
1576 case 16:
1577 return ((jjbitVec18[i2] & l2) != 0L);
1578 case 17:
1579 return ((jjbitVec19[i2] & l2) != 0L);
1580 case 30:
1581 return ((jjbitVec20[i2] & l2) != 0L);
1582 case 31:
1583 return ((jjbitVec21[i2] & l2) != 0L);
1584 case 32:
1585 return ((jjbitVec40[i2] & l2) != 0L);
1586 case 33:
1587 return ((jjbitVec22[i2] & l2) != 0L);
1588 case 48:
1589 return ((jjbitVec41[i2] & l2) != 0L);
1590 case 49:
1591 return ((jjbitVec24[i2] & l2) != 0L);
1592 case 159:
1593 return ((jjbitVec25[i2] & l2) != 0L);
1594 case 215:
1595 return ((jjbitVec26[i2] & l2) != 0L);
1596 default :
1597 if ((jjbitVec3[i1] & l1) != 0L)
1598 return true;
1599 return false;
1600 }
1601 }
1602 public static final String[] jjstrLiteralImages = {
1603 "", "\133", "\75", "\46\75", "\174\75", "\163\164\141\162\164",
1604 "\144\151\166", "\151\156\143\154\165\144\145", "\176", "\135",
1605 "\147\162\141\155\155\141\162", "\173", "\175", "\156\141\155\145\163\160\141\143\145",
1606 "\144\145\146\141\165\154\164", "\151\156\150\145\162\151\164", "\144\141\164\141\164\171\160\145\163",
1607 "\145\155\160\164\171", "\164\145\170\164", "\156\157\164\101\154\154\157\167\145\144", "\174", "\46",
1608 "\54", "\53", "\77", "\52", "\145\154\145\155\145\156\164",
1609 "\141\164\164\162\151\142\165\164\145", "\50", "\51", "\55", "\154\151\163\164", "\155\151\170\145\144",
1610 "\145\170\164\145\162\156\141\154", "\160\141\162\145\156\164", "\163\164\162\151\156\147",
1611 "\164\157\153\145\156", null, null, null, null, null, null, null, null, null, null, null, null, null,
1612 null, null, null, null, null, null, null, null, null, "\76\76", null, };
1613 public static final String[] lexStateNames = {
1614 "DEFAULT",
1615 "AFTER_SINGLE_LINE_COMMENT",
1616 "AFTER_DOCUMENTATION",
1617 };
1618 public static final int[] jjnewLexState = {
1619 -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,
1620 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 2, -1, 1, 2, -1, -1, -1, -1, -1, -1,
1621 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1622 };
1623 static final long[] jjtoToken = {
1624 0x1fc00b1fffffffffL,
1625 };
1626 static final long[] jjtoSkip = {
1627 0x148000000000L,
1628 };
1629 static final long[] jjtoSpecial = {
1630 0x140000000000L,
1631 };
1632 private UCode_UCodeESC_CharStream input_stream;
1633 private final int[] jjrounds = new int[43];
1634 private final int[] jjstateSet = new int[86];
1635 StringBuffer image;
1636 int jjimageLen;
1637 int lengthOfMatch;
1638 protected char curChar;
1639 public CompactSyntaxTokenManager(UCode_UCodeESC_CharStream stream)
1640 {
1641 if (UCode_UCodeESC_CharStream.staticFlag)
1642 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1643 input_stream = stream;
1644 }
1645 public CompactSyntaxTokenManager(UCode_UCodeESC_CharStream stream, int lexState)
1646 {
1647 this(stream);
1648 SwitchTo(lexState);
1649 }
1650 public void ReInit(UCode_UCodeESC_CharStream stream)
1651 {
1652 jjmatchedPos = jjnewStateCnt = 0;
1653 curLexState = defaultLexState;
1654 input_stream = stream;
1655 ReInitRounds();
1656 }
1657 private final void ReInitRounds()
1658 {
1659 int i;
1660 jjround = 0x80000001;
1661 for (i = 43; i-- > 0;)
1662 jjrounds[i] = 0x80000000;
1663 }
1664 public void ReInit(UCode_UCodeESC_CharStream stream, int lexState)
1665 {
1666 ReInit(stream);
1667 SwitchTo(lexState);
1668 }
1669 public void SwitchTo(int lexState)
1670 {
1671 if (lexState >= 3 || lexState < 0)
1672 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1673 else
1674 curLexState = lexState;
1675 }
1676
1677 private final Token jjFillToken()
1678 {
1679 Token t = Token.newToken(jjmatchedKind);
1680 t.kind = jjmatchedKind;
1681 String im = jjstrLiteralImages[jjmatchedKind];
1682 t.image = (im == null) ? input_stream.GetImage() : im;
1683 t.beginLine = input_stream.getBeginLine();
1684 t.beginColumn = input_stream.getBeginColumn();
1685 t.endLine = input_stream.getEndLine();
1686 t.endColumn = input_stream.getEndColumn();
1687 return t;
1688 }
1689
1690 int curLexState = 0;
1691 int defaultLexState = 0;
1692 int jjnewStateCnt;
1693 int jjround;
1694 int jjmatchedPos;
1695 int jjmatchedKind;
1696
1697 public final Token getNextToken()
1698 {
1699 int kind;
1700 Token specialToken = null;
1701 Token matchedToken;
1702 int curPos = 0;
1703
1704 EOFLoop :
1705 for (;;)
1706 {
1707 try
1708 {
1709 curChar = input_stream.BeginToken();
1710 }
1711 catch(EOFException e)
1712 {
1713 jjmatchedKind = 0;
1714 matchedToken = jjFillToken();
1715 matchedToken.specialToken = specialToken;
1716 return matchedToken;
1717 }
1718 image = null;
1719 jjimageLen = 0;
1720
1721 switch(curLexState)
1722 {
1723 case 0:
1724 jjmatchedKind = 0x7fffffff;
1725 jjmatchedPos = 0;
1726 curPos = jjMoveStringLiteralDfa0_0();
1727 break;
1728 case 1:
1729 jjmatchedKind = 0x7fffffff;
1730 jjmatchedPos = 0;
1731 curPos = jjMoveStringLiteralDfa0_1();
1732 break;
1733 case 2:
1734 jjmatchedKind = 0x7fffffff;
1735 jjmatchedPos = 0;
1736 curPos = jjMoveStringLiteralDfa0_2();
1737 break;
1738 }
1739 if (jjmatchedKind != 0x7fffffff)
1740 {
1741 if (jjmatchedPos + 1 < curPos)
1742 input_stream.backup(curPos - jjmatchedPos - 1);
1743 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1744 {
1745 matchedToken = jjFillToken();
1746 matchedToken.specialToken = specialToken;
1747 if (jjnewLexState[jjmatchedKind] != -1)
1748 curLexState = jjnewLexState[jjmatchedKind];
1749 return matchedToken;
1750 }
1751 else
1752 {
1753 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1754 {
1755 matchedToken = jjFillToken();
1756 if (specialToken == null)
1757 specialToken = matchedToken;
1758 else
1759 {
1760 matchedToken.specialToken = specialToken;
1761 specialToken = (specialToken.next = matchedToken);
1762 }
1763 SkipLexicalActions(matchedToken);
1764 }
1765 else
1766 SkipLexicalActions(null);
1767 if (jjnewLexState[jjmatchedKind] != -1)
1768 curLexState = jjnewLexState[jjmatchedKind];
1769 continue EOFLoop;
1770 }
1771 }
1772 int error_line = input_stream.getEndLine();
1773 int error_column = input_stream.getEndColumn();
1774 String error_after = null;
1775 boolean EOFSeen = false;
1776 try { input_stream.readChar(); input_stream.backup(1); }
1777 catch (EOFException e1) {
1778 EOFSeen = true;
1779 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1780 if (curChar == '\n' || curChar == '\r') {
1781 error_line++;
1782 error_column = 0;
1783 }
1784 else
1785 error_column++;
1786 }
1787 if (!EOFSeen) {
1788 input_stream.backup(1);
1789 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1790 }
1791 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1792 }
1793 }
1794
1795 final void SkipLexicalActions(Token matchedToken)
1796 {
1797 switch(jjmatchedKind)
1798 {
1799 default :
1800 break;
1801 }
1802 }
1803 }