|
1
2 package com.thaiopensource.relaxng.parse.compact;
3 import com.thaiopensource.relaxng.parse.SchemaBuilder;
4 import com.thaiopensource.relaxng.parse.Annotations;
5 import com.thaiopensource.relaxng.parse.DataPatternBuilder;
6 import com.thaiopensource.relaxng.parse.ParsedElementAnnotation;
7 import com.thaiopensource.relaxng.parse.ElementAnnotationBuilder;
8 import com.thaiopensource.relaxng.parse.CommentList;
9 import com.thaiopensource.relaxng.parse.ParsedPattern;
10 import com.thaiopensource.relaxng.parse.ParsedNameClass;
11 import com.thaiopensource.relaxng.parse.Scope;
12 import com.thaiopensource.relaxng.parse.GrammarSection;
13 import com.thaiopensource.relaxng.parse.Div;
14 import com.thaiopensource.relaxng.parse.Grammar;
15 import com.thaiopensource.relaxng.parse.Include;
16 import com.thaiopensource.relaxng.parse.IncludedGrammar;
17 import com.thaiopensource.relaxng.parse.IllegalSchemaException;
18 import com.thaiopensource.relaxng.parse.BuildException;
19 import com.thaiopensource.relaxng.parse.Location;
20 import com.thaiopensource.relaxng.parse.Context;
21 import com.thaiopensource.xml.util.WellKnownNamespaces;
22 import com.thaiopensource.util.Localizer;
23 import org.xml.sax.ErrorHandler  ;
24 import org.xml.sax.SAXException ;
25 import org.xml.sax.SAXParseException ;
26 import org.xml.sax.Locator ;
27 import org.xml.sax.helpers.LocatorImpl ;
28 import java.util.Hashtable ;
29 import java.util.Enumeration ;
30 import java.io.Reader ;
31 import java.net.MalformedURLException ;
32 import java.net.URL ;
33
34 public class CompactSyntaxTokenManager implements CompactSyntaxConstants
35 {
36 private final int jjStopStringLiteralDfa_0(int pos, long active0)
37 {
38 switch (pos)
39 {
40 case 0:
41 if ((active0 & 0x1f8c0fe4e0L) != 0L)
42 {
43 jjmatchedKind = 54;
44 return 43;
45 }
46 if ((active0 & 0x800000000000000L) != 0L)
47 {
48 jjmatchedKind = 60;
49 return -1;
50 }
51 return -1;
52 case 1:
53 if ((active0 & 0x1f8c0fe4e0L) != 0L)
54 {
55 jjmatchedKind = 54;
56 jjmatchedPos = 1;
57 return 43;
58 }
59 if ((active0 & 0x800000000000000L) != 0L)
60 {
61 if (jjmatchedPos == 0)
62 {
63 jjmatchedKind = 60;
64 jjmatchedPos = 0;
65 }
66 return -1;
67 }
68 return -1;
69 case 2:
70 if ((active0 & 0x1f8c0fe4a0L) != 0L)
71 {
72 jjmatchedKind = 54;
73 jjmatchedPos = 2;
74 return 43;
75 }
76 if ((active0 & 0x40L) != 0L)
77 return 43;
78 return -1;
79 case 3:
80 if ((active0 & 0x1f0c0be4a0L) != 0L)
81 {
82 jjmatchedKind = 54;
83 jjmatchedPos = 3;
84 return 43;
85 }
86 if ((active0 & 0x80040000L) != 0L)
87 return 43;
88 return -1;
89 case 4:
90 if ((active0 & 0xe0c09e480L) != 0L)
91 {
92 jjmatchedKind = 54;
93 jjmatchedPos = 4;
94 return 43;
95 }
96 if ((active0 & 0x1100020020L) != 0L)
97 return 43;
98 return -1;
99 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}
1174private final int jjMoveStringLiteralDfa0_1()
1175{
1176 return jjMoveNfa_1(1, 0);
1177}
1178private 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}
1338private final int jjMoveStringLiteralDfa0_2()
1339{
1340 return jjMoveNfa_2(1, 0);
1341}
1342private 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}
1472static 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};
1476private 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}
1488private 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}
1544private 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}
1602public 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,
1612null, null, null, null, null, null, null, null, null, "\76\76", null, };
1613public static final String [] lexStateNames = {
1614 "DEFAULT",
1615 "AFTER_SINGLE_LINE_COMMENT",
1616 "AFTER_DOCUMENTATION",
1617};
1618public 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};
1623static final long[] jjtoToken = {
1624 0x1fc00b1fffffffffL,
1625};
1626static final long[] jjtoSkip = {
1627 0x148000000000L,
1628};
1629static final long[] jjtoSpecial = {
1630 0x140000000000L,
1631};
1632private UCode_UCodeESC_CharStream input_stream;
1633private final int[] jjrounds = new int[43];
1634private final int[] jjstateSet = new int[86];
1635StringBuffer image;
1636int jjimageLen;
1637int lengthOfMatch;
1638protected char curChar;
1639public 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}
1645public CompactSyntaxTokenManager(UCode_UCodeESC_CharStream stream, int lexState)
1646{
1647 this(stream);
1648 SwitchTo(lexState);
1649}
1650public void ReInit(UCode_UCodeESC_CharStream stream)
1651{
1652 jjmatchedPos = jjnewStateCnt = 0;
1653 curLexState = defaultLexState;
1654 input_stream = stream;
1655 ReInitRounds();
1656}
1657private final void ReInitRounds()
1658{
1659 int i;
1660 jjround = 0x80000001;
1661 for (i = 43; i-- > 0;)
1662 jjrounds[i] = 0x80000000;
1663}
1664public void ReInit(UCode_UCodeESC_CharStream stream, int lexState)
1665{
1666 ReInit(stream);
1667 SwitchTo(lexState);
1668}
1669public 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
1677private 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
1690int curLexState = 0;
1691int defaultLexState = 0;
1692int jjnewStateCnt;
1693int jjround;
1694int jjmatchedPos;
1695int jjmatchedKind;
1696
1697public 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
1795final void SkipLexicalActions(Token matchedToken)
1796{
1797 switch(jjmatchedKind)
1798 {
1799 default :
1800 break;
1801 }
1802}
1803}
1804 |
Popular Tags |
Java API By Example, From Geeks To Geeks.