source: proto/RE2PBS/re2pbsj.g @ 1130

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

Initial check in.

File size: 5.9 KB
Line 
1/*
2
3  AnTLR Grammar (Java)
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    Equivalent AnTLRWorks Java implementation to for AST visualization and debug.
12
13*/
14
15grammar re2pbsj;
16
17options {       
18        language = Java;
19}
20
21@header {
22
23}
24
25@members {
26
27}
28
29@lexer::header {
30}
31
32@lexer::members {
33
34}
35
36prog    :       re EOF
37        ;
38               
39re      :       union?
40        ;       
41       
42union   :       concatenation (Or concatenation)*
43        ;
44       
45concatenation
46        : atom+
47        ;       
48
49atom   
50@init {
51   
52}
53@after {
54
55}
56        :
57        (       
58//      character       
59        single
60        |
61        characterClass 
62        )
63        (Quantifier)?
64        ;
65       
66characterClass
67@init {
68       
69}
70        :
71        SquareBracketStart                     
72        (Caret)?
73        (
74        range           
75        |
76        single         
77        )+
78        SquareBracketEnd                       
79        ;
80
81/*     
82range   : 
83        characterClassCharacter Hyphen characterClassCharacter                                                         
84        ;       
85       
86single  :
87        characterClassCharacter
88        ;
89*/     
90
91range   : 
92        single Hyphen single
93        ;       
94               
95single
96        : UnicodeCharacter     
97                                                                       
98        | SmallHexNumber       
99       
100        | EscapeSuperMetaCharacter
101
102        | NotSuperMetaCharacter
103       
104        ;
105
106/*
107character
108
109        : UnicodeCharacter     
110                                                                       
111        | SmallHexNumber       
112                                                               
113        | EscapeMetaCharacter   
114       
115        | NotMetaCharacter             
116                                                                                                                                       
117        ;       
118*/
119
120/*
121characterClassCharacter
122
123        : UnicodeCharacter
124                                       
125        | SmallHexNumber
126                                                                                                                               
127        | i = EscapeCharacterClassMetaCharacter
128                                                                               
129        | j = ~(Hyphen | Escape | Caret | SquareBracketEnd)
130        ;       
131*/             
132
133NewLine            :  ('\r''\n' | '\n' | '\r' )     {$channel=HIDDEN;}  ; // LFCR - Windows | LF - Unix | CR - Mac --> Specifiy using Unicode or Small Hex Escape
134
135Escape             :  '\\'     ;
136
137// metacharacters
138Or                 :  '|'      ;
139
140// character class metacharacters       
141SquareBracketStart :  '['      ;       
142Hyphen             :  '-'      ;       
143Caret              :  '^'      ;       
144SquareBracketEnd   :  ']'      ;       
145
146UnicodeCharacter
147        : Escape 'u' HexDigit HexDigit HexDigit HexDigit
148        ;       
149
150SmallHexNumber
151        : Escape 'x' HexDigit HexDigit
152        ;
153
154fragment
155HexDigit
156        : ('0'..'9' | 'a'..'f' | 'A'..'F')
157        ;
158
159/* Single character token defintions must precede character class token definitions,
160   since the MetaCharacter set is a superset of the CharacterClassMetaCharacterSet
161*/
162
163/*
164EscapeMetaCharacter
165        : Escape MetaCharacter
166        ;
167
168NotMetaCharacter
169        : ~(MetaCharacter)
170        ;
171       
172fragment
173MetaCharacter
174        : (QuestionMark | Star | Cross | Or | SquareBracketStart | SquareBracketEnd | Escape)
175        ;
176*/
177
178/*
179EscapeCharacterClassMetaCharacter
180        : Escape CharacterClassMetaCharacter
181        ;
182
183       
184NotCharacterClassMetaCharacter 
185        : ~(CharacterClassMetaCharacter)
186        ;
187
188fragment
189CharacterClassMetaCharacter
190        : (Hyphen | Escape | Caret | SquareBracketEnd)
191        ;
192*/
193
194
195//A super set of the standard single regular expression and character class characters
196
197EscapeSuperMetaCharacter
198        : Escape SuperMetaCharacters
199        ;
200       
201NotSuperMetaCharacter
202        : ~(SuperMetaCharacters)
203        ;       
204       
205fragment
206SuperMetaCharacters
207        : (QuestionMark | Star | Cross | Or | SquareBracketStart | SquareBracketEnd | Escape | Hyphen | Escape | Caret)
208        ;
209
210
211//EscapeMetaCharacter
212//      : Escape MetaCharacter
213//      ;
214
215//NotMetaCharacter
216//      : ~(MetaCharacter)
217//      ;
218       
219//fragment
220//MetaCharacter
221//      : (QuestionMark | Star | Cross | Or | SquareBracketStart | SquareBracketEnd | Escape)
222//      ;       
223
224Quantifier
225        :  QuestionMark
226        |  Star
227        |  Cross
228        ;       
229       
230// repetition
231fragment       
232QuestionMark       :  '?'      ;       
233
234fragment       
235Star               :  '*'      ;       
236
237fragment       
238Cross               :  '+'      ;       
239
240/*
241
242*/
243
244
245/* Escape Characters
246
247Escape characters occur on three levels.
248
249(1) Regular expression meta characters.
250(2) Character class meta characters.
251(3) Python string escape characters.
252
253(1) For the purpose of this prototype the character set defined by the
254logical negation the token type 'Characters' defines the regular expression
255meta characters.
256
257(2) CARET, HYPHEN, BACKSLASH, ESCAPE
258
259CARET           - Strip leading '\'
260HYPHEN          - Strip leading '\'
261BACKSLACH       - Supported by RE Compiler     
262ESCAPE          - Supported by RE Compiler
263
264(3) Several Python character class compiler escape characters must be 'escaped' for correct
265interpretation by the underlying character class compiler.
266
267'*'  Indicates those characters that must be escaped since the RE compiler does not escape these characters,
268i.e. some special handling is required.
269
270Escape Sequence         Meaning                 Notes
271\n                      Ignored                 - Not supported via the RE compiler, use \xhh syntax
272\\                      Backslash (\)           - Supported by RE compiler
273\'                      Single quote (')        *       
274\"                      Double quote (")        *     
275\a                      ASCII Bell (BEL)        - Not supported via the RE compiler, use \xhh syntax
276\b                      ASCII Backspace (BS)    - Not supported via the RE compiler, use \xhh syntax
277\f                      ASCII Formfeed (FF)     - Not supported via the RE compiler, use \xhh syntax
278\n                      ASCII Linefeed (LF)     - Not supported via the RE compiler, use \xhh syntax
279\N{name}                Character named name in the Unicode database (Unicode only) - Not supported     
280\r                      ASCII Carriage Return (CR)       
281\t                      ASCII Horizontal Tab (TAB)       
282\uxxxx                  Character with 16-bit hex value xxxx (Unicode only)     - Supported by RE compiler
283\Uxxxxxxxx              Character with 32-bit hex value xxxxxxxx (Unicode only) - Not supported via the RE compiler,
284\v      ASCII Vertical Tab (VT)                 - Not supported via the RE compiler, use \xhh syntax
285\ooo    Character with octal value ooo  (3,5)   - Supported by RE compiler
286\xhh    Character with hex value hh     (4,5)   - Supported by RE compiler
287
288*/
289
290/*
291Robert D. Cameron's Regular Expression BNF
292
293<RE>    ::=     <union> | <simple-RE>
294<union>         ::=     <RE> "|" <simple-RE>
295<simple-RE>     ::=     <concatenation> | <basic-RE>
296<concatenation>         ::=     <simple-RE> <basic-RE>
297<basic-RE>      ::=     <star> | <plus> | <elementary-RE>
298<star>  ::=     <elementary-RE> "*"
299<plus>  ::=     <elementary-RE> "+"
300<elementary-RE>         ::=     <group> | <any> | <eos> | <char> | <set>
301<group>         ::=     "(" <RE> ")"
302<any>   ::=     "."
303<eos>   ::=     "$"
304<char>  ::=     any non metacharacter | "\" metacharacter
305<set>   ::=     <positive-set> | <negative-set>
306<positive-set>  ::=     "[" <set-items> "]"
307<negative-set>  ::=     "[^" <set-items> "]"
308<set-items>     ::=     <set-item> | <set-item> <set-items>
309<set-items>     ::=     <range> | <char>
310<range>         ::=     <char> "-" <char>
311
312*/
Note: See TracBrowser for help on using the repository browser.