source: proto/RE2PBS/re2pbs.g @ 1149

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

Add prototype

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