1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 package zeus.concepts;
26
27 import java.util.*;
28 import java.io.*;
29 import zeus.util.*;
30
31 public class OntologyParser implements OntologyParserConstants {
32
33 final public void parse(OntologyDb model) throws ParseException {
34 Token version, system, count, name = null, type = null, value = null;
35 Token parent, fact, restriction, default_token;
36 jj_consume_token(BEGIN_ONTOLOGY);
37 jj_consume_token(BEGIN_PREAMBLE);
38 jj_consume_token(SYSTEM);
39 system = jj_consume_token(SYSTEM_NAME);
40 jj_consume_token(VERSION);
41 version = jj_consume_token(LITERAL);
42 jj_consume_token(END_PREAMBLE);
43 String ver = Misc.literalToString(version.image);
44 if ( !ver.equals(SystemProps.getProperty("version.id")) )
45 model.__setWarning("File and system versions are different");
46 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
47 case BEGIN_RESTRICTIONS:
48 jj_consume_token(BEGIN_RESTRICTIONS);
49 label_1:
50 while (true) {
51 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
52 case BEGIN_RESTRICTION_ITEM:
53 ;
54 break;
55 default:
56 jj_la1[0] = jj_gen;
57 break label_1;
58 }
59 jj_consume_token(BEGIN_RESTRICTION_ITEM);
60 jj_consume_token(NAME);
61 name = jj_consume_token(ID);
62 jj_consume_token(TYPE);
63 type = jj_consume_token(ID);
64 jj_consume_token(VALUE);
65 value = jj_consume_token(LITERAL);
66 jj_consume_token(END_RESTRICTION_ITEM);
67 String s = Misc.literalToString(value.image);
68 model.__addRestriction(name.image,type.image,s);
69 }
70 jj_consume_token(END_RESTRICTIONS);
71 break;
72 default:
73 jj_la1[1] = jj_gen;
74 ;
75 }
76 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
77 case BEGIN_FACTS:
78 jj_consume_token(BEGIN_FACTS);
79 label_2:
80 while (true) {
81 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
82 case BEGIN_FACT_ITEM:
83 ;
84 break;
85 default:
86 jj_la1[2] = jj_gen;
87 break label_2;
88 }
89 jj_consume_token(BEGIN_FACT_ITEM);
90 jj_consume_token(NAME);
91 fact = jj_consume_token(ID);
92 jj_consume_token(PARENT);
93 parent = jj_consume_token(ID);
94 model.__addChildFact(parent.image,fact.image);
95 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
96 case BEGIN_ATTRIBUTE_LIST:
97 jj_consume_token(BEGIN_ATTRIBUTE_LIST);
98 label_3:
99 while (true) {
100 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
101 case BEGIN_ATTRIBUTE_ITEM:
102 ;
103 break;
104 default:
105 jj_la1[3] = jj_gen;
106 break label_3;
107 }
108 jj_consume_token(BEGIN_ATTRIBUTE_ITEM);
109 jj_consume_token(NAME);
110 name = jj_consume_token(ID);
111 jj_consume_token(TYPE);
112 type = jj_consume_token(ID);
113 jj_consume_token(RESTRICTION);
114 restriction = jj_consume_token(LITERAL);
115 jj_consume_token(DEFAULT_TAG);
116 default_token = jj_consume_token(LITERAL);
117 jj_consume_token(END_ATTRIBUTE_ITEM);
118 String s1, s2;
119 s1 = Misc.literalToString(restriction.image);
120 s2 = Misc.literalToString(default_token.image);
121 model.__addNewAttributeRow(fact.image,name.image,
122 type.image,s1,s2);
123 }
124 jj_consume_token(END_ATTRIBUTE_LIST);
125 break;
126 default:
127 jj_la1[4] = jj_gen;
128 ;
129 }
130 jj_consume_token(END_FACT_ITEM);
131 }
132 jj_consume_token(END_FACTS);
133 break;
134 default:
135 jj_la1[5] = jj_gen;
136 ;
137 }
138 jj_consume_token(END_ONTOLOGY);
139 }
140
141 public OntologyParserTokenManager token_source;
142 ASCII_CharStream jj_input_stream;
143 public Token token, jj_nt;
144 private int jj_ntk;
145 private int jj_gen;
146 final private int[] jj_la1 = new int[6];
147 final private int[] jj_la1_0 = {0x10000,0x8000,0x40000,0x100000,0x80000,0x20000,};
148 final private int[] jj_la1_1 = {0x0,0x0,0x0,0x0,0x0,0x0,};
149
150 public OntologyParser(java.io.InputStream stream) {
151 jj_input_stream = new ASCII_CharStream(stream, 1, 1);
152 token_source = new OntologyParserTokenManager(jj_input_stream);
153 token = new Token();
154 jj_ntk = -1;
155 jj_gen = 0;
156 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
157 }
158
159 public void ReInit(java.io.InputStream stream) {
160 jj_input_stream.ReInit(stream, 1, 1);
161 token_source.ReInit(jj_input_stream);
162 token = new Token();
163 jj_ntk = -1;
164 jj_gen = 0;
165 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
166 }
167
168 public OntologyParser(OntologyParserTokenManager tm) {
169 token_source = tm;
170 token = new Token();
171 jj_ntk = -1;
172 jj_gen = 0;
173 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
174 }
175
176 public void ReInit(OntologyParserTokenManager tm) {
177 token_source = tm;
178 token = new Token();
179 jj_ntk = -1;
180 jj_gen = 0;
181 for (int i = 0; i < 6; i++) jj_la1[i] = -1;
182 }
183
184 final private Token jj_consume_token(int kind) throws ParseException {
185 Token oldToken;
186 if ((oldToken = token).next != null) token = token.next;
187 else token = token.next = token_source.getNextToken();
188 jj_ntk = -1;
189 if (token.kind == kind) {
190 jj_gen++;
191 return token;
192 }
193 token = oldToken;
194 jj_kind = kind;
195 throw generateParseException();
196 }
197
198 final public Token getNextToken() {
199 if (token.next != null) token = token.next;
200 else token = token.next = token_source.getNextToken();
201 jj_ntk = -1;
202 jj_gen++;
203 return token;
204 }
205
206 final public Token getToken(int index) {
207 Token t = token;
208 for (int i = 0; i < index; i++) {
209 if (t.next != null) t = t.next;
210 else t = t.next = token_source.getNextToken();
211 }
212 return t;
213 }
214
215 final private int jj_ntk() {
216 if ((jj_nt=token.next) == null)
217 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
218 else
219 return (jj_ntk = jj_nt.kind);
220 }
221
222 private java.util.Vector jj_expentries = new java.util.Vector();
223 private int[] jj_expentry;
224 private int jj_kind = -1;
225
226 final public ParseException generateParseException() {
227 jj_expentries.removeAllElements();
228 boolean[] la1tokens = new boolean[46];
229 for (int i = 0; i < 46; i++) {
230 la1tokens[i] = false;
231 }
232 if (jj_kind >= 0) {
233 la1tokens[jj_kind] = true;
234 jj_kind = -1;
235 }
236 for (int i = 0; i < 6; i++) {
237 if (jj_la1[i] == jj_gen) {
238 for (int j = 0; j < 32; j++) {
239 if ((jj_la1_0[i] & (1<<j)) != 0) {
240 la1tokens[j] = true;
241 }
242 if ((jj_la1_1[i] & (1<<j)) != 0) {
243 la1tokens[32+j] = true;
244 }
245 }
246 }
247 }
248 for (int i = 0; i < 46; i++) {
249 if (la1tokens[i]) {
250 jj_expentry = new int[1];
251 jj_expentry[0] = i;
252 jj_expentries.addElement(jj_expentry);
253 }
254 }
255 int[][] exptokseq = new int[jj_expentries.size()][];
256 for (int i = 0; i < jj_expentries.size(); i++) {
257 exptokseq[i] = (int[])jj_expentries.elementAt(i);
258 }
259 return new ParseException(token, exptokseq, tokenImage);
260 }
261
262 final public void enable_tracing() {
263 }
264
265 final public void disable_tracing() {
266 }
267
268 }
269
270 interface OntologyParserConstants {
271
272 int EOF = 0;
273 int SINGLE_LINE_COMMENT = 9;
274 int FORMAL_COMMENT = 10;
275 int MULTI_LINE_COMMENT = 11;
276 int BEGIN_ONTOLOGY = 13;
277 int BEGIN_PREAMBLE = 14;
278 int BEGIN_RESTRICTIONS = 15;
279 int BEGIN_RESTRICTION_ITEM = 16;
280 int BEGIN_FACTS = 17;
281 int BEGIN_FACT_ITEM = 18;
282 int BEGIN_ATTRIBUTE_LIST = 19;
283 int BEGIN_ATTRIBUTE_ITEM = 20;
284 int END_PREAMBLE = 21;
285 int END_RESTRICTION_ITEM = 22;
286 int END_RESTRICTIONS = 23;
287 int END_ATTRIBUTE_ITEM = 24;
288 int END_ATTRIBUTE_LIST = 25;
289 int END_FACT_ITEM = 26;
290 int END_FACTS = 27;
291 int END_ONTOLOGY = 28;
292 int SYSTEM_NAME = 29;
293 int SYSTEM = 30;
294 int VERSION = 31;
295 int NAME = 32;
296 int PARENT = 33;
297 int TYPE = 34;
298 int VALUE = 35;
299 int RESTRICTION = 36;
300 int DEFAULT_TAG = 37;
301 int ID = 38;
302 int INTEGER = 39;
303 int REAL = 40;
304 int LITERAL = 41;
305 int EXPONENT = 42;
306 int LETTER = 43;
307 int DIGIT = 44;
308 int DECIMAL = 45;
309
310 int DEFAULT = 0;
311 int IN_SINGLE_LINE_COMMENT = 1;
312 int IN_FORMAL_COMMENT = 2;
313 int IN_MULTI_LINE_COMMENT = 3;
314
315 String[] tokenImage = {
316 "<EOF>",
317 "\" \"",
318 "\"//t\"",
319 "\"//n\"",
320 "\"//r\"",
321 "\"//f\"",
322 "\"//\"",
323 "<token of kind 7>",
324 "\"/*\"",
325 "<SINGLE_LINE_COMMENT>",
326 "\"*/\"",
327 "\"*/\"",
328 "<token of kind 12>",
329 "\"BEGIN_ONTOLOGY\"",
330 "\"BEGIN_PREAMBLE\"",
331 "\"BEGIN_RESTRICTIONS\"",
332 "\"BEGIN_RESTRICTION_ITEM\"",
333 "\"BEGIN_FACTS\"",
334 "\"BEGIN_FACT_ITEM\"",
335 "\"BEGIN_ATTRIBUTE_LIST\"",
336 "\"BEGIN_ATTRIBUTE_ITEM\"",
337 "\"END_PREAMBLE\"",
338 "\"END_RESTRICTION_ITEM\"",
339 "\"END_RESTRICTIONS\"",
340 "\"END_ATTRIBUTE_ITEM\"",
341 "\"END_ATTRIBUTE_LIST\"",
342 "\"END_FACT_ITEM\"",
343 "\"END_FACTS\"",
344 "\"END_ONTOLOGY\"",
345 "\"ZEUS-Ontology-Editor\"",
346 "\":system\"",
347 "\":version\"",
348 "\":name\"",
349 "\":parent\"",
350 "\":type\"",
351 "\":value\"",
352 "\":restriction\"",
353 "\":default\"",
354 "<ID>",
355 "<INTEGER>",
356 "<REAL>",
357 "<LITERAL>",
358 "<EXPONENT>",
359 "<LETTER>",
360 "<DIGIT>",
361 "<DECIMAL>",
362 };
363
364 }
365
366 class OntologyParserTokenManager implements OntologyParserConstants
367 {
368 private final int jjStopAtPos(int pos, int kind)
369 {
370 jjmatchedKind = kind;
371 jjmatchedPos = pos;
372 return pos + 1;
373 }
374 private final int jjMoveStringLiteralDfa0_3()
375 {
376 switch(curChar)
377 {
378 case 42:
379 return jjMoveStringLiteralDfa1_3(0x800L);
380 default :
381 return 1;
382 }
383 }
384 private final int jjMoveStringLiteralDfa1_3(long active0)
385 {
386 try { curChar = input_stream.readChar(); }
387 catch(java.io.IOException e) {
388 return 1;
389 }
390 switch(curChar)
391 {
392 case 47:
393 if ((active0 & 0x800L) != 0L)
394 return jjStopAtPos(1, 11);
395 break;
396 default :
397 return 2;
398 }
399 return 2;
400 }
401 private final int jjMoveStringLiteralDfa0_2()
402 {
403 switch(curChar)
404 {
405 case 42:
406 return jjMoveStringLiteralDfa1_2(0x400L);
407 default :
408 return 1;
409 }
410 }
411 private final int jjMoveStringLiteralDfa1_2(long active0)
412 {
413 try { curChar = input_stream.readChar(); }
414 catch(java.io.IOException e) {
415 return 1;
416 }
417 switch(curChar)
418 {
419 case 47:
420 if ((active0 & 0x400L) != 0L)
421 return jjStopAtPos(1, 10);
422 break;
423 default :
424 return 2;
425 }
426 return 2;
427 }
428 private final int jjMoveStringLiteralDfa0_1()
429 {
430 return jjMoveNfa_1(0, 0);
431 }
432 private final void jjCheckNAdd(int state)
433 {
434 if (jjrounds[state] != jjround)
435 {
436 jjstateSet[jjnewStateCnt++] = state;
437 jjrounds[state] = jjround;
438 }
439 }
440 private final void jjAddStates(int start, int end)
441 {
442 do {
443 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
444 } while (start++ != end);
445 }
446 private final void jjCheckNAddTwoStates(int state1, int state2)
447 {
448 jjCheckNAdd(state1);
449 jjCheckNAdd(state2);
450 }
451 private final void jjCheckNAddStates(int start, int end)
452 {
453 do {
454 jjCheckNAdd(jjnextStates[start]);
455 } while (start++ != end);
456 }
457 private final void jjCheckNAddStates(int start)
458 {
459 jjCheckNAdd(jjnextStates[start]);
460 jjCheckNAdd(jjnextStates[start + 1]);
461 }
462 private final int jjMoveNfa_1(int startState, int curPos)
463 {
464 int[] nextStates;
465 int startsAt = 0;
466 jjnewStateCnt = 3;
467 int i = 1;
468 jjstateSet[0] = startState;
469 int j, kind = 0x7fffffff;
470 for (;;)
471 {
472 if (++jjround == 0x7fffffff)
473 ReInitRounds();
474 if (curChar < 64)
475 {
476 long l = 1L << curChar;
477 MatchLoop: do
478 {
479 switch(jjstateSet[--i])
480 {
481 case 0:
482 if ((0x2400L & l) != 0L)
483 {
484 if (kind > 9)
485 kind = 9;
486 }
487 if (curChar == 13)
488 jjstateSet[jjnewStateCnt++] = 1;
489 break;
490 case 1:
491 if (curChar == 10 && kind > 9)
492 kind = 9;
493 break;
494 case 2:
495 if (curChar == 13)
496 jjstateSet[jjnewStateCnt++] = 1;
497 break;
498 default : break;
499 }
500 } while(i != startsAt);
501 }
502 else if (curChar < 128)
503 {
504 long l = 1L << (curChar & 077);
505 MatchLoop: do
506 {
507 switch(jjstateSet[--i])
508 {
509 default : break;
510 }
511 } while(i != startsAt);
512 }
513 else
514 {
515 int i2 = (curChar & 0xff) >> 6;
516 long l2 = 1L << (curChar & 077);
517 MatchLoop: do
518 {
519 switch(jjstateSet[--i])
520 {
521 default : break;
522 }
523 } while(i != startsAt);
524 }
525 if (kind != 0x7fffffff)
526 {
527 jjmatchedKind = kind;
528 jjmatchedPos = curPos;
529 kind = 0x7fffffff;
530 }
531 ++curPos;
532 if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
533 return curPos;
534 try { curChar = input_stream.readChar(); }
535 catch(java.io.IOException e) { return curPos; }
536 }
537 }
538 private final int jjStopStringLiteralDfa_0(int pos, long active0)
539 {
540 switch (pos)
541 {
542 case 0:
543 if ((active0 & 0x3fffe000L) != 0L)
544 {
545 jjmatchedKind = 38;
546 return 5;
547 }
548 if ((active0 & 0x140L) != 0L)
549 return 2;
550 return -1;
551 case 1:
552 if ((active0 & 0x100L) != 0L)
553 return 0;
554 if ((active0 & 0x3fffe000L) != 0L)
555 {
556 jjmatchedKind = 38;
557 jjmatchedPos = 1;
558 return 5;
559 }
560 return -1;
561 case 2:
562 if ((active0 & 0x3fffe000L) != 0L)
563 {
564 jjmatchedKind = 38;
565 jjmatchedPos = 2;
566 return 5;
567 }
568 return -1;
569 case 3:
570 if ((active0 & 0x3fffe000L) != 0L)
571 {
572 jjmatchedKind = 38;
573 jjmatchedPos = 3;
574 return 5;
575 }
576 return -1;
577 case 4:
578 if ((active0 & 0x1fffe000L) != 0L)
579 {
580 jjmatchedKind = 38;
581 jjmatchedPos = 4;
582 return 5;
583 }
584 if ((active0 & 0x20000000L) != 0L)
585 {
586 if (jjmatchedPos < 3)
587 {
588 jjmatchedKind = 38;
589 jjmatchedPos = 3;
590 }
591 return -1;
592 }
593 return -1;
594 case 5:
595 if ((active0 & 0x1fffe000L) != 0L)
596 {
597 jjmatchedKind = 38;
598 jjmatchedPos = 5;
599 return 5;
600 }
601 if ((active0 & 0x20000000L) != 0L)
602 {
603 if (jjmatchedPos < 3)
604 {
605 jjmatchedKind = 38;
606 jjmatchedPos = 3;
607 }
608 return -1;
609 }
610 return -1;
611 case 6:
612 if ((active0 & 0x1fffe000L) != 0L)
613 {
614 jjmatchedKind = 38;
615 jjmatchedPos = 6;
616 return 5;
617 }
618 if ((active0 & 0x20000000L) != 0L)
619 {
620 if (jjmatchedPos < 3)
621 {
622 jjmatchedKind = 38;
623 jjmatchedPos = 3;
624 }
625 return -1;
626 }
627 return -1;
628 case 7:
629 if ((active0 & 0x1fffe000L) != 0L)
630 {
631 jjmatchedKind = 38;
632 jjmatchedPos = 7;
633 return 5;
634 }
635 if ((active0 & 0x20000000L) != 0L)
636 {
637 if (jjmatchedPos < 3)
638 {
639 jjmatchedKind = 38;
640 jjmatchedPos = 3;
641 }
642 return -1;
643 }
644 return -1;
645 case 8:
646 if ((active0 & 0x8000000L) != 0L)
647 return 5;
648 if ((active0 & 0x17ffe000L) != 0L)
649 {
650 jjmatchedKind = 38;
651 jjmatchedPos = 8;
652 return 5;
653 }
654 if ((active0 & 0x20000000L) != 0L)
655 {
656 if (jjmatchedPos < 3)
657 {
658 jjmatchedKind = 38;
659 jjmatchedPos = 3;
660 }
661 return -1;
662 }
663 return -1;
664 case 9:
665 if ((active0 & 0x17ffe000L) != 0L)
666 {
667 jjmatchedKind = 38;
668 jjmatchedPos = 9;
669 return 5;
670 }
671 if ((active0 & 0x20000000L) != 0L)
672 {
673 if (jjmatchedPos < 3)
674 {
675 jjmatchedKind = 38;
676 jjmatchedPos = 3;
677 }
678 return -1;
679 }
680 return -1;
681 case 10:
682 if ((active0 & 0x20000L) != 0L)
683 return 5;
684 if ((active0 & 0x20000000L) != 0L)
685 {
686 if (jjmatchedPos < 3)
687 {
688 jjmatchedKind = 38;
689 jjmatchedPos = 3;
690 }
691 return -1;
692 }
693 if ((active0 & 0x17fde000L) != 0L)
694 {
695 jjmatchedKind = 38;
696 jjmatchedPos = 10;
697 return 5;
698 }
699 return -1;
700 case 11:
701 if ((active0 & 0x7dde000L) != 0L)
702 {
703 jjmatchedKind = 38;
704 jjmatchedPos = 11;
705 return 5;
706 }
707 if ((active0 & 0x10200000L) != 0L)
708 return 5;
709 if ((active0 & 0x20000000L) != 0L)
710 {
711 if (jjmatchedPos < 3)
712 {
713 jjmatchedKind = 38;
714 jjmatchedPos = 3;
715 }
716 return -1;
717 }
718 return -1;
719 case 12:
720 if ((active0 & 0x4000000L) != 0L)
721 return 5;
722 if ((active0 & 0x3dde000L) != 0L)
723 {
724 jjmatchedKind = 38;
725 jjmatchedPos = 12;
726 return 5;
727 }
728 if ((active0 & 0x20000000L) != 0L)
729 {
730 if (jjmatchedPos < 3)
731 {
732 jjmatchedKind = 38;
733 jjmatchedPos = 3;
734 }
735 return -1;
736 }
737 return -1;
738 case 13:
739 if ((active0 & 0x6000L) != 0L)
740 return 5;
741 if ((active0 & 0x3dd8000L) != 0L)
742 {
743 jjmatchedKind = 38;
744 jjmatchedPos = 13;
745 return 5;
746 }
747 if ((active0 & 0x20000000L) != 0L)
748 {
749 if (jjmatchedPos < 3)
750 {
751 jjmatchedKind = 38;
752 jjmatchedPos = 3;
753 }
754 return -1;
755 }
756 return -1;
757 case 14:
758 if ((active0 & 0x40000L) != 0L)
759 return 5;
760 if ((active0 & 0x3d98000L) != 0L)
761 {
762 jjmatchedKind = 38;
763 jjmatchedPos = 14;
764 return 5;
765 }
766 if ((active0 & 0x20000000L) != 0L)
767 {
768 if (jjmatchedPos < 3)
769 {
770 jjmatchedKind = 38;
771 jjmatchedPos = 3;
772 }
773 return -1;
774 }
775 return -1;
776 case 15:
777 if ((active0 & 0x800000L) != 0L)
778 return 5;
779 if ((active0 & 0x20000000L) != 0L)
780 {
781 if (jjmatchedPos < 3)
782 {
783 jjmatchedKind = 38;
784 jjmatchedPos = 3;
785 }
786 return -1;
787 }
788 if ((active0 & 0x3598000L) != 0L)
789 {
790 jjmatchedKind = 38;
791 jjmatchedPos = 15;
792 return 5;
793 }
794 return -1;
795 case 16:
796 if ((active0 & 0x3598000L) != 0L)
797 {
798 jjmatchedKind = 38;
799 jjmatchedPos = 16;
800 return 5;
801 }
802 if ((active0 & 0x20000000L) != 0L)
803 {
804 if (jjmatchedPos < 3)
805 {
806 jjmatchedKind = 38;
807 jjmatchedPos = 3;
808 }
809 return -1;
810 }
811 return -1;
812 case 17:
813 if ((active0 & 0x3008000L) != 0L)
814 return 5;
815 if ((active0 & 0x590000L) != 0L)
816 {
817 jjmatchedKind = 38;
818 jjmatchedPos = 17;
819 return 5;
820 }
821 if ((active0 & 0x20000000L) != 0L)
822 {
823 if (jjmatchedPos < 3)
824 {
825 jjmatchedKind = 38;
826 jjmatchedPos = 3;
827 }
828 return -1;
829 }
830 return -1;
831 case 18:
832 if ((active0 & 0x590000L) != 0L)
833 {
834 jjmatchedKind = 38;
835 jjmatchedPos = 18;
836 return 5;
837 }
838 if ((active0 & 0x20000000L) != 0L)
839 {
840 if (jjmatchedPos < 3)
841 {
842 jjmatchedKind = 38;
843 jjmatchedPos = 3;
844 }
845 return -1;
846 }
847 return -1;
848 case 19:
849 if ((active0 & 0x580000L) != 0L)
850 return 5;
851 if ((active0 & 0x20000000L) != 0L)
852 {
853 if (jjmatchedPos < 3)
854 {
855 jjmatchedKind = 38;
856 jjmatchedPos = 3;
857 }
858 return -1;
859 }
860 if ((active0 & 0x10000L) != 0L)
861 {
862 jjmatchedKind = 38;
863 jjmatchedPos = 19;
864 return 5;
865 }
866 return -1;
867 case 20:
868 if ((active0 & 0x10000L) != 0L)
869 {
870 jjmatchedKind = 38;
871 jjmatchedPos = 20;
872 return 5;
873 }
874 return -1;
875 default :
876 return -1;
877 }
878 }
879 private final int jjStartNfa_0(int pos, long active0)
880 {
881 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
882 }
883 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
884 {
885 jjmatchedKind = kind;
886 jjmatchedPos = pos;
887 try { curChar = input_stream.readChar(); }
888 catch(java.io.IOException e) { return pos + 1; }
889 return jjMoveNfa_0(state, pos + 1);
890 }
891 private final int jjMoveStringLiteralDfa0_0()
892 {
893 switch(curChar)
894 {
895 case 47:
896 return jjMoveStringLiteralDfa1_0(0x140L);
897 case 58:
898 return jjMoveStringLiteralDfa1_0(0x3fc0000000L);
899 case 66:
900 return jjMoveStringLiteralDfa1_0(0x1fe000L);
901 case 69:
902 return jjMoveStringLiteralDfa1_0(0x1fe00000L);
903 case 90:
904 return jjMoveStringLiteralDfa1_0(0x20000000L);
905 default :
906 return jjMoveNfa_0(3, 0);
907 }
908 }
909 private final int jjMoveStringLiteralDfa1_0(long active0)
910 {
911 try { curChar = input_stream.readChar(); }
912 catch(java.io.IOException e) {
913 jjStopStringLiteralDfa_0(0, active0);
914 return 1;
915 }
916 switch(curChar)
917 {
918 case 42:
919 if ((active0 & 0x100L) != 0L)
920 return jjStartNfaWithStates_0(1, 8, 0);
921 break;
922 case 47:
923 if ((active0 & 0x40L) != 0L)
924 return jjStopAtPos(1, 6);
925 break;
926 case 69:
927 return jjMoveStringLiteralDfa2_0(active0, 0x201fe000L);
928 case 78:
929 return jjMoveStringLiteralDfa2_0(active0, 0x1fe00000L);
930 case 100:
931 return jjMoveStringLiteralDfa2_0(active0, 0x2000000000L);
932 case 110:
933 return jjMoveStringLiteralDfa2_0(active0, 0x100000000L);
934 case 112:
935 return jjMoveStringLiteralDfa2_0(active0, 0x200000000L);
936 case 114:
937 return jjMoveStringLiteralDfa2_0(active0, 0x1000000000L);
938 case 115:
939 return jjMoveStringLiteralDfa2_0(active0, 0x40000000L);
940 case 116:
941 return jjMoveStringLiteralDfa2_0(active0, 0x400000000L);
942 case 118:
943 return jjMoveStringLiteralDfa2_0(active0, 0x880000000L);
944 default :
945 break;
946 }
947 return jjStartNfa_0(0, active0);
948 }
949 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
950 {
951 if (((active0 &= old0)) == 0L)
952 return jjStartNfa_0(0, old0);
953 try { curChar = input_stream.readChar(); }
954 catch(java.io.IOException e) {
955 jjStopStringLiteralDfa_0(1, active0);
956 return 2;
957 }
958 switch(curChar)
959 {
960 case 68:
961 return jjMoveStringLiteralDfa3_0(active0, 0x1fe00000L);
962 case 71:
963 return jjMoveStringLiteralDfa3_0(active0, 0x1fe000L);
964 case 85:
965 return jjMoveStringLiteralDfa3_0(active0, 0x20000000L);
966 case 97:
967 return jjMoveStringLiteralDfa3_0(active0, 0xb00000000L);
968 case 101:
969 return jjMoveStringLiteralDfa3_0(active0, 0x3080000000L);
970 case 121:
971 return jjMoveStringLiteralDfa3_0(active0, 0x440000000L);
972 default :
973 break;
974 }
975 return jjStartNfa_0(1, active0);
976 }
977 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
978 {
979 if (((active0 &= old0)) == 0L)
980 return jjStartNfa_0(1, old0);
981 try { curChar = input_stream.readChar(); }
982 catch(java.io.IOException e) {
983 jjStopStringLiteralDfa_0(2, active0);
984 return 3;
985 }
986 switch(curChar)
987 {
988 case 73:
989 return jjMoveStringLiteralDfa4_0(active0, 0x1fe000L);
990 case 83:
991 return jjMoveStringLiteralDfa4_0(active0, 0x20000000L);
992 case 95:
993 return jjMoveStringLiteralDfa4_0(active0, 0x1fe00000L);
994 case 102:
995 return jjMoveStringLiteralDfa4_0(active0, 0x2000000000L);
996 case 108:
997 return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
998 case 109:
999 return jjMoveStringLiteralDfa4_0(active0, 0x100000000L);
1000 case 112:
1001 return jjMoveStringLiteralDfa4_0(active0, 0x400000000L);
1002 case 114:
1003 return jjMoveStringLiteralDfa4_0(active0, 0x280000000L);
1004 case 115:
1005 return jjMoveStringLiteralDfa4_0(active0, 0x1040000000L);
1006 default :
1007 break;
1008 }
1009 return jjStartNfa_0(2, active0);
1010 }
1011 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
1012 {
1013 if (((active0 &= old0)) == 0L)
1014 return jjStartNfa_0(2, old0);
1015 try { curChar = input_stream.readChar(); }
1016 catch(java.io.IOException e) {
1017 jjStopStringLiteralDfa_0(3, active0);
1018 return 4;
1019 }
1020 switch(curChar)
1021 {
1022 case 45:
1023 return jjMoveStringLiteralDfa5_0(active0, 0x20000000L);
1024 case 65:
1025 return jjMoveStringLiteralDfa5_0(active0, 0x3000000L);
1026 case 70:
1027 return jjMoveStringLiteralDfa5_0(active0, 0xc000000L);
1028 case 78:
1029 return jjMoveStringLiteralDfa5_0(active0, 0x1fe000L);
1030 case 79:
1031 return jjMoveStringLiteralDfa5_0(active0, 0x10000000L);
1032 case 80:
1033 return jjMoveStringLiteralDfa5_0(active0, 0x200000L);
1034 case 82:
1035 return jjMoveStringLiteralDfa5_0(active0, 0xc00000L);
1036 case 97:
1037 return jjMoveStringLiteralDfa5_0(active0, 0x2000000000L);
1038 case 101:
1039 if ((active0 & 0x100000000L) != 0L)
1040 return jjStopAtPos(4, 32);
1041 else if ((active0 & 0x400000000L) != 0L)
1042 return jjStopAtPos(4, 34);
1043 return jjMoveStringLiteralDfa5_0(active0, 0x200000000L);
1044 case 115:
1045 return jjMoveStringLiteralDfa5_0(active0, 0x80000000L);
1046 case 116:
1047 return jjMoveStringLiteralDfa5_0(active0, 0x1040000000L);
1048 case 117:
1049 return jjMoveStringLiteralDfa5_0(active0, 0x800000000L);
1050 default :
1051 break;
1052 }
1053 return jjStartNfa_0(3, active0);
1054 }
1055 private final int jjMoveStringLiteralDfa5_0(long old0, long active0)
1056 {
1057 if (((active0 &= old0)) == 0L)
1058 return jjStartNfa_0(3, old0);
1059 try { curChar = input_stream.readChar(); }
1060 catch(java.io.IOException e) {
1061 jjStopStringLiteralDfa_0(4, active0);
1062 return 5;
1063 }
1064 switch(curChar)
1065 {
1066 case 65:
1067 return jjMoveStringLiteralDfa6_0(active0, 0xc000000L);
1068 case 69:
1069 return jjMoveStringLiteralDfa6_0(active0, 0xc00000L);
1070 case 78:
1071 return jjMoveStringLiteralDfa6_0(active0, 0x10000000L);
1072 case 79:
1073 return jjMoveStringLiteralDfa6_0(active0, 0x20000000L);
1074 case 82:
1075 return jjMoveStringLiteralDfa6_0(active0, 0x200000L);
1076 case 84:
1077 return jjMoveStringLiteralDfa6_0(active0, 0x3000000L);
1078 case 95:
1079 return jjMoveStringLiteralDfa6_0(active0, 0x1fe000L);
1080 case 101:
1081 if ((active0 & 0x800000000L) != 0L)
1082 return jjStopAtPos(5, 35);
1083 return jjMoveStringLiteralDfa6_0(active0, 0x40000000L);
1084 case 105:
1085 return jjMoveStringLiteralDfa6_0(active0, 0x80000000L);
1086 case 110:
1087 return jjMoveStringLiteralDfa6_0(active0, 0x200000000L);
1088 case 114:
1089 return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L);
1090 case 117:
1091 return jjMoveStringLiteralDfa6_0(active0, 0x2000000000L);
1092 default :
1093 break;
1094 }
1095 return jjStartNfa_0(4, active0);
1096 }
1097 private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
1098 {
1099 if (((active0 &= old0)) == 0L)
1100 return jjStartNfa_0(4, old0);
1101 try { curChar = input_stream.readChar(); }
1102 catch(java.io.IOException e) {
1103 jjStopStringLiteralDfa_0(5, active0);
1104 return 6;
1105 }
1106 switch(curChar)
1107 {
1108 case 65:
1109 return jjMoveStringLiteralDfa7_0(active0, 0x180000L);
1110 case 67:
1111 return jjMoveStringLiteralDfa7_0(active0, 0xc000000L);
1112 case 69:
1113 return jjMoveStringLiteralDfa7_0(active0, 0x200000L);
1114 case 70:
1115 return jjMoveStringLiteralDfa7_0(active0, 0x60000L);
1116 case 79:
1117 return jjMoveStringLiteralDfa7_0(active0, 0x2000L);
1118 case 80:
1119 return jjMoveStringLiteralDfa7_0(active0, 0x4000L);
1120 case 82:
1121 return jjMoveStringLiteralDfa7_0(active0, 0x18000L);
1122 case 83:
1123 return jjMoveStringLiteralDfa7_0(active0, 0xc00000L);
1124 case 84:
1125 return jjMoveStringLiteralDfa7_0(active0, 0x13000000L);
1126 case 105:
1127 return jjMoveStringLiteralDfa7_0(active0, 0x1000000000L);
1128 case 108:
1129 return jjMoveStringLiteralDfa7_0(active0, 0x2000000000L);
1130 case 109:
1131 if ((active0 & 0x40000000L) != 0L)
1132 return jjStopAtPos(6, 30);
1133 break;
1134 case 110:
1135 return jjMoveStringLiteralDfa7_0(active0, 0x20000000L);
1136 case 111:
1137 return jjMoveStringLiteralDfa7_0(active0, 0x80000000L);
1138 case 116:
1139 if ((active0 & 0x200000000L) != 0L)
1140 return jjStopAtPos(6, 33);
1141 break;
1142 default :
1143 break;
1144 }
1145 return jjStartNfa_0(5, active0);
1146 }
1147 private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
1148 {
1149 if (((active0 &= old0)) == 0L)
1150 return jjStartNfa_0(5, old0);
1151 try { curChar = input_stream.readChar(); }
1152 catch(java.io.IOException e) {
1153 jjStopStringLiteralDfa_0(6, active0);
1154 return 7;
1155 }
1156 switch(curChar)
1157 {
1158 case 65:
1159 return jjMoveStringLiteralDfa8_0(active0, 0x260000L);
1160 case 69:
1161 return jjMoveStringLiteralDfa8_0(active0, 0x18000L);
1162 case 78:
1163 return jjMoveStringLiteralDfa8_0(active0, 0x2000L);
1164 case 79:
1165 return jjMoveStringLiteralDfa8_0(active0, 0x10000000L);
1166 case 82:
1167 return jjMoveStringLiteralDfa8_0(active0, 0x3004000L);
1168 case 84:
1169 return jjMoveStringLiteralDfa8_0(active0, 0xcd80000L);
1170 case 99:
1171 return jjMoveStringLiteralDfa8_0(active0, 0x1000000000L);
1172 case 110:
1173 if ((active0 & 0x80000000L) != 0L)
1174 return jjStopAtPos(7, 31);
1175 break;
1176 case 116:
1177 if ((active0 & 0x2000000000L) != 0L)
1178 return jjStopAtPos(7, 37);
1179 return jjMoveStringLiteralDfa8_0(active0, 0x20000000L);
1180 default :
1181 break;
1182 }
1183 return jjStartNfa_0(6, active0);
1184 }
1185 private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
1186 {
1187 if (((active0 &= old0)) == 0L)
1188 return jjStartNfa_0(6, old0);
1189 try { curChar = input_stream.readChar(); }
1190 catch(java.io.IOException e) {
1191 jjStopStringLiteralDfa_0(7, active0);
1192 return 8;
1193 }
1194 switch(curChar)
1195 {
1196 case 67:
1197 return jjMoveStringLiteralDfa9_0(active0, 0x60000L);
1198 case 69:
1199 return jjMoveStringLiteralDfa9_0(active0, 0x4000L);
1200 case 73:
1201 return jjMoveStringLiteralDfa9_0(active0, 0x3000000L);
1202 case 76:
1203 return jjMoveStringLiteralDfa9_0(active0, 0x10000000L);
1204 case 77:
1205 return jjMoveStringLiteralDfa9_0(active0, 0x200000L);
1206 case 82:
1207 return jjMoveStringLiteralDfa9_0(active0, 0xc00000L);
1208 case 83:
1209 if ((active0 & 0x8000000L) != 0L)
1210 return jjStartNfaWithStates_0(8, 27, 5);
1211 return jjMoveStringLiteralDfa9_0(active0, 0x18000L);
1212 case 84:
1213 return jjMoveStringLiteralDfa9_0(active0, 0x182000L);
1214 case 95:
1215 return jjMoveStringLiteralDfa9_0(active0, 0x4000000L);
1216 case 111:
1217 return jjMoveStringLiteralDfa9_0(active0, 0x20000000L);
1218 case 116:
1219 return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
1220 default :
1221 break;
1222 }
1223 return jjStartNfa_0(7, active0);
1224 }
1225 private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
1226 {
1227 if (((active0 &= old0)) == 0L)
1228 return jjStartNfa_0(7, old0);
1229 try { curChar = input_stream.readChar(); }
1230 catch(java.io.IOException e) {
1231 jjStopStringLiteralDfa_0(8, active0);
1232 return 9;
1233 }
1234 switch(curChar)
1235 {
1236 case 65:
1237 return jjMoveStringLiteralDfa10_0(active0, 0x4000L);
1238 case 66:
1239 return jjMoveStringLiteralDfa10_0(active0, 0x3200000L);
1240 case 73:
1241 return jjMoveStringLiteralDfa10_0(active0, 0x4c00000L);
1242 case 79:
1243 return jjMoveStringLiteralDfa10_0(active0, 0x10002000L);
1244 case 82:
1245 return jjMoveStringLiteralDfa10_0(active0, 0x180000L);
1246 case 84:
1247 return jjMoveStringLiteralDfa10_0(active0, 0x78000L);
1248 case 105:
1249 return jjMoveStringLiteralDfa10_0(active0, 0x1000000000L);
1250 case 108:
1251 return jjMoveStringLiteralDfa10_0(active0, 0x20000000L);
1252 default :
1253 break;
1254 }
1255 return jjStartNfa_0(8, active0);
1256 }
1257 private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
1258 {
1259 if (((active0 &= old0)) == 0L)
1260 return jjStartNfa_0(8, old0);
1261 try { curChar = input_stream.readChar(); }
1262 catch(java.io.IOException e) {
1263 jjStopStringLiteralDfa_0(9, active0);
1264 return 10;
1265 }
1266 switch(curChar)
1267 {
1268 case 67:
1269 return jjMoveStringLiteralDfa11_0(active0, 0xc00000L);
1270 case 71:
1271 return jjMoveStringLiteralDfa11_0(active0, 0x10000000L);
1272 case 73:
1273 return jjMoveStringLiteralDfa11_0(active0, 0x180000L);
1274 case 76:
1275 return jjMoveStringLiteralDfa11_0(active0, 0x202000L);
1276 case 77:
1277 return jjMoveStringLiteralDfa11_0(active0, 0x4000L);
1278 case 82:
1279 return jjMoveStringLiteralDfa11_0(active0, 0x18000L);
1280 case 83:
1281 if ((active0 & 0x20000L) != 0L)
1282 return jjStartNfaWithStates_0(10, 17, 5);
1283 break;
1284 case 84:
1285 return jjMoveStringLiteralDfa11_0(active0, 0x4000000L);
1286 case 85:
1287 return jjMoveStringLiteralDfa11_0(active0, 0x3000000L);
1288 case 95:
1289 return jjMoveStringLiteralDfa11_0(active0, 0x40000L);
1290 case 111:
1291 return jjMoveStringLiteralDfa11_0(active0, 0x1020000000L);
1292 default :
1293 break;
1294 }
1295 return jjStartNfa_0(9, active0);
1296 }
1297 private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
1298 {
1299 if (((active0 &= old0)) == 0L)
1300 return jjStartNfa_0(9, old0);
1301 try { curChar = input_stream.readChar(); }
1302 catch(java.io.IOException e) {
1303 jjStopStringLiteralDfa_0(10, active0);
1304 return 11;
1305 }
1306 switch(curChar)
1307 {
1308 case 66:
1309 return jjMoveStringLiteralDfa12_0(active0, 0x184000L);
1310 case 69:
1311 if ((active0 & 0x200000L) != 0L)
1312 return jjStartNfaWithStates_0(11, 21, 5);
1313 return jjMoveStringLiteralDfa12_0(active0, 0x4000000L);
1314 case 73:
1315 return jjMoveStringLiteralDfa12_0(active0, 0x58000L);
1316 case 79:
1317 return jjMoveStringLiteralDfa12_0(active0, 0x2000L);
1318 case 84:
1319 return jjMoveStringLiteralDfa12_0(active0, 0x3c00000L);
1320 case 89:
1321 if ((active0 & 0x10000000L) != 0L)
1322 return jjStartNfaWithStates_0(11, 28, 5);
1323 break;
1324 case 103:
1325 return jjMoveStringLiteralDfa12_0(active0, 0x20000000L);
1326 case 110:
1327 if ((active0 & 0x1000000000L) != 0L)
1328 return jjStopAtPos(11, 36);
1329 break;
1330 default :
1331 break;
1332 }
1333 return jjStartNfa_0(10, active0);
1334 }
1335 private final int jjMoveStringLiteralDfa12_0(long old0, long active0)
1336 {
1337 if (((active0 &= old0)) == 0L)
1338 return jjStartNfa_0(10, old0);
1339 try { curChar = input_stream.readChar(); }
1340 catch(java.io.IOException e) {
1341 jjStopStringLiteralDfa_0(11, active0);
1342 return 12;
1343 }
1344 switch(curChar)
1345 {
1346 case 67:
1347 return jjMoveStringLiteralDfa13_0(active0, 0x18000L);
1348 case 69:
1349 return jjMoveStringLiteralDfa13_0(active0, 0x3000000L);
1350 case 71:
1351 return jjMoveStringLiteralDfa13_0(active0, 0x2000L);
1352 case 73:
1353 return jjMoveStringLiteralDfa13_0(active0, 0xc00000L);
1354 case 76:
1355 return jjMoveStringLiteralDfa13_0(active0, 0x4000L);
1356 case 77:
1357 if ((active0 & 0x4000000L) != 0L)
1358 return jjStartNfaWithStates_0(12, 26, 5);
1359 break;
1360 case 84:
1361 return jjMoveStringLiteralDfa13_0(active0, 0x40000L);
1362 case 85:
1363 return jjMoveStringLiteralDfa13_0(active0, 0x180000L);
1364 case 121:
1365 return jjMoveStringLiteralDfa13_0(active0, 0x20000000L);
1366 default :
1367 break;
1368 }
1369 return jjStartNfa_0(11, active0);
1370 }
1371 private final int jjMoveStringLiteralDfa13_0(long old0, long active0)
1372 {
1373 if (((active0 &= old0)) == 0L)
1374 return jjStartNfa_0(11, old0);
1375 try { curChar = input_stream.readChar(); }
1376 catch(java.io.IOException e) {
1377 jjStopStringLiteralDfa_0(12, active0);
1378 return 13;
1379 }
1380 switch(curChar)
1381 {
1382 case 45:
1383 return jjMoveStringLiteralDfa14_0(active0, 0x20000000L);
1384 case 69:
1385 if ((active0 & 0x4000L) != 0L)
1386 return jjStartNfaWithStates_0(13, 14, 5);
1387 return jjMoveStringLiteralDfa14_0(active0, 0x40000L);
1388 case 79:
1389 return jjMoveStringLiteralDfa14_0(active0, 0xc00000L);
1390 case 84:
1391 return jjMoveStringLiteralDfa14_0(active0, 0x198000L);
1392 case 89:
1393 if ((active0 & 0x2000L) != 0L)
1394 return jjStartNfaWithStates_0(13, 13, 5);
1395 break;
1396 case 95:
1397 return jjMoveStringLiteralDfa14_0(active0, 0x3000000L);
1398 default :
1399 break;
1400 }
1401 return jjStartNfa_0(12, active0);
1402 }
1403 private final int jjMoveStringLiteralDfa14_0(long old0, long active0)
1404 {
1405 if (((active0 &= old0)) == 0L)
1406 return jjStartNfa_0(12, old0);
1407 try { curChar = input_stream.readChar(); }
1408 catch(java.io.IOException e) {
1409 jjStopStringLiteralDfa_0(13, active0);
1410 return 14;
1411 }
1412 switch(curChar)
1413 {
1414 case 69:
1415 return jjMoveStringLiteralDfa15_0(active0, 0x20180000L);
1416 case 73:
1417 return jjMoveStringLiteralDfa15_0(active0, 0x1018000L);
1418 case 76:
1419 return jjMoveStringLiteralDfa15_0(active0, 0x2000000L);
1420 case 77:
1421 if ((active0 & 0x40000L) != 0L)
1422 return jjStartNfaWithStates_0(14, 18, 5);
1423 break;
1424 case 78:
1425 return jjMoveStringLiteralDfa15_0(active0, 0xc00000L);
1426 default :
1427 break;
1428 }
1429 return jjStartNfa_0(13, active0);
1430 }
1431 private final int jjMoveStringLiteralDfa15_0(long old0, long active0)
1432 {
1433 if (((active0 &= old0)) == 0L)
1434 return jjStartNfa_0(13, old0);
1435 try { curChar = input_stream.readChar(); }
1436 catch(java.io.IOException e) {
1437 jjStopStringLiteralDfa_0(14, active0);
1438 return 15;
1439 }
1440 switch(curChar)
1441 {
1442 case 73:
1443 return jjMoveStringLiteralDfa16_0(active0, 0x2000000L);
1444 case 79:
1445 return jjMoveStringLiteralDfa16_0(active0, 0x18000L);
1446 case 83:
1447 if ((active0 & 0x800000L) != 0L)
1448 return jjStartNfaWithStates_0(15, 23, 5);
1449 break;
1450 case 84:
1451 return jjMoveStringLiteralDfa16_0(active0, 0x1000000L);
1452 case 95:
1453 return jjMoveStringLiteralDfa16_0(active0, 0x580000L);
1454 case 100:
1455 return jjMoveStringLiteralDfa16_0(active0, 0x20000000L);
1456 default :
1457 break;
1458 }
1459 return jjStartNfa_0(14, active0);
1460 }
1461 private final int jjMoveStringLiteralDfa16_0(long old0, long active0)
1462 {
1463 if (((active0 &= old0)) == 0L)
1464 return jjStartNfa_0(14, old0);
1465 try { curChar = input_stream.readChar(); }
1466 catch(java.io.IOException e) {
1467 jjStopStringLiteralDfa_0(15, active0);
1468 return 16;
1469 }
1470 switch(curChar)
1471 {
1472 case 69:
1473 return jjMoveStringLiteralDfa17_0(active0, 0x1000000L);
1474 case 73:
1475 return jjMoveStringLiteralDfa17_0(active0, 0x500000L);
1476 case 76:
1477 return jjMoveStringLiteralDfa17_0(active0, 0x80000L);
1478 case 78:
1479 return jjMoveStringLiteralDfa17_0(active0, 0x18000L);
1480 case 83:
1481 return jjMoveStringLiteralDfa17_0(active0, 0x2000000L);
1482 case 105:
1483 return jjMoveStringLiteralDfa17_0(active0, 0x20000000L);
1484 default :
1485 break;
1486 }
1487 return jjStartNfa_0(15, active0);
1488 }
1489 private final int jjMoveStringLiteralDfa17_0(long old0, long active0)
1490 {
1491 if (((active0 &= old0)) == 0L)
1492 return jjStartNfa_0(15, old0);
1493 try { curChar = input_stream.readChar(); }
1494 catch(java.io.IOException e) {
1495 jjStopStringLiteralDfa_0(16, active0);
1496 return 17;
1497 }
1498 switch(curChar)
1499 {
1500 case 73:
1501 return jjMoveStringLiteralDfa18_0(active0, 0x80000L);
1502 case 77:
1503 if ((active0 & 0x1000000L) != 0L)
1504 return jjStartNfaWithStates_0(17, 24, 5);
1505 break;
1506 case 83:
1507 if ((active0 & 0x8000L) != 0L)
1508 return jjStartNfaWithStates_0(17, 15, 5);
1509 break;
1510 case 84:
1511 if ((active0 & 0x2000000L) != 0L)
1512 return jjStartNfaWithStates_0(17, 25, 5);
1513 return jjMoveStringLiteralDfa18_0(active0, 0x500000L);
1514 case 95:
1515 return jjMoveStringLiteralDfa18_0(active0, 0x10000L);
1516 case 116:
1517 return jjMoveStringLiteralDfa18_0(active0, 0x20000000L);
1518 default :
1519 break;
1520 }
1521 return jjStartNfa_0(16, active0);
1522 }
1523 private final int jjMoveStringLiteralDfa18_0(long old0, long active0)
1524 {
1525 if (((active0 &= old0)) == 0L)
1526 return jjStartNfa_0(16, old0);
1527 try { curChar = input_stream.readChar(); }
1528 catch(java.io.IOException e) {
1529 jjStopStringLiteralDfa_0(17, active0);
1530 return 18;
1531 }
1532 switch(curChar)
1533 {
1534 case 69:
1535 return jjMoveStringLiteralDfa19_0(active0, 0x500000L);
1536 case 73:
1537 return jjMoveStringLiteralDfa19_0(active0, 0x10000L);
1538 case 83:
1539 return jjMoveStringLiteralDfa19_0(active0, 0x80000L);
1540 case 111:
1541 return jjMoveStringLiteralDfa19_0(active0, 0x20000000L);
1542 default :
1543 break;
1544 }
1545 return jjStartNfa_0(17, active0);
1546 }
1547 private final int jjMoveStringLiteralDfa19_0(long old0, long active0)
1548 {
1549 if (((active0 &= old0)) == 0L)
1550 return jjStartNfa_0(17, old0);
1551 try { curChar = input_stream.readChar(); }
1552 catch(java.io.IOException e) {
1553 jjStopStringLiteralDfa_0(18, active0);
1554 return 19;
1555 }
1556 switch(curChar)
1557 {
1558 case 77:
1559 if ((active0 & 0x100000L) != 0L)
1560 return jjStartNfaWithStates_0(19, 20, 5);
1561 else if ((active0 & 0x400000L) != 0L)
1562 return jjStartNfaWithStates_0(19, 22, 5);
1563 break;
1564 case 84:
1565 if ((active0 & 0x80000L) != 0L)
1566 return jjStartNfaWithStates_0(19, 19, 5);
1567 return jjMoveStringLiteralDfa20_0(active0, 0x10000L);
1568 case 114:
1569 if ((active0 & 0x20000000L) != 0L)
1570 return jjStopAtPos(19, 29);
1571 break;
1572 default :
1573 break;
1574 }
1575 return jjStartNfa_0(18, active0);
1576 }
1577 private final int jjMoveStringLiteralDfa20_0(long old0, long active0)
1578 {
1579 if (((active0 &= old0)) == 0L)
1580 return jjStartNfa_0(18, old0);
1581 try { curChar = input_stream.readChar(); }
1582 catch(java.io.IOException e) {
1583 jjStopStringLiteralDfa_0(19, active0);
1584 return 20;
1585 }
1586 switch(curChar)
1587 {
1588 case 69:
1589 return jjMoveStringLiteralDfa21_0(active0, 0x10000L);
1590 default :
1591 break;
1592 }
1593 return jjStartNfa_0(19, active0);
1594 }
1595 private final int jjMoveStringLiteralDfa21_0(long old0, long active0)
1596 {
1597 if (((active0 &= old0)) == 0L)
1598 return jjStartNfa_0(19, old0);
1599 try { curChar = input_stream.readChar(); }
1600 catch(java.io.IOException e) {
1601 jjStopStringLiteralDfa_0(20, active0);
1602 return 21;
1603 }
1604 switch(curChar)
1605 {
1606 case 77:
1607 if ((active0 & 0x10000L) != 0L)
1608 return jjStartNfaWithStates_0(21, 16, 5);
1609 break;
1610 default :
1611 break;
1612 }
1613 return jjStartNfa_0(20, active0);
1614 }
1615 static final long[] jjbitVec0 = {
1616 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
1617 };
1618 private final int jjMoveNfa_0(int startState, int curPos)
1619 {
1620 int[] nextStates;
1621 int startsAt = 0;
1622 jjnewStateCnt = 40;
1623 int i = 1;
1624 jjstateSet[0] = startState;
1625 int j, kind = 0x7fffffff;
1626 for (;;)
1627 {
1628 if (++jjround == 0x7fffffff)
1629 ReInitRounds();
1630 if (curChar < 64)
1631 {
1632 long l = 1L << curChar;
1633 MatchLoop: do
1634 {
1635 switch(jjstateSet[--i])
1636 {
1637 case 3:
1638 if ((0x3ff000000000000L & l) != 0L)
1639 jjCheckNAddStates(0, 6);
1640 else if (curChar == 34)
1641 jjCheckNAddStates(7, 9);
1642 else if (curChar == 46)
1643 jjCheckNAdd(11);
1644 else if (curChar == 47)
1645 jjstateSet[jjnewStateCnt++] = 2;
1646 if ((0x3fe000000000000L & l) != 0L)
1647 {
1648 if (kind > 39)
1649 kind = 39;
1650 jjCheckNAddTwoStates(9, 7);
1651 }
1652 else if (curChar == 48)
1653 {
1654 if (kind > 39)
1655 kind = 39;
1656 jjCheckNAdd(7);
1657 }
1658 break;
1659 case 0:
1660 if (curChar == 42)
1661 jjstateSet[jjnewStateCnt++] = 1;
1662 break;
1663 case 1:
1664 if ((0xffff7fffffffffffL & l) != 0L && kind > 7)
1665 kind = 7;
1666 break;
1667 case 2:
1668 if (curChar == 42)
1669 jjstateSet[jjnewStateCnt++] = 0;
1670 break;
1671 case 5:
1672 if ((0x3ff001000000000L & l) == 0L)
1673 break;
1674 if (kind > 38)
1675 kind = 38;
1676 jjstateSet[jjnewStateCnt++] = 5;
1677 break;
1678 case 6:
1679 if (curChar != 48)
1680 break;
1681 if (kind > 39)
1682 kind = 39;
1683 jjCheckNAdd(7);
1684 break;
1685 case 8:
1686 if ((0x3fe000000000000L & l) == 0L)
1687 break;
1688 if (kind > 39)
1689 kind = 39;
1690 jjCheckNAddTwoStates(9, 7);
1691 break;
1692 case 9:
1693 if ((0x3ff000000000000L & l) == 0L)
1694 break;
1695 if (kind > 39)
1696 kind = 39;
1697 jjCheckNAddTwoStates(9, 7);
1698 break;
1699 case 10:
1700 if (curChar == 46)
1701 jjCheckNAdd(11);
1702 break;
1703 case 11:
1704 if ((0x3ff000000000000L & l) == 0L)
1705 break;
1706 if (kind > 40)
1707 kind = 40;
1708 jjCheckNAddStates(10, 12);
1709 break;
1710 case 13:
1711 if ((0x280000000000L & l) != 0L)
1712 jjCheckNAdd(14);
1713 break;
1714 case 14:
1715 if ((0x3ff000000000000L & l) == 0L)
1716 break;
1717 if (kind > 40)
1718 kind = 40;
1719 jjCheckNAddTwoStates(14, 15);
1720 break;
1721 case 16:
1722 if (curChar == 34)
1723 jjCheckNAddStates(7, 9);
1724 break;
1725 case 17:
1726 if ((0xfffffffbffffdbffL & l) != 0L)
1727 jjCheckNAddStates(7, 9);
1728 break;
1729 case 19:
1730 if ((0x8400000000L & l) != 0L)
1731 jjCheckNAddStates(7, 9);
1732 break;
1733 case 20:
1734 if (curChar == 34 && kind > 41)
1735 kind = 41;
1736 break;
1737 case 21:
1738 if ((0xff000000000000L & l) != 0L)
1739 jjCheckNAddStates(13, 16);
1740 break;
1741 case 22:
1742 if ((0xff000000000000L & l) != 0L)
1743 jjCheckNAddStates(7, 9);
1744 break;
1745 case 23:
1746 if ((0xf000000000000L & l) != 0L)
1747 jjstateSet[jjnewStateCnt++] = 24;
1748 break;
1749 case 24:
1750 if ((0xff000000000000L & l) != 0L)
1751 jjCheckNAdd(22);
1752 break;
1753 case 25:
1754 if ((0x3ff000000000000L & l) != 0L)
1755 jjCheckNAddStates(0, 6);
1756 break;
1757 case 26:
1758 if ((0x3ff000000000000L & l) != 0L)
1759 jjCheckNAddTwoStates(26, 27);
1760 break;
1761 case 27:
1762 if (curChar != 46)
1763 break;
1764 if (kind > 40)
1765 kind = 40;
1766 jjCheckNAddStates(17, 19);
1767 break;
1768 case 28:
1769 if ((0x3ff000000000000L & l) == 0L)
1770 break;
1771 if (kind > 40)
1772 kind = 40;
1773 jjCheckNAddStates(17, 19);
1774 break;
1775 case 30:
1776 if ((0x280000000000L & l) != 0L)
1777 jjCheckNAdd(31);
1778 break;
1779 case 31:
1780 if ((0x3ff000000000000L & l) == 0L)
1781 break;
1782 if (kind > 40)
1783 kind = 40;
1784 jjCheckNAddTwoStates(31, 15);
1785 break;
1786 case 32:
1787 if ((0x3ff000000000000L & l) != 0L)
1788 jjCheckNAddTwoStates(32, 33);
1789 break;
1790 case 34:
1791 if ((0x280000000000L & l) != 0L)
1792 jjCheckNAdd(35);
1793 break;
1794 case 35:
1795 if ((0x3ff000000000000L & l) == 0L)
1796 break;
1797 if (kind > 40)
1798 kind = 40;
1799 jjCheckNAddTwoStates(35, 15);
1800 break;
1801 case 36:
1802 if ((0x3ff000000000000L & l) != 0L)
1803 jjCheckNAddStates(20, 22);
1804 break;
1805 case 38:
1806 if ((0x280000000000L & l) != 0L)
1807 jjCheckNAdd(39);
1808 break;
1809 case 39:
1810 if ((0x3ff000000000000L & l) != 0L)
1811 jjCheckNAddTwoStates(39, 15);
1812 break;
1813 default : break;
1814 }
1815 } while(i != startsAt);
1816 }
1817 else if (curChar < 128)
1818 {
1819 long l = 1L << (curChar & 077);
1820 MatchLoop: do
1821 {
1822 switch(jjstateSet[--i])
1823 {
1824 case 3:
1825 case 5:
1826 if ((0x7fffffe87fffffeL & l) == 0L)
1827 break;
1828 if (kind > 38)
1829 kind = 38;
1830 jjCheckNAdd(5);
1831 break;
1832 case 1:
1833 if (kind > 7)
1834 kind = 7;
1835 break;
1836 case 7:
1837 if ((0x100000001000L & l) != 0L && kind > 39)
1838 kind = 39;
1839 break;
1840 case 12:
1841 if ((0x2000000020L & l) != 0L)
1842 jjAddStates(23, 24);
1843 break;
1844 case 15:
1845 if ((0x5000000050L & l) != 0L && kind > 40)
1846 kind = 40;
1847 break;
1848 case 17:
1849 if ((0xffffffffefffffffL & l) != 0L)
1850 jjCheckNAddStates(7, 9);
1851 break;
1852 case 18:
1853 if (curChar == 92)
1854 jjAddStates(25, 27);
1855 break;
1856 case 19:
1857 if ((0x14404410000000L & l) != 0L)
1858 jjCheckNAddStates(7, 9);
1859 break;
1860 case 29:
1861 if ((0x2000000020L & l) != 0L)
1862 jjAddStates(28, 29);
1863 break;
1864 case 33:
1865 if ((0x2000000020L & l) != 0L)
1866 jjAddStates(30, 31);
1867 break;
1868 case 37:
1869 if ((0x2000000020L & l) != 0L)
1870 jjAddStates(32, 33);
1871 break;
1872 default : break;
1873 }
1874 } while(i != startsAt);
1875 }
1876 else
1877 {
1878 int i2 = (curChar & 0xff) >> 6;
1879 long l2 = 1L << (curChar & 077);
1880 MatchLoop: do
1881 {
1882 switch(jjstateSet[--i])
1883 {
1884 case 1:
1885 if ((jjbitVec0[i2] & l2) != 0L && kind > 7)
1886 kind = 7;
1887 break;
1888 case 17:
1889 if ((jjbitVec0[i2] & l2) != 0L)
1890 jjAddStates(7, 9);
1891 break;
1892 default : break;
1893 }
1894 } while(i != startsAt);
1895 }
1896 if (kind != 0x7fffffff)
1897 {
1898 jjmatchedKind = kind;
1899 jjmatchedPos = curPos;
1900 kind = 0x7fffffff;
1901 }
1902 ++curPos;
1903 if ((i = jjnewStateCnt) == (startsAt = 40 - (jjnewStateCnt = startsAt)))
1904 return curPos;
1905 try { curChar = input_stream.readChar(); }
1906 catch(java.io.IOException e) { return curPos; }
1907 }
1908 }
1909 static final int[] jjnextStates = {
1910 26, 27, 32, 33, 36, 37, 15, 17, 18, 20, 11, 12, 15, 17, 18, 22,
1911 20, 28, 29, 15, 36, 37, 15, 13, 14, 19, 21, 23, 30, 31, 34, 35,
1912 38, 39,
1913 };
1914 public static final String[] jjstrLiteralImages = {
1915 "", null, null, null, null, null, null, null, null, null, null, null, null,
1916 "\102\105\107\111\116\137\117\116\124\117\114\117\107\131", "\102\105\107\111\116\137\120\122\105\101\115\102\114\105",
1917 "\102\105\107\111\116\137\122\105\123\124\122\111\103\124\111\117\116\123",
1918 "\102\105\107\111\116\137\122\105\123\124\122\111\103\124\111\117\116\137\111\124\105\115", "\102\105\107\111\116\137\106\101\103\124\123",
1919 "\102\105\107\111\116\137\106\101\103\124\137\111\124\105\115",
1920 "\102\105\107\111\116\137\101\124\124\122\111\102\125\124\105\137\114\111\123\124",
1921 "\102\105\107\111\116\137\101\124\124\122\111\102\125\124\105\137\111\124\105\115", "\105\116\104\137\120\122\105\101\115\102\114\105",
1922 "\105\116\104\137\122\105\123\124\122\111\103\124\111\117\116\137\111\124\105\115", "\105\116\104\137\122\105\123\124\122\111\103\124\111\117\116\123",
1923 "\105\116\104\137\101\124\124\122\111\102\125\124\105\137\111\124\105\115", "\105\116\104\137\101\124\124\122\111\102\125\124\105\137\114\111\123\124",
1924 "\105\116\104\137\106\101\103\124\137\111\124\105\115", "\105\116\104\137\106\101\103\124\123",
1925 "\105\116\104\137\117\116\124\117\114\117\107\131",
1926 "\132\105\125\123\55\117\156\164\157\154\157\147\171\55\105\144\151\164\157\162", "\72\163\171\163\164\145\155", "\72\166\145\162\163\151\157\156",
1927 "\72\156\141\155\145", "\72\160\141\162\145\156\164", "\72\164\171\160\145",
1928 "\72\166\141\154\165\145", "\72\162\145\163\164\162\151\143\164\151\157\156",
1929 "\72\144\145\146\141\165\154\164", null, null, null, null, null, null, null, null, };
1930 public static final String[] lexStateNames = {
1931 "DEFAULT",
1932 "IN_SINGLE_LINE_COMMENT",
1933 "IN_FORMAL_COMMENT",
1934 "IN_MULTI_LINE_COMMENT",
1935 };
1936 public static final int[] jjnewLexState = {
1937 -1, -1, -1, -1, -1, -1, 1, 2, 3, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1938 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1939 };
1940 static final long[] jjtoToken = {
1941 0x3ffffffe001L,
1942 };
1943 static final long[] jjtoSkip = {
1944 0xe3eL,
1945 };
1946 static final long[] jjtoSpecial = {
1947 0xe00L,
1948 };
1949 static final long[] jjtoMore = {
1950 0x11c0L,
1951 };
1952 private ASCII_CharStream input_stream;
1953 private final int[] jjrounds = new int[40];
1954 private final int[] jjstateSet = new int[80];
1955 StringBuffer image;
1956 int jjimageLen;
1957 int lengthOfMatch;
1958 protected char curChar;
1959 public OntologyParserTokenManager(ASCII_CharStream stream)
1960 {
1961 if (ASCII_CharStream.staticFlag)
1962 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1963 input_stream = stream;
1964 }
1965 public OntologyParserTokenManager(ASCII_CharStream stream, int lexState)
1966 {
1967 this(stream);
1968 SwitchTo(lexState);
1969 }
1970 public void ReInit(ASCII_CharStream stream)
1971 {
1972 jjmatchedPos = jjnewStateCnt = 0;
1973 curLexState = defaultLexState;
1974 input_stream = stream;
1975 ReInitRounds();
1976 }
1977 private final void ReInitRounds()
1978 {
1979 int i;
1980 jjround = 0x80000001;
1981 for (i = 40; i-- > 0;)
1982 jjrounds[i] = 0x80000000;
1983 }
1984 public void ReInit(ASCII_CharStream stream, int lexState)
1985 {
1986 ReInit(stream);
1987 SwitchTo(lexState);
1988 }
1989 public void SwitchTo(int lexState)
1990 {
1991 if (lexState >= 4 || lexState < 0)
1992 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1993 else
1994 curLexState = lexState;
1995 }
1996
1997 private final Token jjFillToken()
1998 {
1999 Token t = Token.newToken(jjmatchedKind);
2000 t.kind = jjmatchedKind;
2001 String im = jjstrLiteralImages[jjmatchedKind];
2002 t.image = (im == null) ? input_stream.GetImage() : im;
2003 t.beginLine = input_stream.getBeginLine();
2004 t.beginColumn = input_stream.getBeginColumn();
2005 t.endLine = input_stream.getEndLine();
2006 t.endColumn = input_stream.getEndColumn();
2007 return t;
2008 }
2009
2010 int curLexState = 0;
2011 int defaultLexState = 0;
2012 int jjnewStateCnt;
2013 int jjround;
2014 int jjmatchedPos;
2015 int jjmatchedKind;
2016
2017 public final Token getNextToken()
2018 {
2019 int kind;
2020 Token specialToken = null;
2021 Token matchedToken;
2022 int curPos = 0;
2023
2024
2025 try {
2026
2027 EOFLoop :
2028 for (;;)
2029 {
2030 try
2031 {
2032 curChar = input_stream.BeginToken();
2033 }
2034 catch(java.io.IOException e)
2035 {
2036 jjmatchedKind = 0;
2037 matchedToken = jjFillToken();
2038 matchedToken.specialToken = specialToken;
2039 return matchedToken;
2040 }
2041 image = null;
2042 jjimageLen = 0;
2043
2044 for (;;)
2045 {
2046 switch(curLexState)
2047 {
2048 case 0:
2049 try {
2050 while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)
2051 curChar = input_stream.BeginToken();
2052 }
2053
2054 catch(java.io.IOException e1) {
2055 jjmatchedKind = 0;
2056 matchedToken = new Token();
2057 matchedToken.kind = 0;
2058 matchedToken.image = "<EOF>";
2059 matchedToken.specialToken = specialToken;
2060 matchedToken.next = null;
2061 return matchedToken;
2062 }
2063
2064 jjmatchedKind = 0x7fffffff;
2065 jjmatchedPos = 0;
2066 curPos = jjMoveStringLiteralDfa0_0();
2067 break;
2068 case 1:
2069 jjmatchedKind = 0x7fffffff;
2070 jjmatchedPos = 0;
2071 curPos = jjMoveStringLiteralDfa0_1();
2072 if (jjmatchedPos == 0 && jjmatchedKind > 12)
2073 {
2074 jjmatchedKind = 12;
2075 }
2076 break;
2077 case 2:
2078 jjmatchedKind = 0x7fffffff;
2079 jjmatchedPos = 0;
2080 curPos = jjMoveStringLiteralDfa0_2();
2081 if (jjmatchedPos == 0 && jjmatchedKind > 12)
2082 {
2083 jjmatchedKind = 12;
2084 }
2085 break;
2086 case 3:
2087 jjmatchedKind = 0x7fffffff;
2088 jjmatchedPos = 0;
2089 curPos = jjMoveStringLiteralDfa0_3();
2090 if (jjmatchedPos == 0 && jjmatchedKind > 12)
2091 {
2092 jjmatchedKind = 12;
2093 }
2094 break;
2095 }
2096 if (jjmatchedKind != 0x7fffffff)
2097 {
2098 if (jjmatchedPos + 1 < curPos)
2099 input_stream.backup(curPos - jjmatchedPos - 1);
2100 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2101 {
2102 matchedToken = jjFillToken();
2103 matchedToken.specialToken = specialToken;
2104 if (jjnewLexState[jjmatchedKind] != -1)
2105 curLexState = jjnewLexState[jjmatchedKind];
2106 return matchedToken;
2107 }
2108 else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2109 {
2110 if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
2111 {
2112 matchedToken = jjFillToken();
2113 if (specialToken == null)
2114 specialToken = matchedToken;
2115 else
2116 {
2117 matchedToken.specialToken = specialToken;
2118 specialToken = (specialToken.next = matchedToken);
2119 }
2120 SkipLexicalActions(matchedToken);
2121 }
2122 else
2123 SkipLexicalActions(null);
2124 if (jjnewLexState[jjmatchedKind] != -1)
2125 curLexState = jjnewLexState[jjmatchedKind];
2126 continue EOFLoop;
2127 }
2128 MoreLexicalActions();
2129 if (jjnewLexState[jjmatchedKind] != -1)
2130 curLexState = jjnewLexState[jjmatchedKind];
2131 curPos = 0;
2132 jjmatchedKind = 0x7fffffff;
2133 try {
2134 curChar = input_stream.readChar();
2135 continue;
2136 }
2137 catch (java.io.IOException e1) { }
2138 }
2139 int error_line = input_stream.getEndLine();
2140 int error_column = input_stream.getEndColumn();
2141 String error_after = null;
2142 boolean EOFSeen = false;
2143 try { input_stream.readChar(); input_stream.backup(1); }
2144 catch (java.io.IOException e1) {
2145 EOFSeen = true;
2146 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2147 if (curChar == '\n' || curChar == '\r') {
2148 error_line++;
2149 error_column = 0;
2150 }
2151 else
2152 error_column++;
2153 }
2154 if (!EOFSeen) {
2155 input_stream.backup(1);
2156 error_after = curPos <= 1 ? "" : input_stream.GetImage();
2157 }
2158 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
2159 }
2160 }
2161
2162 }
2163 catch(Exception x) {
2164 jjmatchedKind = 0;
2165 matchedToken = new Token();
2166 matchedToken.kind = 0;
2167 matchedToken.image = "<EOF>";
2168 matchedToken.specialToken = specialToken;
2169 matchedToken.next = null;
2170 return matchedToken;
2171 }
2172
2173 }
2174
2175 final void SkipLexicalActions(Token matchedToken)
2176 {
2177 switch(jjmatchedKind)
2178 {
2179 default :
2180 break;
2181 }
2182 }
2183 final void MoreLexicalActions()
2184 {
2185 jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
2186 switch(jjmatchedKind)
2187 {
2188 case 7 :
2189 if (image == null)
2190 image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
2191 else
2192 image.append(new String(input_stream.GetSuffix(jjimageLen)));
2193 jjimageLen = 0;
2194 input_stream.backup(1);
2195 break;
2196 default :
2197 break;
2198 }
2199 }
2200 }