]>
Commit | Line | Data |
---|---|---|
30fdf114 LG |
1 | # $ANTLR 3.0.1 C.g 2009-02-16 16:02:51 |
2 | ||
3 | from antlr3 import * | |
4 | from antlr3.compat import set, frozenset | |
5 | ||
6 | ||
7 | # for convenience in actions | |
8 | HIDDEN = BaseRecognizer.HIDDEN | |
9 | ||
10 | # token types | |
11 | T29=29 | |
12 | HexDigit=13 | |
13 | T70=70 | |
14 | T74=74 | |
15 | T85=85 | |
16 | T102=102 | |
17 | T114=114 | |
18 | T103=103 | |
19 | STRING_LITERAL=9 | |
20 | T32=32 | |
21 | T81=81 | |
22 | T41=41 | |
23 | FloatTypeSuffix=16 | |
24 | T113=113 | |
25 | T62=62 | |
26 | T109=109 | |
27 | DECIMAL_LITERAL=7 | |
28 | IntegerTypeSuffix=14 | |
29 | T68=68 | |
30 | T73=73 | |
31 | T84=84 | |
32 | T33=33 | |
33 | UnicodeVocabulary=21 | |
34 | T78=78 | |
35 | T115=115 | |
36 | WS=19 | |
37 | LINE_COMMAND=24 | |
38 | T42=42 | |
39 | T96=96 | |
40 | T71=71 | |
41 | LINE_COMMENT=23 | |
42 | T72=72 | |
43 | T94=94 | |
44 | FLOATING_POINT_LITERAL=10 | |
45 | T76=76 | |
46 | UnicodeEscape=18 | |
47 | T75=75 | |
48 | T89=89 | |
49 | T67=67 | |
50 | T31=31 | |
51 | T60=60 | |
52 | T82=82 | |
53 | T100=100 | |
54 | T49=49 | |
55 | IDENTIFIER=4 | |
56 | T30=30 | |
57 | CHARACTER_LITERAL=8 | |
58 | T79=79 | |
59 | T36=36 | |
60 | T58=58 | |
61 | T93=93 | |
62 | T35=35 | |
63 | T107=107 | |
64 | OCTAL_LITERAL=6 | |
65 | T83=83 | |
66 | T61=61 | |
67 | HEX_LITERAL=5 | |
68 | T45=45 | |
69 | T34=34 | |
70 | T101=101 | |
71 | T64=64 | |
72 | T25=25 | |
73 | T91=91 | |
74 | T105=105 | |
75 | T37=37 | |
76 | T86=86 | |
77 | T116=116 | |
78 | EscapeSequence=12 | |
79 | T26=26 | |
80 | T51=51 | |
81 | T111=111 | |
82 | T46=46 | |
83 | T77=77 | |
84 | T38=38 | |
85 | T106=106 | |
86 | T112=112 | |
87 | T69=69 | |
88 | T39=39 | |
89 | T44=44 | |
90 | T55=55 | |
91 | LETTER=11 | |
92 | Exponent=15 | |
93 | T95=95 | |
94 | T50=50 | |
95 | T110=110 | |
96 | T108=108 | |
97 | BS=20 | |
98 | T92=92 | |
99 | T43=43 | |
100 | T28=28 | |
101 | T40=40 | |
102 | T66=66 | |
103 | COMMENT=22 | |
104 | T88=88 | |
105 | T63=63 | |
106 | T57=57 | |
107 | T65=65 | |
108 | T98=98 | |
109 | T56=56 | |
110 | T87=87 | |
111 | T80=80 | |
112 | T59=59 | |
113 | T97=97 | |
114 | T48=48 | |
115 | T54=54 | |
116 | EOF=-1 | |
117 | T104=104 | |
118 | T47=47 | |
119 | Tokens=117 | |
120 | T53=53 | |
121 | OctalEscape=17 | |
122 | T99=99 | |
123 | T27=27 | |
124 | T52=52 | |
125 | T90=90 | |
126 | ||
127 | class CLexer(Lexer): | |
128 | ||
129 | grammarFileName = "C.g" | |
130 | ||
131 | def __init__(self, input=None): | |
132 | Lexer.__init__(self, input) | |
133 | self.dfa25 = self.DFA25( | |
134 | self, 25, | |
135 | eot = self.DFA25_eot, | |
136 | eof = self.DFA25_eof, | |
137 | min = self.DFA25_min, | |
138 | max = self.DFA25_max, | |
139 | accept = self.DFA25_accept, | |
140 | special = self.DFA25_special, | |
141 | transition = self.DFA25_transition | |
142 | ) | |
143 | self.dfa35 = self.DFA35( | |
144 | self, 35, | |
145 | eot = self.DFA35_eot, | |
146 | eof = self.DFA35_eof, | |
147 | min = self.DFA35_min, | |
148 | max = self.DFA35_max, | |
149 | accept = self.DFA35_accept, | |
150 | special = self.DFA35_special, | |
151 | transition = self.DFA35_transition | |
152 | ) | |
153 | ||
154 | ||
155 | ||
156 | ||
157 | ||
158 | ||
159 | # $ANTLR start T25 | |
160 | def mT25(self, ): | |
161 | ||
162 | try: | |
163 | self.type = T25 | |
164 | ||
165 | # C.g:7:5: ( ';' ) | |
166 | # C.g:7:7: ';' | |
167 | self.match(u';') | |
168 | ||
169 | ||
170 | ||
171 | ||
172 | ||
173 | finally: | |
174 | ||
175 | pass | |
176 | ||
177 | # $ANTLR end T25 | |
178 | ||
179 | ||
180 | ||
181 | # $ANTLR start T26 | |
182 | def mT26(self, ): | |
183 | ||
184 | try: | |
185 | self.type = T26 | |
186 | ||
187 | # C.g:8:5: ( 'typedef' ) | |
188 | # C.g:8:7: 'typedef' | |
189 | self.match("typedef") | |
190 | ||
191 | ||
192 | ||
193 | ||
194 | ||
195 | ||
196 | finally: | |
197 | ||
198 | pass | |
199 | ||
200 | # $ANTLR end T26 | |
201 | ||
202 | ||
203 | ||
204 | # $ANTLR start T27 | |
205 | def mT27(self, ): | |
206 | ||
207 | try: | |
208 | self.type = T27 | |
209 | ||
210 | # C.g:9:5: ( ',' ) | |
211 | # C.g:9:7: ',' | |
212 | self.match(u',') | |
213 | ||
214 | ||
215 | ||
216 | ||
217 | ||
218 | finally: | |
219 | ||
220 | pass | |
221 | ||
222 | # $ANTLR end T27 | |
223 | ||
224 | ||
225 | ||
226 | # $ANTLR start T28 | |
227 | def mT28(self, ): | |
228 | ||
229 | try: | |
230 | self.type = T28 | |
231 | ||
232 | # C.g:10:5: ( '=' ) | |
233 | # C.g:10:7: '=' | |
234 | self.match(u'=') | |
235 | ||
236 | ||
237 | ||
238 | ||
239 | ||
240 | finally: | |
241 | ||
242 | pass | |
243 | ||
244 | # $ANTLR end T28 | |
245 | ||
246 | ||
247 | ||
248 | # $ANTLR start T29 | |
249 | def mT29(self, ): | |
250 | ||
251 | try: | |
252 | self.type = T29 | |
253 | ||
254 | # C.g:11:5: ( 'extern' ) | |
255 | # C.g:11:7: 'extern' | |
256 | self.match("extern") | |
257 | ||
258 | ||
259 | ||
260 | ||
261 | ||
262 | ||
263 | finally: | |
264 | ||
265 | pass | |
266 | ||
267 | # $ANTLR end T29 | |
268 | ||
269 | ||
270 | ||
271 | # $ANTLR start T30 | |
272 | def mT30(self, ): | |
273 | ||
274 | try: | |
275 | self.type = T30 | |
276 | ||
277 | # C.g:12:5: ( 'static' ) | |
278 | # C.g:12:7: 'static' | |
279 | self.match("static") | |
280 | ||
281 | ||
282 | ||
283 | ||
284 | ||
285 | ||
286 | finally: | |
287 | ||
288 | pass | |
289 | ||
290 | # $ANTLR end T30 | |
291 | ||
292 | ||
293 | ||
294 | # $ANTLR start T31 | |
295 | def mT31(self, ): | |
296 | ||
297 | try: | |
298 | self.type = T31 | |
299 | ||
300 | # C.g:13:5: ( 'auto' ) | |
301 | # C.g:13:7: 'auto' | |
302 | self.match("auto") | |
303 | ||
304 | ||
305 | ||
306 | ||
307 | ||
308 | ||
309 | finally: | |
310 | ||
311 | pass | |
312 | ||
313 | # $ANTLR end T31 | |
314 | ||
315 | ||
316 | ||
317 | # $ANTLR start T32 | |
318 | def mT32(self, ): | |
319 | ||
320 | try: | |
321 | self.type = T32 | |
322 | ||
323 | # C.g:14:5: ( 'register' ) | |
324 | # C.g:14:7: 'register' | |
325 | self.match("register") | |
326 | ||
327 | ||
328 | ||
329 | ||
330 | ||
331 | ||
332 | finally: | |
333 | ||
334 | pass | |
335 | ||
336 | # $ANTLR end T32 | |
337 | ||
338 | ||
339 | ||
340 | # $ANTLR start T33 | |
341 | def mT33(self, ): | |
342 | ||
343 | try: | |
344 | self.type = T33 | |
345 | ||
346 | # C.g:15:5: ( 'STATIC' ) | |
347 | # C.g:15:7: 'STATIC' | |
348 | self.match("STATIC") | |
349 | ||
350 | ||
351 | ||
352 | ||
353 | ||
354 | ||
355 | finally: | |
356 | ||
357 | pass | |
358 | ||
359 | # $ANTLR end T33 | |
360 | ||
361 | ||
362 | ||
363 | # $ANTLR start T34 | |
364 | def mT34(self, ): | |
365 | ||
366 | try: | |
367 | self.type = T34 | |
368 | ||
369 | # C.g:16:5: ( 'void' ) | |
370 | # C.g:16:7: 'void' | |
371 | self.match("void") | |
372 | ||
373 | ||
374 | ||
375 | ||
376 | ||
377 | ||
378 | finally: | |
379 | ||
380 | pass | |
381 | ||
382 | # $ANTLR end T34 | |
383 | ||
384 | ||
385 | ||
386 | # $ANTLR start T35 | |
387 | def mT35(self, ): | |
388 | ||
389 | try: | |
390 | self.type = T35 | |
391 | ||
392 | # C.g:17:5: ( 'char' ) | |
393 | # C.g:17:7: 'char' | |
394 | self.match("char") | |
395 | ||
396 | ||
397 | ||
398 | ||
399 | ||
400 | ||
401 | finally: | |
402 | ||
403 | pass | |
404 | ||
405 | # $ANTLR end T35 | |
406 | ||
407 | ||
408 | ||
409 | # $ANTLR start T36 | |
410 | def mT36(self, ): | |
411 | ||
412 | try: | |
413 | self.type = T36 | |
414 | ||
415 | # C.g:18:5: ( 'short' ) | |
416 | # C.g:18:7: 'short' | |
417 | self.match("short") | |
418 | ||
419 | ||
420 | ||
421 | ||
422 | ||
423 | ||
424 | finally: | |
425 | ||
426 | pass | |
427 | ||
428 | # $ANTLR end T36 | |
429 | ||
430 | ||
431 | ||
432 | # $ANTLR start T37 | |
433 | def mT37(self, ): | |
434 | ||
435 | try: | |
436 | self.type = T37 | |
437 | ||
438 | # C.g:19:5: ( 'int' ) | |
439 | # C.g:19:7: 'int' | |
440 | self.match("int") | |
441 | ||
442 | ||
443 | ||
444 | ||
445 | ||
446 | ||
447 | finally: | |
448 | ||
449 | pass | |
450 | ||
451 | # $ANTLR end T37 | |
452 | ||
453 | ||
454 | ||
455 | # $ANTLR start T38 | |
456 | def mT38(self, ): | |
457 | ||
458 | try: | |
459 | self.type = T38 | |
460 | ||
461 | # C.g:20:5: ( 'long' ) | |
462 | # C.g:20:7: 'long' | |
463 | self.match("long") | |
464 | ||
465 | ||
466 | ||
467 | ||
468 | ||
469 | ||
470 | finally: | |
471 | ||
472 | pass | |
473 | ||
474 | # $ANTLR end T38 | |
475 | ||
476 | ||
477 | ||
478 | # $ANTLR start T39 | |
479 | def mT39(self, ): | |
480 | ||
481 | try: | |
482 | self.type = T39 | |
483 | ||
484 | # C.g:21:5: ( 'float' ) | |
485 | # C.g:21:7: 'float' | |
486 | self.match("float") | |
487 | ||
488 | ||
489 | ||
490 | ||
491 | ||
492 | ||
493 | finally: | |
494 | ||
495 | pass | |
496 | ||
497 | # $ANTLR end T39 | |
498 | ||
499 | ||
500 | ||
501 | # $ANTLR start T40 | |
502 | def mT40(self, ): | |
503 | ||
504 | try: | |
505 | self.type = T40 | |
506 | ||
507 | # C.g:22:5: ( 'double' ) | |
508 | # C.g:22:7: 'double' | |
509 | self.match("double") | |
510 | ||
511 | ||
512 | ||
513 | ||
514 | ||
515 | ||
516 | finally: | |
517 | ||
518 | pass | |
519 | ||
520 | # $ANTLR end T40 | |
521 | ||
522 | ||
523 | ||
524 | # $ANTLR start T41 | |
525 | def mT41(self, ): | |
526 | ||
527 | try: | |
528 | self.type = T41 | |
529 | ||
530 | # C.g:23:5: ( 'signed' ) | |
531 | # C.g:23:7: 'signed' | |
532 | self.match("signed") | |
533 | ||
534 | ||
535 | ||
536 | ||
537 | ||
538 | ||
539 | finally: | |
540 | ||
541 | pass | |
542 | ||
543 | # $ANTLR end T41 | |
544 | ||
545 | ||
546 | ||
547 | # $ANTLR start T42 | |
548 | def mT42(self, ): | |
549 | ||
550 | try: | |
551 | self.type = T42 | |
552 | ||
553 | # C.g:24:5: ( 'unsigned' ) | |
554 | # C.g:24:7: 'unsigned' | |
555 | self.match("unsigned") | |
556 | ||
557 | ||
558 | ||
559 | ||
560 | ||
561 | ||
562 | finally: | |
563 | ||
564 | pass | |
565 | ||
566 | # $ANTLR end T42 | |
567 | ||
568 | ||
569 | ||
570 | # $ANTLR start T43 | |
571 | def mT43(self, ): | |
572 | ||
573 | try: | |
574 | self.type = T43 | |
575 | ||
576 | # C.g:25:5: ( '{' ) | |
577 | # C.g:25:7: '{' | |
578 | self.match(u'{') | |
579 | ||
580 | ||
581 | ||
582 | ||
583 | ||
584 | finally: | |
585 | ||
586 | pass | |
587 | ||
588 | # $ANTLR end T43 | |
589 | ||
590 | ||
591 | ||
592 | # $ANTLR start T44 | |
593 | def mT44(self, ): | |
594 | ||
595 | try: | |
596 | self.type = T44 | |
597 | ||
598 | # C.g:26:5: ( '}' ) | |
599 | # C.g:26:7: '}' | |
600 | self.match(u'}') | |
601 | ||
602 | ||
603 | ||
604 | ||
605 | ||
606 | finally: | |
607 | ||
608 | pass | |
609 | ||
610 | # $ANTLR end T44 | |
611 | ||
612 | ||
613 | ||
614 | # $ANTLR start T45 | |
615 | def mT45(self, ): | |
616 | ||
617 | try: | |
618 | self.type = T45 | |
619 | ||
620 | # C.g:27:5: ( 'struct' ) | |
621 | # C.g:27:7: 'struct' | |
622 | self.match("struct") | |
623 | ||
624 | ||
625 | ||
626 | ||
627 | ||
628 | ||
629 | finally: | |
630 | ||
631 | pass | |
632 | ||
633 | # $ANTLR end T45 | |
634 | ||
635 | ||
636 | ||
637 | # $ANTLR start T46 | |
638 | def mT46(self, ): | |
639 | ||
640 | try: | |
641 | self.type = T46 | |
642 | ||
643 | # C.g:28:5: ( 'union' ) | |
644 | # C.g:28:7: 'union' | |
645 | self.match("union") | |
646 | ||
647 | ||
648 | ||
649 | ||
650 | ||
651 | ||
652 | finally: | |
653 | ||
654 | pass | |
655 | ||
656 | # $ANTLR end T46 | |
657 | ||
658 | ||
659 | ||
660 | # $ANTLR start T47 | |
661 | def mT47(self, ): | |
662 | ||
663 | try: | |
664 | self.type = T47 | |
665 | ||
666 | # C.g:29:5: ( ':' ) | |
667 | # C.g:29:7: ':' | |
668 | self.match(u':') | |
669 | ||
670 | ||
671 | ||
672 | ||
673 | ||
674 | finally: | |
675 | ||
676 | pass | |
677 | ||
678 | # $ANTLR end T47 | |
679 | ||
680 | ||
681 | ||
682 | # $ANTLR start T48 | |
683 | def mT48(self, ): | |
684 | ||
685 | try: | |
686 | self.type = T48 | |
687 | ||
688 | # C.g:30:5: ( 'enum' ) | |
689 | # C.g:30:7: 'enum' | |
690 | self.match("enum") | |
691 | ||
692 | ||
693 | ||
694 | ||
695 | ||
696 | ||
697 | finally: | |
698 | ||
699 | pass | |
700 | ||
701 | # $ANTLR end T48 | |
702 | ||
703 | ||
704 | ||
705 | # $ANTLR start T49 | |
706 | def mT49(self, ): | |
707 | ||
708 | try: | |
709 | self.type = T49 | |
710 | ||
711 | # C.g:31:5: ( 'const' ) | |
712 | # C.g:31:7: 'const' | |
713 | self.match("const") | |
714 | ||
715 | ||
716 | ||
717 | ||
718 | ||
719 | ||
720 | finally: | |
721 | ||
722 | pass | |
723 | ||
724 | # $ANTLR end T49 | |
725 | ||
726 | ||
727 | ||
728 | # $ANTLR start T50 | |
729 | def mT50(self, ): | |
730 | ||
731 | try: | |
732 | self.type = T50 | |
733 | ||
734 | # C.g:32:5: ( 'volatile' ) | |
735 | # C.g:32:7: 'volatile' | |
736 | self.match("volatile") | |
737 | ||
738 | ||
739 | ||
740 | ||
741 | ||
742 | ||
743 | finally: | |
744 | ||
745 | pass | |
746 | ||
747 | # $ANTLR end T50 | |
748 | ||
749 | ||
750 | ||
751 | # $ANTLR start T51 | |
752 | def mT51(self, ): | |
753 | ||
754 | try: | |
755 | self.type = T51 | |
756 | ||
757 | # C.g:33:5: ( 'IN' ) | |
758 | # C.g:33:7: 'IN' | |
759 | self.match("IN") | |
760 | ||
761 | ||
762 | ||
763 | ||
764 | ||
765 | ||
766 | finally: | |
767 | ||
768 | pass | |
769 | ||
770 | # $ANTLR end T51 | |
771 | ||
772 | ||
773 | ||
774 | # $ANTLR start T52 | |
775 | def mT52(self, ): | |
776 | ||
777 | try: | |
778 | self.type = T52 | |
779 | ||
780 | # C.g:34:5: ( 'OUT' ) | |
781 | # C.g:34:7: 'OUT' | |
782 | self.match("OUT") | |
783 | ||
784 | ||
785 | ||
786 | ||
787 | ||
788 | ||
789 | finally: | |
790 | ||
791 | pass | |
792 | ||
793 | # $ANTLR end T52 | |
794 | ||
795 | ||
796 | ||
797 | # $ANTLR start T53 | |
798 | def mT53(self, ): | |
799 | ||
800 | try: | |
801 | self.type = T53 | |
802 | ||
803 | # C.g:35:5: ( 'OPTIONAL' ) | |
804 | # C.g:35:7: 'OPTIONAL' | |
805 | self.match("OPTIONAL") | |
806 | ||
807 | ||
808 | ||
809 | ||
810 | ||
811 | ||
812 | finally: | |
813 | ||
814 | pass | |
815 | ||
816 | # $ANTLR end T53 | |
817 | ||
818 | ||
819 | ||
820 | # $ANTLR start T54 | |
821 | def mT54(self, ): | |
822 | ||
823 | try: | |
824 | self.type = T54 | |
825 | ||
826 | # C.g:36:5: ( 'CONST' ) | |
827 | # C.g:36:7: 'CONST' | |
828 | self.match("CONST") | |
829 | ||
830 | ||
831 | ||
832 | ||
833 | ||
834 | ||
835 | finally: | |
836 | ||
837 | pass | |
838 | ||
839 | # $ANTLR end T54 | |
840 | ||
841 | ||
842 | ||
843 | # $ANTLR start T55 | |
844 | def mT55(self, ): | |
845 | ||
846 | try: | |
847 | self.type = T55 | |
848 | ||
849 | # C.g:37:5: ( 'UNALIGNED' ) | |
850 | # C.g:37:7: 'UNALIGNED' | |
851 | self.match("UNALIGNED") | |
852 | ||
853 | ||
854 | ||
855 | ||
856 | ||
857 | ||
858 | finally: | |
859 | ||
860 | pass | |
861 | ||
862 | # $ANTLR end T55 | |
863 | ||
864 | ||
865 | ||
866 | # $ANTLR start T56 | |
867 | def mT56(self, ): | |
868 | ||
869 | try: | |
870 | self.type = T56 | |
871 | ||
872 | # C.g:38:5: ( 'VOLATILE' ) | |
873 | # C.g:38:7: 'VOLATILE' | |
874 | self.match("VOLATILE") | |
875 | ||
876 | ||
877 | ||
878 | ||
879 | ||
880 | ||
881 | finally: | |
882 | ||
883 | pass | |
884 | ||
885 | # $ANTLR end T56 | |
886 | ||
887 | ||
888 | ||
889 | # $ANTLR start T57 | |
890 | def mT57(self, ): | |
891 | ||
892 | try: | |
893 | self.type = T57 | |
894 | ||
895 | # C.g:39:5: ( 'GLOBAL_REMOVE_IF_UNREFERENCED' ) | |
896 | # C.g:39:7: 'GLOBAL_REMOVE_IF_UNREFERENCED' | |
897 | self.match("GLOBAL_REMOVE_IF_UNREFERENCED") | |
898 | ||
899 | ||
900 | ||
901 | ||
902 | ||
903 | ||
904 | finally: | |
905 | ||
906 | pass | |
907 | ||
908 | # $ANTLR end T57 | |
909 | ||
910 | ||
911 | ||
912 | # $ANTLR start T58 | |
913 | def mT58(self, ): | |
914 | ||
915 | try: | |
916 | self.type = T58 | |
917 | ||
918 | # C.g:40:5: ( 'EFIAPI' ) | |
919 | # C.g:40:7: 'EFIAPI' | |
920 | self.match("EFIAPI") | |
921 | ||
922 | ||
923 | ||
924 | ||
925 | ||
926 | ||
927 | finally: | |
928 | ||
929 | pass | |
930 | ||
931 | # $ANTLR end T58 | |
932 | ||
933 | ||
934 | ||
935 | # $ANTLR start T59 | |
936 | def mT59(self, ): | |
937 | ||
938 | try: | |
939 | self.type = T59 | |
940 | ||
941 | # C.g:41:5: ( 'EFI_BOOTSERVICE' ) | |
942 | # C.g:41:7: 'EFI_BOOTSERVICE' | |
943 | self.match("EFI_BOOTSERVICE") | |
944 | ||
945 | ||
946 | ||
947 | ||
948 | ||
949 | ||
950 | finally: | |
951 | ||
952 | pass | |
953 | ||
954 | # $ANTLR end T59 | |
955 | ||
956 | ||
957 | ||
958 | # $ANTLR start T60 | |
959 | def mT60(self, ): | |
960 | ||
961 | try: | |
962 | self.type = T60 | |
963 | ||
964 | # C.g:42:5: ( 'EFI_RUNTIMESERVICE' ) | |
965 | # C.g:42:7: 'EFI_RUNTIMESERVICE' | |
966 | self.match("EFI_RUNTIMESERVICE") | |
967 | ||
968 | ||
969 | ||
970 | ||
971 | ||
972 | ||
973 | finally: | |
974 | ||
975 | pass | |
976 | ||
977 | # $ANTLR end T60 | |
978 | ||
979 | ||
980 | ||
981 | # $ANTLR start T61 | |
982 | def mT61(self, ): | |
983 | ||
984 | try: | |
985 | self.type = T61 | |
986 | ||
987 | # C.g:43:5: ( '(' ) | |
988 | # C.g:43:7: '(' | |
989 | self.match(u'(') | |
990 | ||
991 | ||
992 | ||
993 | ||
994 | ||
995 | finally: | |
996 | ||
997 | pass | |
998 | ||
999 | # $ANTLR end T61 | |
1000 | ||
1001 | ||
1002 | ||
1003 | # $ANTLR start T62 | |
1004 | def mT62(self, ): | |
1005 | ||
1006 | try: | |
1007 | self.type = T62 | |
1008 | ||
1009 | # C.g:44:5: ( ')' ) | |
1010 | # C.g:44:7: ')' | |
1011 | self.match(u')') | |
1012 | ||
1013 | ||
1014 | ||
1015 | ||
1016 | ||
1017 | finally: | |
1018 | ||
1019 | pass | |
1020 | ||
1021 | # $ANTLR end T62 | |
1022 | ||
1023 | ||
1024 | ||
1025 | # $ANTLR start T63 | |
1026 | def mT63(self, ): | |
1027 | ||
1028 | try: | |
1029 | self.type = T63 | |
1030 | ||
1031 | # C.g:45:5: ( '[' ) | |
1032 | # C.g:45:7: '[' | |
1033 | self.match(u'[') | |
1034 | ||
1035 | ||
1036 | ||
1037 | ||
1038 | ||
1039 | finally: | |
1040 | ||
1041 | pass | |
1042 | ||
1043 | # $ANTLR end T63 | |
1044 | ||
1045 | ||
1046 | ||
1047 | # $ANTLR start T64 | |
1048 | def mT64(self, ): | |
1049 | ||
1050 | try: | |
1051 | self.type = T64 | |
1052 | ||
1053 | # C.g:46:5: ( ']' ) | |
1054 | # C.g:46:7: ']' | |
1055 | self.match(u']') | |
1056 | ||
1057 | ||
1058 | ||
1059 | ||
1060 | ||
1061 | finally: | |
1062 | ||
1063 | pass | |
1064 | ||
1065 | # $ANTLR end T64 | |
1066 | ||
1067 | ||
1068 | ||
1069 | # $ANTLR start T65 | |
1070 | def mT65(self, ): | |
1071 | ||
1072 | try: | |
1073 | self.type = T65 | |
1074 | ||
1075 | # C.g:47:5: ( '*' ) | |
1076 | # C.g:47:7: '*' | |
1077 | self.match(u'*') | |
1078 | ||
1079 | ||
1080 | ||
1081 | ||
1082 | ||
1083 | finally: | |
1084 | ||
1085 | pass | |
1086 | ||
1087 | # $ANTLR end T65 | |
1088 | ||
1089 | ||
1090 | ||
1091 | # $ANTLR start T66 | |
1092 | def mT66(self, ): | |
1093 | ||
1094 | try: | |
1095 | self.type = T66 | |
1096 | ||
1097 | # C.g:48:5: ( '...' ) | |
1098 | # C.g:48:7: '...' | |
1099 | self.match("...") | |
1100 | ||
1101 | ||
1102 | ||
1103 | ||
1104 | ||
1105 | ||
1106 | finally: | |
1107 | ||
1108 | pass | |
1109 | ||
1110 | # $ANTLR end T66 | |
1111 | ||
1112 | ||
1113 | ||
1114 | # $ANTLR start T67 | |
1115 | def mT67(self, ): | |
1116 | ||
1117 | try: | |
1118 | self.type = T67 | |
1119 | ||
1120 | # C.g:49:5: ( '+' ) | |
1121 | # C.g:49:7: '+' | |
1122 | self.match(u'+') | |
1123 | ||
1124 | ||
1125 | ||
1126 | ||
1127 | ||
1128 | finally: | |
1129 | ||
1130 | pass | |
1131 | ||
1132 | # $ANTLR end T67 | |
1133 | ||
1134 | ||
1135 | ||
1136 | # $ANTLR start T68 | |
1137 | def mT68(self, ): | |
1138 | ||
1139 | try: | |
1140 | self.type = T68 | |
1141 | ||
1142 | # C.g:50:5: ( '-' ) | |
1143 | # C.g:50:7: '-' | |
1144 | self.match(u'-') | |
1145 | ||
1146 | ||
1147 | ||
1148 | ||
1149 | ||
1150 | finally: | |
1151 | ||
1152 | pass | |
1153 | ||
1154 | # $ANTLR end T68 | |
1155 | ||
1156 | ||
1157 | ||
1158 | # $ANTLR start T69 | |
1159 | def mT69(self, ): | |
1160 | ||
1161 | try: | |
1162 | self.type = T69 | |
1163 | ||
1164 | # C.g:51:5: ( '/' ) | |
1165 | # C.g:51:7: '/' | |
1166 | self.match(u'/') | |
1167 | ||
1168 | ||
1169 | ||
1170 | ||
1171 | ||
1172 | finally: | |
1173 | ||
1174 | pass | |
1175 | ||
1176 | # $ANTLR end T69 | |
1177 | ||
1178 | ||
1179 | ||
1180 | # $ANTLR start T70 | |
1181 | def mT70(self, ): | |
1182 | ||
1183 | try: | |
1184 | self.type = T70 | |
1185 | ||
1186 | # C.g:52:5: ( '%' ) | |
1187 | # C.g:52:7: '%' | |
1188 | self.match(u'%') | |
1189 | ||
1190 | ||
1191 | ||
1192 | ||
1193 | ||
1194 | finally: | |
1195 | ||
1196 | pass | |
1197 | ||
1198 | # $ANTLR end T70 | |
1199 | ||
1200 | ||
1201 | ||
1202 | # $ANTLR start T71 | |
1203 | def mT71(self, ): | |
1204 | ||
1205 | try: | |
1206 | self.type = T71 | |
1207 | ||
1208 | # C.g:53:5: ( '++' ) | |
1209 | # C.g:53:7: '++' | |
1210 | self.match("++") | |
1211 | ||
1212 | ||
1213 | ||
1214 | ||
1215 | ||
1216 | ||
1217 | finally: | |
1218 | ||
1219 | pass | |
1220 | ||
1221 | # $ANTLR end T71 | |
1222 | ||
1223 | ||
1224 | ||
1225 | # $ANTLR start T72 | |
1226 | def mT72(self, ): | |
1227 | ||
1228 | try: | |
1229 | self.type = T72 | |
1230 | ||
1231 | # C.g:54:5: ( '--' ) | |
1232 | # C.g:54:7: '--' | |
1233 | self.match("--") | |
1234 | ||
1235 | ||
1236 | ||
1237 | ||
1238 | ||
1239 | ||
1240 | finally: | |
1241 | ||
1242 | pass | |
1243 | ||
1244 | # $ANTLR end T72 | |
1245 | ||
1246 | ||
1247 | ||
1248 | # $ANTLR start T73 | |
1249 | def mT73(self, ): | |
1250 | ||
1251 | try: | |
1252 | self.type = T73 | |
1253 | ||
1254 | # C.g:55:5: ( 'sizeof' ) | |
1255 | # C.g:55:7: 'sizeof' | |
1256 | self.match("sizeof") | |
1257 | ||
1258 | ||
1259 | ||
1260 | ||
1261 | ||
1262 | ||
1263 | finally: | |
1264 | ||
1265 | pass | |
1266 | ||
1267 | # $ANTLR end T73 | |
1268 | ||
1269 | ||
1270 | ||
1271 | # $ANTLR start T74 | |
1272 | def mT74(self, ): | |
1273 | ||
1274 | try: | |
1275 | self.type = T74 | |
1276 | ||
1277 | # C.g:56:5: ( '.' ) | |
1278 | # C.g:56:7: '.' | |
1279 | self.match(u'.') | |
1280 | ||
1281 | ||
1282 | ||
1283 | ||
1284 | ||
1285 | finally: | |
1286 | ||
1287 | pass | |
1288 | ||
1289 | # $ANTLR end T74 | |
1290 | ||
1291 | ||
1292 | ||
1293 | # $ANTLR start T75 | |
1294 | def mT75(self, ): | |
1295 | ||
1296 | try: | |
1297 | self.type = T75 | |
1298 | ||
1299 | # C.g:57:5: ( '->' ) | |
1300 | # C.g:57:7: '->' | |
1301 | self.match("->") | |
1302 | ||
1303 | ||
1304 | ||
1305 | ||
1306 | ||
1307 | ||
1308 | finally: | |
1309 | ||
1310 | pass | |
1311 | ||
1312 | # $ANTLR end T75 | |
1313 | ||
1314 | ||
1315 | ||
1316 | # $ANTLR start T76 | |
1317 | def mT76(self, ): | |
1318 | ||
1319 | try: | |
1320 | self.type = T76 | |
1321 | ||
1322 | # C.g:58:5: ( '&' ) | |
1323 | # C.g:58:7: '&' | |
1324 | self.match(u'&') | |
1325 | ||
1326 | ||
1327 | ||
1328 | ||
1329 | ||
1330 | finally: | |
1331 | ||
1332 | pass | |
1333 | ||
1334 | # $ANTLR end T76 | |
1335 | ||
1336 | ||
1337 | ||
1338 | # $ANTLR start T77 | |
1339 | def mT77(self, ): | |
1340 | ||
1341 | try: | |
1342 | self.type = T77 | |
1343 | ||
1344 | # C.g:59:5: ( '~' ) | |
1345 | # C.g:59:7: '~' | |
1346 | self.match(u'~') | |
1347 | ||
1348 | ||
1349 | ||
1350 | ||
1351 | ||
1352 | finally: | |
1353 | ||
1354 | pass | |
1355 | ||
1356 | # $ANTLR end T77 | |
1357 | ||
1358 | ||
1359 | ||
1360 | # $ANTLR start T78 | |
1361 | def mT78(self, ): | |
1362 | ||
1363 | try: | |
1364 | self.type = T78 | |
1365 | ||
1366 | # C.g:60:5: ( '!' ) | |
1367 | # C.g:60:7: '!' | |
1368 | self.match(u'!') | |
1369 | ||
1370 | ||
1371 | ||
1372 | ||
1373 | ||
1374 | finally: | |
1375 | ||
1376 | pass | |
1377 | ||
1378 | # $ANTLR end T78 | |
1379 | ||
1380 | ||
1381 | ||
1382 | # $ANTLR start T79 | |
1383 | def mT79(self, ): | |
1384 | ||
1385 | try: | |
1386 | self.type = T79 | |
1387 | ||
1388 | # C.g:61:5: ( '*=' ) | |
1389 | # C.g:61:7: '*=' | |
1390 | self.match("*=") | |
1391 | ||
1392 | ||
1393 | ||
1394 | ||
1395 | ||
1396 | ||
1397 | finally: | |
1398 | ||
1399 | pass | |
1400 | ||
1401 | # $ANTLR end T79 | |
1402 | ||
1403 | ||
1404 | ||
1405 | # $ANTLR start T80 | |
1406 | def mT80(self, ): | |
1407 | ||
1408 | try: | |
1409 | self.type = T80 | |
1410 | ||
1411 | # C.g:62:5: ( '/=' ) | |
1412 | # C.g:62:7: '/=' | |
1413 | self.match("/=") | |
1414 | ||
1415 | ||
1416 | ||
1417 | ||
1418 | ||
1419 | ||
1420 | finally: | |
1421 | ||
1422 | pass | |
1423 | ||
1424 | # $ANTLR end T80 | |
1425 | ||
1426 | ||
1427 | ||
1428 | # $ANTLR start T81 | |
1429 | def mT81(self, ): | |
1430 | ||
1431 | try: | |
1432 | self.type = T81 | |
1433 | ||
1434 | # C.g:63:5: ( '%=' ) | |
1435 | # C.g:63:7: '%=' | |
1436 | self.match("%=") | |
1437 | ||
1438 | ||
1439 | ||
1440 | ||
1441 | ||
1442 | ||
1443 | finally: | |
1444 | ||
1445 | pass | |
1446 | ||
1447 | # $ANTLR end T81 | |
1448 | ||
1449 | ||
1450 | ||
1451 | # $ANTLR start T82 | |
1452 | def mT82(self, ): | |
1453 | ||
1454 | try: | |
1455 | self.type = T82 | |
1456 | ||
1457 | # C.g:64:5: ( '+=' ) | |
1458 | # C.g:64:7: '+=' | |
1459 | self.match("+=") | |
1460 | ||
1461 | ||
1462 | ||
1463 | ||
1464 | ||
1465 | ||
1466 | finally: | |
1467 | ||
1468 | pass | |
1469 | ||
1470 | # $ANTLR end T82 | |
1471 | ||
1472 | ||
1473 | ||
1474 | # $ANTLR start T83 | |
1475 | def mT83(self, ): | |
1476 | ||
1477 | try: | |
1478 | self.type = T83 | |
1479 | ||
1480 | # C.g:65:5: ( '-=' ) | |
1481 | # C.g:65:7: '-=' | |
1482 | self.match("-=") | |
1483 | ||
1484 | ||
1485 | ||
1486 | ||
1487 | ||
1488 | ||
1489 | finally: | |
1490 | ||
1491 | pass | |
1492 | ||
1493 | # $ANTLR end T83 | |
1494 | ||
1495 | ||
1496 | ||
1497 | # $ANTLR start T84 | |
1498 | def mT84(self, ): | |
1499 | ||
1500 | try: | |
1501 | self.type = T84 | |
1502 | ||
1503 | # C.g:66:5: ( '<<=' ) | |
1504 | # C.g:66:7: '<<=' | |
1505 | self.match("<<=") | |
1506 | ||
1507 | ||
1508 | ||
1509 | ||
1510 | ||
1511 | ||
1512 | finally: | |
1513 | ||
1514 | pass | |
1515 | ||
1516 | # $ANTLR end T84 | |
1517 | ||
1518 | ||
1519 | ||
1520 | # $ANTLR start T85 | |
1521 | def mT85(self, ): | |
1522 | ||
1523 | try: | |
1524 | self.type = T85 | |
1525 | ||
1526 | # C.g:67:5: ( '>>=' ) | |
1527 | # C.g:67:7: '>>=' | |
1528 | self.match(">>=") | |
1529 | ||
1530 | ||
1531 | ||
1532 | ||
1533 | ||
1534 | ||
1535 | finally: | |
1536 | ||
1537 | pass | |
1538 | ||
1539 | # $ANTLR end T85 | |
1540 | ||
1541 | ||
1542 | ||
1543 | # $ANTLR start T86 | |
1544 | def mT86(self, ): | |
1545 | ||
1546 | try: | |
1547 | self.type = T86 | |
1548 | ||
1549 | # C.g:68:5: ( '&=' ) | |
1550 | # C.g:68:7: '&=' | |
1551 | self.match("&=") | |
1552 | ||
1553 | ||
1554 | ||
1555 | ||
1556 | ||
1557 | ||
1558 | finally: | |
1559 | ||
1560 | pass | |
1561 | ||
1562 | # $ANTLR end T86 | |
1563 | ||
1564 | ||
1565 | ||
1566 | # $ANTLR start T87 | |
1567 | def mT87(self, ): | |
1568 | ||
1569 | try: | |
1570 | self.type = T87 | |
1571 | ||
1572 | # C.g:69:5: ( '^=' ) | |
1573 | # C.g:69:7: '^=' | |
1574 | self.match("^=") | |
1575 | ||
1576 | ||
1577 | ||
1578 | ||
1579 | ||
1580 | ||
1581 | finally: | |
1582 | ||
1583 | pass | |
1584 | ||
1585 | # $ANTLR end T87 | |
1586 | ||
1587 | ||
1588 | ||
1589 | # $ANTLR start T88 | |
1590 | def mT88(self, ): | |
1591 | ||
1592 | try: | |
1593 | self.type = T88 | |
1594 | ||
1595 | # C.g:70:5: ( '|=' ) | |
1596 | # C.g:70:7: '|=' | |
1597 | self.match("|=") | |
1598 | ||
1599 | ||
1600 | ||
1601 | ||
1602 | ||
1603 | ||
1604 | finally: | |
1605 | ||
1606 | pass | |
1607 | ||
1608 | # $ANTLR end T88 | |
1609 | ||
1610 | ||
1611 | ||
1612 | # $ANTLR start T89 | |
1613 | def mT89(self, ): | |
1614 | ||
1615 | try: | |
1616 | self.type = T89 | |
1617 | ||
1618 | # C.g:71:5: ( '?' ) | |
1619 | # C.g:71:7: '?' | |
1620 | self.match(u'?') | |
1621 | ||
1622 | ||
1623 | ||
1624 | ||
1625 | ||
1626 | finally: | |
1627 | ||
1628 | pass | |
1629 | ||
1630 | # $ANTLR end T89 | |
1631 | ||
1632 | ||
1633 | ||
1634 | # $ANTLR start T90 | |
1635 | def mT90(self, ): | |
1636 | ||
1637 | try: | |
1638 | self.type = T90 | |
1639 | ||
1640 | # C.g:72:5: ( '||' ) | |
1641 | # C.g:72:7: '||' | |
1642 | self.match("||") | |
1643 | ||
1644 | ||
1645 | ||
1646 | ||
1647 | ||
1648 | ||
1649 | finally: | |
1650 | ||
1651 | pass | |
1652 | ||
1653 | # $ANTLR end T90 | |
1654 | ||
1655 | ||
1656 | ||
1657 | # $ANTLR start T91 | |
1658 | def mT91(self, ): | |
1659 | ||
1660 | try: | |
1661 | self.type = T91 | |
1662 | ||
1663 | # C.g:73:5: ( '&&' ) | |
1664 | # C.g:73:7: '&&' | |
1665 | self.match("&&") | |
1666 | ||
1667 | ||
1668 | ||
1669 | ||
1670 | ||
1671 | ||
1672 | finally: | |
1673 | ||
1674 | pass | |
1675 | ||
1676 | # $ANTLR end T91 | |
1677 | ||
1678 | ||
1679 | ||
1680 | # $ANTLR start T92 | |
1681 | def mT92(self, ): | |
1682 | ||
1683 | try: | |
1684 | self.type = T92 | |
1685 | ||
1686 | # C.g:74:5: ( '|' ) | |
1687 | # C.g:74:7: '|' | |
1688 | self.match(u'|') | |
1689 | ||
1690 | ||
1691 | ||
1692 | ||
1693 | ||
1694 | finally: | |
1695 | ||
1696 | pass | |
1697 | ||
1698 | # $ANTLR end T92 | |
1699 | ||
1700 | ||
1701 | ||
1702 | # $ANTLR start T93 | |
1703 | def mT93(self, ): | |
1704 | ||
1705 | try: | |
1706 | self.type = T93 | |
1707 | ||
1708 | # C.g:75:5: ( '^' ) | |
1709 | # C.g:75:7: '^' | |
1710 | self.match(u'^') | |
1711 | ||
1712 | ||
1713 | ||
1714 | ||
1715 | ||
1716 | finally: | |
1717 | ||
1718 | pass | |
1719 | ||
1720 | # $ANTLR end T93 | |
1721 | ||
1722 | ||
1723 | ||
1724 | # $ANTLR start T94 | |
1725 | def mT94(self, ): | |
1726 | ||
1727 | try: | |
1728 | self.type = T94 | |
1729 | ||
1730 | # C.g:76:5: ( '==' ) | |
1731 | # C.g:76:7: '==' | |
1732 | self.match("==") | |
1733 | ||
1734 | ||
1735 | ||
1736 | ||
1737 | ||
1738 | ||
1739 | finally: | |
1740 | ||
1741 | pass | |
1742 | ||
1743 | # $ANTLR end T94 | |
1744 | ||
1745 | ||
1746 | ||
1747 | # $ANTLR start T95 | |
1748 | def mT95(self, ): | |
1749 | ||
1750 | try: | |
1751 | self.type = T95 | |
1752 | ||
1753 | # C.g:77:5: ( '!=' ) | |
1754 | # C.g:77:7: '!=' | |
1755 | self.match("!=") | |
1756 | ||
1757 | ||
1758 | ||
1759 | ||
1760 | ||
1761 | ||
1762 | finally: | |
1763 | ||
1764 | pass | |
1765 | ||
1766 | # $ANTLR end T95 | |
1767 | ||
1768 | ||
1769 | ||
1770 | # $ANTLR start T96 | |
1771 | def mT96(self, ): | |
1772 | ||
1773 | try: | |
1774 | self.type = T96 | |
1775 | ||
1776 | # C.g:78:5: ( '<' ) | |
1777 | # C.g:78:7: '<' | |
1778 | self.match(u'<') | |
1779 | ||
1780 | ||
1781 | ||
1782 | ||
1783 | ||
1784 | finally: | |
1785 | ||
1786 | pass | |
1787 | ||
1788 | # $ANTLR end T96 | |
1789 | ||
1790 | ||
1791 | ||
1792 | # $ANTLR start T97 | |
1793 | def mT97(self, ): | |
1794 | ||
1795 | try: | |
1796 | self.type = T97 | |
1797 | ||
1798 | # C.g:79:5: ( '>' ) | |
1799 | # C.g:79:7: '>' | |
1800 | self.match(u'>') | |
1801 | ||
1802 | ||
1803 | ||
1804 | ||
1805 | ||
1806 | finally: | |
1807 | ||
1808 | pass | |
1809 | ||
1810 | # $ANTLR end T97 | |
1811 | ||
1812 | ||
1813 | ||
1814 | # $ANTLR start T98 | |
1815 | def mT98(self, ): | |
1816 | ||
1817 | try: | |
1818 | self.type = T98 | |
1819 | ||
1820 | # C.g:80:5: ( '<=' ) | |
1821 | # C.g:80:7: '<=' | |
1822 | self.match("<=") | |
1823 | ||
1824 | ||
1825 | ||
1826 | ||
1827 | ||
1828 | ||
1829 | finally: | |
1830 | ||
1831 | pass | |
1832 | ||
1833 | # $ANTLR end T98 | |
1834 | ||
1835 | ||
1836 | ||
1837 | # $ANTLR start T99 | |
1838 | def mT99(self, ): | |
1839 | ||
1840 | try: | |
1841 | self.type = T99 | |
1842 | ||
1843 | # C.g:81:5: ( '>=' ) | |
1844 | # C.g:81:7: '>=' | |
1845 | self.match(">=") | |
1846 | ||
1847 | ||
1848 | ||
1849 | ||
1850 | ||
1851 | ||
1852 | finally: | |
1853 | ||
1854 | pass | |
1855 | ||
1856 | # $ANTLR end T99 | |
1857 | ||
1858 | ||
1859 | ||
1860 | # $ANTLR start T100 | |
1861 | def mT100(self, ): | |
1862 | ||
1863 | try: | |
1864 | self.type = T100 | |
1865 | ||
1866 | # C.g:82:6: ( '<<' ) | |
1867 | # C.g:82:8: '<<' | |
1868 | self.match("<<") | |
1869 | ||
1870 | ||
1871 | ||
1872 | ||
1873 | ||
1874 | ||
1875 | finally: | |
1876 | ||
1877 | pass | |
1878 | ||
1879 | # $ANTLR end T100 | |
1880 | ||
1881 | ||
1882 | ||
1883 | # $ANTLR start T101 | |
1884 | def mT101(self, ): | |
1885 | ||
1886 | try: | |
1887 | self.type = T101 | |
1888 | ||
1889 | # C.g:83:6: ( '>>' ) | |
1890 | # C.g:83:8: '>>' | |
1891 | self.match(">>") | |
1892 | ||
1893 | ||
1894 | ||
1895 | ||
1896 | ||
1897 | ||
1898 | finally: | |
1899 | ||
1900 | pass | |
1901 | ||
1902 | # $ANTLR end T101 | |
1903 | ||
1904 | ||
1905 | ||
1906 | # $ANTLR start T102 | |
1907 | def mT102(self, ): | |
1908 | ||
1909 | try: | |
1910 | self.type = T102 | |
1911 | ||
1912 | # C.g:84:6: ( '__asm__' ) | |
1913 | # C.g:84:8: '__asm__' | |
1914 | self.match("__asm__") | |
1915 | ||
1916 | ||
1917 | ||
1918 | ||
1919 | ||
1920 | ||
1921 | finally: | |
1922 | ||
1923 | pass | |
1924 | ||
1925 | # $ANTLR end T102 | |
1926 | ||
1927 | ||
1928 | ||
1929 | # $ANTLR start T103 | |
1930 | def mT103(self, ): | |
1931 | ||
1932 | try: | |
1933 | self.type = T103 | |
1934 | ||
1935 | # C.g:85:6: ( '_asm' ) | |
1936 | # C.g:85:8: '_asm' | |
1937 | self.match("_asm") | |
1938 | ||
1939 | ||
1940 | ||
1941 | ||
1942 | ||
1943 | ||
1944 | finally: | |
1945 | ||
1946 | pass | |
1947 | ||
1948 | # $ANTLR end T103 | |
1949 | ||
1950 | ||
1951 | ||
1952 | # $ANTLR start T104 | |
1953 | def mT104(self, ): | |
1954 | ||
1955 | try: | |
1956 | self.type = T104 | |
1957 | ||
1958 | # C.g:86:6: ( '__asm' ) | |
1959 | # C.g:86:8: '__asm' | |
1960 | self.match("__asm") | |
1961 | ||
1962 | ||
1963 | ||
1964 | ||
1965 | ||
1966 | ||
1967 | finally: | |
1968 | ||
1969 | pass | |
1970 | ||
1971 | # $ANTLR end T104 | |
1972 | ||
1973 | ||
1974 | ||
1975 | # $ANTLR start T105 | |
1976 | def mT105(self, ): | |
1977 | ||
1978 | try: | |
1979 | self.type = T105 | |
1980 | ||
1981 | # C.g:87:6: ( 'case' ) | |
1982 | # C.g:87:8: 'case' | |
1983 | self.match("case") | |
1984 | ||
1985 | ||
1986 | ||
1987 | ||
1988 | ||
1989 | ||
1990 | finally: | |
1991 | ||
1992 | pass | |
1993 | ||
1994 | # $ANTLR end T105 | |
1995 | ||
1996 | ||
1997 | ||
1998 | # $ANTLR start T106 | |
1999 | def mT106(self, ): | |
2000 | ||
2001 | try: | |
2002 | self.type = T106 | |
2003 | ||
2004 | # C.g:88:6: ( 'default' ) | |
2005 | # C.g:88:8: 'default' | |
2006 | self.match("default") | |
2007 | ||
2008 | ||
2009 | ||
2010 | ||
2011 | ||
2012 | ||
2013 | finally: | |
2014 | ||
2015 | pass | |
2016 | ||
2017 | # $ANTLR end T106 | |
2018 | ||
2019 | ||
2020 | ||
2021 | # $ANTLR start T107 | |
2022 | def mT107(self, ): | |
2023 | ||
2024 | try: | |
2025 | self.type = T107 | |
2026 | ||
2027 | # C.g:89:6: ( 'if' ) | |
2028 | # C.g:89:8: 'if' | |
2029 | self.match("if") | |
2030 | ||
2031 | ||
2032 | ||
2033 | ||
2034 | ||
2035 | ||
2036 | finally: | |
2037 | ||
2038 | pass | |
2039 | ||
2040 | # $ANTLR end T107 | |
2041 | ||
2042 | ||
2043 | ||
2044 | # $ANTLR start T108 | |
2045 | def mT108(self, ): | |
2046 | ||
2047 | try: | |
2048 | self.type = T108 | |
2049 | ||
2050 | # C.g:90:6: ( 'else' ) | |
2051 | # C.g:90:8: 'else' | |
2052 | self.match("else") | |
2053 | ||
2054 | ||
2055 | ||
2056 | ||
2057 | ||
2058 | ||
2059 | finally: | |
2060 | ||
2061 | pass | |
2062 | ||
2063 | # $ANTLR end T108 | |
2064 | ||
2065 | ||
2066 | ||
2067 | # $ANTLR start T109 | |
2068 | def mT109(self, ): | |
2069 | ||
2070 | try: | |
2071 | self.type = T109 | |
2072 | ||
2073 | # C.g:91:6: ( 'switch' ) | |
2074 | # C.g:91:8: 'switch' | |
2075 | self.match("switch") | |
2076 | ||
2077 | ||
2078 | ||
2079 | ||
2080 | ||
2081 | ||
2082 | finally: | |
2083 | ||
2084 | pass | |
2085 | ||
2086 | # $ANTLR end T109 | |
2087 | ||
2088 | ||
2089 | ||
2090 | # $ANTLR start T110 | |
2091 | def mT110(self, ): | |
2092 | ||
2093 | try: | |
2094 | self.type = T110 | |
2095 | ||
2096 | # C.g:92:6: ( 'while' ) | |
2097 | # C.g:92:8: 'while' | |
2098 | self.match("while") | |
2099 | ||
2100 | ||
2101 | ||
2102 | ||
2103 | ||
2104 | ||
2105 | finally: | |
2106 | ||
2107 | pass | |
2108 | ||
2109 | # $ANTLR end T110 | |
2110 | ||
2111 | ||
2112 | ||
2113 | # $ANTLR start T111 | |
2114 | def mT111(self, ): | |
2115 | ||
2116 | try: | |
2117 | self.type = T111 | |
2118 | ||
2119 | # C.g:93:6: ( 'do' ) | |
2120 | # C.g:93:8: 'do' | |
2121 | self.match("do") | |
2122 | ||
2123 | ||
2124 | ||
2125 | ||
2126 | ||
2127 | ||
2128 | finally: | |
2129 | ||
2130 | pass | |
2131 | ||
2132 | # $ANTLR end T111 | |
2133 | ||
2134 | ||
2135 | ||
2136 | # $ANTLR start T112 | |
2137 | def mT112(self, ): | |
2138 | ||
2139 | try: | |
2140 | self.type = T112 | |
2141 | ||
2142 | # C.g:94:6: ( 'for' ) | |
2143 | # C.g:94:8: 'for' | |
2144 | self.match("for") | |
2145 | ||
2146 | ||
2147 | ||
2148 | ||
2149 | ||
2150 | ||
2151 | finally: | |
2152 | ||
2153 | pass | |
2154 | ||
2155 | # $ANTLR end T112 | |
2156 | ||
2157 | ||
2158 | ||
2159 | # $ANTLR start T113 | |
2160 | def mT113(self, ): | |
2161 | ||
2162 | try: | |
2163 | self.type = T113 | |
2164 | ||
2165 | # C.g:95:6: ( 'goto' ) | |
2166 | # C.g:95:8: 'goto' | |
2167 | self.match("goto") | |
2168 | ||
2169 | ||
2170 | ||
2171 | ||
2172 | ||
2173 | ||
2174 | finally: | |
2175 | ||
2176 | pass | |
2177 | ||
2178 | # $ANTLR end T113 | |
2179 | ||
2180 | ||
2181 | ||
2182 | # $ANTLR start T114 | |
2183 | def mT114(self, ): | |
2184 | ||
2185 | try: | |
2186 | self.type = T114 | |
2187 | ||
2188 | # C.g:96:6: ( 'continue' ) | |
2189 | # C.g:96:8: 'continue' | |
2190 | self.match("continue") | |
2191 | ||
2192 | ||
2193 | ||
2194 | ||
2195 | ||
2196 | ||
2197 | finally: | |
2198 | ||
2199 | pass | |
2200 | ||
2201 | # $ANTLR end T114 | |
2202 | ||
2203 | ||
2204 | ||
2205 | # $ANTLR start T115 | |
2206 | def mT115(self, ): | |
2207 | ||
2208 | try: | |
2209 | self.type = T115 | |
2210 | ||
2211 | # C.g:97:6: ( 'break' ) | |
2212 | # C.g:97:8: 'break' | |
2213 | self.match("break") | |
2214 | ||
2215 | ||
2216 | ||
2217 | ||
2218 | ||
2219 | ||
2220 | finally: | |
2221 | ||
2222 | pass | |
2223 | ||
2224 | # $ANTLR end T115 | |
2225 | ||
2226 | ||
2227 | ||
2228 | # $ANTLR start T116 | |
2229 | def mT116(self, ): | |
2230 | ||
2231 | try: | |
2232 | self.type = T116 | |
2233 | ||
2234 | # C.g:98:6: ( 'return' ) | |
2235 | # C.g:98:8: 'return' | |
2236 | self.match("return") | |
2237 | ||
2238 | ||
2239 | ||
2240 | ||
2241 | ||
2242 | ||
2243 | finally: | |
2244 | ||
2245 | pass | |
2246 | ||
2247 | # $ANTLR end T116 | |
2248 | ||
2249 | ||
2250 | ||
2251 | # $ANTLR start IDENTIFIER | |
2252 | def mIDENTIFIER(self, ): | |
2253 | ||
2254 | try: | |
2255 | self.type = IDENTIFIER | |
2256 | ||
2257 | # C.g:533:2: ( LETTER ( LETTER | '0' .. '9' )* ) | |
2258 | # C.g:533:4: LETTER ( LETTER | '0' .. '9' )* | |
2259 | self.mLETTER() | |
2260 | ||
2261 | # C.g:533:11: ( LETTER | '0' .. '9' )* | |
2262 | while True: #loop1 | |
2263 | alt1 = 2 | |
2264 | LA1_0 = self.input.LA(1) | |
2265 | ||
2266 | if (LA1_0 == u'$' or (u'0' <= LA1_0 <= u'9') or (u'A' <= LA1_0 <= u'Z') or LA1_0 == u'_' or (u'a' <= LA1_0 <= u'z')) : | |
2267 | alt1 = 1 | |
2268 | ||
2269 | ||
2270 | if alt1 == 1: | |
2271 | # C.g: | |
2272 | if self.input.LA(1) == u'$' or (u'0' <= self.input.LA(1) <= u'9') or (u'A' <= self.input.LA(1) <= u'Z') or self.input.LA(1) == u'_' or (u'a' <= self.input.LA(1) <= u'z'): | |
2273 | self.input.consume(); | |
2274 | ||
2275 | else: | |
2276 | mse = MismatchedSetException(None, self.input) | |
2277 | self.recover(mse) | |
2278 | raise mse | |
2279 | ||
2280 | ||
2281 | ||
2282 | ||
2283 | else: | |
2284 | break #loop1 | |
2285 | ||
2286 | ||
2287 | ||
2288 | ||
2289 | ||
2290 | ||
2291 | finally: | |
2292 | ||
2293 | pass | |
2294 | ||
2295 | # $ANTLR end IDENTIFIER | |
2296 | ||
2297 | ||
2298 | ||
2299 | # $ANTLR start LETTER | |
2300 | def mLETTER(self, ): | |
2301 | ||
2302 | try: | |
2303 | # C.g:538:2: ( '$' | 'A' .. 'Z' | 'a' .. 'z' | '_' ) | |
2304 | # C.g: | |
2305 | if self.input.LA(1) == u'$' or (u'A' <= self.input.LA(1) <= u'Z') or self.input.LA(1) == u'_' or (u'a' <= self.input.LA(1) <= u'z'): | |
2306 | self.input.consume(); | |
2307 | ||
2308 | else: | |
2309 | mse = MismatchedSetException(None, self.input) | |
2310 | self.recover(mse) | |
2311 | raise mse | |
2312 | ||
2313 | ||
2314 | ||
2315 | ||
2316 | ||
2317 | ||
2318 | finally: | |
2319 | ||
2320 | pass | |
2321 | ||
2322 | # $ANTLR end LETTER | |
2323 | ||
2324 | ||
2325 | ||
2326 | # $ANTLR start CHARACTER_LITERAL | |
2327 | def mCHARACTER_LITERAL(self, ): | |
2328 | ||
2329 | try: | |
2330 | self.type = CHARACTER_LITERAL | |
2331 | ||
2332 | # C.g:545:5: ( ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\'' ) | |
2333 | # C.g:545:9: ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\'' | |
2334 | # C.g:545:9: ( 'L' )? | |
2335 | alt2 = 2 | |
2336 | LA2_0 = self.input.LA(1) | |
2337 | ||
2338 | if (LA2_0 == u'L') : | |
2339 | alt2 = 1 | |
2340 | if alt2 == 1: | |
2341 | # C.g:545:10: 'L' | |
2342 | self.match(u'L') | |
2343 | ||
2344 | ||
2345 | ||
2346 | ||
2347 | self.match(u'\'') | |
2348 | ||
2349 | # C.g:545:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) | |
2350 | alt3 = 2 | |
2351 | LA3_0 = self.input.LA(1) | |
2352 | ||
2353 | if (LA3_0 == u'\\') : | |
2354 | alt3 = 1 | |
2355 | elif ((u'\u0000' <= LA3_0 <= u'&') or (u'(' <= LA3_0 <= u'[') or (u']' <= LA3_0 <= u'\uFFFE')) : | |
2356 | alt3 = 2 | |
2357 | else: | |
2358 | nvae = NoViableAltException("545:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )", 3, 0, self.input) | |
2359 | ||
2360 | raise nvae | |
2361 | ||
2362 | if alt3 == 1: | |
2363 | # C.g:545:23: EscapeSequence | |
2364 | self.mEscapeSequence() | |
2365 | ||
2366 | ||
2367 | ||
2368 | elif alt3 == 2: | |
2369 | # C.g:545:40: ~ ( '\\'' | '\\\\' ) | |
2370 | if (u'\u0000' <= self.input.LA(1) <= u'&') or (u'(' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'): | |
2371 | self.input.consume(); | |
2372 | ||
2373 | else: | |
2374 | mse = MismatchedSetException(None, self.input) | |
2375 | self.recover(mse) | |
2376 | raise mse | |
2377 | ||
2378 | ||
2379 | ||
2380 | ||
2381 | ||
2382 | self.match(u'\'') | |
2383 | ||
2384 | ||
2385 | ||
2386 | ||
2387 | ||
2388 | finally: | |
2389 | ||
2390 | pass | |
2391 | ||
2392 | # $ANTLR end CHARACTER_LITERAL | |
2393 | ||
2394 | ||
2395 | ||
2396 | # $ANTLR start STRING_LITERAL | |
2397 | def mSTRING_LITERAL(self, ): | |
2398 | ||
2399 | try: | |
2400 | self.type = STRING_LITERAL | |
2401 | ||
2402 | # C.g:549:5: ( ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' ) | |
2403 | # C.g:549:8: ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' | |
2404 | # C.g:549:8: ( 'L' )? | |
2405 | alt4 = 2 | |
2406 | LA4_0 = self.input.LA(1) | |
2407 | ||
2408 | if (LA4_0 == u'L') : | |
2409 | alt4 = 1 | |
2410 | if alt4 == 1: | |
2411 | # C.g:549:9: 'L' | |
2412 | self.match(u'L') | |
2413 | ||
2414 | ||
2415 | ||
2416 | ||
2417 | self.match(u'"') | |
2418 | ||
2419 | # C.g:549:19: ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* | |
2420 | while True: #loop5 | |
2421 | alt5 = 3 | |
2422 | LA5_0 = self.input.LA(1) | |
2423 | ||
2424 | if (LA5_0 == u'\\') : | |
2425 | alt5 = 1 | |
2426 | elif ((u'\u0000' <= LA5_0 <= u'!') or (u'#' <= LA5_0 <= u'[') or (u']' <= LA5_0 <= u'\uFFFE')) : | |
2427 | alt5 = 2 | |
2428 | ||
2429 | ||
2430 | if alt5 == 1: | |
2431 | # C.g:549:21: EscapeSequence | |
2432 | self.mEscapeSequence() | |
2433 | ||
2434 | ||
2435 | ||
2436 | elif alt5 == 2: | |
2437 | # C.g:549:38: ~ ( '\\\\' | '\"' ) | |
2438 | if (u'\u0000' <= self.input.LA(1) <= u'!') or (u'#' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'): | |
2439 | self.input.consume(); | |
2440 | ||
2441 | else: | |
2442 | mse = MismatchedSetException(None, self.input) | |
2443 | self.recover(mse) | |
2444 | raise mse | |
2445 | ||
2446 | ||
2447 | ||
2448 | ||
2449 | else: | |
2450 | break #loop5 | |
2451 | ||
2452 | ||
2453 | self.match(u'"') | |
2454 | ||
2455 | ||
2456 | ||
2457 | ||
2458 | ||
2459 | finally: | |
2460 | ||
2461 | pass | |
2462 | ||
2463 | # $ANTLR end STRING_LITERAL | |
2464 | ||
2465 | ||
2466 | ||
2467 | # $ANTLR start HEX_LITERAL | |
2468 | def mHEX_LITERAL(self, ): | |
2469 | ||
2470 | try: | |
2471 | self.type = HEX_LITERAL | |
2472 | ||
2473 | # C.g:552:13: ( '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )? ) | |
2474 | # C.g:552:15: '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )? | |
2475 | self.match(u'0') | |
2476 | ||
2477 | if self.input.LA(1) == u'X' or self.input.LA(1) == u'x': | |
2478 | self.input.consume(); | |
2479 | ||
2480 | else: | |
2481 | mse = MismatchedSetException(None, self.input) | |
2482 | self.recover(mse) | |
2483 | raise mse | |
2484 | ||
2485 | ||
2486 | # C.g:552:29: ( HexDigit )+ | |
2487 | cnt6 = 0 | |
2488 | while True: #loop6 | |
2489 | alt6 = 2 | |
2490 | LA6_0 = self.input.LA(1) | |
2491 | ||
2492 | if ((u'0' <= LA6_0 <= u'9') or (u'A' <= LA6_0 <= u'F') or (u'a' <= LA6_0 <= u'f')) : | |
2493 | alt6 = 1 | |
2494 | ||
2495 | ||
2496 | if alt6 == 1: | |
2497 | # C.g:552:29: HexDigit | |
2498 | self.mHexDigit() | |
2499 | ||
2500 | ||
2501 | ||
2502 | else: | |
2503 | if cnt6 >= 1: | |
2504 | break #loop6 | |
2505 | ||
2506 | eee = EarlyExitException(6, self.input) | |
2507 | raise eee | |
2508 | ||
2509 | cnt6 += 1 | |
2510 | ||
2511 | ||
2512 | # C.g:552:39: ( IntegerTypeSuffix )? | |
2513 | alt7 = 2 | |
2514 | LA7_0 = self.input.LA(1) | |
2515 | ||
2516 | if (LA7_0 == u'L' or LA7_0 == u'U' or LA7_0 == u'l' or LA7_0 == u'u') : | |
2517 | alt7 = 1 | |
2518 | if alt7 == 1: | |
2519 | # C.g:552:39: IntegerTypeSuffix | |
2520 | self.mIntegerTypeSuffix() | |
2521 | ||
2522 | ||
2523 | ||
2524 | ||
2525 | ||
2526 | ||
2527 | ||
2528 | ||
2529 | finally: | |
2530 | ||
2531 | pass | |
2532 | ||
2533 | # $ANTLR end HEX_LITERAL | |
2534 | ||
2535 | ||
2536 | ||
2537 | # $ANTLR start DECIMAL_LITERAL | |
2538 | def mDECIMAL_LITERAL(self, ): | |
2539 | ||
2540 | try: | |
2541 | self.type = DECIMAL_LITERAL | |
2542 | ||
2543 | # C.g:554:17: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )? ) | |
2544 | # C.g:554:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )? | |
2545 | # C.g:554:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) | |
2546 | alt9 = 2 | |
2547 | LA9_0 = self.input.LA(1) | |
2548 | ||
2549 | if (LA9_0 == u'0') : | |
2550 | alt9 = 1 | |
2551 | elif ((u'1' <= LA9_0 <= u'9')) : | |
2552 | alt9 = 2 | |
2553 | else: | |
2554 | nvae = NoViableAltException("554:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )", 9, 0, self.input) | |
2555 | ||
2556 | raise nvae | |
2557 | ||
2558 | if alt9 == 1: | |
2559 | # C.g:554:20: '0' | |
2560 | self.match(u'0') | |
2561 | ||
2562 | ||
2563 | ||
2564 | elif alt9 == 2: | |
2565 | # C.g:554:26: '1' .. '9' ( '0' .. '9' )* | |
2566 | self.matchRange(u'1', u'9') | |
2567 | ||
2568 | # C.g:554:35: ( '0' .. '9' )* | |
2569 | while True: #loop8 | |
2570 | alt8 = 2 | |
2571 | LA8_0 = self.input.LA(1) | |
2572 | ||
2573 | if ((u'0' <= LA8_0 <= u'9')) : | |
2574 | alt8 = 1 | |
2575 | ||
2576 | ||
2577 | if alt8 == 1: | |
2578 | # C.g:554:35: '0' .. '9' | |
2579 | self.matchRange(u'0', u'9') | |
2580 | ||
2581 | ||
2582 | ||
2583 | else: | |
2584 | break #loop8 | |
2585 | ||
2586 | ||
2587 | ||
2588 | ||
2589 | ||
2590 | # C.g:554:46: ( IntegerTypeSuffix )? | |
2591 | alt10 = 2 | |
2592 | LA10_0 = self.input.LA(1) | |
2593 | ||
2594 | if (LA10_0 == u'L' or LA10_0 == u'U' or LA10_0 == u'l' or LA10_0 == u'u') : | |
2595 | alt10 = 1 | |
2596 | if alt10 == 1: | |
2597 | # C.g:554:46: IntegerTypeSuffix | |
2598 | self.mIntegerTypeSuffix() | |
2599 | ||
2600 | ||
2601 | ||
2602 | ||
2603 | ||
2604 | ||
2605 | ||
2606 | ||
2607 | finally: | |
2608 | ||
2609 | pass | |
2610 | ||
2611 | # $ANTLR end DECIMAL_LITERAL | |
2612 | ||
2613 | ||
2614 | ||
2615 | # $ANTLR start OCTAL_LITERAL | |
2616 | def mOCTAL_LITERAL(self, ): | |
2617 | ||
2618 | try: | |
2619 | self.type = OCTAL_LITERAL | |
2620 | ||
2621 | # C.g:556:15: ( '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )? ) | |
2622 | # C.g:556:17: '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )? | |
2623 | self.match(u'0') | |
2624 | ||
2625 | # C.g:556:21: ( '0' .. '7' )+ | |
2626 | cnt11 = 0 | |
2627 | while True: #loop11 | |
2628 | alt11 = 2 | |
2629 | LA11_0 = self.input.LA(1) | |
2630 | ||
2631 | if ((u'0' <= LA11_0 <= u'7')) : | |
2632 | alt11 = 1 | |
2633 | ||
2634 | ||
2635 | if alt11 == 1: | |
2636 | # C.g:556:22: '0' .. '7' | |
2637 | self.matchRange(u'0', u'7') | |
2638 | ||
2639 | ||
2640 | ||
2641 | else: | |
2642 | if cnt11 >= 1: | |
2643 | break #loop11 | |
2644 | ||
2645 | eee = EarlyExitException(11, self.input) | |
2646 | raise eee | |
2647 | ||
2648 | cnt11 += 1 | |
2649 | ||
2650 | ||
2651 | # C.g:556:33: ( IntegerTypeSuffix )? | |
2652 | alt12 = 2 | |
2653 | LA12_0 = self.input.LA(1) | |
2654 | ||
2655 | if (LA12_0 == u'L' or LA12_0 == u'U' or LA12_0 == u'l' or LA12_0 == u'u') : | |
2656 | alt12 = 1 | |
2657 | if alt12 == 1: | |
2658 | # C.g:556:33: IntegerTypeSuffix | |
2659 | self.mIntegerTypeSuffix() | |
2660 | ||
2661 | ||
2662 | ||
2663 | ||
2664 | ||
2665 | ||
2666 | ||
2667 | ||
2668 | finally: | |
2669 | ||
2670 | pass | |
2671 | ||
2672 | # $ANTLR end OCTAL_LITERAL | |
2673 | ||
2674 | ||
2675 | ||
2676 | # $ANTLR start HexDigit | |
2677 | def mHexDigit(self, ): | |
2678 | ||
2679 | try: | |
2680 | # C.g:559:10: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) ) | |
2681 | # C.g:559:12: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) | |
2682 | if (u'0' <= self.input.LA(1) <= u'9') or (u'A' <= self.input.LA(1) <= u'F') or (u'a' <= self.input.LA(1) <= u'f'): | |
2683 | self.input.consume(); | |
2684 | ||
2685 | else: | |
2686 | mse = MismatchedSetException(None, self.input) | |
2687 | self.recover(mse) | |
2688 | raise mse | |
2689 | ||
2690 | ||
2691 | ||
2692 | ||
2693 | ||
2694 | ||
2695 | finally: | |
2696 | ||
2697 | pass | |
2698 | ||
2699 | # $ANTLR end HexDigit | |
2700 | ||
2701 | ||
2702 | ||
2703 | # $ANTLR start IntegerTypeSuffix | |
2704 | def mIntegerTypeSuffix(self, ): | |
2705 | ||
2706 | try: | |
2707 | # C.g:563:2: ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) ) | |
2708 | alt13 = 4 | |
2709 | LA13_0 = self.input.LA(1) | |
2710 | ||
2711 | if (LA13_0 == u'U' or LA13_0 == u'u') : | |
2712 | LA13_1 = self.input.LA(2) | |
2713 | ||
2714 | if (LA13_1 == u'L' or LA13_1 == u'l') : | |
2715 | LA13_3 = self.input.LA(3) | |
2716 | ||
2717 | if (LA13_3 == u'L' or LA13_3 == u'l') : | |
2718 | alt13 = 4 | |
2719 | else: | |
2720 | alt13 = 3 | |
2721 | else: | |
2722 | alt13 = 1 | |
2723 | elif (LA13_0 == u'L' or LA13_0 == u'l') : | |
2724 | alt13 = 2 | |
2725 | else: | |
2726 | nvae = NoViableAltException("561:1: fragment IntegerTypeSuffix : ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) );", 13, 0, self.input) | |
2727 | ||
2728 | raise nvae | |
2729 | ||
2730 | if alt13 == 1: | |
2731 | # C.g:563:4: ( 'u' | 'U' ) | |
2732 | if self.input.LA(1) == u'U' or self.input.LA(1) == u'u': | |
2733 | self.input.consume(); | |
2734 | ||
2735 | else: | |
2736 | mse = MismatchedSetException(None, self.input) | |
2737 | self.recover(mse) | |
2738 | raise mse | |
2739 | ||
2740 | ||
2741 | ||
2742 | ||
2743 | elif alt13 == 2: | |
2744 | # C.g:564:4: ( 'l' | 'L' ) | |
2745 | if self.input.LA(1) == u'L' or self.input.LA(1) == u'l': | |
2746 | self.input.consume(); | |
2747 | ||
2748 | else: | |
2749 | mse = MismatchedSetException(None, self.input) | |
2750 | self.recover(mse) | |
2751 | raise mse | |
2752 | ||
2753 | ||
2754 | ||
2755 | ||
2756 | elif alt13 == 3: | |
2757 | # C.g:565:4: ( 'u' | 'U' ) ( 'l' | 'L' ) | |
2758 | if self.input.LA(1) == u'U' or self.input.LA(1) == u'u': | |
2759 | self.input.consume(); | |
2760 | ||
2761 | else: | |
2762 | mse = MismatchedSetException(None, self.input) | |
2763 | self.recover(mse) | |
2764 | raise mse | |
2765 | ||
2766 | ||
2767 | if self.input.LA(1) == u'L' or self.input.LA(1) == u'l': | |
2768 | self.input.consume(); | |
2769 | ||
2770 | else: | |
2771 | mse = MismatchedSetException(None, self.input) | |
2772 | self.recover(mse) | |
2773 | raise mse | |
2774 | ||
2775 | ||
2776 | ||
2777 | ||
2778 | elif alt13 == 4: | |
2779 | # C.g:566:4: ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) | |
2780 | if self.input.LA(1) == u'U' or self.input.LA(1) == u'u': | |
2781 | self.input.consume(); | |
2782 | ||
2783 | else: | |
2784 | mse = MismatchedSetException(None, self.input) | |
2785 | self.recover(mse) | |
2786 | raise mse | |
2787 | ||
2788 | ||
2789 | if self.input.LA(1) == u'L' or self.input.LA(1) == u'l': | |
2790 | self.input.consume(); | |
2791 | ||
2792 | else: | |
2793 | mse = MismatchedSetException(None, self.input) | |
2794 | self.recover(mse) | |
2795 | raise mse | |
2796 | ||
2797 | ||
2798 | if self.input.LA(1) == u'L' or self.input.LA(1) == u'l': | |
2799 | self.input.consume(); | |
2800 | ||
2801 | else: | |
2802 | mse = MismatchedSetException(None, self.input) | |
2803 | self.recover(mse) | |
2804 | raise mse | |
2805 | ||
2806 | ||
2807 | ||
2808 | ||
2809 | ||
2810 | finally: | |
2811 | ||
2812 | pass | |
2813 | ||
2814 | # $ANTLR end IntegerTypeSuffix | |
2815 | ||
2816 | ||
2817 | ||
2818 | # $ANTLR start FLOATING_POINT_LITERAL | |
2819 | def mFLOATING_POINT_LITERAL(self, ): | |
2820 | ||
2821 | try: | |
2822 | self.type = FLOATING_POINT_LITERAL | |
2823 | ||
2824 | # C.g:570:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? | '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? | ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? | ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix ) | |
2825 | alt25 = 4 | |
2826 | alt25 = self.dfa25.predict(self.input) | |
2827 | if alt25 == 1: | |
2828 | # C.g:570:9: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? | |
2829 | # C.g:570:9: ( '0' .. '9' )+ | |
2830 | cnt14 = 0 | |
2831 | while True: #loop14 | |
2832 | alt14 = 2 | |
2833 | LA14_0 = self.input.LA(1) | |
2834 | ||
2835 | if ((u'0' <= LA14_0 <= u'9')) : | |
2836 | alt14 = 1 | |
2837 | ||
2838 | ||
2839 | if alt14 == 1: | |
2840 | # C.g:570:10: '0' .. '9' | |
2841 | self.matchRange(u'0', u'9') | |
2842 | ||
2843 | ||
2844 | ||
2845 | else: | |
2846 | if cnt14 >= 1: | |
2847 | break #loop14 | |
2848 | ||
2849 | eee = EarlyExitException(14, self.input) | |
2850 | raise eee | |
2851 | ||
2852 | cnt14 += 1 | |
2853 | ||
2854 | ||
2855 | self.match(u'.') | |
2856 | ||
2857 | # C.g:570:25: ( '0' .. '9' )* | |
2858 | while True: #loop15 | |
2859 | alt15 = 2 | |
2860 | LA15_0 = self.input.LA(1) | |
2861 | ||
2862 | if ((u'0' <= LA15_0 <= u'9')) : | |
2863 | alt15 = 1 | |
2864 | ||
2865 | ||
2866 | if alt15 == 1: | |
2867 | # C.g:570:26: '0' .. '9' | |
2868 | self.matchRange(u'0', u'9') | |
2869 | ||
2870 | ||
2871 | ||
2872 | else: | |
2873 | break #loop15 | |
2874 | ||
2875 | ||
2876 | # C.g:570:37: ( Exponent )? | |
2877 | alt16 = 2 | |
2878 | LA16_0 = self.input.LA(1) | |
2879 | ||
2880 | if (LA16_0 == u'E' or LA16_0 == u'e') : | |
2881 | alt16 = 1 | |
2882 | if alt16 == 1: | |
2883 | # C.g:570:37: Exponent | |
2884 | self.mExponent() | |
2885 | ||
2886 | ||
2887 | ||
2888 | ||
2889 | # C.g:570:47: ( FloatTypeSuffix )? | |
2890 | alt17 = 2 | |
2891 | LA17_0 = self.input.LA(1) | |
2892 | ||
2893 | if (LA17_0 == u'D' or LA17_0 == u'F' or LA17_0 == u'd' or LA17_0 == u'f') : | |
2894 | alt17 = 1 | |
2895 | if alt17 == 1: | |
2896 | # C.g:570:47: FloatTypeSuffix | |
2897 | self.mFloatTypeSuffix() | |
2898 | ||
2899 | ||
2900 | ||
2901 | ||
2902 | ||
2903 | ||
2904 | elif alt25 == 2: | |
2905 | # C.g:571:9: '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? | |
2906 | self.match(u'.') | |
2907 | ||
2908 | # C.g:571:13: ( '0' .. '9' )+ | |
2909 | cnt18 = 0 | |
2910 | while True: #loop18 | |
2911 | alt18 = 2 | |
2912 | LA18_0 = self.input.LA(1) | |
2913 | ||
2914 | if ((u'0' <= LA18_0 <= u'9')) : | |
2915 | alt18 = 1 | |
2916 | ||
2917 | ||
2918 | if alt18 == 1: | |
2919 | # C.g:571:14: '0' .. '9' | |
2920 | self.matchRange(u'0', u'9') | |
2921 | ||
2922 | ||
2923 | ||
2924 | else: | |
2925 | if cnt18 >= 1: | |
2926 | break #loop18 | |
2927 | ||
2928 | eee = EarlyExitException(18, self.input) | |
2929 | raise eee | |
2930 | ||
2931 | cnt18 += 1 | |
2932 | ||
2933 | ||
2934 | # C.g:571:25: ( Exponent )? | |
2935 | alt19 = 2 | |
2936 | LA19_0 = self.input.LA(1) | |
2937 | ||
2938 | if (LA19_0 == u'E' or LA19_0 == u'e') : | |
2939 | alt19 = 1 | |
2940 | if alt19 == 1: | |
2941 | # C.g:571:25: Exponent | |
2942 | self.mExponent() | |
2943 | ||
2944 | ||
2945 | ||
2946 | ||
2947 | # C.g:571:35: ( FloatTypeSuffix )? | |
2948 | alt20 = 2 | |
2949 | LA20_0 = self.input.LA(1) | |
2950 | ||
2951 | if (LA20_0 == u'D' or LA20_0 == u'F' or LA20_0 == u'd' or LA20_0 == u'f') : | |
2952 | alt20 = 1 | |
2953 | if alt20 == 1: | |
2954 | # C.g:571:35: FloatTypeSuffix | |
2955 | self.mFloatTypeSuffix() | |
2956 | ||
2957 | ||
2958 | ||
2959 | ||
2960 | ||
2961 | ||
2962 | elif alt25 == 3: | |
2963 | # C.g:572:9: ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? | |
2964 | # C.g:572:9: ( '0' .. '9' )+ | |
2965 | cnt21 = 0 | |
2966 | while True: #loop21 | |
2967 | alt21 = 2 | |
2968 | LA21_0 = self.input.LA(1) | |
2969 | ||
2970 | if ((u'0' <= LA21_0 <= u'9')) : | |
2971 | alt21 = 1 | |
2972 | ||
2973 | ||
2974 | if alt21 == 1: | |
2975 | # C.g:572:10: '0' .. '9' | |
2976 | self.matchRange(u'0', u'9') | |
2977 | ||
2978 | ||
2979 | ||
2980 | else: | |
2981 | if cnt21 >= 1: | |
2982 | break #loop21 | |
2983 | ||
2984 | eee = EarlyExitException(21, self.input) | |
2985 | raise eee | |
2986 | ||
2987 | cnt21 += 1 | |
2988 | ||
2989 | ||
2990 | self.mExponent() | |
2991 | ||
2992 | # C.g:572:30: ( FloatTypeSuffix )? | |
2993 | alt22 = 2 | |
2994 | LA22_0 = self.input.LA(1) | |
2995 | ||
2996 | if (LA22_0 == u'D' or LA22_0 == u'F' or LA22_0 == u'd' or LA22_0 == u'f') : | |
2997 | alt22 = 1 | |
2998 | if alt22 == 1: | |
2999 | # C.g:572:30: FloatTypeSuffix | |
3000 | self.mFloatTypeSuffix() | |
3001 | ||
3002 | ||
3003 | ||
3004 | ||
3005 | ||
3006 | ||
3007 | elif alt25 == 4: | |
3008 | # C.g:573:9: ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix | |
3009 | # C.g:573:9: ( '0' .. '9' )+ | |
3010 | cnt23 = 0 | |
3011 | while True: #loop23 | |
3012 | alt23 = 2 | |
3013 | LA23_0 = self.input.LA(1) | |
3014 | ||
3015 | if ((u'0' <= LA23_0 <= u'9')) : | |
3016 | alt23 = 1 | |
3017 | ||
3018 | ||
3019 | if alt23 == 1: | |
3020 | # C.g:573:10: '0' .. '9' | |
3021 | self.matchRange(u'0', u'9') | |
3022 | ||
3023 | ||
3024 | ||
3025 | else: | |
3026 | if cnt23 >= 1: | |
3027 | break #loop23 | |
3028 | ||
3029 | eee = EarlyExitException(23, self.input) | |
3030 | raise eee | |
3031 | ||
3032 | cnt23 += 1 | |
3033 | ||
3034 | ||
3035 | # C.g:573:21: ( Exponent )? | |
3036 | alt24 = 2 | |
3037 | LA24_0 = self.input.LA(1) | |
3038 | ||
3039 | if (LA24_0 == u'E' or LA24_0 == u'e') : | |
3040 | alt24 = 1 | |
3041 | if alt24 == 1: | |
3042 | # C.g:573:21: Exponent | |
3043 | self.mExponent() | |
3044 | ||
3045 | ||
3046 | ||
3047 | ||
3048 | self.mFloatTypeSuffix() | |
3049 | ||
3050 | ||
3051 | ||
3052 | ||
3053 | finally: | |
3054 | ||
3055 | pass | |
3056 | ||
3057 | # $ANTLR end FLOATING_POINT_LITERAL | |
3058 | ||
3059 | ||
3060 | ||
3061 | # $ANTLR start Exponent | |
3062 | def mExponent(self, ): | |
3063 | ||
3064 | try: | |
3065 | # C.g:577:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ ) | |
3066 | # C.g:577:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ | |
3067 | if self.input.LA(1) == u'E' or self.input.LA(1) == u'e': | |
3068 | self.input.consume(); | |
3069 | ||
3070 | else: | |
3071 | mse = MismatchedSetException(None, self.input) | |
3072 | self.recover(mse) | |
3073 | raise mse | |
3074 | ||
3075 | ||
3076 | # C.g:577:22: ( '+' | '-' )? | |
3077 | alt26 = 2 | |
3078 | LA26_0 = self.input.LA(1) | |
3079 | ||
3080 | if (LA26_0 == u'+' or LA26_0 == u'-') : | |
3081 | alt26 = 1 | |
3082 | if alt26 == 1: | |
3083 | # C.g: | |
3084 | if self.input.LA(1) == u'+' or self.input.LA(1) == u'-': | |
3085 | self.input.consume(); | |
3086 | ||
3087 | else: | |
3088 | mse = MismatchedSetException(None, self.input) | |
3089 | self.recover(mse) | |
3090 | raise mse | |
3091 | ||
3092 | ||
3093 | ||
3094 | ||
3095 | ||
3096 | # C.g:577:33: ( '0' .. '9' )+ | |
3097 | cnt27 = 0 | |
3098 | while True: #loop27 | |
3099 | alt27 = 2 | |
3100 | LA27_0 = self.input.LA(1) | |
3101 | ||
3102 | if ((u'0' <= LA27_0 <= u'9')) : | |
3103 | alt27 = 1 | |
3104 | ||
3105 | ||
3106 | if alt27 == 1: | |
3107 | # C.g:577:34: '0' .. '9' | |
3108 | self.matchRange(u'0', u'9') | |
3109 | ||
3110 | ||
3111 | ||
3112 | else: | |
3113 | if cnt27 >= 1: | |
3114 | break #loop27 | |
3115 | ||
3116 | eee = EarlyExitException(27, self.input) | |
3117 | raise eee | |
3118 | ||
3119 | cnt27 += 1 | |
3120 | ||
3121 | ||
3122 | ||
3123 | ||
3124 | ||
3125 | ||
3126 | finally: | |
3127 | ||
3128 | pass | |
3129 | ||
3130 | # $ANTLR end Exponent | |
3131 | ||
3132 | ||
3133 | ||
3134 | # $ANTLR start FloatTypeSuffix | |
3135 | def mFloatTypeSuffix(self, ): | |
3136 | ||
3137 | try: | |
3138 | # C.g:580:17: ( ( 'f' | 'F' | 'd' | 'D' ) ) | |
3139 | # C.g:580:19: ( 'f' | 'F' | 'd' | 'D' ) | |
3140 | if self.input.LA(1) == u'D' or self.input.LA(1) == u'F' or self.input.LA(1) == u'd' or self.input.LA(1) == u'f': | |
3141 | self.input.consume(); | |
3142 | ||
3143 | else: | |
3144 | mse = MismatchedSetException(None, self.input) | |
3145 | self.recover(mse) | |
3146 | raise mse | |
3147 | ||
3148 | ||
3149 | ||
3150 | ||
3151 | ||
3152 | ||
3153 | finally: | |
3154 | ||
3155 | pass | |
3156 | ||
3157 | # $ANTLR end FloatTypeSuffix | |
3158 | ||
3159 | ||
3160 | ||
3161 | # $ANTLR start EscapeSequence | |
3162 | def mEscapeSequence(self, ): | |
3163 | ||
3164 | try: | |
3165 | # C.g:584:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape ) | |
3166 | alt28 = 2 | |
3167 | LA28_0 = self.input.LA(1) | |
3168 | ||
3169 | if (LA28_0 == u'\\') : | |
3170 | LA28_1 = self.input.LA(2) | |
3171 | ||
3172 | if (LA28_1 == u'"' or LA28_1 == u'\'' or LA28_1 == u'\\' or LA28_1 == u'b' or LA28_1 == u'f' or LA28_1 == u'n' or LA28_1 == u'r' or LA28_1 == u't') : | |
3173 | alt28 = 1 | |
3174 | elif ((u'0' <= LA28_1 <= u'7')) : | |
3175 | alt28 = 2 | |
3176 | else: | |
3177 | nvae = NoViableAltException("582:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 1, self.input) | |
3178 | ||
3179 | raise nvae | |
3180 | ||
3181 | else: | |
3182 | nvae = NoViableAltException("582:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 0, self.input) | |
3183 | ||
3184 | raise nvae | |
3185 | ||
3186 | if alt28 == 1: | |
3187 | # C.g:584:8: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | |
3188 | self.match(u'\\') | |
3189 | ||
3190 | if self.input.LA(1) == u'"' or self.input.LA(1) == u'\'' or self.input.LA(1) == u'\\' or self.input.LA(1) == u'b' or self.input.LA(1) == u'f' or self.input.LA(1) == u'n' or self.input.LA(1) == u'r' or self.input.LA(1) == u't': | |
3191 | self.input.consume(); | |
3192 | ||
3193 | else: | |
3194 | mse = MismatchedSetException(None, self.input) | |
3195 | self.recover(mse) | |
3196 | raise mse | |
3197 | ||
3198 | ||
3199 | ||
3200 | ||
3201 | elif alt28 == 2: | |
3202 | # C.g:585:9: OctalEscape | |
3203 | self.mOctalEscape() | |
3204 | ||
3205 | ||
3206 | ||
3207 | ||
3208 | finally: | |
3209 | ||
3210 | pass | |
3211 | ||
3212 | # $ANTLR end EscapeSequence | |
3213 | ||
3214 | ||
3215 | ||
3216 | # $ANTLR start OctalEscape | |
3217 | def mOctalEscape(self, ): | |
3218 | ||
3219 | try: | |
3220 | # C.g:590:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ) | |
3221 | alt29 = 3 | |
3222 | LA29_0 = self.input.LA(1) | |
3223 | ||
3224 | if (LA29_0 == u'\\') : | |
3225 | LA29_1 = self.input.LA(2) | |
3226 | ||
3227 | if ((u'0' <= LA29_1 <= u'3')) : | |
3228 | LA29_2 = self.input.LA(3) | |
3229 | ||
3230 | if ((u'0' <= LA29_2 <= u'7')) : | |
3231 | LA29_4 = self.input.LA(4) | |
3232 | ||
3233 | if ((u'0' <= LA29_4 <= u'7')) : | |
3234 | alt29 = 1 | |
3235 | else: | |
3236 | alt29 = 2 | |
3237 | else: | |
3238 | alt29 = 3 | |
3239 | elif ((u'4' <= LA29_1 <= u'7')) : | |
3240 | LA29_3 = self.input.LA(3) | |
3241 | ||
3242 | if ((u'0' <= LA29_3 <= u'7')) : | |
3243 | alt29 = 2 | |
3244 | else: | |
3245 | alt29 = 3 | |
3246 | else: | |
3247 | nvae = NoViableAltException("588:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 1, self.input) | |
3248 | ||
3249 | raise nvae | |
3250 | ||
3251 | else: | |
3252 | nvae = NoViableAltException("588:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 0, self.input) | |
3253 | ||
3254 | raise nvae | |
3255 | ||
3256 | if alt29 == 1: | |
3257 | # C.g:590:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | |
3258 | self.match(u'\\') | |
3259 | ||
3260 | # C.g:590:14: ( '0' .. '3' ) | |
3261 | # C.g:590:15: '0' .. '3' | |
3262 | self.matchRange(u'0', u'3') | |
3263 | ||
3264 | ||
3265 | ||
3266 | ||
3267 | # C.g:590:25: ( '0' .. '7' ) | |
3268 | # C.g:590:26: '0' .. '7' | |
3269 | self.matchRange(u'0', u'7') | |
3270 | ||
3271 | ||
3272 | ||
3273 | ||
3274 | # C.g:590:36: ( '0' .. '7' ) | |
3275 | # C.g:590:37: '0' .. '7' | |
3276 | self.matchRange(u'0', u'7') | |
3277 | ||
3278 | ||
3279 | ||
3280 | ||
3281 | ||
3282 | ||
3283 | elif alt29 == 2: | |
3284 | # C.g:591:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | |
3285 | self.match(u'\\') | |
3286 | ||
3287 | # C.g:591:14: ( '0' .. '7' ) | |
3288 | # C.g:591:15: '0' .. '7' | |
3289 | self.matchRange(u'0', u'7') | |
3290 | ||
3291 | ||
3292 | ||
3293 | ||
3294 | # C.g:591:25: ( '0' .. '7' ) | |
3295 | # C.g:591:26: '0' .. '7' | |
3296 | self.matchRange(u'0', u'7') | |
3297 | ||
3298 | ||
3299 | ||
3300 | ||
3301 | ||
3302 | ||
3303 | elif alt29 == 3: | |
3304 | # C.g:592:9: '\\\\' ( '0' .. '7' ) | |
3305 | self.match(u'\\') | |
3306 | ||
3307 | # C.g:592:14: ( '0' .. '7' ) | |
3308 | # C.g:592:15: '0' .. '7' | |
3309 | self.matchRange(u'0', u'7') | |
3310 | ||
3311 | ||
3312 | ||
3313 | ||
3314 | ||
3315 | ||
3316 | ||
3317 | finally: | |
3318 | ||
3319 | pass | |
3320 | ||
3321 | # $ANTLR end OctalEscape | |
3322 | ||
3323 | ||
3324 | ||
3325 | # $ANTLR start UnicodeEscape | |
3326 | def mUnicodeEscape(self, ): | |
3327 | ||
3328 | try: | |
3329 | # C.g:597:5: ( '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit ) | |
3330 | # C.g:597:9: '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit | |
3331 | self.match(u'\\') | |
3332 | ||
3333 | self.match(u'u') | |
3334 | ||
3335 | self.mHexDigit() | |
3336 | ||
3337 | self.mHexDigit() | |
3338 | ||
3339 | self.mHexDigit() | |
3340 | ||
3341 | self.mHexDigit() | |
3342 | ||
3343 | ||
3344 | ||
3345 | ||
3346 | ||
3347 | finally: | |
3348 | ||
3349 | pass | |
3350 | ||
3351 | # $ANTLR end UnicodeEscape | |
3352 | ||
3353 | ||
3354 | ||
3355 | # $ANTLR start WS | |
3356 | def mWS(self, ): | |
3357 | ||
3358 | try: | |
3359 | self.type = WS | |
3360 | ||
3361 | # C.g:600:5: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) ) | |
3362 | # C.g:600:8: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) | |
3363 | if (u'\t' <= self.input.LA(1) <= u'\n') or (u'\f' <= self.input.LA(1) <= u'\r') or self.input.LA(1) == u' ': | |
3364 | self.input.consume(); | |
3365 | ||
3366 | else: | |
3367 | mse = MismatchedSetException(None, self.input) | |
3368 | self.recover(mse) | |
3369 | raise mse | |
3370 | ||
3371 | ||
3372 | #action start | |
3373 | self.channel=HIDDEN; | |
3374 | #action end | |
3375 | ||
3376 | ||
3377 | ||
3378 | ||
3379 | finally: | |
3380 | ||
3381 | pass | |
3382 | ||
3383 | # $ANTLR end WS | |
3384 | ||
3385 | ||
3386 | ||
3387 | # $ANTLR start BS | |
3388 | def mBS(self, ): | |
3389 | ||
3390 | try: | |
3391 | self.type = BS | |
3392 | ||
3393 | # C.g:604:5: ( ( '\\\\' ) ) | |
3394 | # C.g:604:7: ( '\\\\' ) | |
3395 | # C.g:604:7: ( '\\\\' ) | |
3396 | # C.g:604:8: '\\\\' | |
3397 | self.match(u'\\') | |
3398 | ||
3399 | ||
3400 | ||
3401 | ||
3402 | #action start | |
3403 | self.channel=HIDDEN; | |
3404 | #action end | |
3405 | ||
3406 | ||
3407 | ||
3408 | ||
3409 | finally: | |
3410 | ||
3411 | pass | |
3412 | ||
3413 | # $ANTLR end BS | |
3414 | ||
3415 | ||
3416 | ||
3417 | # $ANTLR start UnicodeVocabulary | |
3418 | def mUnicodeVocabulary(self, ): | |
3419 | ||
3420 | try: | |
3421 | self.type = UnicodeVocabulary | |
3422 | ||
3423 | # C.g:612:5: ( '\\u0003' .. '\\uFFFE' ) | |
3424 | # C.g:612:7: '\\u0003' .. '\\uFFFE' | |
3425 | self.matchRange(u'\u0003', u'\uFFFE') | |
3426 | ||
3427 | ||
3428 | ||
3429 | ||
3430 | ||
3431 | finally: | |
3432 | ||
3433 | pass | |
3434 | ||
3435 | # $ANTLR end UnicodeVocabulary | |
3436 | ||
3437 | ||
3438 | ||
3439 | # $ANTLR start COMMENT | |
3440 | def mCOMMENT(self, ): | |
3441 | ||
3442 | try: | |
3443 | self.type = COMMENT | |
3444 | ||
3445 | # C.g:615:5: ( '/*' ( options {greedy=false; } : . )* '*/' ) | |
3446 | # C.g:615:9: '/*' ( options {greedy=false; } : . )* '*/' | |
3447 | self.match("/*") | |
3448 | ||
3449 | ||
3450 | # C.g:615:14: ( options {greedy=false; } : . )* | |
3451 | while True: #loop30 | |
3452 | alt30 = 2 | |
3453 | LA30_0 = self.input.LA(1) | |
3454 | ||
3455 | if (LA30_0 == u'*') : | |
3456 | LA30_1 = self.input.LA(2) | |
3457 | ||
3458 | if (LA30_1 == u'/') : | |
3459 | alt30 = 2 | |
3460 | elif ((u'\u0000' <= LA30_1 <= u'.') or (u'0' <= LA30_1 <= u'\uFFFE')) : | |
3461 | alt30 = 1 | |
3462 | ||
3463 | ||
3464 | elif ((u'\u0000' <= LA30_0 <= u')') or (u'+' <= LA30_0 <= u'\uFFFE')) : | |
3465 | alt30 = 1 | |
3466 | ||
3467 | ||
3468 | if alt30 == 1: | |
3469 | # C.g:615:42: . | |
3470 | self.matchAny() | |
3471 | ||
3472 | ||
3473 | ||
3474 | else: | |
3475 | break #loop30 | |
3476 | ||
3477 | ||
3478 | self.match("*/") | |
3479 | ||
3480 | ||
3481 | #action start | |
3482 | self.channel=HIDDEN; | |
3483 | #action end | |
3484 | ||
3485 | ||
3486 | ||
3487 | ||
3488 | finally: | |
3489 | ||
3490 | pass | |
3491 | ||
3492 | # $ANTLR end COMMENT | |
3493 | ||
3494 | ||
3495 | ||
3496 | # $ANTLR start LINE_COMMENT | |
3497 | def mLINE_COMMENT(self, ): | |
3498 | ||
3499 | try: | |
3500 | self.type = LINE_COMMENT | |
3501 | ||
3502 | # C.g:620:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' ) | |
3503 | # C.g:620:7: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | |
3504 | self.match("//") | |
3505 | ||
3506 | ||
3507 | # C.g:620:12: (~ ( '\\n' | '\\r' ) )* | |
3508 | while True: #loop31 | |
3509 | alt31 = 2 | |
3510 | LA31_0 = self.input.LA(1) | |
3511 | ||
3512 | if ((u'\u0000' <= LA31_0 <= u'\t') or (u'\u000B' <= LA31_0 <= u'\f') or (u'\u000E' <= LA31_0 <= u'\uFFFE')) : | |
3513 | alt31 = 1 | |
3514 | ||
3515 | ||
3516 | if alt31 == 1: | |
3517 | # C.g:620:12: ~ ( '\\n' | '\\r' ) | |
3518 | if (u'\u0000' <= self.input.LA(1) <= u'\t') or (u'\u000B' <= self.input.LA(1) <= u'\f') or (u'\u000E' <= self.input.LA(1) <= u'\uFFFE'): | |
3519 | self.input.consume(); | |
3520 | ||
3521 | else: | |
3522 | mse = MismatchedSetException(None, self.input) | |
3523 | self.recover(mse) | |
3524 | raise mse | |
3525 | ||
3526 | ||
3527 | ||
3528 | ||
3529 | else: | |
3530 | break #loop31 | |
3531 | ||
3532 | ||
3533 | # C.g:620:26: ( '\\r' )? | |
3534 | alt32 = 2 | |
3535 | LA32_0 = self.input.LA(1) | |
3536 | ||
3537 | if (LA32_0 == u'\r') : | |
3538 | alt32 = 1 | |
3539 | if alt32 == 1: | |
3540 | # C.g:620:26: '\\r' | |
3541 | self.match(u'\r') | |
3542 | ||
3543 | ||
3544 | ||
3545 | ||
3546 | self.match(u'\n') | |
3547 | ||
3548 | #action start | |
3549 | self.channel=HIDDEN; | |
3550 | #action end | |
3551 | ||
3552 | ||
3553 | ||
3554 | ||
3555 | finally: | |
3556 | ||
3557 | pass | |
3558 | ||
3559 | # $ANTLR end LINE_COMMENT | |
3560 | ||
3561 | ||
3562 | ||
3563 | # $ANTLR start LINE_COMMAND | |
3564 | def mLINE_COMMAND(self, ): | |
3565 | ||
3566 | try: | |
3567 | self.type = LINE_COMMAND | |
3568 | ||
3569 | # C.g:625:5: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' ) | |
3570 | # C.g:625:7: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' | |
3571 | self.match(u'#') | |
3572 | ||
3573 | # C.g:625:11: (~ ( '\\n' | '\\r' ) )* | |
3574 | while True: #loop33 | |
3575 | alt33 = 2 | |
3576 | LA33_0 = self.input.LA(1) | |
3577 | ||
3578 | if ((u'\u0000' <= LA33_0 <= u'\t') or (u'\u000B' <= LA33_0 <= u'\f') or (u'\u000E' <= LA33_0 <= u'\uFFFE')) : | |
3579 | alt33 = 1 | |
3580 | ||
3581 | ||
3582 | if alt33 == 1: | |
3583 | # C.g:625:11: ~ ( '\\n' | '\\r' ) | |
3584 | if (u'\u0000' <= self.input.LA(1) <= u'\t') or (u'\u000B' <= self.input.LA(1) <= u'\f') or (u'\u000E' <= self.input.LA(1) <= u'\uFFFE'): | |
3585 | self.input.consume(); | |
3586 | ||
3587 | else: | |
3588 | mse = MismatchedSetException(None, self.input) | |
3589 | self.recover(mse) | |
3590 | raise mse | |
3591 | ||
3592 | ||
3593 | ||
3594 | ||
3595 | else: | |
3596 | break #loop33 | |
3597 | ||
3598 | ||
3599 | # C.g:625:25: ( '\\r' )? | |
3600 | alt34 = 2 | |
3601 | LA34_0 = self.input.LA(1) | |
3602 | ||
3603 | if (LA34_0 == u'\r') : | |
3604 | alt34 = 1 | |
3605 | if alt34 == 1: | |
3606 | # C.g:625:25: '\\r' | |
3607 | self.match(u'\r') | |
3608 | ||
3609 | ||
3610 | ||
3611 | ||
3612 | self.match(u'\n') | |
3613 | ||
3614 | #action start | |
3615 | self.channel=HIDDEN; | |
3616 | #action end | |
3617 | ||
3618 | ||
3619 | ||
3620 | ||
3621 | finally: | |
3622 | ||
3623 | pass | |
3624 | ||
3625 | # $ANTLR end LINE_COMMAND | |
3626 | ||
3627 | ||
3628 | ||
3629 | def mTokens(self): | |
3630 | # C.g:1:8: ( T25 | T26 | T27 | T28 | T29 | T30 | T31 | T32 | T33 | T34 | T35 | T36 | T37 | T38 | T39 | T40 | T41 | T42 | T43 | T44 | T45 | T46 | T47 | T48 | T49 | T50 | T51 | T52 | T53 | T54 | T55 | T56 | T57 | T58 | T59 | T60 | T61 | T62 | T63 | T64 | T65 | T66 | T67 | T68 | T69 | T70 | T71 | T72 | T73 | T74 | T75 | T76 | T77 | T78 | T79 | T80 | T81 | T82 | T83 | T84 | T85 | T86 | T87 | T88 | T89 | T90 | T91 | T92 | T93 | T94 | T95 | T96 | T97 | T98 | T99 | T100 | T101 | T102 | T103 | T104 | T105 | T106 | T107 | T108 | T109 | T110 | T111 | T112 | T113 | T114 | T115 | T116 | IDENTIFIER | CHARACTER_LITERAL | STRING_LITERAL | HEX_LITERAL | DECIMAL_LITERAL | OCTAL_LITERAL | FLOATING_POINT_LITERAL | WS | BS | UnicodeVocabulary | COMMENT | LINE_COMMENT | LINE_COMMAND ) | |
3631 | alt35 = 105 | |
3632 | alt35 = self.dfa35.predict(self.input) | |
3633 | if alt35 == 1: | |
3634 | # C.g:1:10: T25 | |
3635 | self.mT25() | |
3636 | ||
3637 | ||
3638 | ||
3639 | elif alt35 == 2: | |
3640 | # C.g:1:14: T26 | |
3641 | self.mT26() | |
3642 | ||
3643 | ||
3644 | ||
3645 | elif alt35 == 3: | |
3646 | # C.g:1:18: T27 | |
3647 | self.mT27() | |
3648 | ||
3649 | ||
3650 | ||
3651 | elif alt35 == 4: | |
3652 | # C.g:1:22: T28 | |
3653 | self.mT28() | |
3654 | ||
3655 | ||
3656 | ||
3657 | elif alt35 == 5: | |
3658 | # C.g:1:26: T29 | |
3659 | self.mT29() | |
3660 | ||
3661 | ||
3662 | ||
3663 | elif alt35 == 6: | |
3664 | # C.g:1:30: T30 | |
3665 | self.mT30() | |
3666 | ||
3667 | ||
3668 | ||
3669 | elif alt35 == 7: | |
3670 | # C.g:1:34: T31 | |
3671 | self.mT31() | |
3672 | ||
3673 | ||
3674 | ||
3675 | elif alt35 == 8: | |
3676 | # C.g:1:38: T32 | |
3677 | self.mT32() | |
3678 | ||
3679 | ||
3680 | ||
3681 | elif alt35 == 9: | |
3682 | # C.g:1:42: T33 | |
3683 | self.mT33() | |
3684 | ||
3685 | ||
3686 | ||
3687 | elif alt35 == 10: | |
3688 | # C.g:1:46: T34 | |
3689 | self.mT34() | |
3690 | ||
3691 | ||
3692 | ||
3693 | elif alt35 == 11: | |
3694 | # C.g:1:50: T35 | |
3695 | self.mT35() | |
3696 | ||
3697 | ||
3698 | ||
3699 | elif alt35 == 12: | |
3700 | # C.g:1:54: T36 | |
3701 | self.mT36() | |
3702 | ||
3703 | ||
3704 | ||
3705 | elif alt35 == 13: | |
3706 | # C.g:1:58: T37 | |
3707 | self.mT37() | |
3708 | ||
3709 | ||
3710 | ||
3711 | elif alt35 == 14: | |
3712 | # C.g:1:62: T38 | |
3713 | self.mT38() | |
3714 | ||
3715 | ||
3716 | ||
3717 | elif alt35 == 15: | |
3718 | # C.g:1:66: T39 | |
3719 | self.mT39() | |
3720 | ||
3721 | ||
3722 | ||
3723 | elif alt35 == 16: | |
3724 | # C.g:1:70: T40 | |
3725 | self.mT40() | |
3726 | ||
3727 | ||
3728 | ||
3729 | elif alt35 == 17: | |
3730 | # C.g:1:74: T41 | |
3731 | self.mT41() | |
3732 | ||
3733 | ||
3734 | ||
3735 | elif alt35 == 18: | |
3736 | # C.g:1:78: T42 | |
3737 | self.mT42() | |
3738 | ||
3739 | ||
3740 | ||
3741 | elif alt35 == 19: | |
3742 | # C.g:1:82: T43 | |
3743 | self.mT43() | |
3744 | ||
3745 | ||
3746 | ||
3747 | elif alt35 == 20: | |
3748 | # C.g:1:86: T44 | |
3749 | self.mT44() | |
3750 | ||
3751 | ||
3752 | ||
3753 | elif alt35 == 21: | |
3754 | # C.g:1:90: T45 | |
3755 | self.mT45() | |
3756 | ||
3757 | ||
3758 | ||
3759 | elif alt35 == 22: | |
3760 | # C.g:1:94: T46 | |
3761 | self.mT46() | |
3762 | ||
3763 | ||
3764 | ||
3765 | elif alt35 == 23: | |
3766 | # C.g:1:98: T47 | |
3767 | self.mT47() | |
3768 | ||
3769 | ||
3770 | ||
3771 | elif alt35 == 24: | |
3772 | # C.g:1:102: T48 | |
3773 | self.mT48() | |
3774 | ||
3775 | ||
3776 | ||
3777 | elif alt35 == 25: | |
3778 | # C.g:1:106: T49 | |
3779 | self.mT49() | |
3780 | ||
3781 | ||
3782 | ||
3783 | elif alt35 == 26: | |
3784 | # C.g:1:110: T50 | |
3785 | self.mT50() | |
3786 | ||
3787 | ||
3788 | ||
3789 | elif alt35 == 27: | |
3790 | # C.g:1:114: T51 | |
3791 | self.mT51() | |
3792 | ||
3793 | ||
3794 | ||
3795 | elif alt35 == 28: | |
3796 | # C.g:1:118: T52 | |
3797 | self.mT52() | |
3798 | ||
3799 | ||
3800 | ||
3801 | elif alt35 == 29: | |
3802 | # C.g:1:122: T53 | |
3803 | self.mT53() | |
3804 | ||
3805 | ||
3806 | ||
3807 | elif alt35 == 30: | |
3808 | # C.g:1:126: T54 | |
3809 | self.mT54() | |
3810 | ||
3811 | ||
3812 | ||
3813 | elif alt35 == 31: | |
3814 | # C.g:1:130: T55 | |
3815 | self.mT55() | |
3816 | ||
3817 | ||
3818 | ||
3819 | elif alt35 == 32: | |
3820 | # C.g:1:134: T56 | |
3821 | self.mT56() | |
3822 | ||
3823 | ||
3824 | ||
3825 | elif alt35 == 33: | |
3826 | # C.g:1:138: T57 | |
3827 | self.mT57() | |
3828 | ||
3829 | ||
3830 | ||
3831 | elif alt35 == 34: | |
3832 | # C.g:1:142: T58 | |
3833 | self.mT58() | |
3834 | ||
3835 | ||
3836 | ||
3837 | elif alt35 == 35: | |
3838 | # C.g:1:146: T59 | |
3839 | self.mT59() | |
3840 | ||
3841 | ||
3842 | ||
3843 | elif alt35 == 36: | |
3844 | # C.g:1:150: T60 | |
3845 | self.mT60() | |
3846 | ||
3847 | ||
3848 | ||
3849 | elif alt35 == 37: | |
3850 | # C.g:1:154: T61 | |
3851 | self.mT61() | |
3852 | ||
3853 | ||
3854 | ||
3855 | elif alt35 == 38: | |
3856 | # C.g:1:158: T62 | |
3857 | self.mT62() | |
3858 | ||
3859 | ||
3860 | ||
3861 | elif alt35 == 39: | |
3862 | # C.g:1:162: T63 | |
3863 | self.mT63() | |
3864 | ||
3865 | ||
3866 | ||
3867 | elif alt35 == 40: | |
3868 | # C.g:1:166: T64 | |
3869 | self.mT64() | |
3870 | ||
3871 | ||
3872 | ||
3873 | elif alt35 == 41: | |
3874 | # C.g:1:170: T65 | |
3875 | self.mT65() | |
3876 | ||
3877 | ||
3878 | ||
3879 | elif alt35 == 42: | |
3880 | # C.g:1:174: T66 | |
3881 | self.mT66() | |
3882 | ||
3883 | ||
3884 | ||
3885 | elif alt35 == 43: | |
3886 | # C.g:1:178: T67 | |
3887 | self.mT67() | |
3888 | ||
3889 | ||
3890 | ||
3891 | elif alt35 == 44: | |
3892 | # C.g:1:182: T68 | |
3893 | self.mT68() | |
3894 | ||
3895 | ||
3896 | ||
3897 | elif alt35 == 45: | |
3898 | # C.g:1:186: T69 | |
3899 | self.mT69() | |
3900 | ||
3901 | ||
3902 | ||
3903 | elif alt35 == 46: | |
3904 | # C.g:1:190: T70 | |
3905 | self.mT70() | |
3906 | ||
3907 | ||
3908 | ||
3909 | elif alt35 == 47: | |
3910 | # C.g:1:194: T71 | |
3911 | self.mT71() | |
3912 | ||
3913 | ||
3914 | ||
3915 | elif alt35 == 48: | |
3916 | # C.g:1:198: T72 | |
3917 | self.mT72() | |
3918 | ||
3919 | ||
3920 | ||
3921 | elif alt35 == 49: | |
3922 | # C.g:1:202: T73 | |
3923 | self.mT73() | |
3924 | ||
3925 | ||
3926 | ||
3927 | elif alt35 == 50: | |
3928 | # C.g:1:206: T74 | |
3929 | self.mT74() | |
3930 | ||
3931 | ||
3932 | ||
3933 | elif alt35 == 51: | |
3934 | # C.g:1:210: T75 | |
3935 | self.mT75() | |
3936 | ||
3937 | ||
3938 | ||
3939 | elif alt35 == 52: | |
3940 | # C.g:1:214: T76 | |
3941 | self.mT76() | |
3942 | ||
3943 | ||
3944 | ||
3945 | elif alt35 == 53: | |
3946 | # C.g:1:218: T77 | |
3947 | self.mT77() | |
3948 | ||
3949 | ||
3950 | ||
3951 | elif alt35 == 54: | |
3952 | # C.g:1:222: T78 | |
3953 | self.mT78() | |
3954 | ||
3955 | ||
3956 | ||
3957 | elif alt35 == 55: | |
3958 | # C.g:1:226: T79 | |
3959 | self.mT79() | |
3960 | ||
3961 | ||
3962 | ||
3963 | elif alt35 == 56: | |
3964 | # C.g:1:230: T80 | |
3965 | self.mT80() | |
3966 | ||
3967 | ||
3968 | ||
3969 | elif alt35 == 57: | |
3970 | # C.g:1:234: T81 | |
3971 | self.mT81() | |
3972 | ||
3973 | ||
3974 | ||
3975 | elif alt35 == 58: | |
3976 | # C.g:1:238: T82 | |
3977 | self.mT82() | |
3978 | ||
3979 | ||
3980 | ||
3981 | elif alt35 == 59: | |
3982 | # C.g:1:242: T83 | |
3983 | self.mT83() | |
3984 | ||
3985 | ||
3986 | ||
3987 | elif alt35 == 60: | |
3988 | # C.g:1:246: T84 | |
3989 | self.mT84() | |
3990 | ||
3991 | ||
3992 | ||
3993 | elif alt35 == 61: | |
3994 | # C.g:1:250: T85 | |
3995 | self.mT85() | |
3996 | ||
3997 | ||
3998 | ||
3999 | elif alt35 == 62: | |
4000 | # C.g:1:254: T86 | |
4001 | self.mT86() | |
4002 | ||
4003 | ||
4004 | ||
4005 | elif alt35 == 63: | |
4006 | # C.g:1:258: T87 | |
4007 | self.mT87() | |
4008 | ||
4009 | ||
4010 | ||
4011 | elif alt35 == 64: | |
4012 | # C.g:1:262: T88 | |
4013 | self.mT88() | |
4014 | ||
4015 | ||
4016 | ||
4017 | elif alt35 == 65: | |
4018 | # C.g:1:266: T89 | |
4019 | self.mT89() | |
4020 | ||
4021 | ||
4022 | ||
4023 | elif alt35 == 66: | |
4024 | # C.g:1:270: T90 | |
4025 | self.mT90() | |
4026 | ||
4027 | ||
4028 | ||
4029 | elif alt35 == 67: | |
4030 | # C.g:1:274: T91 | |
4031 | self.mT91() | |
4032 | ||
4033 | ||
4034 | ||
4035 | elif alt35 == 68: | |
4036 | # C.g:1:278: T92 | |
4037 | self.mT92() | |
4038 | ||
4039 | ||
4040 | ||
4041 | elif alt35 == 69: | |
4042 | # C.g:1:282: T93 | |
4043 | self.mT93() | |
4044 | ||
4045 | ||
4046 | ||
4047 | elif alt35 == 70: | |
4048 | # C.g:1:286: T94 | |
4049 | self.mT94() | |
4050 | ||
4051 | ||
4052 | ||
4053 | elif alt35 == 71: | |
4054 | # C.g:1:290: T95 | |
4055 | self.mT95() | |
4056 | ||
4057 | ||
4058 | ||
4059 | elif alt35 == 72: | |
4060 | # C.g:1:294: T96 | |
4061 | self.mT96() | |
4062 | ||
4063 | ||
4064 | ||
4065 | elif alt35 == 73: | |
4066 | # C.g:1:298: T97 | |
4067 | self.mT97() | |
4068 | ||
4069 | ||
4070 | ||
4071 | elif alt35 == 74: | |
4072 | # C.g:1:302: T98 | |
4073 | self.mT98() | |
4074 | ||
4075 | ||
4076 | ||
4077 | elif alt35 == 75: | |
4078 | # C.g:1:306: T99 | |
4079 | self.mT99() | |
4080 | ||
4081 | ||
4082 | ||
4083 | elif alt35 == 76: | |
4084 | # C.g:1:310: T100 | |
4085 | self.mT100() | |
4086 | ||
4087 | ||
4088 | ||
4089 | elif alt35 == 77: | |
4090 | # C.g:1:315: T101 | |
4091 | self.mT101() | |
4092 | ||
4093 | ||
4094 | ||
4095 | elif alt35 == 78: | |
4096 | # C.g:1:320: T102 | |
4097 | self.mT102() | |
4098 | ||
4099 | ||
4100 | ||
4101 | elif alt35 == 79: | |
4102 | # C.g:1:325: T103 | |
4103 | self.mT103() | |
4104 | ||
4105 | ||
4106 | ||
4107 | elif alt35 == 80: | |
4108 | # C.g:1:330: T104 | |
4109 | self.mT104() | |
4110 | ||
4111 | ||
4112 | ||
4113 | elif alt35 == 81: | |
4114 | # C.g:1:335: T105 | |
4115 | self.mT105() | |
4116 | ||
4117 | ||
4118 | ||
4119 | elif alt35 == 82: | |
4120 | # C.g:1:340: T106 | |
4121 | self.mT106() | |
4122 | ||
4123 | ||
4124 | ||
4125 | elif alt35 == 83: | |
4126 | # C.g:1:345: T107 | |
4127 | self.mT107() | |
4128 | ||
4129 | ||
4130 | ||
4131 | elif alt35 == 84: | |
4132 | # C.g:1:350: T108 | |
4133 | self.mT108() | |
4134 | ||
4135 | ||
4136 | ||
4137 | elif alt35 == 85: | |
4138 | # C.g:1:355: T109 | |
4139 | self.mT109() | |
4140 | ||
4141 | ||
4142 | ||
4143 | elif alt35 == 86: | |
4144 | # C.g:1:360: T110 | |
4145 | self.mT110() | |
4146 | ||
4147 | ||
4148 | ||
4149 | elif alt35 == 87: | |
4150 | # C.g:1:365: T111 | |
4151 | self.mT111() | |
4152 | ||
4153 | ||
4154 | ||
4155 | elif alt35 == 88: | |
4156 | # C.g:1:370: T112 | |
4157 | self.mT112() | |
4158 | ||
4159 | ||
4160 | ||
4161 | elif alt35 == 89: | |
4162 | # C.g:1:375: T113 | |
4163 | self.mT113() | |
4164 | ||
4165 | ||
4166 | ||
4167 | elif alt35 == 90: | |
4168 | # C.g:1:380: T114 | |
4169 | self.mT114() | |
4170 | ||
4171 | ||
4172 | ||
4173 | elif alt35 == 91: | |
4174 | # C.g:1:385: T115 | |
4175 | self.mT115() | |
4176 | ||
4177 | ||
4178 | ||
4179 | elif alt35 == 92: | |
4180 | # C.g:1:390: T116 | |
4181 | self.mT116() | |
4182 | ||
4183 | ||
4184 | ||
4185 | elif alt35 == 93: | |
4186 | # C.g:1:395: IDENTIFIER | |
4187 | self.mIDENTIFIER() | |
4188 | ||
4189 | ||
4190 | ||
4191 | elif alt35 == 94: | |
4192 | # C.g:1:406: CHARACTER_LITERAL | |
4193 | self.mCHARACTER_LITERAL() | |
4194 | ||
4195 | ||
4196 | ||
4197 | elif alt35 == 95: | |
4198 | # C.g:1:424: STRING_LITERAL | |
4199 | self.mSTRING_LITERAL() | |
4200 | ||
4201 | ||
4202 | ||
4203 | elif alt35 == 96: | |
4204 | # C.g:1:439: HEX_LITERAL | |
4205 | self.mHEX_LITERAL() | |
4206 | ||
4207 | ||
4208 | ||
4209 | elif alt35 == 97: | |
4210 | # C.g:1:451: DECIMAL_LITERAL | |
4211 | self.mDECIMAL_LITERAL() | |
4212 | ||
4213 | ||
4214 | ||
4215 | elif alt35 == 98: | |
4216 | # C.g:1:467: OCTAL_LITERAL | |
4217 | self.mOCTAL_LITERAL() | |
4218 | ||
4219 | ||
4220 | ||
4221 | elif alt35 == 99: | |
4222 | # C.g:1:481: FLOATING_POINT_LITERAL | |
4223 | self.mFLOATING_POINT_LITERAL() | |
4224 | ||
4225 | ||
4226 | ||
4227 | elif alt35 == 100: | |
4228 | # C.g:1:504: WS | |
4229 | self.mWS() | |
4230 | ||
4231 | ||
4232 | ||
4233 | elif alt35 == 101: | |
4234 | # C.g:1:507: BS | |
4235 | self.mBS() | |
4236 | ||
4237 | ||
4238 | ||
4239 | elif alt35 == 102: | |
4240 | # C.g:1:510: UnicodeVocabulary | |
4241 | self.mUnicodeVocabulary() | |
4242 | ||
4243 | ||
4244 | ||
4245 | elif alt35 == 103: | |
4246 | # C.g:1:528: COMMENT | |
4247 | self.mCOMMENT() | |
4248 | ||
4249 | ||
4250 | ||
4251 | elif alt35 == 104: | |
4252 | # C.g:1:536: LINE_COMMENT | |
4253 | self.mLINE_COMMENT() | |
4254 | ||
4255 | ||
4256 | ||
4257 | elif alt35 == 105: | |
4258 | # C.g:1:549: LINE_COMMAND | |
4259 | self.mLINE_COMMAND() | |
4260 | ||
4261 | ||
4262 | ||
4263 | ||
4264 | ||
4265 | ||
4266 | ||
4267 | ||
4268 | # lookup tables for DFA #25 | |
4269 | ||
4270 | DFA25_eot = DFA.unpack( | |
4271 | u"\7\uffff\1\10\2\uffff" | |
4272 | ) | |
4273 | ||
4274 | DFA25_eof = DFA.unpack( | |
4275 | u"\12\uffff" | |
4276 | ) | |
4277 | ||
4278 | DFA25_min = DFA.unpack( | |
4279 | u"\2\56\1\uffff\1\53\2\uffff\2\60\2\uffff" | |
4280 | ) | |
4281 | ||
4282 | DFA25_max = DFA.unpack( | |
4283 | u"\1\71\1\146\1\uffff\1\71\2\uffff\1\71\1\146\2\uffff" | |
4284 | ) | |
4285 | ||
4286 | DFA25_accept = DFA.unpack( | |
4287 | u"\2\uffff\1\2\1\uffff\1\4\1\1\2\uffff\2\3" | |
4288 | ) | |
4289 | ||
4290 | DFA25_special = DFA.unpack( | |
4291 | u"\12\uffff" | |
4292 | ) | |
4293 | ||
4294 | ||
4295 | DFA25_transition = [ | |
4296 | DFA.unpack(u"\1\2\1\uffff\12\1"), | |
4297 | DFA.unpack(u"\1\5\1\uffff\12\1\12\uffff\1\4\1\3\1\4\35\uffff\1\4" | |
4298 | u"\1\3\1\4"), | |
4299 | DFA.unpack(u""), | |
4300 | DFA.unpack(u"\1\6\1\uffff\1\6\2\uffff\12\7"), | |
4301 | DFA.unpack(u""), | |
4302 | DFA.unpack(u""), | |
4303 | DFA.unpack(u"\12\7"), | |
4304 | DFA.unpack(u"\12\7\12\uffff\1\11\1\uffff\1\11\35\uffff\1\11\1\uffff" | |
4305 | u"\1\11"), | |
4306 | DFA.unpack(u""), | |
4307 | DFA.unpack(u"") | |
4308 | ] | |
4309 | ||
4310 | # class definition for DFA #25 | |
4311 | ||
4312 | DFA25 = DFA | |
4313 | # lookup tables for DFA #35 | |
4314 | ||
4315 | DFA35_eot = DFA.unpack( | |
4316 | u"\2\uffff\1\75\1\uffff\1\100\14\75\3\uffff\7\75\4\uffff\1\147\1" | |
4317 | u"\151\1\155\1\161\1\165\1\167\1\172\1\uffff\1\175\1\u0080\1\u0083" | |
4318 | u"\1\u0085\1\u0088\1\uffff\5\75\1\uffff\2\72\2\u0092\2\uffff\1\72" | |
4319 | u"\2\uffff\1\75\4\uffff\16\75\1\u00ab\4\75\1\u00b1\2\75\3\uffff\1" | |
4320 | u"\u00b5\7\75\35\uffff\1\u00be\1\uffff\1\u00c0\10\uffff\5\75\4\uffff" | |
4321 | u"\1\u00c6\1\u0092\3\uffff\23\75\1\uffff\1\u00db\1\75\1\u00dd\2\75" | |
4322 | u"\1\uffff\3\75\1\uffff\1\u00e3\6\75\4\uffff\5\75\1\uffff\1\75\1" | |
4323 | u"\u00f1\1\u00f2\7\75\1\u00fa\3\75\1\u00fe\3\75\1\u0102\1\u0103\1" | |
4324 | u"\uffff\1\u0104\1\uffff\5\75\1\uffff\10\75\1\u0113\1\75\1\u0115" | |
4325 | u"\2\75\2\uffff\6\75\1\u011e\1\uffff\3\75\1\uffff\2\75\1\u0124\3" | |
4326 | u"\uffff\1\u0125\3\75\1\u0129\1\75\1\u012b\6\75\1\u0133\1\uffff\1" | |
4327 | u"\u0134\1\uffff\1\u0135\1\75\1\u0137\1\u0138\1\u0139\1\u013a\1\u013b" | |
4328 | u"\1\u013c\1\uffff\1\75\1\u013e\1\u013f\2\75\2\uffff\1\u0142\2\75" | |
4329 | u"\1\uffff\1\75\1\uffff\5\75\1\u014b\1\75\3\uffff\1\u014d\6\uffff" | |
4330 | u"\1\75\2\uffff\2\75\1\uffff\1\u0151\7\75\1\uffff\1\u0159\1\uffff" | |
4331 | u"\1\u015a\1\u015b\1\u015c\1\uffff\1\u015d\1\u015e\1\75\1\u0160\3" | |
4332 | u"\75\6\uffff\1\u0164\1\uffff\3\75\1\uffff\20\75\1\u0178\2\75\1\uffff" | |
4333 | u"\4\75\1\u017f\1\75\1\uffff\11\75\1\u018a\1\uffff" | |
4334 | ) | |
4335 | ||
4336 | DFA35_eof = DFA.unpack( | |
4337 | u"\u018b\uffff" | |
4338 | ) | |
4339 | ||
4340 | DFA35_min = DFA.unpack( | |
4341 | u"\1\3\1\uffff\1\171\1\uffff\1\75\1\154\1\150\1\165\1\145\1\124\1" | |
4342 | u"\157\1\141\1\146\1\157\1\154\1\145\1\156\3\uffff\1\116\1\120\1" | |
4343 | u"\117\1\116\1\117\1\114\1\106\4\uffff\1\75\1\56\1\53\1\55\1\52\1" | |
4344 | u"\75\1\46\1\uffff\1\75\1\74\3\75\1\uffff\1\137\1\150\1\157\1\162" | |
4345 | u"\1\42\1\uffff\2\0\2\56\2\uffff\1\0\2\uffff\1\160\4\uffff\1\165" | |
4346 | u"\1\163\1\164\1\141\1\151\1\147\1\157\1\164\1\147\1\101\1\151\1" | |
4347 | u"\156\1\163\1\141\1\44\1\164\1\156\1\162\1\157\1\44\1\146\1\151" | |
4348 | u"\3\uffff\1\44\2\124\1\116\1\101\1\114\1\117\1\111\35\uffff\1\75" | |
4349 | u"\1\uffff\1\75\10\uffff\1\141\1\163\1\151\1\164\1\145\4\uffff\2" | |
4350 | u"\56\3\uffff\1\145\1\155\2\145\1\165\2\164\1\156\1\145\1\162\1\157" | |
4351 | u"\1\151\1\165\1\124\1\144\1\141\1\163\1\145\1\162\1\uffff\1\44\1" | |
4352 | u"\147\1\44\1\141\1\142\1\uffff\1\141\1\151\1\157\1\uffff\1\44\1" | |
4353 | u"\111\1\123\1\114\1\101\1\102\1\101\4\uffff\1\163\1\155\1\154\1" | |
4354 | u"\157\1\141\1\uffff\1\144\2\44\1\162\1\143\1\151\1\143\1\145\1\157" | |
4355 | u"\1\164\1\44\1\163\1\162\1\111\1\44\1\164\1\151\1\164\2\44\1\uffff" | |
4356 | u"\1\44\1\uffff\1\164\1\154\1\165\1\147\1\156\1\uffff\1\117\1\124" | |
4357 | u"\1\111\1\124\1\101\1\102\1\120\1\155\1\44\1\145\1\44\1\153\1\145" | |
4358 | u"\2\uffff\1\156\1\164\1\143\1\150\1\144\1\146\1\44\1\uffff\1\164" | |
4359 | u"\1\156\1\103\1\uffff\1\151\1\156\1\44\3\uffff\1\44\1\145\1\154" | |
4360 | u"\1\156\1\44\1\116\1\44\1\107\1\111\1\114\1\117\1\125\1\111\1\44" | |
4361 | u"\1\uffff\1\44\1\uffff\1\44\1\146\6\44\1\uffff\1\145\2\44\1\154" | |
4362 | u"\1\165\2\uffff\1\44\1\164\1\145\1\uffff\1\101\1\uffff\1\116\1\114" | |
4363 | u"\1\137\1\117\1\116\1\44\1\137\3\uffff\1\44\6\uffff\1\162\2\uffff" | |
4364 | u"\2\145\1\uffff\1\44\1\144\1\114\2\105\1\122\2\124\1\uffff\1\44" | |
4365 | u"\1\uffff\3\44\1\uffff\2\44\1\104\1\44\1\105\1\123\1\111\6\uffff" | |
4366 | u"\1\44\1\uffff\1\115\1\105\1\115\1\uffff\1\117\1\122\1\105\2\126" | |
4367 | u"\1\123\1\105\1\111\1\105\1\137\1\103\1\122\1\111\1\105\1\126\1" | |
4368 | u"\106\1\44\1\111\1\137\1\uffff\1\103\1\125\1\105\1\116\1\44\1\122" | |
4369 | u"\1\uffff\1\105\1\106\1\105\1\122\1\105\1\116\1\103\1\105\1\104" | |
4370 | u"\1\44\1\uffff" | |
4371 | ) | |
4372 | ||
4373 | DFA35_max = DFA.unpack( | |
4374 | u"\1\ufffe\1\uffff\1\171\1\uffff\1\75\1\170\1\167\1\165\1\145\1\124" | |
4375 | u"\2\157\1\156\3\157\1\156\3\uffff\1\116\1\125\1\117\1\116\1\117" | |
4376 | u"\1\114\1\106\4\uffff\1\75\1\71\1\75\1\76\3\75\1\uffff\2\75\1\76" | |
4377 | u"\1\75\1\174\1\uffff\1\141\1\150\1\157\1\162\1\47\1\uffff\2\ufffe" | |
4378 | u"\1\170\1\146\2\uffff\1\ufffe\2\uffff\1\160\4\uffff\1\165\1\163" | |
4379 | u"\1\164\1\162\1\151\1\172\1\157\2\164\1\101\1\154\1\156\1\163\1" | |
4380 | u"\141\1\172\1\164\1\156\1\162\1\157\1\172\1\146\1\163\3\uffff\1" | |
4381 | u"\172\2\124\1\116\1\101\1\114\1\117\1\111\35\uffff\1\75\1\uffff" | |
4382 | u"\1\75\10\uffff\1\141\1\163\1\151\1\164\1\145\4\uffff\2\146\3\uffff" | |
4383 | u"\1\145\1\155\2\145\1\165\2\164\1\156\1\145\1\162\1\157\1\151\1" | |
4384 | u"\165\1\124\1\144\1\141\1\164\1\145\1\162\1\uffff\1\172\1\147\1" | |
4385 | u"\172\1\141\1\142\1\uffff\1\141\1\151\1\157\1\uffff\1\172\1\111" | |
4386 | u"\1\123\1\114\1\101\1\102\1\137\4\uffff\1\163\1\155\1\154\1\157" | |
4387 | u"\1\141\1\uffff\1\144\2\172\1\162\1\143\1\151\1\143\1\145\1\157" | |
4388 | u"\1\164\1\172\1\163\1\162\1\111\1\172\1\164\1\151\1\164\2\172\1" | |
4389 | u"\uffff\1\172\1\uffff\1\164\1\154\1\165\1\147\1\156\1\uffff\1\117" | |
4390 | u"\1\124\1\111\1\124\1\101\1\122\1\120\1\155\1\172\1\145\1\172\1" | |
4391 | u"\153\1\145\2\uffff\1\156\1\164\1\143\1\150\1\144\1\146\1\172\1" | |
4392 | u"\uffff\1\164\1\156\1\103\1\uffff\1\151\1\156\1\172\3\uffff\1\172" | |
4393 | u"\1\145\1\154\1\156\1\172\1\116\1\172\1\107\1\111\1\114\1\117\1" | |
4394 | u"\125\1\111\1\172\1\uffff\1\172\1\uffff\1\172\1\146\6\172\1\uffff" | |
4395 | u"\1\145\2\172\1\154\1\165\2\uffff\1\172\1\164\1\145\1\uffff\1\101" | |
4396 | u"\1\uffff\1\116\1\114\1\137\1\117\1\116\1\172\1\137\3\uffff\1\172" | |
4397 | u"\6\uffff\1\162\2\uffff\2\145\1\uffff\1\172\1\144\1\114\2\105\1" | |
4398 | u"\122\2\124\1\uffff\1\172\1\uffff\3\172\1\uffff\2\172\1\104\1\172" | |
4399 | u"\1\105\1\123\1\111\6\uffff\1\172\1\uffff\1\115\1\105\1\115\1\uffff" | |
4400 | u"\1\117\1\122\1\105\2\126\1\123\1\105\1\111\1\105\1\137\1\103\1" | |
4401 | u"\122\1\111\1\105\1\126\1\106\1\172\1\111\1\137\1\uffff\1\103\1" | |
4402 | u"\125\1\105\1\116\1\172\1\122\1\uffff\1\105\1\106\1\105\1\122\1" | |
4403 | u"\105\1\116\1\103\1\105\1\104\1\172\1\uffff" | |
4404 | ) | |
4405 | ||
4406 | DFA35_accept = DFA.unpack( | |
4407 | u"\1\uffff\1\1\1\uffff\1\3\15\uffff\1\23\1\24\1\27\7\uffff\1\45\1" | |
4408 | u"\46\1\47\1\50\7\uffff\1\65\5\uffff\1\101\5\uffff\1\135\4\uffff" | |
4409 | u"\1\144\1\145\1\uffff\1\146\1\1\1\uffff\1\135\1\3\1\106\1\4\26\uffff" | |
4410 | u"\1\23\1\24\1\27\10\uffff\1\45\1\46\1\47\1\50\1\67\1\51\1\52\1\62" | |
4411 | u"\1\143\1\57\1\72\1\53\1\63\1\73\1\60\1\54\1\70\1\150\1\147\1\55" | |
4412 | u"\1\71\1\56\1\76\1\103\1\64\1\65\1\107\1\66\1\112\1\uffff\1\110" | |
4413 | u"\1\uffff\1\113\1\111\1\77\1\105\1\100\1\102\1\104\1\101\5\uffff" | |
4414 | u"\1\136\1\137\1\140\1\141\2\uffff\1\144\1\145\1\151\23\uffff\1\123" | |
4415 | u"\5\uffff\1\127\3\uffff\1\33\7\uffff\1\74\1\114\1\75\1\115\5\uffff" | |
4416 | u"\1\142\24\uffff\1\15\1\uffff\1\130\5\uffff\1\34\15\uffff\1\30\1" | |
4417 | u"\124\7\uffff\1\7\3\uffff\1\12\3\uffff\1\121\1\13\1\16\16\uffff" | |
4418 | u"\1\117\1\uffff\1\131\10\uffff\1\14\5\uffff\1\31\1\17\3\uffff\1" | |
4419 | u"\26\1\uffff\1\36\7\uffff\1\120\1\126\1\133\1\uffff\1\5\1\25\1\6" | |
4420 | u"\1\125\1\21\1\61\1\uffff\1\134\1\11\2\uffff\1\20\10\uffff\1\42" | |
4421 | u"\1\uffff\1\2\3\uffff\1\122\7\uffff\1\116\1\10\1\32\1\132\1\22\1" | |
4422 | u"\35\1\uffff\1\40\3\uffff\1\37\23\uffff\1\43\6\uffff\1\44\12\uffff" | |
4423 | u"\1\41" | |
4424 | ) | |
4425 | ||
4426 | DFA35_special = DFA.unpack( | |
4427 | u"\u018b\uffff" | |
4428 | ) | |
4429 | ||
4430 | ||
4431 | DFA35_transition = [ | |
4432 | DFA.unpack(u"\6\72\2\67\1\72\2\67\22\72\1\67\1\47\1\64\1\71\1\62" | |
4433 | u"\1\44\1\45\1\63\1\33\1\34\1\37\1\41\1\3\1\42\1\40\1\43\1\65\11" | |
4434 | u"\66\1\23\1\1\1\50\1\4\1\51\1\54\1\72\2\62\1\26\1\62\1\32\1\62\1" | |
4435 | u"\31\1\62\1\24\2\62\1\61\2\62\1\25\3\62\1\11\1\62\1\27\1\30\4\62" | |
4436 | u"\1\35\1\70\1\36\1\52\1\55\1\72\1\7\1\60\1\13\1\17\1\5\1\16\1\57" | |
4437 | u"\1\62\1\14\2\62\1\15\5\62\1\10\1\6\1\2\1\20\1\12\1\56\3\62\1\21" | |
4438 | u"\1\53\1\22\1\46\uff80\72"), | |
4439 | DFA.unpack(u""), | |
4440 | DFA.unpack(u"\1\74"), | |
4441 | DFA.unpack(u""), | |
4442 | DFA.unpack(u"\1\77"), | |
4443 | DFA.unpack(u"\1\102\1\uffff\1\101\11\uffff\1\103"), | |
4444 | DFA.unpack(u"\1\107\1\106\12\uffff\1\104\2\uffff\1\105"), | |
4445 | DFA.unpack(u"\1\110"), | |
4446 | DFA.unpack(u"\1\111"), | |
4447 | DFA.unpack(u"\1\112"), | |
4448 | DFA.unpack(u"\1\113"), | |
4449 | DFA.unpack(u"\1\115\6\uffff\1\116\6\uffff\1\114"), | |
4450 | DFA.unpack(u"\1\117\7\uffff\1\120"), | |
4451 | DFA.unpack(u"\1\121"), | |
4452 | DFA.unpack(u"\1\123\2\uffff\1\122"), | |
4453 | DFA.unpack(u"\1\125\11\uffff\1\124"), | |
4454 | DFA.unpack(u"\1\126"), | |
4455 | DFA.unpack(u""), | |
4456 | DFA.unpack(u""), | |
4457 | DFA.unpack(u""), | |
4458 | DFA.unpack(u"\1\132"), | |
4459 | DFA.unpack(u"\1\134\4\uffff\1\133"), | |
4460 | DFA.unpack(u"\1\135"), | |
4461 | DFA.unpack(u"\1\136"), | |
4462 | DFA.unpack(u"\1\137"), | |
4463 | DFA.unpack(u"\1\140"), | |
4464 | DFA.unpack(u"\1\141"), | |
4465 | DFA.unpack(u""), | |
4466 | DFA.unpack(u""), | |
4467 | DFA.unpack(u""), | |
4468 | DFA.unpack(u""), | |
4469 | DFA.unpack(u"\1\146"), | |
4470 | DFA.unpack(u"\1\150\1\uffff\12\152"), | |
4471 | DFA.unpack(u"\1\153\21\uffff\1\154"), | |
4472 | DFA.unpack(u"\1\160\17\uffff\1\157\1\156"), | |
4473 | DFA.unpack(u"\1\164\4\uffff\1\163\15\uffff\1\162"), | |
4474 | DFA.unpack(u"\1\166"), | |
4475 | DFA.unpack(u"\1\171\26\uffff\1\170"), | |
4476 | DFA.unpack(u""), | |
4477 | DFA.unpack(u"\1\174"), | |
4478 | DFA.unpack(u"\1\177\1\176"), | |
4479 | DFA.unpack(u"\1\u0082\1\u0081"), | |
4480 | DFA.unpack(u"\1\u0084"), | |
4481 | DFA.unpack(u"\1\u0086\76\uffff\1\u0087"), | |
4482 | DFA.unpack(u""), | |
4483 | DFA.unpack(u"\1\u008a\1\uffff\1\u008b"), | |
4484 | DFA.unpack(u"\1\u008c"), | |
4485 | DFA.unpack(u"\1\u008d"), | |
4486 | DFA.unpack(u"\1\u008e"), | |
4487 | DFA.unpack(u"\1\u0090\4\uffff\1\u008f"), | |
4488 | DFA.unpack(u""), | |
4489 | DFA.unpack(u"\47\u008f\1\uffff\uffd7\u008f"), | |
4490 | DFA.unpack(u"\uffff\u0090"), | |
4491 | DFA.unpack(u"\1\152\1\uffff\10\u0093\2\152\12\uffff\3\152\21\uffff" | |
4492 | u"\1\u0091\13\uffff\3\152\21\uffff\1\u0091"), | |
4493 | DFA.unpack(u"\1\152\1\uffff\12\u0094\12\uffff\3\152\35\uffff\3\152"), | |
4494 | DFA.unpack(u""), | |
4495 | DFA.unpack(u""), | |
4496 | DFA.unpack(u"\uffff\u0097"), | |
4497 | DFA.unpack(u""), | |
4498 | DFA.unpack(u""), | |
4499 | DFA.unpack(u"\1\u0098"), | |
4500 | DFA.unpack(u""), | |
4501 | DFA.unpack(u""), | |
4502 | DFA.unpack(u""), | |
4503 | DFA.unpack(u""), | |
4504 | DFA.unpack(u"\1\u0099"), | |
4505 | DFA.unpack(u"\1\u009a"), | |
4506 | DFA.unpack(u"\1\u009b"), | |
4507 | DFA.unpack(u"\1\u009d\20\uffff\1\u009c"), | |
4508 | DFA.unpack(u"\1\u009e"), | |
4509 | DFA.unpack(u"\1\u009f\22\uffff\1\u00a0"), | |
4510 | DFA.unpack(u"\1\u00a1"), | |
4511 | DFA.unpack(u"\1\u00a2"), | |
4512 | DFA.unpack(u"\1\u00a3\14\uffff\1\u00a4"), | |
4513 | DFA.unpack(u"\1\u00a5"), | |
4514 | DFA.unpack(u"\1\u00a6\2\uffff\1\u00a7"), | |
4515 | DFA.unpack(u"\1\u00a8"), | |
4516 | DFA.unpack(u"\1\u00a9"), | |
4517 | DFA.unpack(u"\1\u00aa"), | |
4518 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4519 | u"\32\75"), | |
4520 | DFA.unpack(u"\1\u00ac"), | |
4521 | DFA.unpack(u"\1\u00ad"), | |
4522 | DFA.unpack(u"\1\u00ae"), | |
4523 | DFA.unpack(u"\1\u00af"), | |
4524 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4525 | u"\24\75\1\u00b0\5\75"), | |
4526 | DFA.unpack(u"\1\u00b2"), | |
4527 | DFA.unpack(u"\1\u00b4\11\uffff\1\u00b3"), | |
4528 | DFA.unpack(u""), | |
4529 | DFA.unpack(u""), | |
4530 | DFA.unpack(u""), | |
4531 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4532 | u"\32\75"), | |
4533 | DFA.unpack(u"\1\u00b6"), | |
4534 | DFA.unpack(u"\1\u00b7"), | |
4535 | DFA.unpack(u"\1\u00b8"), | |
4536 | DFA.unpack(u"\1\u00b9"), | |
4537 | DFA.unpack(u"\1\u00ba"), | |
4538 | DFA.unpack(u"\1\u00bb"), | |
4539 | DFA.unpack(u"\1\u00bc"), | |
4540 | DFA.unpack(u""), | |
4541 | DFA.unpack(u""), | |
4542 | DFA.unpack(u""), | |
4543 | DFA.unpack(u""), | |
4544 | DFA.unpack(u""), | |
4545 | DFA.unpack(u""), | |
4546 | DFA.unpack(u""), | |
4547 | DFA.unpack(u""), | |
4548 | DFA.unpack(u""), | |
4549 | DFA.unpack(u""), | |
4550 | DFA.unpack(u""), | |
4551 | DFA.unpack(u""), | |
4552 | DFA.unpack(u""), | |
4553 | DFA.unpack(u""), | |
4554 | DFA.unpack(u""), | |
4555 | DFA.unpack(u""), | |
4556 | DFA.unpack(u""), | |
4557 | DFA.unpack(u""), | |
4558 | DFA.unpack(u""), | |
4559 | DFA.unpack(u""), | |
4560 | DFA.unpack(u""), | |
4561 | DFA.unpack(u""), | |
4562 | DFA.unpack(u""), | |
4563 | DFA.unpack(u""), | |
4564 | DFA.unpack(u""), | |
4565 | DFA.unpack(u""), | |
4566 | DFA.unpack(u""), | |
4567 | DFA.unpack(u""), | |
4568 | DFA.unpack(u""), | |
4569 | DFA.unpack(u"\1\u00bd"), | |
4570 | DFA.unpack(u""), | |
4571 | DFA.unpack(u"\1\u00bf"), | |
4572 | DFA.unpack(u""), | |
4573 | DFA.unpack(u""), | |
4574 | DFA.unpack(u""), | |
4575 | DFA.unpack(u""), | |
4576 | DFA.unpack(u""), | |
4577 | DFA.unpack(u""), | |
4578 | DFA.unpack(u""), | |
4579 | DFA.unpack(u""), | |
4580 | DFA.unpack(u"\1\u00c1"), | |
4581 | DFA.unpack(u"\1\u00c2"), | |
4582 | DFA.unpack(u"\1\u00c3"), | |
4583 | DFA.unpack(u"\1\u00c4"), | |
4584 | DFA.unpack(u"\1\u00c5"), | |
4585 | DFA.unpack(u""), | |
4586 | DFA.unpack(u""), | |
4587 | DFA.unpack(u""), | |
4588 | DFA.unpack(u""), | |
4589 | DFA.unpack(u"\1\152\1\uffff\10\u0093\2\152\12\uffff\3\152\35\uffff" | |
4590 | u"\3\152"), | |
4591 | DFA.unpack(u"\1\152\1\uffff\12\u0094\12\uffff\3\152\35\uffff\3\152"), | |
4592 | DFA.unpack(u""), | |
4593 | DFA.unpack(u""), | |
4594 | DFA.unpack(u""), | |
4595 | DFA.unpack(u"\1\u00c7"), | |
4596 | DFA.unpack(u"\1\u00c8"), | |
4597 | DFA.unpack(u"\1\u00c9"), | |
4598 | DFA.unpack(u"\1\u00ca"), | |
4599 | DFA.unpack(u"\1\u00cb"), | |
4600 | DFA.unpack(u"\1\u00cc"), | |
4601 | DFA.unpack(u"\1\u00cd"), | |
4602 | DFA.unpack(u"\1\u00ce"), | |
4603 | DFA.unpack(u"\1\u00cf"), | |
4604 | DFA.unpack(u"\1\u00d0"), | |
4605 | DFA.unpack(u"\1\u00d1"), | |
4606 | DFA.unpack(u"\1\u00d2"), | |
4607 | DFA.unpack(u"\1\u00d3"), | |
4608 | DFA.unpack(u"\1\u00d4"), | |
4609 | DFA.unpack(u"\1\u00d5"), | |
4610 | DFA.unpack(u"\1\u00d6"), | |
4611 | DFA.unpack(u"\1\u00d8\1\u00d7"), | |
4612 | DFA.unpack(u"\1\u00d9"), | |
4613 | DFA.unpack(u"\1\u00da"), | |
4614 | DFA.unpack(u""), | |
4615 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4616 | u"\32\75"), | |
4617 | DFA.unpack(u"\1\u00dc"), | |
4618 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4619 | u"\32\75"), | |
4620 | DFA.unpack(u"\1\u00de"), | |
4621 | DFA.unpack(u"\1\u00df"), | |
4622 | DFA.unpack(u""), | |
4623 | DFA.unpack(u"\1\u00e0"), | |
4624 | DFA.unpack(u"\1\u00e1"), | |
4625 | DFA.unpack(u"\1\u00e2"), | |
4626 | DFA.unpack(u""), | |
4627 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4628 | u"\32\75"), | |
4629 | DFA.unpack(u"\1\u00e4"), | |
4630 | DFA.unpack(u"\1\u00e5"), | |
4631 | DFA.unpack(u"\1\u00e6"), | |
4632 | DFA.unpack(u"\1\u00e7"), | |
4633 | DFA.unpack(u"\1\u00e8"), | |
4634 | DFA.unpack(u"\1\u00ea\35\uffff\1\u00e9"), | |
4635 | DFA.unpack(u""), | |
4636 | DFA.unpack(u""), | |
4637 | DFA.unpack(u""), | |
4638 | DFA.unpack(u""), | |
4639 | DFA.unpack(u"\1\u00eb"), | |
4640 | DFA.unpack(u"\1\u00ec"), | |
4641 | DFA.unpack(u"\1\u00ed"), | |
4642 | DFA.unpack(u"\1\u00ee"), | |
4643 | DFA.unpack(u"\1\u00ef"), | |
4644 | DFA.unpack(u""), | |
4645 | DFA.unpack(u"\1\u00f0"), | |
4646 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4647 | u"\32\75"), | |
4648 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4649 | u"\32\75"), | |
4650 | DFA.unpack(u"\1\u00f3"), | |
4651 | DFA.unpack(u"\1\u00f4"), | |
4652 | DFA.unpack(u"\1\u00f5"), | |
4653 | DFA.unpack(u"\1\u00f6"), | |
4654 | DFA.unpack(u"\1\u00f7"), | |
4655 | DFA.unpack(u"\1\u00f8"), | |
4656 | DFA.unpack(u"\1\u00f9"), | |
4657 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4658 | u"\32\75"), | |
4659 | DFA.unpack(u"\1\u00fb"), | |
4660 | DFA.unpack(u"\1\u00fc"), | |
4661 | DFA.unpack(u"\1\u00fd"), | |
4662 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4663 | u"\32\75"), | |
4664 | DFA.unpack(u"\1\u00ff"), | |
4665 | DFA.unpack(u"\1\u0100"), | |
4666 | DFA.unpack(u"\1\u0101"), | |
4667 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4668 | u"\32\75"), | |
4669 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4670 | u"\32\75"), | |
4671 | DFA.unpack(u""), | |
4672 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4673 | u"\32\75"), | |
4674 | DFA.unpack(u""), | |
4675 | DFA.unpack(u"\1\u0105"), | |
4676 | DFA.unpack(u"\1\u0106"), | |
4677 | DFA.unpack(u"\1\u0107"), | |
4678 | DFA.unpack(u"\1\u0108"), | |
4679 | DFA.unpack(u"\1\u0109"), | |
4680 | DFA.unpack(u""), | |
4681 | DFA.unpack(u"\1\u010a"), | |
4682 | DFA.unpack(u"\1\u010b"), | |
4683 | DFA.unpack(u"\1\u010c"), | |
4684 | DFA.unpack(u"\1\u010d"), | |
4685 | DFA.unpack(u"\1\u010e"), | |
4686 | DFA.unpack(u"\1\u010f\17\uffff\1\u0110"), | |
4687 | DFA.unpack(u"\1\u0111"), | |
4688 | DFA.unpack(u"\1\u0112"), | |
4689 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4690 | u"\32\75"), | |
4691 | DFA.unpack(u"\1\u0114"), | |
4692 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4693 | u"\32\75"), | |
4694 | DFA.unpack(u"\1\u0116"), | |
4695 | DFA.unpack(u"\1\u0117"), | |
4696 | DFA.unpack(u""), | |
4697 | DFA.unpack(u""), | |
4698 | DFA.unpack(u"\1\u0118"), | |
4699 | DFA.unpack(u"\1\u0119"), | |
4700 | DFA.unpack(u"\1\u011a"), | |
4701 | DFA.unpack(u"\1\u011b"), | |
4702 | DFA.unpack(u"\1\u011c"), | |
4703 | DFA.unpack(u"\1\u011d"), | |
4704 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4705 | u"\32\75"), | |
4706 | DFA.unpack(u""), | |
4707 | DFA.unpack(u"\1\u011f"), | |
4708 | DFA.unpack(u"\1\u0120"), | |
4709 | DFA.unpack(u"\1\u0121"), | |
4710 | DFA.unpack(u""), | |
4711 | DFA.unpack(u"\1\u0122"), | |
4712 | DFA.unpack(u"\1\u0123"), | |
4713 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4714 | u"\32\75"), | |
4715 | DFA.unpack(u""), | |
4716 | DFA.unpack(u""), | |
4717 | DFA.unpack(u""), | |
4718 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4719 | u"\32\75"), | |
4720 | DFA.unpack(u"\1\u0126"), | |
4721 | DFA.unpack(u"\1\u0127"), | |
4722 | DFA.unpack(u"\1\u0128"), | |
4723 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4724 | u"\32\75"), | |
4725 | DFA.unpack(u"\1\u012a"), | |
4726 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4727 | u"\32\75"), | |
4728 | DFA.unpack(u"\1\u012c"), | |
4729 | DFA.unpack(u"\1\u012d"), | |
4730 | DFA.unpack(u"\1\u012e"), | |
4731 | DFA.unpack(u"\1\u012f"), | |
4732 | DFA.unpack(u"\1\u0130"), | |
4733 | DFA.unpack(u"\1\u0131"), | |
4734 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\u0132\1" | |
4735 | u"\uffff\32\75"), | |
4736 | DFA.unpack(u""), | |
4737 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4738 | u"\32\75"), | |
4739 | DFA.unpack(u""), | |
4740 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4741 | u"\32\75"), | |
4742 | DFA.unpack(u"\1\u0136"), | |
4743 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4744 | u"\32\75"), | |
4745 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4746 | u"\32\75"), | |
4747 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4748 | u"\32\75"), | |
4749 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4750 | u"\32\75"), | |
4751 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4752 | u"\32\75"), | |
4753 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4754 | u"\32\75"), | |
4755 | DFA.unpack(u""), | |
4756 | DFA.unpack(u"\1\u013d"), | |
4757 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4758 | u"\32\75"), | |
4759 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4760 | u"\32\75"), | |
4761 | DFA.unpack(u"\1\u0140"), | |
4762 | DFA.unpack(u"\1\u0141"), | |
4763 | DFA.unpack(u""), | |
4764 | DFA.unpack(u""), | |
4765 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4766 | u"\32\75"), | |
4767 | DFA.unpack(u"\1\u0143"), | |
4768 | DFA.unpack(u"\1\u0144"), | |
4769 | DFA.unpack(u""), | |
4770 | DFA.unpack(u"\1\u0145"), | |
4771 | DFA.unpack(u""), | |
4772 | DFA.unpack(u"\1\u0146"), | |
4773 | DFA.unpack(u"\1\u0147"), | |
4774 | DFA.unpack(u"\1\u0148"), | |
4775 | DFA.unpack(u"\1\u0149"), | |
4776 | DFA.unpack(u"\1\u014a"), | |
4777 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4778 | u"\32\75"), | |
4779 | DFA.unpack(u"\1\u014c"), | |
4780 | DFA.unpack(u""), | |
4781 | DFA.unpack(u""), | |
4782 | DFA.unpack(u""), | |
4783 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4784 | u"\32\75"), | |
4785 | DFA.unpack(u""), | |
4786 | DFA.unpack(u""), | |
4787 | DFA.unpack(u""), | |
4788 | DFA.unpack(u""), | |
4789 | DFA.unpack(u""), | |
4790 | DFA.unpack(u""), | |
4791 | DFA.unpack(u"\1\u014e"), | |
4792 | DFA.unpack(u""), | |
4793 | DFA.unpack(u""), | |
4794 | DFA.unpack(u"\1\u014f"), | |
4795 | DFA.unpack(u"\1\u0150"), | |
4796 | DFA.unpack(u""), | |
4797 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4798 | u"\32\75"), | |
4799 | DFA.unpack(u"\1\u0152"), | |
4800 | DFA.unpack(u"\1\u0153"), | |
4801 | DFA.unpack(u"\1\u0154"), | |
4802 | DFA.unpack(u"\1\u0155"), | |
4803 | DFA.unpack(u"\1\u0156"), | |
4804 | DFA.unpack(u"\1\u0157"), | |
4805 | DFA.unpack(u"\1\u0158"), | |
4806 | DFA.unpack(u""), | |
4807 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4808 | u"\32\75"), | |
4809 | DFA.unpack(u""), | |
4810 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4811 | u"\32\75"), | |
4812 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4813 | u"\32\75"), | |
4814 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4815 | u"\32\75"), | |
4816 | DFA.unpack(u""), | |
4817 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4818 | u"\32\75"), | |
4819 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4820 | u"\32\75"), | |
4821 | DFA.unpack(u"\1\u015f"), | |
4822 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4823 | u"\32\75"), | |
4824 | DFA.unpack(u"\1\u0161"), | |
4825 | DFA.unpack(u"\1\u0162"), | |
4826 | DFA.unpack(u"\1\u0163"), | |
4827 | DFA.unpack(u""), | |
4828 | DFA.unpack(u""), | |
4829 | DFA.unpack(u""), | |
4830 | DFA.unpack(u""), | |
4831 | DFA.unpack(u""), | |
4832 | DFA.unpack(u""), | |
4833 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4834 | u"\32\75"), | |
4835 | DFA.unpack(u""), | |
4836 | DFA.unpack(u"\1\u0165"), | |
4837 | DFA.unpack(u"\1\u0166"), | |
4838 | DFA.unpack(u"\1\u0167"), | |
4839 | DFA.unpack(u""), | |
4840 | DFA.unpack(u"\1\u0168"), | |
4841 | DFA.unpack(u"\1\u0169"), | |
4842 | DFA.unpack(u"\1\u016a"), | |
4843 | DFA.unpack(u"\1\u016b"), | |
4844 | DFA.unpack(u"\1\u016c"), | |
4845 | DFA.unpack(u"\1\u016d"), | |
4846 | DFA.unpack(u"\1\u016e"), | |
4847 | DFA.unpack(u"\1\u016f"), | |
4848 | DFA.unpack(u"\1\u0170"), | |
4849 | DFA.unpack(u"\1\u0171"), | |
4850 | DFA.unpack(u"\1\u0172"), | |
4851 | DFA.unpack(u"\1\u0173"), | |
4852 | DFA.unpack(u"\1\u0174"), | |
4853 | DFA.unpack(u"\1\u0175"), | |
4854 | DFA.unpack(u"\1\u0176"), | |
4855 | DFA.unpack(u"\1\u0177"), | |
4856 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4857 | u"\32\75"), | |
4858 | DFA.unpack(u"\1\u0179"), | |
4859 | DFA.unpack(u"\1\u017a"), | |
4860 | DFA.unpack(u""), | |
4861 | DFA.unpack(u"\1\u017b"), | |
4862 | DFA.unpack(u"\1\u017c"), | |
4863 | DFA.unpack(u"\1\u017d"), | |
4864 | DFA.unpack(u"\1\u017e"), | |
4865 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4866 | u"\32\75"), | |
4867 | DFA.unpack(u"\1\u0180"), | |
4868 | DFA.unpack(u""), | |
4869 | DFA.unpack(u"\1\u0181"), | |
4870 | DFA.unpack(u"\1\u0182"), | |
4871 | DFA.unpack(u"\1\u0183"), | |
4872 | DFA.unpack(u"\1\u0184"), | |
4873 | DFA.unpack(u"\1\u0185"), | |
4874 | DFA.unpack(u"\1\u0186"), | |
4875 | DFA.unpack(u"\1\u0187"), | |
4876 | DFA.unpack(u"\1\u0188"), | |
4877 | DFA.unpack(u"\1\u0189"), | |
4878 | DFA.unpack(u"\1\75\13\uffff\12\75\7\uffff\32\75\4\uffff\1\75\1\uffff" | |
4879 | u"\32\75"), | |
4880 | DFA.unpack(u"") | |
4881 | ] | |
4882 | ||
4883 | # class definition for DFA #35 | |
4884 | ||
4885 | DFA35 = DFA | |
4886 | ||
4887 |