5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 /*
26 * Copyright (C) 2004-2011
27 *
28 * Permission is hereby granted, free of charge, to any person obtaining a copy
29 * of this software and associated documentation files (the "Software"), to deal
30 * in the Software without restriction, including without limitation the rights
31 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
32 * copies of the Software, and to permit persons to whom the Software is
33 * furnished to do so, subject to the following conditions:
34 *
35 * The above copyright notice and this permission notice shall be included in
36 * all copies or substantial portions of the Software.
37 *
38 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
39 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
40 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
41 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
42 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
43 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
44 * THE SOFTWARE.
45 */
46 /* Generated By:JavaCC: Do not edit this line. CompactSyntaxTokenManager.java */
47 package com.sun.xml.internal.rngom.parse.compact;
48 import java.io.Reader;
49 import java.net.MalformedURLException;
50 import java.net.URL;
51 import java.util.Arrays;
52 import java.util.ArrayList;
53 import java.util.Collections;
54 import java.util.Enumeration;
55 import java.util.Hashtable;
56 import java.util.List;
57 import com.sun.xml.internal.rngom.ast.builder.Annotations;
58 import com.sun.xml.internal.rngom.ast.builder.BuildException;
59 import com.sun.xml.internal.rngom.ast.builder.CommentList;
60 import com.sun.xml.internal.rngom.ast.builder.DataPatternBuilder;
61 import com.sun.xml.internal.rngom.ast.builder.Div;
62 import com.sun.xml.internal.rngom.ast.builder.ElementAnnotationBuilder;
63 import com.sun.xml.internal.rngom.ast.builder.Grammar;
64 import com.sun.xml.internal.rngom.ast.builder.GrammarSection;
65 import com.sun.xml.internal.rngom.ast.builder.Include;
66 import com.sun.xml.internal.rngom.ast.builder.IncludedGrammar;
67 import com.sun.xml.internal.rngom.ast.builder.NameClassBuilder;
68 import com.sun.xml.internal.rngom.ast.builder.SchemaBuilder;
69 import com.sun.xml.internal.rngom.ast.builder.Scope;
70 import com.sun.xml.internal.rngom.ast.om.Location;
71 import com.sun.xml.internal.rngom.ast.om.ParsedElementAnnotation;
72 import com.sun.xml.internal.rngom.ast.om.ParsedNameClass;
73 import com.sun.xml.internal.rngom.ast.om.ParsedPattern;
74 import com.sun.xml.internal.rngom.parse.Context;
75 import com.sun.xml.internal.rngom.parse.IllegalSchemaException;
76 import com.sun.xml.internal.rngom.parse.Parseable;
77 import org.xml.sax.ErrorHandler;
78 import org.xml.sax.SAXException;
79 import org.xml.sax.SAXParseException;
80 import org.xml.sax.helpers.LocatorImpl;
81 import com.sun.xml.internal.rngom.util.Localizer;
82 import com.sun.xml.internal.rngom.xml.util.WellKnownNamespaces;
83
84 /** Token Manager. */
85 public class CompactSyntaxTokenManager implements CompactSyntaxConstants
86 {
87
88 /** Debug output. */
89 public java.io.PrintStream debugStream = System.out;
90 /** Set debug output. */
91 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
92 private final int jjStopStringLiteralDfa_0(int pos, long active0)
93 {
94 switch (pos)
95 {
96 case 0:
97 if ((active0 & 0x1f8c0fe4e0L) != 0L)
98 {
99 jjmatchedKind = 54;
100 return 43;
101 }
102 if ((active0 & 0x800000000000000L) != 0L)
103 {
104 jjmatchedKind = 60;
105 return -1;
106 }
107 return -1;
108 case 1:
109 if ((active0 & 0x1f8c0fe4e0L) != 0L)
110 {
183 return 43;
184 return -1;
185 case 8:
186 if ((active0 & 0x80000L) != 0L)
187 {
188 jjmatchedKind = 54;
189 jjmatchedPos = 8;
190 return 43;
191 }
192 if ((active0 & 0x8012000L) != 0L)
193 return 43;
194 return -1;
195 default :
196 return -1;
197 }
198 }
199 private final int jjStartNfa_0(int pos, long active0)
200 {
201 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
202 }
203 private int jjStopAtPos(int pos, int kind)
204 {
205 jjmatchedKind = kind;
206 jjmatchedPos = pos;
207 return pos + 1;
208 }
209 private int jjMoveStringLiteralDfa0_0()
210 {
211 switch(curChar)
212 {
213 case 38:
214 jjmatchedKind = 21;
215 return jjMoveStringLiteralDfa1_0(0x8L);
216 case 40:
217 return jjStopAtPos(0, 28);
218 case 41:
219 return jjStopAtPos(0, 29);
220 case 42:
221 return jjStopAtPos(0, 25);
222 case 43:
223 return jjStopAtPos(0, 23);
224 case 44:
225 return jjStopAtPos(0, 22);
226 case 45:
227 return jjStopAtPos(0, 30);
228 case 61:
229 return jjStopAtPos(0, 2);
253 return jjMoveStringLiteralDfa1_0(0x82000L);
254 case 112:
255 return jjMoveStringLiteralDfa1_0(0x400000000L);
256 case 115:
257 return jjMoveStringLiteralDfa1_0(0x800000020L);
258 case 116:
259 return jjMoveStringLiteralDfa1_0(0x1000040000L);
260 case 123:
261 return jjStopAtPos(0, 11);
262 case 124:
263 jjmatchedKind = 20;
264 return jjMoveStringLiteralDfa1_0(0x10L);
265 case 125:
266 return jjStopAtPos(0, 12);
267 case 126:
268 return jjStopAtPos(0, 8);
269 default :
270 return jjMoveNfa_0(3, 0);
271 }
272 }
273 private int jjMoveStringLiteralDfa1_0(long active0)
274 {
275 try { curChar = input_stream.readChar(); }
276 catch(java.io.IOException e) {
277 jjStopStringLiteralDfa_0(0, active0);
278 return 1;
279 }
280 switch(curChar)
281 {
282 case 61:
283 if ((active0 & 0x8L) != 0L)
284 return jjStopAtPos(1, 3);
285 else if ((active0 & 0x10L) != 0L)
286 return jjStopAtPos(1, 4);
287 break;
288 case 62:
289 if ((active0 & 0x800000000000000L) != 0L)
290 return jjStopAtPos(1, 59);
291 break;
292 case 97:
293 return jjMoveStringLiteralDfa2_0(active0, 0x400012000L);
297 return jjMoveStringLiteralDfa2_0(active0, 0x180000040L);
298 case 108:
299 return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
300 case 109:
301 return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
302 case 110:
303 return jjMoveStringLiteralDfa2_0(active0, 0x8080L);
304 case 111:
305 return jjMoveStringLiteralDfa2_0(active0, 0x1000080000L);
306 case 114:
307 return jjMoveStringLiteralDfa2_0(active0, 0x400L);
308 case 116:
309 return jjMoveStringLiteralDfa2_0(active0, 0x808000020L);
310 case 120:
311 return jjMoveStringLiteralDfa2_0(active0, 0x200000000L);
312 default :
313 break;
314 }
315 return jjStartNfa_0(0, active0);
316 }
317 private int jjMoveStringLiteralDfa2_0(long old0, long active0)
318 {
319 if (((active0 &= old0)) == 0L)
320 return jjStartNfa_0(0, old0);
321 try { curChar = input_stream.readChar(); }
322 catch(java.io.IOException e) {
323 jjStopStringLiteralDfa_0(1, active0);
324 return 2;
325 }
326 switch(curChar)
327 {
328 case 97:
329 return jjMoveStringLiteralDfa3_0(active0, 0x420L);
330 case 99:
331 return jjMoveStringLiteralDfa3_0(active0, 0x80L);
332 case 101:
333 return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
334 case 102:
335 return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
336 case 104:
337 return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
341 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
342 case 112:
343 return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
344 case 114:
345 return jjMoveStringLiteralDfa3_0(active0, 0xc00000000L);
346 case 115:
347 return jjMoveStringLiteralDfa3_0(active0, 0x80000000L);
348 case 116:
349 return jjMoveStringLiteralDfa3_0(active0, 0x208090000L);
350 case 118:
351 if ((active0 & 0x40L) != 0L)
352 return jjStartNfaWithStates_0(2, 6, 43);
353 break;
354 case 120:
355 return jjMoveStringLiteralDfa3_0(active0, 0x100040000L);
356 default :
357 break;
358 }
359 return jjStartNfa_0(1, active0);
360 }
361 private int jjMoveStringLiteralDfa3_0(long old0, long active0)
362 {
363 if (((active0 &= old0)) == 0L)
364 return jjStartNfa_0(1, old0);
365 try { curChar = input_stream.readChar(); }
366 catch(java.io.IOException e) {
367 jjStopStringLiteralDfa_0(2, active0);
368 return 3;
369 }
370 switch(curChar)
371 {
372 case 65:
373 return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
374 case 97:
375 return jjMoveStringLiteralDfa4_0(active0, 0x14000L);
376 case 101:
377 return jjMoveStringLiteralDfa4_0(active0, 0x170000a000L);
378 case 105:
379 return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
380 case 108:
381 return jjMoveStringLiteralDfa4_0(active0, 0x80L);
382 case 109:
383 return jjMoveStringLiteralDfa4_0(active0, 0x4000400L);
384 case 114:
385 return jjMoveStringLiteralDfa4_0(active0, 0x8000020L);
386 case 116:
387 if ((active0 & 0x40000L) != 0L)
388 return jjStartNfaWithStates_0(3, 18, 43);
389 else if ((active0 & 0x80000000L) != 0L)
390 return jjStartNfaWithStates_0(3, 31, 43);
391 return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
392 default :
393 break;
394 }
395 return jjStartNfa_0(2, active0);
396 }
397 private int jjMoveStringLiteralDfa4_0(long old0, long active0)
398 {
399 if (((active0 &= old0)) == 0L)
400 return jjStartNfa_0(2, old0);
401 try { curChar = input_stream.readChar(); }
402 catch(java.io.IOException e) {
403 jjStopStringLiteralDfa_0(3, active0);
404 return 4;
405 }
406 switch(curChar)
407 {
408 case 100:
409 if ((active0 & 0x100000000L) != 0L)
410 return jjStartNfaWithStates_0(4, 32, 43);
411 break;
412 case 101:
413 return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
414 case 105:
415 return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
416 case 108:
417 return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
423 return jjMoveStringLiteralDfa5_0(active0, 0xc00000000L);
424 case 114:
425 return jjMoveStringLiteralDfa5_0(active0, 0x200008000L);
426 case 115:
427 return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
428 case 116:
429 if ((active0 & 0x20L) != 0L)
430 return jjStartNfaWithStates_0(4, 5, 43);
431 return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
432 case 117:
433 return jjMoveStringLiteralDfa5_0(active0, 0x4080L);
434 case 121:
435 if ((active0 & 0x20000L) != 0L)
436 return jjStartNfaWithStates_0(4, 17, 43);
437 break;
438 default :
439 break;
440 }
441 return jjStartNfa_0(3, active0);
442 }
443 private int jjMoveStringLiteralDfa5_0(long old0, long active0)
444 {
445 if (((active0 &= old0)) == 0L)
446 return jjStartNfa_0(3, old0);
447 try { curChar = input_stream.readChar(); }
448 catch(java.io.IOException e) {
449 jjStopStringLiteralDfa_0(4, active0);
450 return 5;
451 }
452 switch(curChar)
453 {
454 case 97:
455 return jjMoveStringLiteralDfa6_0(active0, 0x400L);
456 case 98:
457 return jjMoveStringLiteralDfa6_0(active0, 0x8000000L);
458 case 100:
459 return jjMoveStringLiteralDfa6_0(active0, 0x80L);
460 case 103:
461 if ((active0 & 0x800000000L) != 0L)
462 return jjStartNfaWithStates_0(5, 35, 43);
463 break;
464 case 105:
465 return jjMoveStringLiteralDfa6_0(active0, 0x8000L);
466 case 108:
467 return jjMoveStringLiteralDfa6_0(active0, 0x84000L);
468 case 110:
469 return jjMoveStringLiteralDfa6_0(active0, 0x204000000L);
470 case 112:
471 return jjMoveStringLiteralDfa6_0(active0, 0x2000L);
472 case 116:
473 if ((active0 & 0x400000000L) != 0L)
474 return jjStartNfaWithStates_0(5, 34, 43);
475 break;
476 case 121:
477 return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
478 default :
479 break;
480 }
481 return jjStartNfa_0(4, active0);
482 }
483 private int jjMoveStringLiteralDfa6_0(long old0, long active0)
484 {
485 if (((active0 &= old0)) == 0L)
486 return jjStartNfa_0(4, old0);
487 try { curChar = input_stream.readChar(); }
488 catch(java.io.IOException e) {
489 jjStopStringLiteralDfa_0(5, active0);
490 return 6;
491 }
492 switch(curChar)
493 {
494 case 97:
495 return jjMoveStringLiteralDfa7_0(active0, 0x200002000L);
496 case 101:
497 if ((active0 & 0x80L) != 0L)
498 return jjStartNfaWithStates_0(6, 7, 43);
499 break;
500 case 111:
501 return jjMoveStringLiteralDfa7_0(active0, 0x80000L);
502 case 112:
503 return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
504 case 114:
505 if ((active0 & 0x400L) != 0L)
506 return jjStartNfaWithStates_0(6, 10, 43);
507 break;
508 case 116:
509 if ((active0 & 0x4000L) != 0L)
510 return jjStartNfaWithStates_0(6, 14, 43);
511 else if ((active0 & 0x8000L) != 0L)
512 return jjStartNfaWithStates_0(6, 15, 43);
513 else if ((active0 & 0x4000000L) != 0L)
514 return jjStartNfaWithStates_0(6, 26, 43);
515 break;
516 case 117:
517 return jjMoveStringLiteralDfa7_0(active0, 0x8000000L);
518 default :
519 break;
520 }
521 return jjStartNfa_0(5, active0);
522 }
523 private int jjMoveStringLiteralDfa7_0(long old0, long active0)
524 {
525 if (((active0 &= old0)) == 0L)
526 return jjStartNfa_0(5, old0);
527 try { curChar = input_stream.readChar(); }
528 catch(java.io.IOException e) {
529 jjStopStringLiteralDfa_0(6, active0);
530 return 7;
531 }
532 switch(curChar)
533 {
534 case 99:
535 return jjMoveStringLiteralDfa8_0(active0, 0x2000L);
536 case 101:
537 return jjMoveStringLiteralDfa8_0(active0, 0x10000L);
538 case 108:
539 if ((active0 & 0x200000000L) != 0L)
540 return jjStartNfaWithStates_0(7, 33, 43);
541 break;
542 case 116:
543 return jjMoveStringLiteralDfa8_0(active0, 0x8000000L);
544 case 119:
545 return jjMoveStringLiteralDfa8_0(active0, 0x80000L);
546 default :
547 break;
548 }
549 return jjStartNfa_0(6, active0);
550 }
551 private int jjMoveStringLiteralDfa8_0(long old0, long active0)
552 {
553 if (((active0 &= old0)) == 0L)
554 return jjStartNfa_0(6, old0);
555 try { curChar = input_stream.readChar(); }
556 catch(java.io.IOException e) {
557 jjStopStringLiteralDfa_0(7, active0);
558 return 8;
559 }
560 switch(curChar)
561 {
562 case 101:
563 if ((active0 & 0x2000L) != 0L)
564 return jjStartNfaWithStates_0(8, 13, 43);
565 else if ((active0 & 0x8000000L) != 0L)
566 return jjStartNfaWithStates_0(8, 27, 43);
567 return jjMoveStringLiteralDfa9_0(active0, 0x80000L);
568 case 115:
569 if ((active0 & 0x10000L) != 0L)
570 return jjStartNfaWithStates_0(8, 16, 43);
571 break;
572 default :
573 break;
574 }
575 return jjStartNfa_0(7, active0);
576 }
577 private int jjMoveStringLiteralDfa9_0(long old0, long active0)
578 {
579 if (((active0 &= old0)) == 0L)
580 return jjStartNfa_0(7, old0);
581 try { curChar = input_stream.readChar(); }
582 catch(java.io.IOException e) {
583 jjStopStringLiteralDfa_0(8, active0);
584 return 9;
585 }
586 switch(curChar)
587 {
588 case 100:
589 if ((active0 & 0x80000L) != 0L)
590 return jjStartNfaWithStates_0(9, 19, 43);
591 break;
592 default :
593 break;
594 }
595 return jjStartNfa_0(8, active0);
596 }
597 private int jjStartNfaWithStates_0(int pos, int kind, int state)
598 {
599 jjmatchedKind = kind;
600 jjmatchedPos = pos;
601 try { curChar = input_stream.readChar(); }
602 catch(java.io.IOException e) { return pos + 1; }
603 return jjMoveNfa_0(state, pos + 1);
604 }
605 static final long[] jjbitVec0 = {
606 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
607 };
608 static final long[] jjbitVec2 = {
609 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
610 };
611 static final long[] jjbitVec3 = {
612 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
613 };
614 static final long[] jjbitVec4 = {
615 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
616 };
617 static final long[] jjbitVec5 = {
618 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
619 };
620 static final long[] jjbitVec6 = {
621 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
622 };
623 static final long[] jjbitVec7 = {
708 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
709 };
710 static final long[] jjbitVec36 = {
711 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
712 };
713 static final long[] jjbitVec37 = {
714 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
715 };
716 static final long[] jjbitVec38 = {
717 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
718 };
719 static final long[] jjbitVec39 = {
720 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
721 };
722 static final long[] jjbitVec40 = {
723 0x0L, 0x0L, 0x0L, 0x21fff0000L
724 };
725 static final long[] jjbitVec41 = {
726 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
727 };
728 private int jjMoveNfa_0(int startState, int curPos)
729 {
730 int startsAt = 0;
731 jjnewStateCnt = 43;
732 int i = 1;
733 jjstateSet[0] = startState;
734 int kind = 0x7fffffff;
735 for (;;)
736 {
737 if (++jjround == 0x7fffffff)
738 ReInitRounds();
739 if (curChar < 64)
740 {
741 long l = 1L << curChar;
742 do
743 {
744 switch(jjstateSet[--i])
745 {
746 case 3:
747 if ((0xfffffffffffff9ffL & l) != 0L)
748 {
749 if (kind > 60)
750 kind = 60;
751 }
752 if ((0x100000601L & l) != 0L)
753 {
754 if (kind > 39)
755 kind = 39;
756 jjCheckNAdd(0);
757 }
758 else if (curChar == 39)
759 jjstateSet[jjnewStateCnt++] = 31;
760 else if (curChar == 34)
761 jjstateSet[jjnewStateCnt++] = 22;
762 else if (curChar == 35)
942 jjCheckNAddTwoStates(39, 40);
943 break;
944 case 40:
945 if (curChar == 58)
946 jjstateSet[jjnewStateCnt++] = 41;
947 break;
948 case 42:
949 if ((0x3ff600000000000L & l) == 0L)
950 break;
951 if (kind > 57)
952 kind = 57;
953 jjstateSet[jjnewStateCnt++] = 42;
954 break;
955 default : break;
956 }
957 } while(i != startsAt);
958 }
959 else if (curChar < 128)
960 {
961 long l = 1L << (curChar & 077);
962 do
963 {
964 switch(jjstateSet[--i])
965 {
966 case 3:
967 if (kind > 60)
968 kind = 60;
969 if ((0x7fffffe87fffffeL & l) != 0L)
970 {
971 if (kind > 54)
972 kind = 54;
973 jjCheckNAddStates(10, 14);
974 }
975 else if (curChar == 92)
976 jjstateSet[jjnewStateCnt++] = 7;
977 break;
978 case 43:
979 if ((0x7fffffe87fffffeL & l) != 0L)
980 jjCheckNAddTwoStates(39, 40);
981 if ((0x7fffffe87fffffeL & l) != 0L)
982 jjCheckNAddTwoStates(36, 38);
1049 break;
1050 case 41:
1051 case 42:
1052 if ((0x7fffffe87fffffeL & l) == 0L)
1053 break;
1054 if (kind > 57)
1055 kind = 57;
1056 jjCheckNAdd(42);
1057 break;
1058 default : break;
1059 }
1060 } while(i != startsAt);
1061 }
1062 else
1063 {
1064 int hiByte = (int)(curChar >> 8);
1065 int i1 = hiByte >> 6;
1066 long l1 = 1L << (hiByte & 077);
1067 int i2 = (curChar & 0xff) >> 6;
1068 long l2 = 1L << (curChar & 077);
1069 do
1070 {
1071 switch(jjstateSet[--i])
1072 {
1073 case 3:
1074 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1075 {
1076 if (kind > 60)
1077 kind = 60;
1078 }
1079 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1080 {
1081 if (kind > 54)
1082 kind = 54;
1083 jjCheckNAddStates(10, 14);
1084 }
1085 break;
1086 case 43:
1087 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1088 {
1089 if (kind > 54)
1179 kind = 57;
1180 jjCheckNAdd(42);
1181 break;
1182 default : break;
1183 }
1184 } while(i != startsAt);
1185 }
1186 if (kind != 0x7fffffff)
1187 {
1188 jjmatchedKind = kind;
1189 jjmatchedPos = curPos;
1190 kind = 0x7fffffff;
1191 }
1192 ++curPos;
1193 if ((i = jjnewStateCnt) == (startsAt = 43 - (jjnewStateCnt = startsAt)))
1194 return curPos;
1195 try { curChar = input_stream.readChar(); }
1196 catch(java.io.IOException e) { return curPos; }
1197 }
1198 }
1199 private int jjMoveStringLiteralDfa0_1()
1200 {
1201 return jjMoveNfa_1(1, 0);
1202 }
1203 private int jjMoveNfa_1(int startState, int curPos)
1204 {
1205 int startsAt = 0;
1206 jjnewStateCnt = 10;
1207 int i = 1;
1208 jjstateSet[0] = startState;
1209 int kind = 0x7fffffff;
1210 for (;;)
1211 {
1212 if (++jjround == 0x7fffffff)
1213 ReInitRounds();
1214 if (curChar < 64)
1215 {
1216 long l = 1L << curChar;
1217 do
1218 {
1219 switch(jjstateSet[--i])
1220 {
1221 case 1:
1222 if ((0xfffffffffffff9ffL & l) != 0L)
1223 {
1224 if (kind > 60)
1225 kind = 60;
1226 }
1227 if ((0x100000601L & l) != 0L)
1228 {
1229 if (kind > 39)
1230 kind = 39;
1231 jjCheckNAdd(0);
1232 }
1233 if ((0x401L & l) != 0L)
1234 jjCheckNAddStates(19, 22);
1235 break;
1236 case 0:
1237 if ((0x100000601L & l) == 0L)
1274 if (curChar != 35)
1275 break;
1276 if (kind > 44)
1277 kind = 44;
1278 jjCheckNAdd(9);
1279 break;
1280 case 9:
1281 if ((0xfffffffffffffbfeL & l) == 0L)
1282 break;
1283 if (kind > 44)
1284 kind = 44;
1285 jjCheckNAdd(9);
1286 break;
1287 default : break;
1288 }
1289 } while(i != startsAt);
1290 }
1291 else if (curChar < 128)
1292 {
1293 long l = 1L << (curChar & 077);
1294 do
1295 {
1296 switch(jjstateSet[--i])
1297 {
1298 case 1:
1299 if (kind > 60)
1300 kind = 60;
1301 break;
1302 case 5:
1303 if (kind > 43)
1304 kind = 43;
1305 jjstateSet[jjnewStateCnt++] = 5;
1306 break;
1307 case 9:
1308 if (kind > 44)
1309 kind = 44;
1310 jjstateSet[jjnewStateCnt++] = 9;
1311 break;
1312 default : break;
1313 }
1314 } while(i != startsAt);
1315 }
1316 else
1317 {
1318 int hiByte = (int)(curChar >> 8);
1319 int i1 = hiByte >> 6;
1320 long l1 = 1L << (hiByte & 077);
1321 int i2 = (curChar & 0xff) >> 6;
1322 long l2 = 1L << (curChar & 077);
1323 do
1324 {
1325 switch(jjstateSet[--i])
1326 {
1327 case 1:
1328 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1329 kind = 60;
1330 break;
1331 case 5:
1332 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1333 break;
1334 if (kind > 43)
1335 kind = 43;
1336 jjstateSet[jjnewStateCnt++] = 5;
1337 break;
1338 case 9:
1339 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1340 break;
1341 if (kind > 44)
1342 kind = 44;
1343 jjstateSet[jjnewStateCnt++] = 9;
1344 break;
1345 default : break;
1346 }
1347 } while(i != startsAt);
1348 }
1349 if (kind != 0x7fffffff)
1350 {
1351 jjmatchedKind = kind;
1352 jjmatchedPos = curPos;
1353 kind = 0x7fffffff;
1354 }
1355 ++curPos;
1356 if ((i = jjnewStateCnt) == (startsAt = 10 - (jjnewStateCnt = startsAt)))
1357 return curPos;
1358 try { curChar = input_stream.readChar(); }
1359 catch(java.io.IOException e) { return curPos; }
1360 }
1361 }
1362 private int jjMoveStringLiteralDfa0_2()
1363 {
1364 return jjMoveNfa_2(1, 0);
1365 }
1366 private int jjMoveNfa_2(int startState, int curPos)
1367 {
1368 int startsAt = 0;
1369 jjnewStateCnt = 7;
1370 int i = 1;
1371 jjstateSet[0] = startState;
1372 int kind = 0x7fffffff;
1373 for (;;)
1374 {
1375 if (++jjround == 0x7fffffff)
1376 ReInitRounds();
1377 if (curChar < 64)
1378 {
1379 long l = 1L << curChar;
1380 do
1381 {
1382 switch(jjstateSet[--i])
1383 {
1384 case 1:
1385 if ((0xfffffffffffff9ffL & l) != 0L)
1386 {
1387 if (kind > 60)
1388 kind = 60;
1389 }
1390 if ((0x100000601L & l) != 0L)
1391 {
1392 if (kind > 39)
1393 kind = 39;
1394 jjCheckNAdd(0);
1395 }
1396 if ((0x401L & l) != 0L)
1397 jjCheckNAddTwoStates(2, 5);
1398 break;
1399 case 0:
1400 if ((0x100000601L & l) == 0L)
1419 break;
1420 if (kind > 41)
1421 kind = 41;
1422 jjCheckNAdd(4);
1423 break;
1424 case 5:
1425 if (curChar == 35)
1426 jjstateSet[jjnewStateCnt++] = 3;
1427 break;
1428 case 6:
1429 if ((0xfffffffffffff9ffL & l) != 0L && kind > 60)
1430 kind = 60;
1431 break;
1432 default : break;
1433 }
1434 } while(i != startsAt);
1435 }
1436 else if (curChar < 128)
1437 {
1438 long l = 1L << (curChar & 077);
1439 do
1440 {
1441 switch(jjstateSet[--i])
1442 {
1443 case 1:
1444 if (kind > 60)
1445 kind = 60;
1446 break;
1447 case 4:
1448 if (kind > 41)
1449 kind = 41;
1450 jjstateSet[jjnewStateCnt++] = 4;
1451 break;
1452 default : break;
1453 }
1454 } while(i != startsAt);
1455 }
1456 else
1457 {
1458 int hiByte = (int)(curChar >> 8);
1459 int i1 = hiByte >> 6;
1460 long l1 = 1L << (hiByte & 077);
1461 int i2 = (curChar & 0xff) >> 6;
1462 long l2 = 1L << (curChar & 077);
1463 do
1464 {
1465 switch(jjstateSet[--i])
1466 {
1467 case 1:
1468 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1469 kind = 60;
1470 break;
1471 case 4:
1472 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1473 break;
1474 if (kind > 41)
1475 kind = 41;
1476 jjstateSet[jjnewStateCnt++] = 4;
1477 break;
1478 default : break;
1479 }
1480 } while(i != startsAt);
1481 }
1482 if (kind != 0x7fffffff)
1483 {
1605 case 31:
1606 return ((jjbitVec21[i2] & l2) != 0L);
1607 case 32:
1608 return ((jjbitVec40[i2] & l2) != 0L);
1609 case 33:
1610 return ((jjbitVec22[i2] & l2) != 0L);
1611 case 48:
1612 return ((jjbitVec41[i2] & l2) != 0L);
1613 case 49:
1614 return ((jjbitVec24[i2] & l2) != 0L);
1615 case 159:
1616 return ((jjbitVec25[i2] & l2) != 0L);
1617 case 215:
1618 return ((jjbitVec26[i2] & l2) != 0L);
1619 default :
1620 if ((jjbitVec3[i1] & l1) != 0L)
1621 return true;
1622 return false;
1623 }
1624 }
1625
1626 /** Token literal values. */
1627 public static final String[] jjstrLiteralImages = {
1628 "", "\133", "\75", "\46\75", "\174\75", "\163\164\141\162\164",
1629 "\144\151\166", "\151\156\143\154\165\144\145", "\176", "\135",
1630 "\147\162\141\155\155\141\162", "\173", "\175", "\156\141\155\145\163\160\141\143\145",
1631 "\144\145\146\141\165\154\164", "\151\156\150\145\162\151\164", "\144\141\164\141\164\171\160\145\163",
1632 "\145\155\160\164\171", "\164\145\170\164", "\156\157\164\101\154\154\157\167\145\144", "\174", "\46",
1633 "\54", "\53", "\77", "\52", "\145\154\145\155\145\156\164",
1634 "\141\164\164\162\151\142\165\164\145", "\50", "\51", "\55", "\154\151\163\164", "\155\151\170\145\144",
1635 "\145\170\164\145\162\156\141\154", "\160\141\162\145\156\164", "\163\164\162\151\156\147",
1636 "\164\157\153\145\156", null, null, null, null, null, null, null, null, null, null, null, null, null,
1637 null, null, null, null, null, null, null, null, null, "\76\76", null, };
1638
1639 /** Lexer state names. */
1640 public static final String[] lexStateNames = {
1641 "DEFAULT",
1642 "AFTER_SINGLE_LINE_COMMENT",
1643 "AFTER_DOCUMENTATION",
1644 };
1645
1646 /** Lex State array. */
1647 public static final int[] jjnewLexState = {
1648 -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,
1649 -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,
1650 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1651 };
1652 static final long[] jjtoToken = {
1653 0x1fc00b1fffffffffL,
1654 };
1655 static final long[] jjtoSkip = {
1656 0x148000000000L,
1657 };
1658 static final long[] jjtoSpecial = {
1659 0x140000000000L,
1660 };
1661 protected JavaCharStream input_stream;
1662 private final int[] jjrounds = new int[43];
1663 private final int[] jjstateSet = new int[86];
1664 private final StringBuilder jjimage = new StringBuilder();
1665 private StringBuilder image = jjimage;
1666 private int jjimageLen;
1667 private int lengthOfMatch;
1668 protected char curChar;
1669 /** Constructor. */
1670 public CompactSyntaxTokenManager(JavaCharStream stream){
1671 if (JavaCharStream.staticFlag)
1672 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1673 input_stream = stream;
1674 }
1675
1676 /** Constructor. */
1677 public CompactSyntaxTokenManager(JavaCharStream stream, int lexState){
1678 this(stream);
1679 SwitchTo(lexState);
1680 }
1681
1682 /** Reinitialise parser. */
1683 public void ReInit(JavaCharStream stream)
1684 {
1685 jjmatchedPos = jjnewStateCnt = 0;
1686 curLexState = defaultLexState;
1687 input_stream = stream;
1688 ReInitRounds();
1689 }
1690 private void ReInitRounds()
1691 {
1692 int i;
1693 jjround = 0x80000001;
1694 for (i = 43; i-- > 0;)
1695 jjrounds[i] = 0x80000000;
1696 }
1697
1698 /** Reinitialise parser. */
1699 public void ReInit(JavaCharStream stream, int lexState)
1700 {
1701 ReInit(stream);
1702 SwitchTo(lexState);
1703 }
1704
1705 /** Switch to specified lex state. */
1706 public void SwitchTo(int lexState)
1707 {
1708 if (lexState >= 3 || lexState < 0)
1709 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1710 else
1711 curLexState = lexState;
1712 }
1713
1714 protected Token jjFillToken()
1715 {
1716 final Token t;
1717 final String curTokenImage;
1718 final int beginLine;
1719 final int endLine;
1720 final int beginColumn;
1721 final int endColumn;
1722 String im = jjstrLiteralImages[jjmatchedKind];
1723 curTokenImage = (im == null) ? input_stream.GetImage() : im;
1724 beginLine = input_stream.getBeginLine();
1725 beginColumn = input_stream.getBeginColumn();
1726 endLine = input_stream.getEndLine();
1727 endColumn = input_stream.getEndColumn();
1728 t = Token.newToken(jjmatchedKind, curTokenImage);
1729
1730 t.beginLine = beginLine;
1731 t.endLine = endLine;
1732 t.beginColumn = beginColumn;
1733 t.endColumn = endColumn;
1734
1735 return t;
1736 }
1737
1738 int curLexState = 0;
1739 int defaultLexState = 0;
1740 int jjnewStateCnt;
1741 int jjround;
1742 int jjmatchedPos;
1743 int jjmatchedKind;
1744
1745 /** Get the next Token. */
1746 public Token getNextToken()
1747 {
1748 Token specialToken = null;
1749 Token matchedToken;
1750 int curPos = 0;
1751
1752 EOFLoop :
1753 for (;;)
1754 {
1755 try
1756 {
1757 curChar = input_stream.BeginToken();
1758 }
1759 catch(java.io.IOException e)
1760 {
1761 jjmatchedKind = 0;
1762 matchedToken = jjFillToken();
1763 matchedToken.specialToken = specialToken;
1764 return matchedToken;
1765 }
1766 image = jjimage;
1767 image.setLength(0);
1768 jjimageLen = 0;
1769
1770 switch(curLexState)
1771 {
1772 case 0:
1773 jjmatchedKind = 0x7fffffff;
1774 jjmatchedPos = 0;
1775 curPos = jjMoveStringLiteralDfa0_0();
1776 break;
1777 case 1:
1778 jjmatchedKind = 0x7fffffff;
1779 jjmatchedPos = 0;
1780 curPos = jjMoveStringLiteralDfa0_1();
1781 break;
1782 case 2:
1783 jjmatchedKind = 0x7fffffff;
1784 jjmatchedPos = 0;
1785 curPos = jjMoveStringLiteralDfa0_2();
1786 break;
1787 }
1832 }
1833 else
1834 error_column++;
1835 }
1836 if (!EOFSeen) {
1837 input_stream.backup(1);
1838 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1839 }
1840 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1841 }
1842 }
1843
1844 void SkipLexicalActions(Token matchedToken)
1845 {
1846 switch(jjmatchedKind)
1847 {
1848 default :
1849 break;
1850 }
1851 }
1852 private void jjCheckNAdd(int state)
1853 {
1854 if (jjrounds[state] != jjround)
1855 {
1856 jjstateSet[jjnewStateCnt++] = state;
1857 jjrounds[state] = jjround;
1858 }
1859 }
1860 private void jjAddStates(int start, int end)
1861 {
1862 do {
1863 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1864 } while (start++ != end);
1865 }
1866 private void jjCheckNAddTwoStates(int state1, int state2)
1867 {
1868 jjCheckNAdd(state1);
1869 jjCheckNAdd(state2);
1870 }
1871
1872 private void jjCheckNAddStates(int start, int end)
1873 {
1874 do {
1875 jjCheckNAdd(jjnextStates[start]);
1876 } while (start++ != end);
1877 }
1878
1879 }
|
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 /* Generated By:JavaCC: Do not edit this line. CompactSyntaxTokenManager.java */
26 package com.sun.xml.internal.rngom.parse.compact;
27 import java.io.Reader;
28 import java.net.MalformedURLException;
29 import java.net.URL;
30 import java.util.Arrays;
31 import java.util.ArrayList;
32 import java.util.Collections;
33 import java.util.Enumeration;
34 import java.util.Hashtable;
35 import java.util.List;
36 import com.sun.xml.internal.rngom.ast.builder.Annotations;
37 import com.sun.xml.internal.rngom.ast.builder.BuildException;
38 import com.sun.xml.internal.rngom.ast.builder.CommentList;
39 import com.sun.xml.internal.rngom.ast.builder.DataPatternBuilder;
40 import com.sun.xml.internal.rngom.ast.builder.Div;
41 import com.sun.xml.internal.rngom.ast.builder.ElementAnnotationBuilder;
42 import com.sun.xml.internal.rngom.ast.builder.Grammar;
43 import com.sun.xml.internal.rngom.ast.builder.GrammarSection;
44 import com.sun.xml.internal.rngom.ast.builder.Include;
45 import com.sun.xml.internal.rngom.ast.builder.IncludedGrammar;
46 import com.sun.xml.internal.rngom.ast.builder.NameClassBuilder;
47 import com.sun.xml.internal.rngom.ast.builder.SchemaBuilder;
48 import com.sun.xml.internal.rngom.ast.builder.Scope;
49 import com.sun.xml.internal.rngom.ast.om.Location;
50 import com.sun.xml.internal.rngom.ast.om.ParsedElementAnnotation;
51 import com.sun.xml.internal.rngom.ast.om.ParsedNameClass;
52 import com.sun.xml.internal.rngom.ast.om.ParsedPattern;
53 import com.sun.xml.internal.rngom.parse.Context;
54 import com.sun.xml.internal.rngom.parse.IllegalSchemaException;
55 import com.sun.xml.internal.rngom.parse.Parseable;
56 import org.xml.sax.ErrorHandler;
57 import org.xml.sax.SAXException;
58 import org.xml.sax.SAXParseException;
59 import org.xml.sax.helpers.LocatorImpl;
60 import com.sun.xml.internal.rngom.util.Localizer;
61 import com.sun.xml.internal.rngom.xml.util.WellKnownNamespaces;
62
63 public class CompactSyntaxTokenManager implements CompactSyntaxConstants
64 {
65 public java.io.PrintStream debugStream = System.out;
66 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
67 private final int jjStopStringLiteralDfa_0(int pos, long active0)
68 {
69 switch (pos)
70 {
71 case 0:
72 if ((active0 & 0x1f8c0fe4e0L) != 0L)
73 {
74 jjmatchedKind = 54;
75 return 43;
76 }
77 if ((active0 & 0x800000000000000L) != 0L)
78 {
79 jjmatchedKind = 60;
80 return -1;
81 }
82 return -1;
83 case 1:
84 if ((active0 & 0x1f8c0fe4e0L) != 0L)
85 {
158 return 43;
159 return -1;
160 case 8:
161 if ((active0 & 0x80000L) != 0L)
162 {
163 jjmatchedKind = 54;
164 jjmatchedPos = 8;
165 return 43;
166 }
167 if ((active0 & 0x8012000L) != 0L)
168 return 43;
169 return -1;
170 default :
171 return -1;
172 }
173 }
174 private final int jjStartNfa_0(int pos, long active0)
175 {
176 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
177 }
178 private final int jjStopAtPos(int pos, int kind)
179 {
180 jjmatchedKind = kind;
181 jjmatchedPos = pos;
182 return pos + 1;
183 }
184 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
185 {
186 jjmatchedKind = kind;
187 jjmatchedPos = pos;
188 try { curChar = input_stream.readChar(); }
189 catch(java.io.IOException e) { return pos + 1; }
190 return jjMoveNfa_0(state, pos + 1);
191 }
192 private final int jjMoveStringLiteralDfa0_0()
193 {
194 switch(curChar)
195 {
196 case 38:
197 jjmatchedKind = 21;
198 return jjMoveStringLiteralDfa1_0(0x8L);
199 case 40:
200 return jjStopAtPos(0, 28);
201 case 41:
202 return jjStopAtPos(0, 29);
203 case 42:
204 return jjStopAtPos(0, 25);
205 case 43:
206 return jjStopAtPos(0, 23);
207 case 44:
208 return jjStopAtPos(0, 22);
209 case 45:
210 return jjStopAtPos(0, 30);
211 case 61:
212 return jjStopAtPos(0, 2);
236 return jjMoveStringLiteralDfa1_0(0x82000L);
237 case 112:
238 return jjMoveStringLiteralDfa1_0(0x400000000L);
239 case 115:
240 return jjMoveStringLiteralDfa1_0(0x800000020L);
241 case 116:
242 return jjMoveStringLiteralDfa1_0(0x1000040000L);
243 case 123:
244 return jjStopAtPos(0, 11);
245 case 124:
246 jjmatchedKind = 20;
247 return jjMoveStringLiteralDfa1_0(0x10L);
248 case 125:
249 return jjStopAtPos(0, 12);
250 case 126:
251 return jjStopAtPos(0, 8);
252 default :
253 return jjMoveNfa_0(3, 0);
254 }
255 }
256 private final int jjMoveStringLiteralDfa1_0(long active0)
257 {
258 try { curChar = input_stream.readChar(); }
259 catch(java.io.IOException e) {
260 jjStopStringLiteralDfa_0(0, active0);
261 return 1;
262 }
263 switch(curChar)
264 {
265 case 61:
266 if ((active0 & 0x8L) != 0L)
267 return jjStopAtPos(1, 3);
268 else if ((active0 & 0x10L) != 0L)
269 return jjStopAtPos(1, 4);
270 break;
271 case 62:
272 if ((active0 & 0x800000000000000L) != 0L)
273 return jjStopAtPos(1, 59);
274 break;
275 case 97:
276 return jjMoveStringLiteralDfa2_0(active0, 0x400012000L);
280 return jjMoveStringLiteralDfa2_0(active0, 0x180000040L);
281 case 108:
282 return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
283 case 109:
284 return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
285 case 110:
286 return jjMoveStringLiteralDfa2_0(active0, 0x8080L);
287 case 111:
288 return jjMoveStringLiteralDfa2_0(active0, 0x1000080000L);
289 case 114:
290 return jjMoveStringLiteralDfa2_0(active0, 0x400L);
291 case 116:
292 return jjMoveStringLiteralDfa2_0(active0, 0x808000020L);
293 case 120:
294 return jjMoveStringLiteralDfa2_0(active0, 0x200000000L);
295 default :
296 break;
297 }
298 return jjStartNfa_0(0, active0);
299 }
300 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
301 {
302 if (((active0 &= old0)) == 0L)
303 return jjStartNfa_0(0, old0);
304 try { curChar = input_stream.readChar(); }
305 catch(java.io.IOException e) {
306 jjStopStringLiteralDfa_0(1, active0);
307 return 2;
308 }
309 switch(curChar)
310 {
311 case 97:
312 return jjMoveStringLiteralDfa3_0(active0, 0x420L);
313 case 99:
314 return jjMoveStringLiteralDfa3_0(active0, 0x80L);
315 case 101:
316 return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
317 case 102:
318 return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
319 case 104:
320 return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
324 return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
325 case 112:
326 return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
327 case 114:
328 return jjMoveStringLiteralDfa3_0(active0, 0xc00000000L);
329 case 115:
330 return jjMoveStringLiteralDfa3_0(active0, 0x80000000L);
331 case 116:
332 return jjMoveStringLiteralDfa3_0(active0, 0x208090000L);
333 case 118:
334 if ((active0 & 0x40L) != 0L)
335 return jjStartNfaWithStates_0(2, 6, 43);
336 break;
337 case 120:
338 return jjMoveStringLiteralDfa3_0(active0, 0x100040000L);
339 default :
340 break;
341 }
342 return jjStartNfa_0(1, active0);
343 }
344 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
345 {
346 if (((active0 &= old0)) == 0L)
347 return jjStartNfa_0(1, old0);
348 try { curChar = input_stream.readChar(); }
349 catch(java.io.IOException e) {
350 jjStopStringLiteralDfa_0(2, active0);
351 return 3;
352 }
353 switch(curChar)
354 {
355 case 65:
356 return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
357 case 97:
358 return jjMoveStringLiteralDfa4_0(active0, 0x14000L);
359 case 101:
360 return jjMoveStringLiteralDfa4_0(active0, 0x170000a000L);
361 case 105:
362 return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
363 case 108:
364 return jjMoveStringLiteralDfa4_0(active0, 0x80L);
365 case 109:
366 return jjMoveStringLiteralDfa4_0(active0, 0x4000400L);
367 case 114:
368 return jjMoveStringLiteralDfa4_0(active0, 0x8000020L);
369 case 116:
370 if ((active0 & 0x40000L) != 0L)
371 return jjStartNfaWithStates_0(3, 18, 43);
372 else if ((active0 & 0x80000000L) != 0L)
373 return jjStartNfaWithStates_0(3, 31, 43);
374 return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
375 default :
376 break;
377 }
378 return jjStartNfa_0(2, active0);
379 }
380 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
381 {
382 if (((active0 &= old0)) == 0L)
383 return jjStartNfa_0(2, old0);
384 try { curChar = input_stream.readChar(); }
385 catch(java.io.IOException e) {
386 jjStopStringLiteralDfa_0(3, active0);
387 return 4;
388 }
389 switch(curChar)
390 {
391 case 100:
392 if ((active0 & 0x100000000L) != 0L)
393 return jjStartNfaWithStates_0(4, 32, 43);
394 break;
395 case 101:
396 return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
397 case 105:
398 return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
399 case 108:
400 return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
406 return jjMoveStringLiteralDfa5_0(active0, 0xc00000000L);
407 case 114:
408 return jjMoveStringLiteralDfa5_0(active0, 0x200008000L);
409 case 115:
410 return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
411 case 116:
412 if ((active0 & 0x20L) != 0L)
413 return jjStartNfaWithStates_0(4, 5, 43);
414 return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
415 case 117:
416 return jjMoveStringLiteralDfa5_0(active0, 0x4080L);
417 case 121:
418 if ((active0 & 0x20000L) != 0L)
419 return jjStartNfaWithStates_0(4, 17, 43);
420 break;
421 default :
422 break;
423 }
424 return jjStartNfa_0(3, active0);
425 }
426 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
427 {
428 if (((active0 &= old0)) == 0L)
429 return jjStartNfa_0(3, old0);
430 try { curChar = input_stream.readChar(); }
431 catch(java.io.IOException e) {
432 jjStopStringLiteralDfa_0(4, active0);
433 return 5;
434 }
435 switch(curChar)
436 {
437 case 97:
438 return jjMoveStringLiteralDfa6_0(active0, 0x400L);
439 case 98:
440 return jjMoveStringLiteralDfa6_0(active0, 0x8000000L);
441 case 100:
442 return jjMoveStringLiteralDfa6_0(active0, 0x80L);
443 case 103:
444 if ((active0 & 0x800000000L) != 0L)
445 return jjStartNfaWithStates_0(5, 35, 43);
446 break;
447 case 105:
448 return jjMoveStringLiteralDfa6_0(active0, 0x8000L);
449 case 108:
450 return jjMoveStringLiteralDfa6_0(active0, 0x84000L);
451 case 110:
452 return jjMoveStringLiteralDfa6_0(active0, 0x204000000L);
453 case 112:
454 return jjMoveStringLiteralDfa6_0(active0, 0x2000L);
455 case 116:
456 if ((active0 & 0x400000000L) != 0L)
457 return jjStartNfaWithStates_0(5, 34, 43);
458 break;
459 case 121:
460 return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
461 default :
462 break;
463 }
464 return jjStartNfa_0(4, active0);
465 }
466 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
467 {
468 if (((active0 &= old0)) == 0L)
469 return jjStartNfa_0(4, old0);
470 try { curChar = input_stream.readChar(); }
471 catch(java.io.IOException e) {
472 jjStopStringLiteralDfa_0(5, active0);
473 return 6;
474 }
475 switch(curChar)
476 {
477 case 97:
478 return jjMoveStringLiteralDfa7_0(active0, 0x200002000L);
479 case 101:
480 if ((active0 & 0x80L) != 0L)
481 return jjStartNfaWithStates_0(6, 7, 43);
482 break;
483 case 111:
484 return jjMoveStringLiteralDfa7_0(active0, 0x80000L);
485 case 112:
486 return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
487 case 114:
488 if ((active0 & 0x400L) != 0L)
489 return jjStartNfaWithStates_0(6, 10, 43);
490 break;
491 case 116:
492 if ((active0 & 0x4000L) != 0L)
493 return jjStartNfaWithStates_0(6, 14, 43);
494 else if ((active0 & 0x8000L) != 0L)
495 return jjStartNfaWithStates_0(6, 15, 43);
496 else if ((active0 & 0x4000000L) != 0L)
497 return jjStartNfaWithStates_0(6, 26, 43);
498 break;
499 case 117:
500 return jjMoveStringLiteralDfa7_0(active0, 0x8000000L);
501 default :
502 break;
503 }
504 return jjStartNfa_0(5, active0);
505 }
506 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
507 {
508 if (((active0 &= old0)) == 0L)
509 return jjStartNfa_0(5, old0);
510 try { curChar = input_stream.readChar(); }
511 catch(java.io.IOException e) {
512 jjStopStringLiteralDfa_0(6, active0);
513 return 7;
514 }
515 switch(curChar)
516 {
517 case 99:
518 return jjMoveStringLiteralDfa8_0(active0, 0x2000L);
519 case 101:
520 return jjMoveStringLiteralDfa8_0(active0, 0x10000L);
521 case 108:
522 if ((active0 & 0x200000000L) != 0L)
523 return jjStartNfaWithStates_0(7, 33, 43);
524 break;
525 case 116:
526 return jjMoveStringLiteralDfa8_0(active0, 0x8000000L);
527 case 119:
528 return jjMoveStringLiteralDfa8_0(active0, 0x80000L);
529 default :
530 break;
531 }
532 return jjStartNfa_0(6, active0);
533 }
534 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
535 {
536 if (((active0 &= old0)) == 0L)
537 return jjStartNfa_0(6, old0);
538 try { curChar = input_stream.readChar(); }
539 catch(java.io.IOException e) {
540 jjStopStringLiteralDfa_0(7, active0);
541 return 8;
542 }
543 switch(curChar)
544 {
545 case 101:
546 if ((active0 & 0x2000L) != 0L)
547 return jjStartNfaWithStates_0(8, 13, 43);
548 else if ((active0 & 0x8000000L) != 0L)
549 return jjStartNfaWithStates_0(8, 27, 43);
550 return jjMoveStringLiteralDfa9_0(active0, 0x80000L);
551 case 115:
552 if ((active0 & 0x10000L) != 0L)
553 return jjStartNfaWithStates_0(8, 16, 43);
554 break;
555 default :
556 break;
557 }
558 return jjStartNfa_0(7, active0);
559 }
560 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
561 {
562 if (((active0 &= old0)) == 0L)
563 return jjStartNfa_0(7, old0);
564 try { curChar = input_stream.readChar(); }
565 catch(java.io.IOException e) {
566 jjStopStringLiteralDfa_0(8, active0);
567 return 9;
568 }
569 switch(curChar)
570 {
571 case 100:
572 if ((active0 & 0x80000L) != 0L)
573 return jjStartNfaWithStates_0(9, 19, 43);
574 break;
575 default :
576 break;
577 }
578 return jjStartNfa_0(8, active0);
579 }
580 private final void jjCheckNAdd(int state)
581 {
582 if (jjrounds[state] != jjround)
583 {
584 jjstateSet[jjnewStateCnt++] = state;
585 jjrounds[state] = jjround;
586 }
587 }
588 private final void jjAddStates(int start, int end)
589 {
590 do {
591 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
592 } while (start++ != end);
593 }
594 private final void jjCheckNAddTwoStates(int state1, int state2)
595 {
596 jjCheckNAdd(state1);
597 jjCheckNAdd(state2);
598 }
599 private final void jjCheckNAddStates(int start, int end)
600 {
601 do {
602 jjCheckNAdd(jjnextStates[start]);
603 } while (start++ != end);
604 }
605 private final void jjCheckNAddStates(int start)
606 {
607 jjCheckNAdd(jjnextStates[start]);
608 jjCheckNAdd(jjnextStates[start + 1]);
609 }
610 static final long[] jjbitVec0 = {
611 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
612 };
613 static final long[] jjbitVec2 = {
614 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
615 };
616 static final long[] jjbitVec3 = {
617 0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
618 };
619 static final long[] jjbitVec4 = {
620 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
621 };
622 static final long[] jjbitVec5 = {
623 0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
624 };
625 static final long[] jjbitVec6 = {
626 0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
627 };
628 static final long[] jjbitVec7 = {
713 0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
714 };
715 static final long[] jjbitVec36 = {
716 0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
717 };
718 static final long[] jjbitVec37 = {
719 0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
720 };
721 static final long[] jjbitVec38 = {
722 0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
723 };
724 static final long[] jjbitVec39 = {
725 0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
726 };
727 static final long[] jjbitVec40 = {
728 0x0L, 0x0L, 0x0L, 0x21fff0000L
729 };
730 static final long[] jjbitVec41 = {
731 0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
732 };
733 private final int jjMoveNfa_0(int startState, int curPos)
734 {
735 int[] nextStates;
736 int startsAt = 0;
737 jjnewStateCnt = 43;
738 int i = 1;
739 jjstateSet[0] = startState;
740 int j, kind = 0x7fffffff;
741 for (;;)
742 {
743 if (++jjround == 0x7fffffff)
744 ReInitRounds();
745 if (curChar < 64)
746 {
747 long l = 1L << curChar;
748 MatchLoop: do
749 {
750 switch(jjstateSet[--i])
751 {
752 case 3:
753 if ((0xfffffffffffff9ffL & l) != 0L)
754 {
755 if (kind > 60)
756 kind = 60;
757 }
758 if ((0x100000601L & l) != 0L)
759 {
760 if (kind > 39)
761 kind = 39;
762 jjCheckNAdd(0);
763 }
764 else if (curChar == 39)
765 jjstateSet[jjnewStateCnt++] = 31;
766 else if (curChar == 34)
767 jjstateSet[jjnewStateCnt++] = 22;
768 else if (curChar == 35)
948 jjCheckNAddTwoStates(39, 40);
949 break;
950 case 40:
951 if (curChar == 58)
952 jjstateSet[jjnewStateCnt++] = 41;
953 break;
954 case 42:
955 if ((0x3ff600000000000L & l) == 0L)
956 break;
957 if (kind > 57)
958 kind = 57;
959 jjstateSet[jjnewStateCnt++] = 42;
960 break;
961 default : break;
962 }
963 } while(i != startsAt);
964 }
965 else if (curChar < 128)
966 {
967 long l = 1L << (curChar & 077);
968 MatchLoop: do
969 {
970 switch(jjstateSet[--i])
971 {
972 case 3:
973 if (kind > 60)
974 kind = 60;
975 if ((0x7fffffe87fffffeL & l) != 0L)
976 {
977 if (kind > 54)
978 kind = 54;
979 jjCheckNAddStates(10, 14);
980 }
981 else if (curChar == 92)
982 jjstateSet[jjnewStateCnt++] = 7;
983 break;
984 case 43:
985 if ((0x7fffffe87fffffeL & l) != 0L)
986 jjCheckNAddTwoStates(39, 40);
987 if ((0x7fffffe87fffffeL & l) != 0L)
988 jjCheckNAddTwoStates(36, 38);
1055 break;
1056 case 41:
1057 case 42:
1058 if ((0x7fffffe87fffffeL & l) == 0L)
1059 break;
1060 if (kind > 57)
1061 kind = 57;
1062 jjCheckNAdd(42);
1063 break;
1064 default : break;
1065 }
1066 } while(i != startsAt);
1067 }
1068 else
1069 {
1070 int hiByte = (int)(curChar >> 8);
1071 int i1 = hiByte >> 6;
1072 long l1 = 1L << (hiByte & 077);
1073 int i2 = (curChar & 0xff) >> 6;
1074 long l2 = 1L << (curChar & 077);
1075 MatchLoop: do
1076 {
1077 switch(jjstateSet[--i])
1078 {
1079 case 3:
1080 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1081 {
1082 if (kind > 60)
1083 kind = 60;
1084 }
1085 if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1086 {
1087 if (kind > 54)
1088 kind = 54;
1089 jjCheckNAddStates(10, 14);
1090 }
1091 break;
1092 case 43:
1093 if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1094 {
1095 if (kind > 54)
1185 kind = 57;
1186 jjCheckNAdd(42);
1187 break;
1188 default : break;
1189 }
1190 } while(i != startsAt);
1191 }
1192 if (kind != 0x7fffffff)
1193 {
1194 jjmatchedKind = kind;
1195 jjmatchedPos = curPos;
1196 kind = 0x7fffffff;
1197 }
1198 ++curPos;
1199 if ((i = jjnewStateCnt) == (startsAt = 43 - (jjnewStateCnt = startsAt)))
1200 return curPos;
1201 try { curChar = input_stream.readChar(); }
1202 catch(java.io.IOException e) { return curPos; }
1203 }
1204 }
1205 private final int jjMoveStringLiteralDfa0_1()
1206 {
1207 return jjMoveNfa_1(1, 0);
1208 }
1209 private final int jjMoveNfa_1(int startState, int curPos)
1210 {
1211 int[] nextStates;
1212 int startsAt = 0;
1213 jjnewStateCnt = 10;
1214 int i = 1;
1215 jjstateSet[0] = startState;
1216 int j, kind = 0x7fffffff;
1217 for (;;)
1218 {
1219 if (++jjround == 0x7fffffff)
1220 ReInitRounds();
1221 if (curChar < 64)
1222 {
1223 long l = 1L << curChar;
1224 MatchLoop: do
1225 {
1226 switch(jjstateSet[--i])
1227 {
1228 case 1:
1229 if ((0xfffffffffffff9ffL & l) != 0L)
1230 {
1231 if (kind > 60)
1232 kind = 60;
1233 }
1234 if ((0x100000601L & l) != 0L)
1235 {
1236 if (kind > 39)
1237 kind = 39;
1238 jjCheckNAdd(0);
1239 }
1240 if ((0x401L & l) != 0L)
1241 jjCheckNAddStates(19, 22);
1242 break;
1243 case 0:
1244 if ((0x100000601L & l) == 0L)
1281 if (curChar != 35)
1282 break;
1283 if (kind > 44)
1284 kind = 44;
1285 jjCheckNAdd(9);
1286 break;
1287 case 9:
1288 if ((0xfffffffffffffbfeL & l) == 0L)
1289 break;
1290 if (kind > 44)
1291 kind = 44;
1292 jjCheckNAdd(9);
1293 break;
1294 default : break;
1295 }
1296 } while(i != startsAt);
1297 }
1298 else if (curChar < 128)
1299 {
1300 long l = 1L << (curChar & 077);
1301 MatchLoop: do
1302 {
1303 switch(jjstateSet[--i])
1304 {
1305 case 1:
1306 if (kind > 60)
1307 kind = 60;
1308 break;
1309 case 5:
1310 if (kind > 43)
1311 kind = 43;
1312 jjstateSet[jjnewStateCnt++] = 5;
1313 break;
1314 case 9:
1315 if (kind > 44)
1316 kind = 44;
1317 jjstateSet[jjnewStateCnt++] = 9;
1318 break;
1319 default : break;
1320 }
1321 } while(i != startsAt);
1322 }
1323 else
1324 {
1325 int hiByte = (int)(curChar >> 8);
1326 int i1 = hiByte >> 6;
1327 long l1 = 1L << (hiByte & 077);
1328 int i2 = (curChar & 0xff) >> 6;
1329 long l2 = 1L << (curChar & 077);
1330 MatchLoop: do
1331 {
1332 switch(jjstateSet[--i])
1333 {
1334 case 1:
1335 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1336 kind = 60;
1337 break;
1338 case 5:
1339 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1340 break;
1341 if (kind > 43)
1342 kind = 43;
1343 jjstateSet[jjnewStateCnt++] = 5;
1344 break;
1345 case 9:
1346 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1347 break;
1348 if (kind > 44)
1349 kind = 44;
1350 jjstateSet[jjnewStateCnt++] = 9;
1351 break;
1352 default : break;
1353 }
1354 } while(i != startsAt);
1355 }
1356 if (kind != 0x7fffffff)
1357 {
1358 jjmatchedKind = kind;
1359 jjmatchedPos = curPos;
1360 kind = 0x7fffffff;
1361 }
1362 ++curPos;
1363 if ((i = jjnewStateCnt) == (startsAt = 10 - (jjnewStateCnt = startsAt)))
1364 return curPos;
1365 try { curChar = input_stream.readChar(); }
1366 catch(java.io.IOException e) { return curPos; }
1367 }
1368 }
1369 private final int jjMoveStringLiteralDfa0_2()
1370 {
1371 return jjMoveNfa_2(1, 0);
1372 }
1373 private final int jjMoveNfa_2(int startState, int curPos)
1374 {
1375 int[] nextStates;
1376 int startsAt = 0;
1377 jjnewStateCnt = 7;
1378 int i = 1;
1379 jjstateSet[0] = startState;
1380 int j, kind = 0x7fffffff;
1381 for (;;)
1382 {
1383 if (++jjround == 0x7fffffff)
1384 ReInitRounds();
1385 if (curChar < 64)
1386 {
1387 long l = 1L << curChar;
1388 MatchLoop: do
1389 {
1390 switch(jjstateSet[--i])
1391 {
1392 case 1:
1393 if ((0xfffffffffffff9ffL & l) != 0L)
1394 {
1395 if (kind > 60)
1396 kind = 60;
1397 }
1398 if ((0x100000601L & l) != 0L)
1399 {
1400 if (kind > 39)
1401 kind = 39;
1402 jjCheckNAdd(0);
1403 }
1404 if ((0x401L & l) != 0L)
1405 jjCheckNAddTwoStates(2, 5);
1406 break;
1407 case 0:
1408 if ((0x100000601L & l) == 0L)
1427 break;
1428 if (kind > 41)
1429 kind = 41;
1430 jjCheckNAdd(4);
1431 break;
1432 case 5:
1433 if (curChar == 35)
1434 jjstateSet[jjnewStateCnt++] = 3;
1435 break;
1436 case 6:
1437 if ((0xfffffffffffff9ffL & l) != 0L && kind > 60)
1438 kind = 60;
1439 break;
1440 default : break;
1441 }
1442 } while(i != startsAt);
1443 }
1444 else if (curChar < 128)
1445 {
1446 long l = 1L << (curChar & 077);
1447 MatchLoop: do
1448 {
1449 switch(jjstateSet[--i])
1450 {
1451 case 1:
1452 if (kind > 60)
1453 kind = 60;
1454 break;
1455 case 4:
1456 if (kind > 41)
1457 kind = 41;
1458 jjstateSet[jjnewStateCnt++] = 4;
1459 break;
1460 default : break;
1461 }
1462 } while(i != startsAt);
1463 }
1464 else
1465 {
1466 int hiByte = (int)(curChar >> 8);
1467 int i1 = hiByte >> 6;
1468 long l1 = 1L << (hiByte & 077);
1469 int i2 = (curChar & 0xff) >> 6;
1470 long l2 = 1L << (curChar & 077);
1471 MatchLoop: do
1472 {
1473 switch(jjstateSet[--i])
1474 {
1475 case 1:
1476 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1477 kind = 60;
1478 break;
1479 case 4:
1480 if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1481 break;
1482 if (kind > 41)
1483 kind = 41;
1484 jjstateSet[jjnewStateCnt++] = 4;
1485 break;
1486 default : break;
1487 }
1488 } while(i != startsAt);
1489 }
1490 if (kind != 0x7fffffff)
1491 {
1613 case 31:
1614 return ((jjbitVec21[i2] & l2) != 0L);
1615 case 32:
1616 return ((jjbitVec40[i2] & l2) != 0L);
1617 case 33:
1618 return ((jjbitVec22[i2] & l2) != 0L);
1619 case 48:
1620 return ((jjbitVec41[i2] & l2) != 0L);
1621 case 49:
1622 return ((jjbitVec24[i2] & l2) != 0L);
1623 case 159:
1624 return ((jjbitVec25[i2] & l2) != 0L);
1625 case 215:
1626 return ((jjbitVec26[i2] & l2) != 0L);
1627 default :
1628 if ((jjbitVec3[i1] & l1) != 0L)
1629 return true;
1630 return false;
1631 }
1632 }
1633 public static final String[] jjstrLiteralImages = {
1634 "", "\133", "\75", "\46\75", "\174\75", "\163\164\141\162\164",
1635 "\144\151\166", "\151\156\143\154\165\144\145", "\176", "\135",
1636 "\147\162\141\155\155\141\162", "\173", "\175", "\156\141\155\145\163\160\141\143\145",
1637 "\144\145\146\141\165\154\164", "\151\156\150\145\162\151\164", "\144\141\164\141\164\171\160\145\163",
1638 "\145\155\160\164\171", "\164\145\170\164", "\156\157\164\101\154\154\157\167\145\144", "\174", "\46",
1639 "\54", "\53", "\77", "\52", "\145\154\145\155\145\156\164",
1640 "\141\164\164\162\151\142\165\164\145", "\50", "\51", "\55", "\154\151\163\164", "\155\151\170\145\144",
1641 "\145\170\164\145\162\156\141\154", "\160\141\162\145\156\164", "\163\164\162\151\156\147",
1642 "\164\157\153\145\156", null, null, null, null, null, null, null, null, null, null, null, null, null,
1643 null, null, null, null, null, null, null, null, null, "\76\76", null, };
1644 public static final String[] lexStateNames = {
1645 "DEFAULT",
1646 "AFTER_SINGLE_LINE_COMMENT",
1647 "AFTER_DOCUMENTATION",
1648 };
1649 public static final int[] jjnewLexState = {
1650 -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,
1651 -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,
1652 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1653 };
1654 static final long[] jjtoToken = {
1655 0x1fc00b1fffffffffL,
1656 };
1657 static final long[] jjtoSkip = {
1658 0x148000000000L,
1659 };
1660 static final long[] jjtoSpecial = {
1661 0x140000000000L,
1662 };
1663 protected JavaCharStream input_stream;
1664 private final int[] jjrounds = new int[43];
1665 private final int[] jjstateSet = new int[86];
1666 StringBuffer image;
1667 int jjimageLen;
1668 int lengthOfMatch;
1669 protected char curChar;
1670 public CompactSyntaxTokenManager(JavaCharStream stream)
1671 {
1672 if (JavaCharStream.staticFlag)
1673 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1674 input_stream = stream;
1675 }
1676 public CompactSyntaxTokenManager(JavaCharStream stream, int lexState)
1677 {
1678 this(stream);
1679 SwitchTo(lexState);
1680 }
1681 public void ReInit(JavaCharStream stream)
1682 {
1683 jjmatchedPos = jjnewStateCnt = 0;
1684 curLexState = defaultLexState;
1685 input_stream = stream;
1686 ReInitRounds();
1687 }
1688 private final void ReInitRounds()
1689 {
1690 int i;
1691 jjround = 0x80000001;
1692 for (i = 43; i-- > 0;)
1693 jjrounds[i] = 0x80000000;
1694 }
1695 public void ReInit(JavaCharStream stream, int lexState)
1696 {
1697 ReInit(stream);
1698 SwitchTo(lexState);
1699 }
1700 public void SwitchTo(int lexState)
1701 {
1702 if (lexState >= 3 || lexState < 0)
1703 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1704 else
1705 curLexState = lexState;
1706 }
1707
1708 protected Token jjFillToken()
1709 {
1710 Token t = Token.newToken(jjmatchedKind);
1711 t.kind = jjmatchedKind;
1712 String im = jjstrLiteralImages[jjmatchedKind];
1713 t.image = (im == null) ? input_stream.GetImage() : im;
1714 t.beginLine = input_stream.getBeginLine();
1715 t.beginColumn = input_stream.getBeginColumn();
1716 t.endLine = input_stream.getEndLine();
1717 t.endColumn = input_stream.getEndColumn();
1718 return t;
1719 }
1720
1721 int curLexState = 0;
1722 int defaultLexState = 0;
1723 int jjnewStateCnt;
1724 int jjround;
1725 int jjmatchedPos;
1726 int jjmatchedKind;
1727
1728 public Token getNextToken()
1729 {
1730 int kind;
1731 Token specialToken = null;
1732 Token matchedToken;
1733 int curPos = 0;
1734
1735 EOFLoop :
1736 for (;;)
1737 {
1738 try
1739 {
1740 curChar = input_stream.BeginToken();
1741 }
1742 catch(java.io.IOException e)
1743 {
1744 jjmatchedKind = 0;
1745 matchedToken = jjFillToken();
1746 matchedToken.specialToken = specialToken;
1747 return matchedToken;
1748 }
1749 image = null;
1750 jjimageLen = 0;
1751
1752 switch(curLexState)
1753 {
1754 case 0:
1755 jjmatchedKind = 0x7fffffff;
1756 jjmatchedPos = 0;
1757 curPos = jjMoveStringLiteralDfa0_0();
1758 break;
1759 case 1:
1760 jjmatchedKind = 0x7fffffff;
1761 jjmatchedPos = 0;
1762 curPos = jjMoveStringLiteralDfa0_1();
1763 break;
1764 case 2:
1765 jjmatchedKind = 0x7fffffff;
1766 jjmatchedPos = 0;
1767 curPos = jjMoveStringLiteralDfa0_2();
1768 break;
1769 }
1814 }
1815 else
1816 error_column++;
1817 }
1818 if (!EOFSeen) {
1819 input_stream.backup(1);
1820 error_after = curPos <= 1 ? "" : input_stream.GetImage();
1821 }
1822 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1823 }
1824 }
1825
1826 void SkipLexicalActions(Token matchedToken)
1827 {
1828 switch(jjmatchedKind)
1829 {
1830 default :
1831 break;
1832 }
1833 }
1834 }
|