-
Notifications
You must be signed in to change notification settings - Fork 0
/
grammar.ebnf
264 lines (134 loc) · 12.8 KB
/
grammar.ebnf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
<program> ::= <main block>
<main block> ::= {<declaration part>} <compound statement> "."
<declaration part> ::= {<variable declaration part> | <constant declaration part> | <type declaration part>} | <function declaration part> | <procedure declaration part>
<function declaration part> ::= "function" <identifier> "(" <parameters list> ")" ":" <type> ";" <variable declaration part> <compound statement> ";"
<procedure declaration part> ::= "procedure" <identifier> "(" <parameters list> ")" ";" <variable declaration part> <compound statement> ";"
<type declaration part> := "type" <type declaration> {<type declaration>}
<type declaration> := <identifier> "=" ["Type"] (<array type> | <identifier>) ";"
<constant declaration part> ::= "const" <constant declaration> {<constant declaration>}
<constant declaration> ::= <identifier> "=" <const expression> ";"
<variable declaration part> ::= "var" <variable declaration> ";" {variable declaration ";"}
<variable declaration> ::= <multiple variables> | <single variable>
<multiple variables> ::= <identifier> {"," <identifier>} ":" (<type> | <array type>)
<single variable> ::= <identifier> ":" (<type> {"=" <const expression>} | <array type>)
<type> ::= <identifier> | <array type>
<array type> := "Array" "[" <int const expr> ".." <int const expr> "]" "Of" (<type> | <array type> )
<int const expr> := <const simple expression>
<compound statement> ::= "begin" <statement> {; <statement>} [ ";" ] "end"
<statement> ::= <simple statement> | <structured statement>
<simple statement> ::= <assignment statement> | <procedure statement>
<assignment statement> ::= <variable reference> <assignment operators> <expression>
<identifier> ::= <letter> {<letter> | <dec digit>}
<letter> ::= _ | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
<dec digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<assignment operators> :: = ":=" | "+=" | "-=" | "*=" | "/="
<const expression> ::= <const simple expression> [<relational operator> <const simple expression>]
<const simple expression> ::= <simple expression> ::= (<const term> { ("+" | "-" | "or" | "xor") <const term>})
<const term> ::= <const factor> {("*" | "/" | "div" | "mod" | "and" | "shl" | "shr") <const factor>}
<const factor> ::= "(" <const expression> ")" | <unsigned constant> | <char constant> | <string constant> | "not" <factor>
<expression> ::= <simple expression> [<relational operator> <simple expression>]
<relational operator> ::= "=" | "<>" | "<" | "<=" | ">=" | ">"
<simple expression> ::= (<term> { ("+" | "-" | "or" | "xor") <term>}) [ "^" ]
<term> ::= <factor> {("*" | "/" | "div" | "mod" | "and" | "shl" | "shr") <factor>}
<factor> ::= "(" <expression> ")" | <variable reference> | <unsigned constant> | <function call> | <char constant> | <string constant> | <record access> | <array access> | "not" <factor> | <value typecast> | <address factor>
<char constant> := "'" <ASCII char> "'"
<string constant> := "'" <ASCII char> {<ASCII char>} "'"
<unsigned constant> ::= <unsigned number>
<unsigned number> ::= <unsigned integer> | <unsigned float>
<unsigned float> ::= <dec integer> [. <dec integer>] [(E|e) <dec integer>]
<unsigned integer> ::= <dec integer> | <bin integer> | <hex integer> | <oct integer>
<dec integer> ::= <dec digit> {<dec digit>}
<bin integer> ::= "%"(0|1){(0|1)}
<hex integer> ::= "$"(<digit> | <hex letter>) {(<digit> | <hex letter>)}
<hex letter> ::= A | B | C | D | E | F | a | b | c | d | e | f
<oct integer> ::= "&" <oct digit> { <oct digit> }
<oct digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7"
<function call> ::= <variable reference> <actual parameter list>
<record access> ::= (<variable reference> | <function call>) "." <identifier>
<array access> ::= (<variable reference> | <record access>) "[" <expression> {","" <expression>} "]"
<variable reference> := (<identifier> | <record access> | <array access> | <function call>) ["^"]
<value typecast> ::= <type identifier> "(" <expression> ")"
<type identifier> ::= <identifier>
<address factor> ::= "@" <variable reference>
<procedure statement> ::= <variable reference> <actual parameter list>
<actual parameter list> ::= "(" [<expression> {"," <expression>} ] ")"
<structured statement> ::= <compound statement> | <if statement> | <repetitive statement>
<if statement> ::= "if" <expression> "then" <statement> {"else" <statement>}
<repetitive statement> ::= <while statement> | <for statement>
<while statement> ::= "while" <expression> "do" <statement>
<for statement> ::= "for" <control variable> ":=" <initial value> ("to" | "downto") <final value> "do" <statement>
<control variable> ::= <variable identifier>
<variable identifier> ::= <identifier>
<initial value> ::= <expression>
<final value> ::= <expression>
------------------------------------------------------------------------------------------------------------------------
<program> ::= <main block>
<main block> ::= {<main block section>;}
begin
<statement part>
end.
<main block section> ::= <type definition part> |
<variable declaration part> |
<constant definition part> |
<procedure and function declaration part>
<type definition part> ::= [ type <type definition> {; <type definition>} ]
<type definition> ::= <identifier> = <type>
<identifier> ::= <letter> {<letter> | <digit>}
<letter> ::= _ | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
<digit> ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<type> ::= <simple type> | <array type> | <pointer type> | <record type>
<simple type> ::= <identifier>
<array type> ::= array "[" <index ranges> "]" of <type>
<index ranges> ::= <index range> {, <index range>}
<index range> ::= <integer> .. <integer>
<integer> ::= [<sign>] <unsigned integer>
<sign> ::= + | -
<unsigned integer> ::= (<dec integer> | <bin integer> | <hex integer>)
<dec integer> ::= <digit> {<digit>}
<bin integer> ::= %(0|1){(0|1)}
<hex integer> ::= $(<digit> | <hex letter>) {(<digit> | <hex letter>)}
<hex letter> ::= A | B | C | D | E | F | a | b | c | d | e | f
<pointer type> ::= ^ <simple type>
<record type> ::= record [<field list>] end
<field list> ::= <field section> {; <field section>}
<field section> ::= <identifier> {, <identifier>} : <type>
<constant definition part> ::= [ const <constant definition> {; <constant definition> } ]
<constant definition> ::= <identifier> : <type> = <initializer>
<initializer> ::= <string literal> | <record constant> | <array constant> | [<sign>] <identifier> | <expression>
<string literal> ::= <char literal> | <simple string literal> | [<char literal>]<string literal> | [<simple string literal>]<string literal>
<char literal> ::= #<dec integer>
<simple string literal> ::= '<character> {<character>}'
<expression> ::= <simple expression> | <simple expression> <relational operator> <simple expression>
<relational operator> ::= = | "<>" | "<" | <= | >= | ">"
<simple expression> ::= <term> | <sign> <term>| <simple expression> <adding operator> <term>
<adding operator> ::= + | - | or
<term> ::= <factor> | <term> <multiplying operator> <factor>
<multiplying operator> ::= * | / | div | mod | and
<factor> ::= <identifier> | <unsigned number> | ( <expression> ) | <function call> | <record access> | <array access> | not <factor>
<unsigned number> ::= <unsigned integer> | <unsigned float>
<unsigned float> ::= <unsigned integer> [. <unsigned integer>] [(E|e) <integer>]
<function call> ::= <identifier> | <identifier "(" <expression> {, <expression>} ")"
<record access> ::= (<identifier> | <function call>) . <identifier>
<array access> ::= <identifier> "[" <expression> {,<expression>} "]"
<variable declaration part> ::= [ var <variable declaration> {; <variable declaration> } ]
<variable declaration> ::= <identifier> {,<identifier>} : <type> | <identifier> : <type> = <initializer>
<procedure and function declaration part> ::= {<procedure declaration > | <function declaration > ;}
<procedure declaration> ::= <procedure heading> <block>
<procedure heading> ::= procedure <identifier> ["(" <formal parameter section> {;<formal parameter section>}")"];
<formal parameter section> ::= [[var] <identifier> {, <identifier>} : <simple type>]
<block> ::= {<block section>;} <compound statement>
<block section> ::= <type definition part> | <variable declaration part> | <constant definition part>
<compound statement> ::= begin <statement part> end;
<statement part> ::= [<statement> {; <statement>}]
<statement> ::= <simple statement> | <structured statement>
<simple statement> ::= <assignment statement> | <function call>
<assignment statement> ::= <assignable> := <expression>
<assignable> := <identifier> | <expression>^
<structured statement> ::= <compound statement> | <if statement> | <while statement> | <repeat statemant> | <for statement>
<if statement> ::= if <expression> then <statement> [ else <statement> ]
<while statement> ::= while <expression> do <statement>
<repeat statement> ::= repeat <statement part> until <expression>
<for statement> ::= for <identifier> := <for bounds> do <statement>
<for bounds> ::= <expresion> (to | downto) <expression>
<function declaration> ::= <function heading> <block>
<function heading> ::= function <identifier> ["(" <formal parameter section> {;<formal parameter section>}")"] : <simple type>;