source: proto/scatterRE/ref/re2pbs/bin/re2pbsParser.py @ 2248

Last change on this file since 2248 was 2248, checked in by ksherdy, 7 years ago

Updated path.

File size: 25.7 KB
Line 
1# $ANTLR 3.1.3 Mar 17, 2009 19:23:44 re2pbs.g 2012-07-11 14:31:18
2
3import sys
4from antlr3 import *
5from antlr3.compat import set, frozenset
6         
7from re2pbs import *
8from codepoint_symbol_table import *
9from charset_compiler import chardeflist2py
10from charset_def import CharSetDef
11
12
13
14# for convenience in actions
15HIDDEN = BaseRecognizer.HIDDEN
16
17# token types
18RoundBracketStart=8
19Cross=7
20EOF=-1
21HexDigit=20
22Escape=19
23SmallHexNumber=15
24NewLine=18
25SquareBracketEnd=12
26Hyphen=13
27NotSuperMetaCharacter=17
28SuperMetaCharacters=21
29SquareBracketStart=10
30RoundBracketEnd=9
31QuestionMark=5
32UnicodeCharacter=14
33Star=6
34Or=4
35EscapeSuperMetaCharacter=16
36Caret=11
37
38# token names
39tokenNames = [
40    "<invalid>", "<EOR>", "<DOWN>", "<UP>", 
41    "Or", "QuestionMark", "Star", "Cross", "RoundBracketStart", "RoundBracketEnd", 
42    "SquareBracketStart", "Caret", "SquareBracketEnd", "Hyphen", "UnicodeCharacter", 
43    "SmallHexNumber", "EscapeSuperMetaCharacter", "NotSuperMetaCharacter", 
44    "NewLine", "Escape", "HexDigit", "SuperMetaCharacters"
45]
46
47
48
49
50class re2pbsParser(Parser):
51    grammarFileName = "re2pbs.g"
52    antlr_version = version_str_to_tuple("3.1.3 Mar 17, 2009 19:23:44")
53    antlr_version_str = "3.1.3 Mar 17, 2009 19:23:44"
54    tokenNames = tokenNames
55
56    def __init__(self, input, state=None, *args, **kwargs):
57        if state is None:
58            state = RecognizerSharedState()
59
60        super(re2pbsParser, self).__init__(input, state, *args, **kwargs)
61
62
63
64
65
66
67               
68
69
70       
71
72             
73    symbol_table = CodePointSymbolTable()
74
75
76
77    # $ANTLR start "prog"
78    # re2pbs.g:72:1: prog : r= re EOF ;
79    def prog(self, ):
80
81        r = None
82
83
84        try:
85            try:
86                # re2pbs.g:72:6: (r= re EOF )
87                # re2pbs.g:72:8: r= re EOF
88                pass 
89                self._state.following.append(self.FOLLOW_re_in_prog60)
90                r = self.re()
91
92                self._state.following.pop()
93                self.match(self.input, EOF, self.FOLLOW_EOF_in_prog62)
94                #action start
95                 
96                lex_strms = ''
97                cc_code = ''
98                pbs_code = ''
99                pbs_debug = ''
100                prefix = 'lex.'
101                # Character Class compiler dependency
102                lexical_item_names = self.symbol_table.symbols.keys()
103                cc_code = chardeflist2py(generate_chardefsets(self.symbol_table.symbols.items(), prefix))
104                # Generate prototype.py based on the template file 'prototype_template.py'.
105                factory = GeneratorFactory()   
106                prototype = Program(factory, 'prototype_template.py', 'prototype.py')
107                lex_strms = prototype.generate_lex_strms(lexical_item_names)
108
109                (pbs_code, pbs_debug) = prototype.generate_pbs_code_pbs_debug(r.union.concatenation_list, prefix)               
110                prototype.generate(lex_strms, cc_code, pbs_code, pbs_debug)
111                # Generate 'compilable.py' based on the template file 'compilable_template.py'.
112                factory = GeneratorFactory()   
113                compilable = Program(factory, 'compilable_template.py', 'compilable.py')
114                lex_strms = compilable.generate_lex_strms(lexical_item_names)
115                (pbs_code, pbs_debug) = compilable.generate_pbs_code_pbs_debug(r.union.concatenation_list, prefix)             
116                compilable.generate(lex_strms, cc_code, pbs_code, pbs_debug)
117
118                #action end
119
120
121
122
123            except RecognitionException, re:
124                self.reportError(re)
125                self.recover(self.input, re)
126        finally:
127
128            pass
129        return 
130
131    # $ANTLR end "prog"
132
133
134    # $ANTLR start "re"
135    # re2pbs.g:102:1: re returns [object] : ( union )? ;
136    def re(self, ):
137
138        object = None
139
140        union1 = None
141
142
143               
144        object = RE()
145
146        try:
147            try:
148                # re2pbs.g:109:2: ( ( union )? )
149                # re2pbs.g:109:5: ( union )?
150                pass 
151                # re2pbs.g:109:5: ( union )?
152                alt1 = 2
153                LA1_0 = self.input.LA(1)
154
155                if (LA1_0 == RoundBracketStart or LA1_0 == SquareBracketStart or (UnicodeCharacter <= LA1_0 <= NotSuperMetaCharacter)) :
156                    alt1 = 1
157                if alt1 == 1:
158                    # re2pbs.g:109:6: union
159                    pass 
160                    self._state.following.append(self.FOLLOW_union_in_re94)
161                    union1 = self.union()
162
163                    self._state.following.pop()
164                    #action start
165                               
166                    object.union = union1
167                                       
168                    #action end
169
170
171
172
173
174
175                #action start
176                       
177                # print object.debug()
178
179                #action end
180
181            except RecognitionException, re:
182                self.reportError(re)
183                self.recover(self.input, re)
184        finally:
185
186            pass
187        return object
188
189    # $ANTLR end "re"
190
191
192    # $ANTLR start "union"
193    # re2pbs.g:116:1: union returns [object] : c0= concatenation ( Or ck= concatenation )* ;
194    def union(self, ):
195
196        object = None
197
198        c0 = None
199
200        ck = None
201
202
203               
204        object = Union()       
205
206        try:
207            try:
208                # re2pbs.g:123:2: (c0= concatenation ( Or ck= concatenation )* )
209                # re2pbs.g:123:4: c0= concatenation ( Or ck= concatenation )*
210                pass 
211                self._state.following.append(self.FOLLOW_concatenation_in_union137)
212                c0 = self.concatenation()
213
214                self._state.following.pop()
215                #action start
216                   
217                # initialize an object
218                object.concatenation_list.append(c0)
219                               
220                #action end
221                # re2pbs.g:128:3: ( Or ck= concatenation )*
222                while True: #loop2
223                    alt2 = 2
224                    LA2_0 = self.input.LA(1)
225
226                    if (LA2_0 == Or) :
227                        alt2 = 1
228
229
230                    if alt2 == 1:
231                        # re2pbs.g:129:3: Or ck= concatenation
232                        pass 
233                        self.match(self.input, Or, self.FOLLOW_Or_in_union152)
234                        self._state.following.append(self.FOLLOW_concatenation_in_union158)
235                        ck = self.concatenation()
236
237                        self._state.following.pop()
238                        #action start
239                           
240                        # initialize an object
241                        object.concatenation_list.append(ck)
242                                       
243                        #action end
244
245
246                    else:
247                        break #loop2
248
249
250
251                #action start
252                       
253                #print object.debug()
254
255                #action end
256
257            except RecognitionException, re:
258                self.reportError(re)
259                self.recover(self.input, re)
260        finally:
261
262            pass
263        return object
264
265    # $ANTLR end "union"
266
267
268    # $ANTLR start "concatenation"
269    # re2pbs.g:137:1: concatenation returns [object] : ( atom )+ ;
270    def concatenation(self, ):
271
272        object = None
273
274        atom2 = None
275
276
277               
278        object = Concatenation()
279
280        try:
281            try:
282                # re2pbs.g:144:2: ( ( atom )+ )
283                # re2pbs.g:144:4: ( atom )+
284                pass 
285                # re2pbs.g:144:4: ( atom )+
286                cnt3 = 0
287                while True: #loop3
288                    alt3 = 2
289                    LA3_0 = self.input.LA(1)
290
291                    if (LA3_0 == RoundBracketStart or LA3_0 == SquareBracketStart or (UnicodeCharacter <= LA3_0 <= NotSuperMetaCharacter)) :
292                        alt3 = 1
293
294
295                    if alt3 == 1:
296                        # re2pbs.g:144:5: atom
297                        pass 
298                        self._state.following.append(self.FOLLOW_atom_in_concatenation197)
299                        atom2 = self.atom()
300
301                        self._state.following.pop()
302                        #action start
303                        object.atom_list.append(atom2)
304                        #action end
305
306
307                    else:
308                        if cnt3 >= 1:
309                            break #loop3
310
311                        eee = EarlyExitException(3, self.input)
312                        raise eee
313
314                    cnt3 += 1
315
316
317
318                #action start
319                       
320                #print object.debug()
321
322                #action end
323
324            except RecognitionException, re:
325                self.reportError(re)
326                self.recover(self.input, re)
327        finally:
328
329            pass
330        return object
331
332    # $ANTLR end "concatenation"
333
334
335    # $ANTLR start "atom"
336    # re2pbs.g:147:1: atom returns [object] : ( group (q0= QuestionMark )? | ( single | characterClass ) (q1= QuestionMark | Star | Cross )? ) ;
337    def atom(self, ):
338
339        object = None
340
341        q0 = None
342        q1 = None
343        Star5 = None
344        Cross6 = None
345        single3 = None
346
347        characterClass4 = None
348
349
350               
351        symbol = CodePointSymbol()     
352        object = Atom()     
353
354        try:
355            try:
356                # re2pbs.g:157:2: ( ( group (q0= QuestionMark )? | ( single | characterClass ) (q1= QuestionMark | Star | Cross )? ) )
357                # re2pbs.g:158:2: ( group (q0= QuestionMark )? | ( single | characterClass ) (q1= QuestionMark | Star | Cross )? )
358                pass 
359                # re2pbs.g:158:2: ( group (q0= QuestionMark )? | ( single | characterClass ) (q1= QuestionMark | Star | Cross )? )
360                alt7 = 2
361                LA7_0 = self.input.LA(1)
362
363                if (LA7_0 == RoundBracketStart) :
364                    alt7 = 1
365                elif (LA7_0 == SquareBracketStart or (UnicodeCharacter <= LA7_0 <= NotSuperMetaCharacter)) :
366                    alt7 = 2
367                else:
368                    nvae = NoViableAltException("", 7, 0, self.input)
369
370                    raise nvae
371
372                if alt7 == 1:
373                    # re2pbs.g:159:3: group (q0= QuestionMark )?
374                    pass 
375                    self._state.following.append(self.FOLLOW_group_in_atom233)
376                    self.group()
377
378                    self._state.following.pop()
379                    # re2pbs.g:160:3: (q0= QuestionMark )?
380                    alt4 = 2
381                    LA4_0 = self.input.LA(1)
382
383                    if (LA4_0 == QuestionMark) :
384                        alt4 = 1
385                    if alt4 == 1:
386                        # re2pbs.g:160:4: q0= QuestionMark
387                        pass 
388                        q0=self.match(self.input, QuestionMark, self.FOLLOW_QuestionMark_in_atom243)
389                        #action start
390                        object.quantifier = q0.text
391                        #action end
392
393
394
395
396
397                elif alt7 == 2:
398                    # re2pbs.g:162:3: ( single | characterClass ) (q1= QuestionMark | Star | Cross )?
399                    pass 
400                    # re2pbs.g:162:3: ( single | characterClass )
401                    alt5 = 2
402                    LA5_0 = self.input.LA(1)
403
404                    if ((UnicodeCharacter <= LA5_0 <= NotSuperMetaCharacter)) :
405                        alt5 = 1
406                    elif (LA5_0 == SquareBracketStart) :
407                        alt5 = 2
408                    else:
409                        nvae = NoViableAltException("", 5, 0, self.input)
410
411                        raise nvae
412
413                    if alt5 == 1:
414                        # re2pbs.g:163:4: single
415                        pass 
416                        self._state.following.append(self.FOLLOW_single_in_atom262)
417                        single3 = self.single()
418
419                        self._state.following.pop()
420                        #action start
421                                   
422                        symbol.add_codepoint(single3.codepoint)
423                        object.strm_name = symbol.key()
424                                                       
425                        #action end
426
427
428                    elif alt5 == 2:
429                        # re2pbs.g:168:4: characterClass
430                        pass 
431                        self._state.following.append(self.FOLLOW_characterClass_in_atom276)
432                        characterClass4 = self.characterClass()
433
434                        self._state.following.pop()
435                        #action start
436                               
437                        for obj in characterClass4.single_or_range: 
438                                if isinstance(obj,Single): 
439                                        symbol.add_codepoint(obj.codepoint, characterClass4.invert) 
440                                elif isinstance(obj,Range): 
441                                        symbol.add_codepoint_range(obj.codepoint_lower, obj.codepoint_upper, characterClass4.invert)
442                        object.strm_name = symbol.key()
443                                                       
444                        #action end
445
446
447
448                    # re2pbs.g:178:3: (q1= QuestionMark | Star | Cross )?
449                    alt6 = 4
450                    LA6 = self.input.LA(1)
451                    if LA6 == QuestionMark:
452                        alt6 = 1
453                    elif LA6 == Star:
454                        alt6 = 2
455                    elif LA6 == Cross:
456                        alt6 = 3
457                    if alt6 == 1:
458                        # re2pbs.g:178:5: q1= QuestionMark
459                        pass 
460                        q1=self.match(self.input, QuestionMark, self.FOLLOW_QuestionMark_in_atom298)
461                        #action start
462                        object.quantifier = q1.text
463                        #action end
464
465
466                    elif alt6 == 2:
467                        # re2pbs.g:179:5: Star
468                        pass 
469                        Star5=self.match(self.input, Star, self.FOLLOW_Star_in_atom308)
470                        #action start
471                        object.quantifier = Star5.text
472                        #action end
473
474
475                    elif alt6 == 3:
476                        # re2pbs.g:180:5: Cross
477                        pass 
478                        Cross6=self.match(self.input, Cross, self.FOLLOW_Cross_in_atom319)
479                        #action start
480                        object.quantifier = Cross6.text
481                        #action end
482
483
484
485
486
487
488
489
490
491                #action start
492                       
493                       
494                self.symbol_table.insert(symbol.key(), symbol)                 
495                #print object.debug()
496
497                #action end
498
499            except RecognitionException, re:
500                self.reportError(re)
501                self.recover(self.input, re)
502        finally:
503
504            pass
505        return object
506
507    # $ANTLR end "atom"
508
509
510    # $ANTLR start "group"
511    # re2pbs.g:184:1: group : RoundBracketStart re RoundBracketEnd ;
512    def group(self, ):
513
514        try:
515            try:
516                # re2pbs.g:184:7: ( RoundBracketStart re RoundBracketEnd )
517                # re2pbs.g:185:2: RoundBracketStart re RoundBracketEnd
518                pass 
519                self.match(self.input, RoundBracketStart, self.FOLLOW_RoundBracketStart_in_group341)
520                self._state.following.append(self.FOLLOW_re_in_group344)
521                self.re()
522
523                self._state.following.pop()
524                self.match(self.input, RoundBracketEnd, self.FOLLOW_RoundBracketEnd_in_group347)
525
526
527
528
529            except RecognitionException, re:
530                self.reportError(re)
531                self.recover(self.input, re)
532        finally:
533
534            pass
535        return 
536
537    # $ANTLR end "group"
538
539
540    # $ANTLR start "characterClass"
541    # re2pbs.g:190:1: characterClass returns [object] : SquareBracketStart ( Caret )? ( range | single )+ SquareBracketEnd ;
542    def characterClass(self, ):
543
544        object = None
545
546        range7 = None
547
548        single8 = None
549
550
551               
552        object = CharacterClass()
553
554        try:
555            try:
556                # re2pbs.g:197:2: ( SquareBracketStart ( Caret )? ( range | single )+ SquareBracketEnd )
557                # re2pbs.g:198:2: SquareBracketStart ( Caret )? ( range | single )+ SquareBracketEnd
558                pass 
559                self.match(self.input, SquareBracketStart, self.FOLLOW_SquareBracketStart_in_characterClass376)
560                # re2pbs.g:199:2: ( Caret )?
561                alt8 = 2
562                LA8_0 = self.input.LA(1)
563
564                if (LA8_0 == Caret) :
565                    alt8 = 1
566                if alt8 == 1:
567                    # re2pbs.g:199:3: Caret
568                    pass 
569                    self.match(self.input, Caret, self.FOLLOW_Caret_in_characterClass384)
570                    #action start
571                    object.invert = True
572                    #action end
573
574
575
576                # re2pbs.g:200:2: ( range | single )+
577                cnt9 = 0
578                while True: #loop9
579                    alt9 = 3
580                    LA9 = self.input.LA(1)
581                    if LA9 == UnicodeCharacter:
582                        LA9_2 = self.input.LA(2)
583
584                        if (LA9_2 == Hyphen) :
585                            alt9 = 1
586                        elif (LA9_2 == SquareBracketEnd or (UnicodeCharacter <= LA9_2 <= NotSuperMetaCharacter)) :
587                            alt9 = 2
588
589
590                    elif LA9 == SmallHexNumber:
591                        LA9_3 = self.input.LA(2)
592
593                        if (LA9_3 == Hyphen) :
594                            alt9 = 1
595                        elif (LA9_3 == SquareBracketEnd or (UnicodeCharacter <= LA9_3 <= NotSuperMetaCharacter)) :
596                            alt9 = 2
597
598
599                    elif LA9 == EscapeSuperMetaCharacter:
600                        LA9_4 = self.input.LA(2)
601
602                        if (LA9_4 == SquareBracketEnd or (UnicodeCharacter <= LA9_4 <= NotSuperMetaCharacter)) :
603                            alt9 = 2
604                        elif (LA9_4 == Hyphen) :
605                            alt9 = 1
606
607
608                    elif LA9 == NotSuperMetaCharacter:
609                        LA9_5 = self.input.LA(2)
610
611                        if (LA9_5 == SquareBracketEnd or (UnicodeCharacter <= LA9_5 <= NotSuperMetaCharacter)) :
612                            alt9 = 2
613                        elif (LA9_5 == Hyphen) :
614                            alt9 = 1
615
616
617
618                    if alt9 == 1:
619                        # re2pbs.g:201:2: range
620                        pass 
621                        self._state.following.append(self.FOLLOW_range_in_characterClass394)
622                        range7 = self.range()
623
624                        self._state.following.pop()
625                        #action start
626                        object.single_or_range.append(range7)
627                        #action end
628
629
630                    elif alt9 == 2:
631                        # re2pbs.g:203:2: single
632                        pass 
633                        self._state.following.append(self.FOLLOW_single_in_characterClass403)
634                        single8 = self.single()
635
636                        self._state.following.pop()
637                        #action start
638                        object.single_or_range.append(single8)
639                        #action end
640
641
642                    else:
643                        if cnt9 >= 1:
644                            break #loop9
645
646                        eee = EarlyExitException(9, self.input)
647                        raise eee
648
649                    cnt9 += 1
650                self.match(self.input, SquareBracketEnd, self.FOLLOW_SquareBracketEnd_in_characterClass413)
651
652
653
654                #action start
655                       
656                #object.debug()
657
658                #action end
659
660            except RecognitionException, re:
661                self.reportError(re)
662                self.recover(self.input, re)
663        finally:
664
665            pass
666        return object
667
668    # $ANTLR end "characterClass"
669
670
671    # $ANTLR start "range"
672    # re2pbs.g:208:1: range returns [object] : lb= single Hyphen ub= single ;
673    def range(self, ):
674
675        object = None
676
677        lb = None
678
679        ub = None
680
681
682             
683        object = Range()
684
685        try:
686            try:
687                # re2pbs.g:215:2: (lb= single Hyphen ub= single )
688                # re2pbs.g:215:5: lb= single Hyphen ub= single
689                pass 
690                self._state.following.append(self.FOLLOW_single_in_range447)
691                lb = self.single()
692
693                self._state.following.pop()
694                #action start
695                object.codepoint_lower = lb.codepoint
696                #action end
697                self.match(self.input, Hyphen, self.FOLLOW_Hyphen_in_range457)
698                self._state.following.append(self.FOLLOW_single_in_range469)
699                ub = self.single()
700
701                self._state.following.pop()
702                #action start
703                object.codepoint_upper = ub.codepoint
704                #action end
705
706
707
708                #action start
709                       
710                #object.debug()
711
712                #action end
713
714            except RecognitionException, re:
715                self.reportError(re)
716                self.recover(self.input, re)
717        finally:
718
719            pass
720        return object
721
722    # $ANTLR end "range"
723
724
725    # $ANTLR start "single"
726    # re2pbs.g:223:1: single returns [object] : (i= UnicodeCharacter | j= SmallHexNumber | k= EscapeSuperMetaCharacter | l= NotSuperMetaCharacter );
727    def single(self, ):
728
729        object = None
730
731        i = None
732        j = None
733        k = None
734        l = None
735
736             
737        object = Single()
738
739        try:
740            try:
741                # re2pbs.g:230:2: (i= UnicodeCharacter | j= SmallHexNumber | k= EscapeSuperMetaCharacter | l= NotSuperMetaCharacter )
742                alt10 = 4
743                LA10 = self.input.LA(1)
744                if LA10 == UnicodeCharacter:
745                    alt10 = 1
746                elif LA10 == SmallHexNumber:
747                    alt10 = 2
748                elif LA10 == EscapeSuperMetaCharacter:
749                    alt10 = 3
750                elif LA10 == NotSuperMetaCharacter:
751                    alt10 = 4
752                else:
753                    nvae = NoViableAltException("", 10, 0, self.input)
754
755                    raise nvae
756
757                if alt10 == 1:
758                    # re2pbs.g:230:4: i= UnicodeCharacter
759                    pass 
760                    i=self.match(self.input, UnicodeCharacter, self.FOLLOW_UnicodeCharacter_in_single513)
761                    #action start
762                    object.codepoint = int(i.text[2:],16)
763                    #action end
764
765
766                elif alt10 == 2:
767                    # re2pbs.g:232:4: j= SmallHexNumber
768                    pass 
769                    j=self.match(self.input, SmallHexNumber, self.FOLLOW_SmallHexNumber_in_single539)
770                    #action start
771                    object.codepoint = int(j.text[2:],16)
772                    #action end
773
774
775                elif alt10 == 3:
776                    # re2pbs.g:234:4: k= EscapeSuperMetaCharacter
777                    pass 
778                    k=self.match(self.input, EscapeSuperMetaCharacter, self.FOLLOW_EscapeSuperMetaCharacter_in_single566)
779                    #action start
780                    object.codepoint = ord(k.text[1:])
781                    #action end
782
783
784                elif alt10 == 4:
785                    # re2pbs.g:236:4: l= NotSuperMetaCharacter
786                    pass 
787                    l=self.match(self.input, NotSuperMetaCharacter, self.FOLLOW_NotSuperMetaCharacter_in_single582)
788                    #action start
789                    object.codepoint = ord(l.text[(len(l.text)-1):])
790                    #action end
791
792
793                #action start
794                       
795                #object.debug()
796
797                #action end
798
799            except RecognitionException, re:
800                self.reportError(re)
801                self.recover(self.input, re)
802        finally:
803
804            pass
805        return object
806
807    # $ANTLR end "single"
808
809
810    # Delegated rules
811
812
813 
814
815    FOLLOW_re_in_prog60 = frozenset([])
816    FOLLOW_EOF_in_prog62 = frozenset([1])
817    FOLLOW_union_in_re94 = frozenset([1])
818    FOLLOW_concatenation_in_union137 = frozenset([1, 4])
819    FOLLOW_Or_in_union152 = frozenset([8, 10, 14, 15, 16, 17])
820    FOLLOW_concatenation_in_union158 = frozenset([1, 4])
821    FOLLOW_atom_in_concatenation197 = frozenset([1, 8, 10, 14, 15, 16, 17])
822    FOLLOW_group_in_atom233 = frozenset([1, 5])
823    FOLLOW_QuestionMark_in_atom243 = frozenset([1])
824    FOLLOW_single_in_atom262 = frozenset([1, 5, 6, 7])
825    FOLLOW_characterClass_in_atom276 = frozenset([1, 5, 6, 7])
826    FOLLOW_QuestionMark_in_atom298 = frozenset([1])
827    FOLLOW_Star_in_atom308 = frozenset([1])
828    FOLLOW_Cross_in_atom319 = frozenset([1])
829    FOLLOW_RoundBracketStart_in_group341 = frozenset([8, 9, 10, 14, 15, 16, 17])
830    FOLLOW_re_in_group344 = frozenset([9])
831    FOLLOW_RoundBracketEnd_in_group347 = frozenset([1])
832    FOLLOW_SquareBracketStart_in_characterClass376 = frozenset([11, 14, 15, 16, 17])
833    FOLLOW_Caret_in_characterClass384 = frozenset([14, 15, 16, 17])
834    FOLLOW_range_in_characterClass394 = frozenset([12, 14, 15, 16, 17])
835    FOLLOW_single_in_characterClass403 = frozenset([12, 14, 15, 16, 17])
836    FOLLOW_SquareBracketEnd_in_characterClass413 = frozenset([1])
837    FOLLOW_single_in_range447 = frozenset([13])
838    FOLLOW_Hyphen_in_range457 = frozenset([14, 15, 16, 17])
839    FOLLOW_single_in_range469 = frozenset([1])
840    FOLLOW_UnicodeCharacter_in_single513 = frozenset([1])
841    FOLLOW_SmallHexNumber_in_single539 = frozenset([1])
842    FOLLOW_EscapeSuperMetaCharacter_in_single566 = frozenset([1])
843    FOLLOW_NotSuperMetaCharacter_in_single582 = frozenset([1])
844
845
846
847def main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
848    from antlr3.main import ParserMain
849    main = ParserMain("re2pbsLexer", re2pbsParser)
850    main.stdin = stdin
851    main.stdout = stdout
852    main.stderr = stderr
853    main.execute(argv)
854
855
856if __name__ == '__main__':
857    main(sys.argv)
Note: See TracBrowser for help on using the repository browser.