source: proto/RE2PBS/re2pbsj.g @ 1647

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