source: proto/RE/ref/re2pbs/bin/re2pbsLexer.py @ 2317

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

Added reference implementation.

File size: 16.6 KB
Line 
1# $ANTLR 3.1.3 Mar 17, 2009 19:23:44 re2pbs.g 2012-07-11 14:49:12
2
3import sys
4from antlr3 import *
5from antlr3.compat import set, frozenset
6                         
7
8
9
10# for convenience in actions
11HIDDEN = BaseRecognizer.HIDDEN
12
13# token types
14RoundBracketStart=8
15Cross=7
16EOF=-1
17Escape=19
18HexDigit=20
19SmallHexNumber=15
20NewLine=18
21SquareBracketEnd=12
22Hyphen=13
23NotSuperMetaCharacter=17
24SuperMetaCharacters=21
25SquareBracketStart=10
26RoundBracketEnd=9
27QuestionMark=5
28UnicodeCharacter=14
29Star=6
30Or=4
31EscapeSuperMetaCharacter=16
32Caret=11
33
34
35class re2pbsLexer(Lexer):
36
37    grammarFileName = "re2pbs.g"
38    antlr_version = version_str_to_tuple("3.1.3 Mar 17, 2009 19:23:44")
39    antlr_version_str = "3.1.3 Mar 17, 2009 19:23:44"
40
41    def __init__(self, input=None, state=None):
42        if state is None:
43            state = RecognizerSharedState()
44        super(re2pbsLexer, self).__init__(input, state)
45
46
47        self.dfa2 = self.DFA2(
48            self, 2,
49            eot = self.DFA2_eot,
50            eof = self.DFA2_eof,
51            min = self.DFA2_min,
52            max = self.DFA2_max,
53            accept = self.DFA2_accept,
54            special = self.DFA2_special,
55            transition = self.DFA2_transition
56            )
57
58
59
60
61                               
62
63
64
65    # $ANTLR start "NewLine"
66    def mNewLine(self, ):
67
68        try:
69            _type = NewLine
70            _channel = DEFAULT_CHANNEL
71
72            # re2pbs.g:241:13: ( ( '\\r' '\\n' | '\\n' | '\\r' ) )
73            # re2pbs.g:241:16: ( '\\r' '\\n' | '\\n' | '\\r' )
74            pass 
75            # re2pbs.g:241:16: ( '\\r' '\\n' | '\\n' | '\\r' )
76            alt1 = 3
77            LA1_0 = self.input.LA(1)
78
79            if (LA1_0 == 13) :
80                LA1_1 = self.input.LA(2)
81
82                if (LA1_1 == 10) :
83                    alt1 = 1
84                else:
85                    alt1 = 3
86            elif (LA1_0 == 10) :
87                alt1 = 2
88            else:
89                nvae = NoViableAltException("", 1, 0, self.input)
90
91                raise nvae
92
93            if alt1 == 1:
94                # re2pbs.g:241:17: '\\r' '\\n'
95                pass 
96                self.match(13)
97                self.match(10)
98
99
100            elif alt1 == 2:
101                # re2pbs.g:241:28: '\\n'
102                pass 
103                self.match(10)
104
105
106            elif alt1 == 3:
107                # re2pbs.g:241:35: '\\r'
108                pass 
109                self.match(13)
110
111
112
113            #action start
114            _channel=HIDDEN;
115            #action end
116
117
118
119            self._state.type = _type
120            self._state.channel = _channel
121
122        finally:
123
124            pass
125
126    # $ANTLR end "NewLine"
127
128
129
130    # $ANTLR start "Escape"
131    def mEscape(self, ):
132
133        try:
134            _type = Escape
135            _channel = DEFAULT_CHANNEL
136
137            # re2pbs.g:244:20: ( '\\\\' )
138            # re2pbs.g:244:23: '\\\\'
139            pass 
140            self.match(92)
141
142
143
144            self._state.type = _type
145            self._state.channel = _channel
146
147        finally:
148
149            pass
150
151    # $ANTLR end "Escape"
152
153
154
155    # $ANTLR start "Or"
156    def mOr(self, ):
157
158        try:
159            _type = Or
160            _channel = DEFAULT_CHANNEL
161
162            # re2pbs.g:245:20: ( '|' )
163            # re2pbs.g:245:23: '|'
164            pass 
165            self.match(124)
166
167
168
169            self._state.type = _type
170            self._state.channel = _channel
171
172        finally:
173
174            pass
175
176    # $ANTLR end "Or"
177
178
179
180    # $ANTLR start "RoundBracketStart"
181    def mRoundBracketStart(self, ):
182
183        try:
184            _type = RoundBracketStart
185            _channel = DEFAULT_CHANNEL
186
187            # re2pbs.g:246:20: ( '(' )
188            # re2pbs.g:246:23: '('
189            pass 
190            self.match(40)
191
192
193
194            self._state.type = _type
195            self._state.channel = _channel
196
197        finally:
198
199            pass
200
201    # $ANTLR end "RoundBracketStart"
202
203
204
205    # $ANTLR start "RoundBracketEnd"
206    def mRoundBracketEnd(self, ):
207
208        try:
209            _type = RoundBracketEnd
210            _channel = DEFAULT_CHANNEL
211
212            # re2pbs.g:247:20: ( ')' )
213            # re2pbs.g:247:23: ')'
214            pass 
215            self.match(41)
216
217
218
219            self._state.type = _type
220            self._state.channel = _channel
221
222        finally:
223
224            pass
225
226    # $ANTLR end "RoundBracketEnd"
227
228
229
230    # $ANTLR start "SquareBracketStart"
231    def mSquareBracketStart(self, ):
232
233        try:
234            _type = SquareBracketStart
235            _channel = DEFAULT_CHANNEL
236
237            # re2pbs.g:248:20: ( '[' )
238            # re2pbs.g:248:23: '['
239            pass 
240            self.match(91)
241
242
243
244            self._state.type = _type
245            self._state.channel = _channel
246
247        finally:
248
249            pass
250
251    # $ANTLR end "SquareBracketStart"
252
253
254
255    # $ANTLR start "Hyphen"
256    def mHyphen(self, ):
257
258        try:
259            _type = Hyphen
260            _channel = DEFAULT_CHANNEL
261
262            # re2pbs.g:249:20: ( '-' )
263            # re2pbs.g:249:23: '-'
264            pass 
265            self.match(45)
266
267
268
269            self._state.type = _type
270            self._state.channel = _channel
271
272        finally:
273
274            pass
275
276    # $ANTLR end "Hyphen"
277
278
279
280    # $ANTLR start "Caret"
281    def mCaret(self, ):
282
283        try:
284            _type = Caret
285            _channel = DEFAULT_CHANNEL
286
287            # re2pbs.g:250:20: ( '^' )
288            # re2pbs.g:250:23: '^'
289            pass 
290            self.match(94)
291
292
293
294            self._state.type = _type
295            self._state.channel = _channel
296
297        finally:
298
299            pass
300
301    # $ANTLR end "Caret"
302
303
304
305    # $ANTLR start "SquareBracketEnd"
306    def mSquareBracketEnd(self, ):
307
308        try:
309            _type = SquareBracketEnd
310            _channel = DEFAULT_CHANNEL
311
312            # re2pbs.g:251:20: ( ']' )
313            # re2pbs.g:251:23: ']'
314            pass 
315            self.match(93)
316
317
318
319            self._state.type = _type
320            self._state.channel = _channel
321
322        finally:
323
324            pass
325
326    # $ANTLR end "SquareBracketEnd"
327
328
329
330    # $ANTLR start "UnicodeCharacter"
331    def mUnicodeCharacter(self, ):
332
333        try:
334            _type = UnicodeCharacter
335            _channel = DEFAULT_CHANNEL
336
337            # re2pbs.g:255:2: ( Escape 'u' HexDigit HexDigit HexDigit HexDigit )
338            # re2pbs.g:255:4: Escape 'u' HexDigit HexDigit HexDigit HexDigit
339            pass 
340            self.mEscape()
341            self.match(117)
342            self.mHexDigit()
343            self.mHexDigit()
344            self.mHexDigit()
345            self.mHexDigit()
346
347
348
349            self._state.type = _type
350            self._state.channel = _channel
351
352        finally:
353
354            pass
355
356    # $ANTLR end "UnicodeCharacter"
357
358
359
360    # $ANTLR start "SmallHexNumber"
361    def mSmallHexNumber(self, ):
362
363        try:
364            _type = SmallHexNumber
365            _channel = DEFAULT_CHANNEL
366
367            # re2pbs.g:259:4: ( Escape 'x' HexDigit HexDigit )
368            # re2pbs.g:259:6: Escape 'x' HexDigit HexDigit
369            pass 
370            self.mEscape()
371            self.match(120)
372            self.mHexDigit()
373            self.mHexDigit()
374
375
376
377            self._state.type = _type
378            self._state.channel = _channel
379
380        finally:
381
382            pass
383
384    # $ANTLR end "SmallHexNumber"
385
386
387
388    # $ANTLR start "HexDigit"
389    def mHexDigit(self, ):
390
391        try:
392            # re2pbs.g:264:2: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
393            # re2pbs.g:264:4: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
394            pass 
395            if (48 <= self.input.LA(1) <= 57) or (65 <= self.input.LA(1) <= 70) or (97 <= self.input.LA(1) <= 102):
396                self.input.consume()
397            else:
398                mse = MismatchedSetException(None, self.input)
399                self.recover(mse)
400                raise mse
401
402
403
404
405
406        finally:
407
408            pass
409
410    # $ANTLR end "HexDigit"
411
412
413
414    # $ANTLR start "EscapeSuperMetaCharacter"
415    def mEscapeSuperMetaCharacter(self, ):
416
417        try:
418            _type = EscapeSuperMetaCharacter
419            _channel = DEFAULT_CHANNEL
420
421            # re2pbs.g:268:2: ( Escape SuperMetaCharacters )
422            # re2pbs.g:268:4: Escape SuperMetaCharacters
423            pass 
424            self.mEscape()
425            self.mSuperMetaCharacters()
426
427
428
429            self._state.type = _type
430            self._state.channel = _channel
431
432        finally:
433
434            pass
435
436    # $ANTLR end "EscapeSuperMetaCharacter"
437
438
439
440    # $ANTLR start "NotSuperMetaCharacter"
441    def mNotSuperMetaCharacter(self, ):
442
443        try:
444            _type = NotSuperMetaCharacter
445            _channel = DEFAULT_CHANNEL
446
447            # re2pbs.g:272:2: (~ ( SuperMetaCharacters ) )
448            # re2pbs.g:272:4: ~ ( SuperMetaCharacters )
449            pass 
450            if (0 <= self.input.LA(1) <= 41) or self.input.LA(1) == 44 or (46 <= self.input.LA(1) <= 62) or (64 <= self.input.LA(1) <= 90) or (95 <= self.input.LA(1) <= 123) or (125 <= self.input.LA(1) <= 65535):
451                self.input.consume()
452            else:
453                mse = MismatchedSetException(None, self.input)
454                self.recover(mse)
455                raise mse
456
457
458
459
460            self._state.type = _type
461            self._state.channel = _channel
462
463        finally:
464
465            pass
466
467    # $ANTLR end "NotSuperMetaCharacter"
468
469
470
471    # $ANTLR start "SuperMetaCharacters"
472    def mSuperMetaCharacters(self, ):
473
474        try:
475            # re2pbs.g:277:2: ( ( QuestionMark | Star | Cross | Or | SquareBracketStart | SquareBracketEnd | Hyphen | Escape | Caret ) )
476            # re2pbs.g:277:4: ( QuestionMark | Star | Cross | Or | SquareBracketStart | SquareBracketEnd | Hyphen | Escape | Caret )
477            pass 
478            if (42 <= self.input.LA(1) <= 43) or self.input.LA(1) == 45 or self.input.LA(1) == 63 or (91 <= self.input.LA(1) <= 94) or self.input.LA(1) == 124:
479                self.input.consume()
480            else:
481                mse = MismatchedSetException(None, self.input)
482                self.recover(mse)
483                raise mse
484
485
486
487
488
489        finally:
490
491            pass
492
493    # $ANTLR end "SuperMetaCharacters"
494
495
496
497    # $ANTLR start "QuestionMark"
498    def mQuestionMark(self, ):
499
500        try:
501            _type = QuestionMark
502            _channel = DEFAULT_CHANNEL
503
504            # re2pbs.g:287:20: ( '?' )
505            # re2pbs.g:287:23: '?'
506            pass 
507            self.match(63)
508
509
510
511            self._state.type = _type
512            self._state.channel = _channel
513
514        finally:
515
516            pass
517
518    # $ANTLR end "QuestionMark"
519
520
521
522    # $ANTLR start "Star"
523    def mStar(self, ):
524
525        try:
526            _type = Star
527            _channel = DEFAULT_CHANNEL
528
529            # re2pbs.g:288:20: ( '*' )
530            # re2pbs.g:288:23: '*'
531            pass 
532            self.match(42)
533
534
535
536            self._state.type = _type
537            self._state.channel = _channel
538
539        finally:
540
541            pass
542
543    # $ANTLR end "Star"
544
545
546
547    # $ANTLR start "Cross"
548    def mCross(self, ):
549
550        try:
551            _type = Cross
552            _channel = DEFAULT_CHANNEL
553
554            # re2pbs.g:289:20: ( '+' )
555            # re2pbs.g:289:23: '+'
556            pass 
557            self.match(43)
558
559
560
561            self._state.type = _type
562            self._state.channel = _channel
563
564        finally:
565
566            pass
567
568    # $ANTLR end "Cross"
569
570
571
572    def mTokens(self):
573        # re2pbs.g:1:8: ( NewLine | Escape | Or | RoundBracketStart | RoundBracketEnd | SquareBracketStart | Hyphen | Caret | SquareBracketEnd | UnicodeCharacter | SmallHexNumber | EscapeSuperMetaCharacter | NotSuperMetaCharacter | QuestionMark | Star | Cross )
574        alt2 = 16
575        alt2 = self.dfa2.predict(self.input)
576        if alt2 == 1:
577            # re2pbs.g:1:10: NewLine
578            pass 
579            self.mNewLine()
580
581
582        elif alt2 == 2:
583            # re2pbs.g:1:18: Escape
584            pass 
585            self.mEscape()
586
587
588        elif alt2 == 3:
589            # re2pbs.g:1:25: Or
590            pass 
591            self.mOr()
592
593
594        elif alt2 == 4:
595            # re2pbs.g:1:28: RoundBracketStart
596            pass 
597            self.mRoundBracketStart()
598
599
600        elif alt2 == 5:
601            # re2pbs.g:1:46: RoundBracketEnd
602            pass 
603            self.mRoundBracketEnd()
604
605
606        elif alt2 == 6:
607            # re2pbs.g:1:62: SquareBracketStart
608            pass 
609            self.mSquareBracketStart()
610
611
612        elif alt2 == 7:
613            # re2pbs.g:1:81: Hyphen
614            pass 
615            self.mHyphen()
616
617
618        elif alt2 == 8:
619            # re2pbs.g:1:88: Caret
620            pass 
621            self.mCaret()
622
623
624        elif alt2 == 9:
625            # re2pbs.g:1:94: SquareBracketEnd
626            pass 
627            self.mSquareBracketEnd()
628
629
630        elif alt2 == 10:
631            # re2pbs.g:1:111: UnicodeCharacter
632            pass 
633            self.mUnicodeCharacter()
634
635
636        elif alt2 == 11:
637            # re2pbs.g:1:128: SmallHexNumber
638            pass 
639            self.mSmallHexNumber()
640
641
642        elif alt2 == 12:
643            # re2pbs.g:1:143: EscapeSuperMetaCharacter
644            pass 
645            self.mEscapeSuperMetaCharacter()
646
647
648        elif alt2 == 13:
649            # re2pbs.g:1:168: NotSuperMetaCharacter
650            pass 
651            self.mNotSuperMetaCharacter()
652
653
654        elif alt2 == 14:
655            # re2pbs.g:1:190: QuestionMark
656            pass 
657            self.mQuestionMark()
658
659
660        elif alt2 == 15:
661            # re2pbs.g:1:203: Star
662            pass 
663            self.mStar()
664
665
666        elif alt2 == 16:
667            # re2pbs.g:1:208: Cross
668            pass 
669            self.mCross()
670
671
672
673
674
675
676
677    # lookup tables for DFA #2
678
679    DFA2_eot = DFA.unpack(
680        u"\3\uffff\1\20\22\uffff"
681        )
682
683    DFA2_eof = DFA.unpack(
684        u"\26\uffff"
685        )
686
687    DFA2_min = DFA.unpack(
688        u"\1\0\2\uffff\1\52\22\uffff"
689        )
690
691    DFA2_max = DFA.unpack(
692        u"\1\uffff\2\uffff\1\174\22\uffff"
693        )
694
695    DFA2_accept = DFA.unpack(
696        u"\1\uffff\2\1\1\uffff\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\15\1\16\1"
697        u"\17\1\20\1\1\1\2\1\14\1\13\1\12\1\4\1\5"
698        )
699
700    DFA2_special = DFA.unpack(
701        u"\1\0\25\uffff"
702        )
703
704           
705    DFA2_transition = [
706        DFA.unpack(u"\12\13\1\2\2\13\1\1\32\13\1\5\1\6\1\15\1\16\1\13\1\10"
707        u"\21\13\1\14\33\13\1\7\1\3\1\12\1\11\35\13\1\4\uff83\13"),
708        DFA.unpack(u""),
709        DFA.unpack(u""),
710        DFA.unpack(u"\2\21\1\uffff\1\21\21\uffff\1\21\33\uffff\4\21\26\uffff"
711        u"\1\23\2\uffff\1\22\3\uffff\1\21"),
712        DFA.unpack(u""),
713        DFA.unpack(u""),
714        DFA.unpack(u""),
715        DFA.unpack(u""),
716        DFA.unpack(u""),
717        DFA.unpack(u""),
718        DFA.unpack(u""),
719        DFA.unpack(u""),
720        DFA.unpack(u""),
721        DFA.unpack(u""),
722        DFA.unpack(u""),
723        DFA.unpack(u""),
724        DFA.unpack(u""),
725        DFA.unpack(u""),
726        DFA.unpack(u""),
727        DFA.unpack(u""),
728        DFA.unpack(u""),
729        DFA.unpack(u"")
730    ]
731
732    # class definition for DFA #2
733
734    class DFA2(DFA):
735        pass
736
737
738        def specialStateTransition(self_, s, input):
739            # convince pylint that my self_ magic is ok ;)
740            # pylint: disable-msg=E0213
741
742            # pretend we are a member of the recognizer
743            # thus semantic predicates can be evaluated
744            self = self_.recognizer
745
746            _s = s
747
748            if s == 0: 
749                LA2_0 = input.LA(1)
750
751                s = -1
752                if (LA2_0 == 13):
753                    s = 1
754
755                elif (LA2_0 == 10):
756                    s = 2
757
758                elif (LA2_0 == 92):
759                    s = 3
760
761                elif (LA2_0 == 124):
762                    s = 4
763
764                elif (LA2_0 == 40):
765                    s = 5
766
767                elif (LA2_0 == 41):
768                    s = 6
769
770                elif (LA2_0 == 91):
771                    s = 7
772
773                elif (LA2_0 == 45):
774                    s = 8
775
776                elif (LA2_0 == 94):
777                    s = 9
778
779                elif (LA2_0 == 93):
780                    s = 10
781
782                elif ((0 <= LA2_0 <= 9) or (11 <= LA2_0 <= 12) or (14 <= LA2_0 <= 39) or LA2_0 == 44 or (46 <= LA2_0 <= 62) or (64 <= LA2_0 <= 90) or (95 <= LA2_0 <= 123) or (125 <= LA2_0 <= 65535)):
783                    s = 11
784
785                elif (LA2_0 == 63):
786                    s = 12
787
788                elif (LA2_0 == 42):
789                    s = 13
790
791                elif (LA2_0 == 43):
792                    s = 14
793
794                if s >= 0:
795                    return s
796
797            nvae = NoViableAltException(self_.getDescription(), 2, _s, input)
798            self_.error(nvae)
799            raise nvae
800 
801
802
803
804def main(argv, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
805    from antlr3.main import LexerMain
806    main = LexerMain(re2pbsLexer)
807    main.stdin = stdin
808    main.stdout = stdout
809    main.stderr = stderr
810    main.execute(argv)
811
812
813if __name__ == '__main__':
814    main(sys.argv)
Note: See TracBrowser for help on using the repository browser.