source: proto/RE2PBS/re2pbs.g @ 1167

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

Refactor. Remove utility code from grammar.

File size: 6.3 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                (
130                Or ck = concatenation   
131                {
132                        # initialize an object
133                        object.concatenation_list.append(ck)
134                } 
135                )*
136        ;
137       
138concatenation returns [object]
139@init {
140        object = Concatenation()
141}
142@after {
143        #print object.debug()
144}
145        : (atom {object.atom_list.append($atom.object)})+
146        ;       
147
148atom returns [object]
149@init {
150        symbol = CodePointSymbol()     
151        object = Atom()     
152}
153@after {
154       
155        self.symbol_table.insert(symbol.key(), symbol)                 
156        #print object.debug()
157}
158        :
159        (
160        single  {
161                        symbol.add_codepoint($single.object.codepoint)
162                        object.strm_name = symbol.key()
163                }
164        |
165        characterClass 
166                {       
167                        for obj in $characterClass.object.single_or_range:
168                                if isinstance(obj,Single):
169                                        symbol.add_codepoint(obj.codepoint, $characterClass.object.invert)
170                                elif isinstance(obj,Range):
171                                        symbol.add_codepoint_range(obj.codepoint_lower, obj.codepoint_upper, $characterClass.object.invert)
172                        object.strm_name = symbol.key()
173                }
174        )
175        (Quantifier {object.quantifier = $Quantifier.text})?
176        ;
177       
178characterClass  returns [object]
179@init {
180        object = CharacterClass()
181}
182@after {
183        #object.debug()
184}
185        :
186        SquareBracketStart                     
187        (Caret  {object.invert = True})?
188        (
189        range           {object.single_or_range.append($range.object)}
190        |
191        single          {object.single_or_range.append($single.object)}
192        )+
193        SquareBracketEnd                       
194        ;
195       
196range   returns [object]
197@init{
198        object = Range()
199}
200@after {
201        #object.debug()
202}
203        :       lb = single {object.codepoint_lower = $lb.object.codepoint}     
204               
205                Hyphen
206               
207                ub = single {object.codepoint_upper = $ub.object.codepoint}     
208                                                                       
209        ;       
210       
211single  returns [object]
212@init{
213        object = Single()
214}
215@after {
216        #object.debug()
217}
218        : i = UnicodeCharacter                                  {object.codepoint = int($i.text[2:],16)}
219                                                                       
220        | j = SmallHexNumber                                    {object.codepoint = int($j.text[2:],16)}
221                                                                       
222        | k = EscapeSuperMetaCharacter                          {object.codepoint = ord($k.text[1:])}
223
224        | l = NotSuperMetaCharacter                             {object.codepoint = ord($l.text[(len($l.text)-1):])}
225                                                                                                                                               
226        ;       
227
228// Lexical
229NewLine            :  ('\r''\n' | '\n' | '\r' )     {$channel=HIDDEN;}  ; // LFCR - Windows | LF - Unix | CR - Mac --> Specifiy using Unicode or Small Hex Escape
230
231// Supermetacharacters
232Escape             :  '\\'     ;
233Or                 :  '|'      ;
234SquareBracketStart :  '['      ;       
235Hyphen             :  '-'      ;       
236Caret              :  '^'      ;       
237SquareBracketEnd   :  ']'      ;       
238
239
240UnicodeCharacter
241        : Escape 'u' HexDigit HexDigit HexDigit HexDigit
242        ;       
243
244SmallHexNumber
245        : Escape 'x' HexDigit HexDigit
246        ;
247
248fragment
249HexDigit
250        : ('0'..'9' | 'a'..'f' | 'A'..'F')
251        ;
252
253EscapeSuperMetaCharacter
254        : Escape SuperMetaCharacters
255        ;
256       
257NotSuperMetaCharacter
258        : ~(SuperMetaCharacters)
259        ;       
260       
261fragment
262SuperMetaCharacters
263        : (QuestionMark | Star | Cross | Or | SquareBracketStart | SquareBracketEnd | Hyphen | Escape | Caret)
264        ;
265       
266Quantifier
267        :  QuestionMark
268        |  Star
269        |  Cross
270        ;       
271
272fragment
273QuestionMark       :  '?'      ;       
274
275fragment
276Star               :  '*'      ;       
277
278fragment
279Cross              :  '+'      ;       
280
Note: See TracBrowser for help on using the repository browser.