source: proto/RE2PBS/re2pbs.g @ 1495

Last change on this file since 1495 was 1203, checked in by ksherdy, 8 years ago

General commit. Last commit over two months prior and details are fuzzy at this point.

File size: 6.5 KB
Line 
1/*
2
3  AnTLR Grammar (Python)
4
5  Regular Expressions to Parallel Bit Stream equation generator.
6
7  The AnTLR parser generator generates re2pbsLexer.py, re2pbsParser.py and re2pbs.tokens.
8
9  re2pbsParser.py parser execution generates 'prototype.py' based on the template file 'prototype_template.py' and
10  and 'compilable.py' based on the template file 'compilable_template.py' via Syntax Directed Translation.
11
12  WARNINGS
13
14  - Restricted meta character handling. All meta characters (character class meta characters, global regular expression meta characters)
15    must be escaped at all scopes/context. The token definition SuperMetaCharacters defines this union of character class
16    and non character class meta characters.
17 
18  - Use the hexadecimal escape sequences to specify newline characters.
19 
20  DEPENDENCIES
21
22  - charset_compiler.py
23  - charset_def.py
24  - codepoint_symbol_table.py
25  - re2pbs.py
26  - prototype_template.py
27  - compilable_template.py
28
29 
30 
31  Copyright (c) 2011, Ken Herdy
32
33  Version 0.7 - April 15, 2011
34 
35      - Restricted meta character handling. All meta characters (character class meta characters, global regular expression meta characters)
36      must be escaped at all scopes/context.
37      - Use of hexadecimal escapes to specify newline characters.
38      - Support alternation, concatenation, repetition operators ('?','+','*')
39      TODO - Add precedence via grouping operator '(' ')'.
40
41  Version 0.8 - (Not Implemented)
42
43        Two pass implementation to support regular expression escape characters at both the
44        the global and character class scopes.
45       
46        i.e.    Pass One - Character class scope pass.
47                Pass Two - Global scope pass.
48*/
49grammar re2pbs;
50
51options {       
52        language = Python;
53}
54
55@header {
56        from re2pbs import *
57        from codepoint_symbol_table import *
58        from charset_compiler import chardeflist2py
59        from charset_def import CharSetDef
60}
61
62@members {
63        symbol_table = CodePointSymbolTable()
64}
65
66@lexer::header {
67}
68
69@lexer::members {
70}
71
72prog    :       r = re EOF
73{
74        lex_strms = ''
75        cc_code = ''
76        pbs_code = ''
77        pbs_debug = ''
78
79        prefix = 'lex.'
80
81        # Character Class compiler dependency
82        lexical_item_names = self.symbol_table.symbols.keys()
83        cc_code = chardeflist2py(generate_chardefsets(self.symbol_table.symbols.items(), prefix))
84
85        # Generate prototype.py based on the template file 'prototype_template.py'.
86        factory = GeneratorFactory()   
87        prototype = Program(factory, 'prototype_template.py', 'prototype.py')
88        lex_strms = prototype.generate_lex_strms(lexical_item_names)
89       
90        (pbs_code, pbs_debug) = prototype.generate_pbs_code_pbs_debug(r.union.concatenation_list, prefix)               
91        prototype.generate(lex_strms, cc_code, pbs_code, pbs_debug)
92
93        # Generate 'compilable.py' based on the template file 'compilable_template.py'.
94        factory = GeneratorFactory()   
95        compilable = Program(factory, 'compilable_template.py', 'compilable.py')
96        lex_strms = compilable.generate_lex_strms(lexical_item_names)
97        (pbs_code, pbs_debug) = compilable.generate_pbs_code_pbs_debug(r.union.concatenation_list, prefix)             
98        compilable.generate(lex_strms, cc_code, pbs_code, pbs_debug)
99}
100        ;
101               
102re      returns [object]
103@init {
104        object = RE()
105}
106@after {
107        # print object.debug()
108}
109        :       (union
110                        {       
111                                object.union = $union.object
112                        }
113                )?
114        ;       
115       
116union   returns [object]
117@init {
118        object = Union()       
119}
120@after {
121        #print object.debug()
122}
123        :       c0 = concatenation             
124                {
125                        # initialize an object
126                        object.concatenation_list.append(c0)
127                }
128                (
129                Or ck = concatenation   
130                {
131                        # initialize an object
132                        object.concatenation_list.append(ck)
133                } 
134                )*
135        ;
136       
137concatenation returns [object]
138@init {
139        object = Concatenation()
140}
141@after {
142        #print object.debug()
143}
144        : (atom {object.atom_list.append($atom.object)})+
145        ;       
146
147atom returns [object]
148@init {
149        symbol = CodePointSymbol()     
150        object = Atom()     
151}
152@after {
153       
154        self.symbol_table.insert(symbol.key(), symbol)                 
155        #print object.debug()
156}
157        :
158        (
159                group   
160                (q0 = QuestionMark      {object.quantifier = $q0.text} )?
161                |
162                (
163                        single  {
164                                        symbol.add_codepoint($single.object.codepoint)
165                                        object.strm_name = symbol.key()
166                                }
167                        |
168                        characterClass 
169                                {       
170                                        for obj in $characterClass.object.single_or_range:
171                                                if isinstance(obj,Single):
172                                                        symbol.add_codepoint(obj.codepoint, $characterClass.object.invert)
173                                                elif isinstance(obj,Range):
174                                                        symbol.add_codepoint_range(obj.codepoint_lower, obj.codepoint_upper, $characterClass.object.invert)
175                                        object.strm_name = symbol.key()
176                                }
177                )
178                ( q1 = QuestionMark     {object.quantifier = $q1.text}
179                | Star                  {object.quantifier = $Star.text}
180                | Cross                 {object.quantifier = $Cross.text} )?
181        )
182        ;
183       
184group   :
185        RoundBracketStart
186        re
187        RoundBracketEnd
188        ;       
189       
190characterClass  returns [object]
191@init {
192        object = CharacterClass()
193}
194@after {
195        #object.debug()
196}
197        :
198        SquareBracketStart                     
199        (Caret  {object.invert = True})?
200        (
201        range           {object.single_or_range.append($range.object)}
202        |
203        single          {object.single_or_range.append($single.object)}
204        )+
205        SquareBracketEnd                       
206        ;
207       
208range   returns [object]
209@init{
210        object = Range()
211}
212@after {
213        #object.debug()
214}
215        :       lb = single {object.codepoint_lower = $lb.object.codepoint}     
216               
217                Hyphen
218               
219                ub = single {object.codepoint_upper = $ub.object.codepoint}     
220                                                                       
221        ;       
222       
223single  returns [object]
224@init{
225        object = Single()
226}
227@after {
228        #object.debug()
229}
230        : i = UnicodeCharacter                                  {object.codepoint = int($i.text[2:],16)}
231                                                                       
232        | j = SmallHexNumber                                    {object.codepoint = int($j.text[2:],16)}
233                                                                       
234        | k = EscapeSuperMetaCharacter                          {object.codepoint = ord($k.text[1:])}
235
236        | l = NotSuperMetaCharacter                             {object.codepoint = ord($l.text[(len($l.text)-1):])}
237                                                                                                                                               
238        ;       
239
240// Lexical
241NewLine            :  ('\r''\n' | '\n' | '\r' )     {$channel=HIDDEN;}  ; // LFCR - Windows | LF - Unix | CR - Mac --> Specifiy using Unicode or Small Hex Escape
242
243// Supermetacharacters
244Escape             :  '\\'     ;
245Or                 :  '|'      ;
246RoundBracketStart  :  '('       ;       
247RoundBracketEnd    :  ')'       ;       
248SquareBracketStart :  '['      ;       
249Hyphen             :  '-'      ;       
250Caret              :  '^'      ;       
251SquareBracketEnd   :  ']'      ;       
252
253
254UnicodeCharacter
255        : Escape 'u' HexDigit HexDigit HexDigit HexDigit
256        ;       
257
258SmallHexNumber
259        : Escape 'x' HexDigit HexDigit
260        ;
261
262fragment
263HexDigit
264        : ('0'..'9' | 'a'..'f' | 'A'..'F')
265        ;
266
267EscapeSuperMetaCharacter
268        : Escape SuperMetaCharacters
269        ;
270       
271NotSuperMetaCharacter
272        : ~(SuperMetaCharacters)
273        ;       
274       
275fragment
276SuperMetaCharacters
277        : (QuestionMark | Star | Cross | Or | SquareBracketStart | SquareBracketEnd | Hyphen | Escape | Caret)
278        ;
279
280/*     
281Quantifier
282        :  QuestionMark
283        |  Star
284        |  Cross
285        ;       
286*/
287QuestionMark       :  '?'      ;       
288Star               :  '*'      ;       
289Cross              :  '+'      ;       
290
Note: See TracBrowser for help on using the repository browser.