Commit | Line | Data |
---|---|---|
5636bb2c C |
1 | /* |
2 | * Copyright 2005-2010, Ecole des Mines de Nantes, University of Copenhagen | |
3 | * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix | |
4 | * This file is part of Coccinelle. | |
5 | * | |
6 | * Coccinelle is free software: you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation, according to version 2 of the License. | |
9 | * | |
10 | * Coccinelle is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with Coccinelle. If not, see <http://www.gnu.org/licenses/>. | |
17 | * | |
18 | * The authors reserve the right to distribute this or future versions of | |
19 | * Coccinelle under other licenses. | |
20 | */ | |
21 | ||
22 | ||
9f8e26f4 | 23 | /* |
ae4735db | 24 | * Copyright 2005-2010, Ecole des Mines de Nantes, University of Copenhagen |
9f8e26f4 C |
25 | * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix |
26 | * This file is part of Coccinelle. | |
27 | * | |
28 | * Coccinelle is free software: you can redistribute it and/or modify | |
29 | * it under the terms of the GNU General Public License as published by | |
30 | * the Free Software Foundation, according to version 2 of the License. | |
31 | * | |
32 | * Coccinelle is distributed in the hope that it will be useful, | |
33 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
34 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
35 | * GNU General Public License for more details. | |
36 | * | |
37 | * You should have received a copy of the GNU General Public License | |
38 | * along with Coccinelle. If not, see <http://www.gnu.org/licenses/>. | |
39 | * | |
40 | * The authors reserve the right to distribute this or future versions of | |
41 | * Coccinelle under other licenses. | |
42 | */ | |
43 | ||
44 | ||
34e49164 C |
45 | %{ |
46 | ||
47 | (* Not clear how to allow function declarations to specify a return type | |
48 | and how to allow both to be specified as static, because they are in | |
49 | different rules. The rules seem to have to be combined, which would allow | |
50 | functions to be declared as local variables *) | |
51 | ||
52 | (* Not clear how to let a function have a parameter of type void. At the | |
53 | moment, void is allowed to be the type of a variable, which is wrong, and a | |
54 | parameter needs both a type and an identifier *) | |
55 | ||
56 | module Ast0 = Ast0_cocci | |
57 | module Ast = Ast_cocci | |
58 | ||
faf9a90c C |
59 | (*let warning s v = |
60 | if !Flag.verbose_parsing | |
34e49164 C |
61 | then Common.warning s v |
62 | else v*) | |
63 | ||
64 | let make_info line logical_line = | |
65 | { Ast.line = line; Ast.logical_line = logical_line } | |
66 | ||
67 | let clt2info (_,line,logical_line) = make_info line logical_line | |
68 | ||
69 | let clt2mcode str = function | |
70 | (Data.MINUS,line,lline) -> | |
71 | (str,Ast0.NONE, | |
72 | (Ast.MINUS({Ast.line=line;Ast.logical_line=lline},ref[]))) | |
73 | | (Data.OPTMINUS,line,lline) -> | |
74 | (str,Ast0.OPT, | |
75 | (Ast.MINUS({Ast.line=line;Ast.logical_line=lline},ref[]))) | |
76 | | (Data.UNIQUEMINUS,line,lline) -> | |
77 | (str,Ast0.UNIQUE, | |
78 | (Ast.MINUS({Ast.line=line;Ast.logical_line=lline},ref[]))) | |
79 | | (Data.MULTIMINUS,line,lline) -> | |
80 | (str,Ast0.MULTI, | |
81 | (Ast.MINUS({Ast.line=line;Ast.logical_line=lline},ref[]))) | |
82 | | (Data.PLUS,line,lline) -> | |
83 | (str,Ast0.NONE,Ast.PLUS({Ast.line=line;Ast.logical_line=lline})) | |
84 | | (Data.CONTEXT,line,lline) -> | |
85 | (str,Ast0.NONE, | |
86 | Ast.CONTEXT({Ast.line=line;Ast.logical_line=lline},ref Ast.NOTHING)) | |
87 | | (Data.OPT,line,lline) -> | |
88 | (str,Ast0.OPT, | |
89 | Ast.CONTEXT({Ast.line=line;Ast.logical_line=lline},ref Ast.NOTHING)) | |
90 | | (Data.UNIQUE,line,lline) -> | |
91 | (str,Ast0.UNIQUE, | |
92 | Ast.CONTEXT({Ast.line=line;Ast.logical_line=lline},ref Ast.NOTHING)) | |
93 | | (Data.MULTI,line,lline) -> | |
94 | (str,Ast0.MULTI, | |
95 | Ast.CONTEXT({Ast.line=line;Ast.logical_line=lline},ref Ast.NOTHING)) | |
96 | ||
97 | let id2name (name, clt) = name | |
98 | let id2clt (name, clt) = clt | |
99 | let id2info (name, clt) = clt2info clt | |
100 | let id2mcode (name, clt) = clt2mcode name clt | |
101 | ||
102 | let arith_op ast_op left op right = | |
103 | Ast0.Binary(left, clt2mcode (Ast.Arith ast_op) op, right) | |
104 | ||
105 | let logic_op ast_op left op right = | |
106 | Ast0.Binary(left, clt2mcode (Ast.Logical ast_op) op, right) | |
107 | ||
108 | let top_dots l = | |
109 | if List.exists (function Ast0.Circles(_) -> true | _ -> false) l | |
110 | then Ast0.CIRCLES(l) | |
111 | else if List.exists (function Ast0.Stars(_) -> true | _ -> false) l | |
112 | then Ast0.STARS(l) | |
113 | else Ast0.DOTS(l) | |
114 | ||
115 | %} | |
116 | ||
117 | ||
118 | %token EOF | |
119 | ||
120 | %token TIdentifier TExpression TStatement TFunction TLocal TType TParameter | |
121 | %token TWhy0 TPlus0 TBang0 Tlist TFresh TConstant TError TWords | |
122 | ||
123 | %token<Data.line_type * int * int> Tchar Tshort Tint Tdouble Tfloat Tlong Tvoid | |
124 | %token<Data.line_type * int * int> Tstruct Tunion | |
125 | %token<Data.line_type * int * int> Tunsigned Tsigned | |
126 | ||
127 | %token<Data.line_type * int * int> Tstatic Tconst Tvolatile | |
128 | ||
129 | %token <Data.line_type * int * int> TIf TElse TWhile TFor TDo TReturn | |
130 | %token <string * (Data.line_type * int * int)> TIdent TFunName TMetaFunName | |
131 | %token <string * (Data.line_type * int * int)> TMetaId TMetaType TMetaErr | |
132 | %token <string * (Data.line_type * int * int)> TMetaParam TMetaParamList | |
133 | %token <string * (Data.line_type * int * int)> TMetaStm TMetaStmList TMetaFunc | |
134 | %token <string * (Data.line_type * int * int)> TMetaLocalFunc TMetaExpList | |
135 | %token <string * Ast0_cocci.fullType list option * (Data.line_type*int*int)> | |
136 | TMetaExp TMetaConst | |
137 | %token TArobArob | |
138 | ||
139 | %token <Data.line_type * int * int> TEllipsis TOEllipsis TCEllipsis | |
140 | %token <Data.line_type * int * int> TWhen | |
141 | %token TLineEnd | |
142 | %token <Data.line_type * int * int> TCircles TOCircles TCCircles | |
143 | %token <Data.line_type * int * int> TStars TOStars TCStars | |
144 | ||
145 | %token <Data.line_type * int * int> TWhy TDotDot TBang TOPar TOPar0 TMid | |
146 | %token <Data.line_type * int * int> TMid0 TCPar TCPar0 | |
147 | ||
148 | %token <string * (Data.line_type * int * int)> TInclude TMinusFile TPlusFile | |
149 | ||
150 | %token <Data.line_type * int * int> TInc TDec | |
151 | ||
152 | %token <string * (Data.line_type * int * int)> TString TChar TFloat TInt | |
153 | ||
154 | %token <Data.line_type * int * int> TOrLog | |
155 | %token <Data.line_type * int * int> TAndLog | |
156 | %token <Data.line_type * int * int> TOr | |
157 | %token <Data.line_type * int * int> TXor | |
faf9a90c | 158 | %token <Data.line_type * int * int> TAnd |
34e49164 | 159 | %token <Data.line_type * int * int> TEqEq TNotEq |
faf9a90c | 160 | %token <Data.line_type * int * int> TInf TSup TInfEq TSupEq |
34e49164 C |
161 | %token <Data.line_type * int * int> TShl TShr |
162 | %token <Data.line_type * int * int> TPlus TMinus | |
faf9a90c | 163 | %token <Data.line_type * int * int> TMul TDiv TMod |
34e49164 C |
164 | |
165 | %token <Data.line_type * int * int> TOBrace TCBrace | |
166 | %token <Data.line_type * int * int> TOCro TCCro | |
167 | ||
168 | %token <Data.line_type * int * int> TPtrOp | |
169 | ||
170 | %token <Data.line_type * int * int> TEq TDot TComma TPtVirg | |
171 | %token <Ast_cocci.assignOp * (Data.line_type * int * int)> TAssign | |
172 | ||
173 | /* operator precedence */ | |
174 | %nonassoc TIf | |
175 | %nonassoc TElse | |
176 | ||
177 | %left TOrLog | |
178 | %left TAndLog | |
179 | %left TOr | |
180 | %left TXor | |
faf9a90c | 181 | %left TAnd |
34e49164 | 182 | %left TEqEq TNotEq |
faf9a90c | 183 | %left TInf TSup TInfEq TSupEq |
34e49164 C |
184 | %left TShl TShr |
185 | %left TPlus TMinus | |
faf9a90c | 186 | %left TMul TDiv TMod |
34e49164 | 187 | |
faf9a90c | 188 | %start main |
34e49164 C |
189 | %type <Ast0_cocci.rule> main |
190 | ||
191 | %start meta_main | |
192 | %type <Ast_cocci.metavar list> meta_main | |
193 | ||
194 | ||
195 | ||
196 | %% | |
197 | ||
198 | main: body EOF { $1 } | body TArobArob { $1 } | |
199 | meta_main: meta_var_list_opt TArobArob { $1 } | |
200 | ||
201 | /***************************************************************************** | |
202 | * | |
203 | * | |
204 | *****************************************************************************/ | |
205 | ||
206 | meta_var: | |
207 | arity TIdentifier pure_ident_or_meta_ident_list TPtVirg | |
208 | { List.map | |
209 | (function name -> | |
210 | !Data.add_id_meta name; | |
211 | Ast.MetaIdDecl($1,name)) | |
212 | $3 } | |
213 | | arity TFresh TIdentifier pure_ident_or_meta_ident_list TPtVirg | |
214 | { List.map | |
215 | (function name -> | |
216 | !Data.add_id_meta name; | |
217 | Ast.MetaFreshIdDecl($1,name)) | |
218 | $4 } | |
219 | | arity TType pure_ident_or_meta_ident_list TPtVirg | |
220 | { List.map | |
221 | (function name -> | |
222 | !Data.add_type_meta name; | |
223 | Ast.MetaTypeDecl($1,name)) | |
faf9a90c | 224 | $3 } |
34e49164 C |
225 | | arity TParameter pure_ident_or_meta_ident_list TPtVirg |
226 | { List.map | |
227 | (function name -> | |
228 | !Data.add_param_meta name; | |
229 | Ast.MetaParamDecl($1,name)) | |
faf9a90c | 230 | $3 } |
34e49164 C |
231 | | arity TParameter Tlist pure_ident_or_meta_ident_list TPtVirg |
232 | { List.map | |
233 | (function name -> | |
234 | !Data.add_paramlist_meta name; | |
235 | Ast.MetaParamListDecl($1,name)) | |
faf9a90c | 236 | $4 } |
34e49164 C |
237 | | arity TError pure_ident_or_meta_ident_list TPtVirg |
238 | { List.map | |
239 | (function name -> | |
240 | !Data.add_err_meta name; | |
241 | Ast.MetaErrDecl($1,name)) | |
242 | $3 } | |
243 | | arity TExpression pure_ident_or_meta_ident_list TPtVirg | |
244 | { List.map | |
245 | (function name -> | |
246 | !Data.add_exp_meta None name; | |
247 | Ast.MetaExpDecl($1,name)) | |
248 | $3 } | |
249 | | arity TExpression Tlist pure_ident_or_meta_ident_list TPtVirg | |
250 | { List.map | |
251 | (function name -> | |
252 | !Data.add_explist_meta name; | |
253 | Ast.MetaExpListDecl($1,name)) | |
254 | $4 } | |
255 | | arity TStatement pure_ident_or_meta_ident_list TPtVirg | |
256 | { List.map | |
257 | (function name -> | |
258 | !Data.add_stm_meta name; | |
259 | Ast.MetaStmDecl($1,name)) | |
260 | $3 } | |
261 | | arity TStatement Tlist pure_ident_or_meta_ident_list TPtVirg | |
262 | { List.map | |
263 | (function name -> | |
264 | !Data.add_stmlist_meta name; | |
265 | Ast.MetaStmListDecl($1,name)) | |
266 | $4 } | |
267 | | arity TFunction pure_ident_or_meta_ident_list TPtVirg | |
268 | { List.map | |
269 | (function name -> | |
270 | !Data.add_func_meta name; | |
271 | Ast.MetaFuncDecl($1,name)) | |
272 | $3 } | |
273 | | arity TLocal TFunction pure_ident_or_meta_ident_list TPtVirg | |
274 | { List.map | |
275 | (function name -> | |
276 | !Data.add_local_func_meta name; | |
277 | Ast.MetaLocalFuncDecl($1,name)) | |
278 | $4 } | |
279 | | arity meta_exp_type pure_ident_or_meta_ident_list TPtVirg | |
280 | { List.map | |
281 | (function name -> | |
282 | !Data.add_exp_meta (Some $2) name; | |
283 | Ast.MetaExpDecl($1,name)) | |
284 | $3 } | |
285 | | arity TConstant meta_exp_type pure_ident_or_meta_ident_list TPtVirg | |
286 | { List.map | |
287 | (function name -> | |
288 | !Data.add_const_meta (Some $3) name; | |
289 | Ast.MetaConstDecl($1,name)) | |
290 | $4 } | |
291 | | arity TConstant pure_ident_or_meta_ident_list TPtVirg | |
292 | { List.map | |
293 | (function name -> | |
294 | !Data.add_const_meta None name; | |
295 | Ast.MetaConstDecl($1,name)) | |
296 | $3 } | |
297 | ||
298 | meta_exp_type: | |
299 | ctype { [$1] } | |
300 | | TOBrace ctype_list TCBrace { $2 } | |
301 | ||
302 | arity: TBang0 { Ast.UNIQUE } | |
303 | | TWhy0 { Ast.OPT } | |
304 | | TPlus0 { Ast.MULTI } | |
305 | | /* empty */ { Ast.NONE } | |
306 | ||
307 | ctype: Tvoid | |
308 | { Ast0.BaseType(clt2mcode Ast.VoidType $1, None) } | |
309 | | ctype_qualif Tchar | |
310 | { Ast0.BaseType(clt2mcode Ast.CharType $2, $1) } | |
311 | | ctype_qualif Tshort | |
312 | { Ast0.BaseType(clt2mcode Ast.ShortType $2, $1) } | |
313 | | ctype_qualif Tint | |
314 | { Ast0.BaseType(clt2mcode Ast.IntType $2, $1) } | |
315 | | Tdouble | |
316 | { Ast0.BaseType(clt2mcode Ast.DoubleType $1, None) } | |
317 | | Tfloat | |
318 | { Ast0.BaseType(clt2mcode Ast.FloatType $1, None) } | |
319 | | ctype_qualif Tlong | |
320 | { Ast0.BaseType(clt2mcode Ast.LongType $2, $1) } | |
321 | | Tstruct pure_ident | |
322 | { Ast0.StructUnionName(id2mcode $2,clt2mcode Ast.Struct $1) } | |
323 | | Tunion pure_ident | |
324 | { Ast0.StructUnionName(id2mcode $2,clt2mcode Ast.Union $1) } | |
325 | | ctype TMul | |
326 | { Ast0.Pointer($1,clt2mcode "*" $2) } | |
327 | | TMetaType | |
328 | { let (nm,clt) = $1 in Ast0.MetaType(clt2mcode nm clt) } | |
329 | ||
330 | ctype_qualif: | |
331 | Tunsigned | |
332 | { Some (clt2mcode Ast.Unsigned $1) } | |
333 | | Tsigned | |
334 | { Some (clt2mcode Ast.Signed $1) } | |
335 | | /* empty */ { None } | |
336 | ||
337 | param_ctype: | |
338 | Tvoid | |
339 | { Ast0.BaseType(clt2mcode Ast.VoidType $1, None) } | |
340 | | ctype_qualif Tchar | |
341 | { Ast0.BaseType(clt2mcode Ast.CharType $2, $1) } | |
342 | | ctype_qualif Tshort | |
343 | { Ast0.BaseType(clt2mcode Ast.ShortType $2, $1) } | |
344 | | ctype_qualif Tint | |
345 | { Ast0.BaseType(clt2mcode Ast.IntType $2, $1) } | |
346 | | Tdouble | |
347 | { Ast0.BaseType(clt2mcode Ast.DoubleType $1, None) } | |
348 | | Tfloat | |
349 | { Ast0.BaseType(clt2mcode Ast.FloatType $1, None) } | |
350 | | ctype_qualif Tlong | |
351 | { Ast0.BaseType(clt2mcode Ast.LongType $2, $1) } | |
352 | | Tstruct pure_ident | |
353 | { Ast0.StructUnionName(id2mcode $2,clt2mcode Ast.Struct $1) } | |
354 | | Tunion pure_ident | |
355 | { Ast0.StructUnionName(id2mcode $2,clt2mcode Ast.Union $1) } | |
356 | | pure_ident { Ast0.TypeName(id2mcode $1) } | |
357 | | param_ctype TMul { Ast0.Pointer($1,clt2mcode "*" $2) } | |
358 | | TMetaType | |
359 | { let (nm,clt) = $1 in Ast0.MetaType(clt2mcode nm clt) } | |
360 | ||
361 | /*****************************************************************************/ | |
362 | ||
363 | /* have to inline everything to avoid conflicts? switch to proper | |
364 | declarations, statements, and expressions for the subterms */ | |
365 | ||
366 | body: function_decl_statement_or_expression { Top_level.top_level $1 } | |
367 | | /* empty */ { [] } | |
368 | ||
369 | /*****************************************************************************/ | |
370 | ||
371 | fundecl: | |
372 | storage TFunName TOPar decl_list TCPar | |
373 | TOBrace pre_post_decl_statement_and_expression_opt TCBrace | |
374 | { Ast0.FunDecl($1, Ast0.Id(id2mcode $2), clt2mcode "(" $3, $4, | |
375 | clt2mcode ")" $5, clt2mcode "{" $6, $7, | |
376 | clt2mcode "}" $8) } | |
377 | | storage TMetaFunName TOPar decl_list TCPar | |
378 | TOBrace pre_post_decl_statement_and_expression_opt TCBrace | |
379 | { Ast0.FunDecl($1, Ast0.MetaFunc(id2mcode $2), clt2mcode "(" $3, $4, | |
380 | clt2mcode ")" $5, clt2mcode "{" $6, $7, | |
381 | clt2mcode "}" $8) } | |
382 | ||
383 | storage: Tstatic { Some (clt2mcode Ast.Static $1) } | |
384 | | /* empty */ { None } | |
385 | ||
386 | decl: decl_qualif param_ctype ident | |
387 | { Ast0.Param($3, $1, $2) } | |
388 | | TMetaParam | |
389 | { let (nm,clt) = $1 in Ast0.MetaParam(clt2mcode nm clt) } | |
390 | ||
391 | decl_qualif: | |
392 | Tconst { Some (clt2mcode Ast.Const $1) } | |
393 | | Tvolatile { Some (clt2mcode Ast.Volatile $1) } | |
394 | | /* empty */ { None } | |
395 | ||
396 | /*****************************************************************************/ | |
397 | ||
398 | statement: | |
399 | TMetaStm | |
400 | { let (nm,clt) = $1 in Ast0.MetaStmt(clt2mcode nm clt) } | |
401 | | expr TPtVirg | |
402 | { Ast0.ExprStatement ($1, clt2mcode ";" $2) } | |
403 | | TIf TOPar eexpr TCPar single_statement %prec TIf | |
404 | { Ast0.IfThen(clt2mcode "if" $1, | |
405 | clt2mcode "(" $2,$3,clt2mcode ")" $4,$5) } | |
406 | | TIf TOPar eexpr TCPar single_statement TElse single_statement | |
407 | { Ast0.IfThenElse(clt2mcode "if" $1, | |
408 | clt2mcode "(" $2,$3,clt2mcode ")" $4,$5, | |
409 | clt2mcode "else" $6,$7) } | |
410 | | TFor TOPar eexpr_opt TPtVirg eexpr_opt TPtVirg eexpr_opt TCPar | |
411 | single_statement | |
412 | { Ast0.For(clt2mcode "for" $1,clt2mcode "(" $2,$3, | |
413 | clt2mcode ";" $4,$5,clt2mcode ";" $6,$7,clt2mcode ")" $8,$9) } | |
414 | | TWhile TOPar eexpr TCPar single_statement | |
415 | { Ast0.While(clt2mcode "while" $1, | |
416 | clt2mcode "(" $2,$3,clt2mcode ")" $4,$5) } | |
417 | | TDo single_statement TWhile TOPar eexpr TCPar TPtVirg | |
418 | { Ast0.Do(clt2mcode "do" $1,$2,clt2mcode "while" $3, | |
419 | clt2mcode "(" $4,$5,clt2mcode ")" $6, clt2mcode ";" $7) } | |
420 | | TReturn eexpr TPtVirg | |
421 | { Ast0.ReturnExpr(clt2mcode "return" $1,$2,clt2mcode ";" $3) } | |
422 | | TReturn TPtVirg | |
423 | { Ast0.Return(clt2mcode "return" $1,clt2mcode ";" $2) } | |
424 | | TOBrace pre_post_decl_statement_and_expression_opt TCBrace | |
425 | { Ast0.Seq(clt2mcode "{" $1,$2,clt2mcode "}" $3) } | |
426 | | TOEllipsis decl_statement_or_expression_dots TCEllipsis | |
427 | { Ast0.Nest(Ast0.DOTS($2)) } | |
428 | | TOCircles decl_statement_or_expression_circles TCCircles | |
429 | { Ast0.Nest(Ast0.CIRCLES($2)) } | |
430 | | TOStars decl_statement_or_expression_stars TCStars | |
431 | { Ast0.Nest(Ast0.STARS($2)) } | |
432 | ||
433 | /* In the following, an identifier as a type is not fully supported. Indeed, | |
434 | the language is ambiguous: what is foo * bar; */ | |
435 | decl_var: ctype d_ident_list TPtVirg | |
436 | { (List.map | |
437 | (function (id,fn) -> Ast0.UnInit(fn $1,id,clt2mcode ";" $3)) | |
438 | $2) } | |
439 | | ctype d_ident TEq eexpr TPtVirg | |
440 | { let (id,fn) = $2 in | |
441 | [Ast0.Init(fn $1,id,clt2mcode "=" $3,$4,clt2mcode ";" $5)] } | |
442 | | pure_ident d_ident TPtVirg | |
443 | { let (id,fn) = $2 in | |
444 | [Ast0.UnInit(fn (Ast0.TypeName(id2mcode $1)),id,clt2mcode ";" $3)] } | |
445 | | pure_ident d_ident TEq eexpr TPtVirg | |
446 | { let (id,fn) = $2 in | |
447 | [Ast0.Init(fn(Ast0.TypeName(id2mcode $1)),id, | |
448 | clt2mcode "=" $3,$4,clt2mcode ";" $5)] } | |
449 | ||
450 | d_ident: | |
451 | ident | |
452 | { ($1,function x -> x) } | |
453 | | ident TOCro eexpr_opt TCCro | |
454 | { ($1,function x -> Ast0.Array(x,clt2mcode "[" $2,$3,clt2mcode "]" $4)) } | |
455 | ||
456 | /* a statement on its own */ | |
457 | single_statement: | |
458 | statement { $1 } | |
459 | | TOPar0 statement_mid TCPar0 | |
460 | { Ast0.Disj($2) } | |
461 | ||
462 | /* a statement that is part of a list */ | |
463 | decl_statement: | |
464 | TMetaStmList | |
465 | { let (nm,clt) = $1 in [Ast0.MetaStmt(clt2mcode nm clt)] } | |
466 | | decl_var | |
467 | { List.map (function x -> Ast0.Decl(x)) $1 } | |
468 | | statement { [$1] } | |
469 | | TOPar0 pre_post_decl_statement_and_expression_opt_mid TCPar0 | |
470 | { if List.for_all (function Ast0.DOTS([]) -> true | _ -> false) $2 | |
471 | then [] | |
472 | else [Ast0.Disj($2)] } | |
473 | ||
474 | /*****************************************************************************/ | |
475 | ||
476 | ||
477 | /*****************************************************************************/ | |
478 | /* The following cannot contain <... ...> at the top level. This can only | |
479 | be allowed as an expression when the expression is delimited on both sides | |
480 | by expression-specific markers. In that case, the rule eexpr is used, which | |
481 | allows <... ...> anywhere. Hopefully, this will not be too much of a problem | |
482 | in practice. */ | |
483 | ||
484 | expr: assign_expr { $1 } | |
485 | ||
486 | assign_expr: | |
487 | cond_expr { $1 } | |
488 | | unary_expr TAssign assign_expr | |
489 | { let (op,clt) = $2 in Ast0.Assignment($1,clt2mcode op clt,$3) } | |
490 | | unary_expr TEq assign_expr | |
491 | { Ast0.Assignment($1,clt2mcode Ast.SimpleAssign $2,$3) } | |
492 | ||
493 | cond_expr: arith_expr { $1 } | |
494 | | arith_expr TWhy eexpr_opt TDotDot cond_expr | |
495 | { Ast0.CondExpr ($1, clt2mcode "?" $2, $3, clt2mcode "?" $4, $5) } | |
496 | ||
497 | arith_expr: cast_expr { $1 } | |
498 | | arith_expr TMul arith_expr { arith_op Ast.Mul $1 $2 $3 } | |
499 | | arith_expr TDiv arith_expr { arith_op Ast.Div $1 $2 $3 } | |
500 | | arith_expr TMod arith_expr { arith_op Ast.Mod $1 $2 $3 } | |
501 | | arith_expr TPlus arith_expr { arith_op Ast.Plus $1 $2 $3 } | |
502 | | arith_expr TMinus arith_expr { arith_op Ast.Minus $1 $2 $3 } | |
503 | | arith_expr TShl arith_expr { arith_op Ast.DecLeft $1 $2 $3 } | |
504 | | arith_expr TShr arith_expr { arith_op Ast.DecRight $1 $2 $3 } | |
505 | | arith_expr TInf arith_expr { logic_op Ast.Inf $1 $2 $3 } | |
506 | | arith_expr TSup arith_expr { logic_op Ast.Sup $1 $2 $3 } | |
507 | | arith_expr TInfEq arith_expr { logic_op Ast.InfEq $1 $2 $3 } | |
508 | | arith_expr TSupEq arith_expr { logic_op Ast.SupEq $1 $2 $3 } | |
509 | | arith_expr TEqEq arith_expr { logic_op Ast.Eq $1 $2 $3 } | |
510 | | arith_expr TNotEq arith_expr { logic_op Ast.NotEq $1 $2 $3 } | |
511 | | arith_expr TAnd arith_expr { arith_op Ast.And $1 $2 $3 } | |
512 | | arith_expr TOr arith_expr { arith_op Ast.Or $1 $2 $3 } | |
513 | | arith_expr TXor arith_expr { arith_op Ast.Xor $1 $2 $3 } | |
514 | | arith_expr TAndLog arith_expr { logic_op Ast.AndLog $1 $2 $3 } | |
515 | | arith_expr TOrLog arith_expr { logic_op Ast.OrLog $1 $2 $3 } | |
516 | ||
517 | cast_expr: unary_expr { $1 } | |
518 | | TOPar ctype TCPar cast_expr | |
519 | { Ast0.Cast (clt2mcode "(" $1, $2, clt2mcode ")" $3, $4) } | |
520 | ||
521 | unary_expr: postfix_expr { $1 } | |
522 | | TInc unary_expr | |
523 | { Ast0.Infix ($2, clt2mcode Ast.Inc $1) } | |
524 | | TDec unary_expr | |
525 | { Ast0.Infix ($2, clt2mcode Ast.Dec $1) } | |
526 | | unary_op unary_expr | |
527 | { let mcode = $1 in Ast0.Unary($2, mcode) } | |
528 | ||
529 | unary_op: TAnd { clt2mcode Ast.GetRef $1 } | |
530 | | TMul { clt2mcode Ast.DeRef $1 } | |
531 | | TPlus { clt2mcode Ast.UnPlus $1 } | |
532 | | TMinus { clt2mcode Ast.UnMinus $1 } | |
533 | | TBang { clt2mcode Ast.Not $1 } | |
534 | ||
535 | postfix_expr: primary_expr { $1 } | |
536 | | postfix_expr TOCro eexpr TCCro | |
537 | { Ast0.ArrayAccess ($1,clt2mcode "[" $2,$3,clt2mcode "]" $4) } | |
538 | | postfix_expr TDot ident | |
539 | { Ast0.RecordAccess($1, clt2mcode "." $2, $3) } | |
540 | | postfix_expr TPtrOp ident | |
541 | { Ast0.RecordPtAccess($1, clt2mcode "->" $2, $3) } | |
542 | | postfix_expr TInc | |
543 | { Ast0.Postfix ($1, clt2mcode Ast.Inc $2) } | |
544 | | postfix_expr TDec | |
545 | { Ast0.Postfix ($1, clt2mcode Ast.Dec $2) } | |
546 | | postfix_expr TOPar eexpr_list_opt TCPar | |
547 | { Ast0.FunCall($1,clt2mcode "(" $2,$3,clt2mcode ")" $4) } | |
548 | ||
549 | primary_expr: ident { Ast0.Ident($1) } | |
550 | | TInt | |
551 | { let (x,clt) = $1 in | |
552 | Ast0.Constant (clt2mcode (Ast.Int x) clt) } | |
553 | | TFloat | |
554 | { let (x,clt) = $1 in | |
555 | Ast0.Constant (clt2mcode (Ast.Float x) clt) } | |
556 | | TString | |
557 | { let (x,clt) = $1 in | |
558 | Ast0.Constant (clt2mcode (Ast.String x) clt) } | |
559 | | TChar | |
560 | { let (x,clt) = $1 in | |
561 | Ast0.Constant (clt2mcode (Ast.Char x) clt) } | |
562 | | TMetaConst | |
563 | { let (nm,ty,clt) = $1 in Ast0.MetaConst(clt2mcode nm clt,ty) } | |
564 | | TMetaErr | |
565 | { let (nm,clt) = $1 in Ast0.MetaErr(clt2mcode nm clt) } | |
566 | | TMetaExp | |
567 | { let (nm,ty,clt) = $1 in Ast0.MetaExpr(clt2mcode nm clt,ty) } | |
568 | | TOPar eexpr TCPar | |
569 | { Ast0.Paren(clt2mcode "(" $1,$2,clt2mcode ")" $3) } | |
570 | | TOPar0 expr_mid TCPar0 { Ast0.DisjExpr($2) } | |
571 | ||
572 | /*****************************************************************************/ | |
573 | ||
574 | eexpr: eassign_expr { $1 } | |
575 | ||
576 | eassign_expr: econd_expr { $1 } | |
577 | | eunary_expr TAssign eassign_expr | |
578 | { let (op,clt) = $2 in | |
579 | Ast0.Assignment($1,clt2mcode op clt,$3) } | |
580 | | eunary_expr TEq eassign_expr | |
581 | { Ast0.Assignment($1,clt2mcode Ast.SimpleAssign $2,$3) } | |
582 | ||
faf9a90c | 583 | econd_expr: earith_expr { $1 } |
34e49164 C |
584 | | earith_expr TWhy eexpr_opt TDotDot econd_expr |
585 | { Ast0.CondExpr ($1, clt2mcode "?" $2, $3, clt2mcode "?" $4, $5) } | |
586 | ||
587 | earith_expr: ecast_expr { $1 } | |
588 | | earith_expr TMul earith_expr { arith_op Ast.Mul $1 $2 $3 } | |
589 | | earith_expr TDiv earith_expr { arith_op Ast.Div $1 $2 $3 } | |
590 | | earith_expr TMod earith_expr { arith_op Ast.Mod $1 $2 $3 } | |
591 | | earith_expr TPlus earith_expr { arith_op Ast.Plus $1 $2 $3 } | |
592 | | earith_expr TMinus earith_expr { arith_op Ast.Minus $1 $2 $3 } | |
593 | | earith_expr TShl earith_expr { arith_op Ast.DecLeft $1 $2 $3 } | |
594 | | earith_expr TShr earith_expr { arith_op Ast.DecRight $1 $2 $3 } | |
595 | | earith_expr TInf earith_expr { logic_op Ast.Inf $1 $2 $3 } | |
596 | | earith_expr TSup earith_expr { logic_op Ast.Sup $1 $2 $3 } | |
597 | | earith_expr TInfEq earith_expr { logic_op Ast.InfEq $1 $2 $3 } | |
598 | | earith_expr TSupEq earith_expr { logic_op Ast.SupEq $1 $2 $3 } | |
599 | | earith_expr TEqEq earith_expr { logic_op Ast.Eq $1 $2 $3 } | |
600 | | earith_expr TNotEq earith_expr { logic_op Ast.NotEq $1 $2 $3 } | |
601 | | earith_expr TAnd earith_expr { arith_op Ast.And $1 $2 $3 } | |
602 | | earith_expr TOr earith_expr { arith_op Ast.Or $1 $2 $3 } | |
603 | | earith_expr TXor earith_expr { arith_op Ast.Xor $1 $2 $3 } | |
604 | | earith_expr TAndLog earith_expr { logic_op Ast.AndLog $1 $2 $3 } | |
605 | | earith_expr TOrLog earith_expr { logic_op Ast.OrLog $1 $2 $3 } | |
606 | ||
607 | ecast_expr: eunary_expr { $1 } | |
608 | | TOPar ctype TCPar ecast_expr | |
609 | { Ast0.Cast (clt2mcode "(" $1, $2, clt2mcode ")" $3, $4) } | |
610 | ||
611 | eunary_expr: epostfix_expr { $1 } | |
612 | | TInc eunary_expr | |
613 | { Ast0.Infix ($2, clt2mcode Ast.Inc $1) } | |
614 | | TDec eunary_expr | |
615 | { Ast0.Infix ($2, clt2mcode Ast.Dec $1) } | |
616 | | unary_op eunary_expr | |
617 | { let mcode = $1 in Ast0.Unary($2, mcode) } | |
618 | ||
619 | epostfix_expr: eprimary_expr { $1 } | |
620 | | epostfix_expr TOCro eexpr TCCro | |
621 | { Ast0.ArrayAccess ($1,clt2mcode "[" $2,$3,clt2mcode "]" $4) } | |
622 | | epostfix_expr TDot ident | |
623 | { Ast0.RecordAccess($1, clt2mcode "." $2, $3) } | |
624 | | epostfix_expr TPtrOp ident | |
625 | { Ast0.RecordPtAccess($1, clt2mcode "->" $2, $3) } | |
626 | | epostfix_expr TInc | |
627 | { Ast0.Postfix ($1, clt2mcode Ast.Inc $2) } | |
628 | | epostfix_expr TDec | |
629 | { Ast0.Postfix ($1, clt2mcode Ast.Dec $2) } | |
630 | | epostfix_expr TOPar eexpr_list_opt TCPar | |
631 | { Ast0.FunCall($1,clt2mcode "(" $2,$3,clt2mcode ")" $4) } | |
632 | ||
633 | eprimary_expr: ident { Ast0.Ident($1) } | |
634 | | TEllipsis { Ast0.Edots(clt2mcode "..." $1,None) } | |
635 | | TInt | |
636 | { let (x,clt) = $1 in | |
637 | Ast0.Constant (clt2mcode (Ast.Int x) clt) } | |
638 | | TFloat | |
639 | { let (x,clt) = $1 in | |
640 | Ast0.Constant (clt2mcode (Ast.Float x) clt) } | |
641 | | TString | |
642 | { let (x,clt) = $1 in | |
643 | Ast0.Constant (clt2mcode (Ast.String x) clt) } | |
644 | | TChar | |
645 | { let (x,clt) = $1 in | |
646 | Ast0.Constant (clt2mcode (Ast.Char x) clt) } | |
647 | | TMetaConst | |
648 | { let (nm,ty,clt) = $1 in Ast0.MetaConst(clt2mcode nm clt,ty) } | |
649 | | TMetaErr | |
650 | { let (nm,clt) = $1 in Ast0.MetaErr(clt2mcode nm clt) } | |
651 | | TMetaExp | |
652 | { let (nm,ty,clt) = $1 in Ast0.MetaExpr(clt2mcode nm clt,ty) } | |
653 | | TOPar eexpr TCPar | |
654 | { Ast0.Paren(clt2mcode "(" $1,$2,clt2mcode ")" $3) } | |
655 | | TOPar0 eexpr_mid TCPar0 | |
656 | { Ast0.DisjExpr($2) } | |
657 | | TOEllipsis expr_dots TCEllipsis | |
658 | { Ast0.NestExpr(Ast0.DOTS($2)) } | |
659 | | TOCircles expr_circles TCCircles | |
660 | { Ast0.NestExpr(Ast0.CIRCLES($2)) } | |
661 | | TOStars expr_stars TCStars | |
662 | { Ast0.NestExpr(Ast0.STARS($2)) } | |
663 | ||
664 | /*****************************************************************************/ | |
665 | ||
666 | dexpr: dassign_expr { $1 } | |
667 | ||
668 | dassign_expr: dcond_expr { $1 } | |
669 | | dunary_expr TAssign dassign_expr | |
670 | { let (op,clt) = $2 in | |
671 | Ast0.Assignment($1,clt2mcode op clt,$3) } | |
672 | | dunary_expr TEq dassign_expr | |
673 | { Ast0.Assignment($1,clt2mcode Ast.SimpleAssign $2,$3) } | |
674 | ||
faf9a90c | 675 | dcond_expr: darith_expr { $1 } |
34e49164 C |
676 | | darith_expr TWhy eexpr_opt TDotDot dcond_expr |
677 | { Ast0.CondExpr ($1, clt2mcode "?" $2, $3, clt2mcode "?" $4, $5) } | |
678 | ||
679 | darith_expr: dcast_expr { $1 } | |
680 | | darith_expr TMul darith_expr { arith_op Ast.Mul $1 $2 $3 } | |
681 | | darith_expr TDiv darith_expr { arith_op Ast.Div $1 $2 $3 } | |
682 | | darith_expr TMod darith_expr { arith_op Ast.Mod $1 $2 $3 } | |
683 | | darith_expr TPlus darith_expr { arith_op Ast.Plus $1 $2 $3 } | |
684 | | darith_expr TMinus darith_expr { arith_op Ast.Minus $1 $2 $3 } | |
685 | | darith_expr TShl darith_expr { arith_op Ast.DecLeft $1 $2 $3 } | |
686 | | darith_expr TShr darith_expr { arith_op Ast.DecRight $1 $2 $3 } | |
687 | | darith_expr TInf darith_expr { logic_op Ast.Inf $1 $2 $3 } | |
688 | | darith_expr TSup darith_expr { logic_op Ast.Sup $1 $2 $3 } | |
689 | | darith_expr TInfEq darith_expr { logic_op Ast.InfEq $1 $2 $3 } | |
690 | | darith_expr TSupEq darith_expr { logic_op Ast.SupEq $1 $2 $3 } | |
691 | | darith_expr TEqEq darith_expr { logic_op Ast.Eq $1 $2 $3 } | |
692 | | darith_expr TNotEq darith_expr { logic_op Ast.NotEq $1 $2 $3 } | |
693 | | darith_expr TAnd darith_expr { arith_op Ast.And $1 $2 $3 } | |
694 | | darith_expr TOr darith_expr { arith_op Ast.Or $1 $2 $3 } | |
695 | | darith_expr TXor darith_expr { arith_op Ast.Xor $1 $2 $3 } | |
696 | | darith_expr TAndLog darith_expr { logic_op Ast.AndLog $1 $2 $3 } | |
697 | | darith_expr TOrLog darith_expr { logic_op Ast.OrLog $1 $2 $3 } | |
698 | ||
699 | dcast_expr: dunary_expr { $1 } | |
700 | | TOPar ctype TCPar dcast_expr | |
701 | { Ast0.Cast (clt2mcode "(" $1, $2, clt2mcode ")" $3, $4) } | |
702 | ||
703 | dunary_expr: dpostfix_expr { $1 } | |
704 | | TInc dunary_expr | |
705 | { Ast0.Infix ($2, clt2mcode Ast.Inc $1) } | |
706 | | TDec dunary_expr | |
707 | { Ast0.Infix ($2, clt2mcode Ast.Dec $1) } | |
708 | | unary_op dunary_expr | |
709 | { let mcode = $1 in Ast0.Unary($2, mcode) } | |
710 | ||
711 | dpostfix_expr: dprimary_expr { $1 } | |
712 | | dpostfix_expr TOCro eexpr TCCro | |
713 | { Ast0.ArrayAccess ($1,clt2mcode "[" $2,$3,clt2mcode "]" $4) } | |
714 | | dpostfix_expr TDot ident | |
715 | { Ast0.RecordAccess($1, clt2mcode "." $2, $3) } | |
716 | | dpostfix_expr TPtrOp ident | |
717 | { Ast0.RecordPtAccess($1, clt2mcode "->" $2, $3) } | |
718 | | dpostfix_expr TInc | |
719 | { Ast0.Postfix ($1, clt2mcode Ast.Inc $2) } | |
720 | | dpostfix_expr TDec | |
721 | { Ast0.Postfix ($1, clt2mcode Ast.Dec $2) } | |
722 | | dpostfix_expr TOPar eexpr_list_opt TCPar | |
723 | { Ast0.FunCall($1,clt2mcode "(" $2,$3,clt2mcode ")" $4) } | |
724 | ||
725 | dprimary_expr: ident { Ast0.Ident($1) } | |
726 | | TInt | |
727 | { let (x,clt) = $1 in | |
728 | Ast0.Constant (clt2mcode (Ast.Int x) clt) } | |
729 | | TFloat | |
730 | { let (x,clt) = $1 in | |
731 | Ast0.Constant (clt2mcode (Ast.Float x) clt) } | |
732 | | TString | |
733 | { let (x,clt) = $1 in | |
734 | Ast0.Constant (clt2mcode (Ast.String x) clt) } | |
735 | | TChar | |
736 | { let (x,clt) = $1 in | |
737 | Ast0.Constant (clt2mcode (Ast.Char x) clt) } | |
738 | | TMetaConst | |
739 | { let (nm,ty,clt) = $1 in Ast0.MetaConst(clt2mcode nm clt,ty) } | |
740 | | TMetaErr | |
741 | { let (nm,clt) = $1 in Ast0.MetaErr(clt2mcode nm clt) } | |
742 | | TMetaExp | |
743 | { let (nm,ty,clt) = $1 in Ast0.MetaExpr(clt2mcode nm clt,ty) } | |
744 | | TOPar eexpr TCPar | |
745 | { Ast0.Paren(clt2mcode "(" $1,$2,clt2mcode ")" $3) } | |
746 | | TOPar0 eexpr_mid TCPar0 | |
747 | { Ast0.DisjExpr($2) } | |
748 | | TOEllipsis expr_dots TCEllipsis | |
749 | { Ast0.NestExpr(Ast0.DOTS($2)) } | |
750 | | TOCircles expr_circles TCCircles | |
751 | { Ast0.NestExpr(Ast0.CIRCLES($2)) } | |
752 | | TOStars expr_stars TCStars | |
753 | { Ast0.NestExpr(Ast0.STARS($2)) } | |
754 | ||
755 | expr_dots: | |
756 | dexpr { [$1] } | |
757 | | dexpr TEllipsis expr_dots | |
758 | { $1 :: Ast0.Edots(clt2mcode "..." $2,None) :: $3 } | |
759 | | dexpr TEllipsis TWhen TNotEq eexpr TLineEnd expr_dots | |
760 | { $1 :: Ast0.Edots(clt2mcode "..." $2,Some $5) :: $7 } | |
761 | ||
762 | expr_circles: | |
763 | dexpr { [$1] } | |
764 | | dexpr TCircles expr_circles | |
765 | { $1 :: Ast0.Ecircles(clt2mcode "ooo" $2,None) :: $3 } | |
766 | | dexpr TCircles TWhen TNotEq eexpr TLineEnd expr_dots | |
767 | { $1 :: Ast0.Ecircles(clt2mcode "ooo" $2,Some $5) :: $7 } | |
768 | ||
769 | expr_stars: | |
770 | dexpr { [$1] } | |
771 | | dexpr TStars expr_stars | |
772 | { $1 :: Ast0.Estars(clt2mcode "***" $2,None) :: $3 } | |
773 | | dexpr TStars TWhen TNotEq eexpr TLineEnd expr_dots | |
774 | { $1 :: Ast0.Estars(clt2mcode "***" $2,Some $5) :: $7 } | |
775 | ||
776 | /*****************************************************************************/ | |
777 | ||
778 | pure_ident: TIdent { $1 } | |
779 | ||
780 | /* allows redeclaring metavariables. used in @@ @@ */ | |
781 | pure_ident_or_meta_ident: | |
782 | TIdent { $1 } | |
783 | | TMetaId { $1 } | |
784 | | TMetaType { $1 } | |
785 | | TMetaParam { $1 } | |
786 | | TMetaParamList { $1 } | |
787 | | TMetaStm { $1 } | |
788 | | TMetaStmList { $1 } | |
789 | | TMetaFunc { $1 } | |
790 | | TMetaLocalFunc { $1 } | |
791 | | TMetaExpList { $1 } | |
792 | | TMetaConst { let (name,_,info) = $1 in (name,info) } | |
793 | | TMetaExp { let (name,_,info) = $1 in (name,info) } | |
794 | | TMetaErr { $1 } | |
795 | ||
796 | ident: TIdent { Ast0.Id(id2mcode $1) } | |
797 | | TMetaId { Ast0.MetaId(id2mcode $1) } | |
798 | | TMetaFunc { Ast0.MetaFunc(id2mcode $1) } | |
799 | | TMetaLocalFunc { Ast0.MetaLocalFunc(id2mcode $1) } | |
800 | ||
801 | /*****************************************************************************/ | |
802 | ||
803 | meta_var_list: meta_var { $1 } | |
804 | | meta_var meta_var_list { $1@$2 } | |
805 | ||
806 | meta_var_list_opt: meta_var_list { $1 } | |
807 | | /* empty */ { [] } | |
808 | ||
809 | d_ident_list: d_ident { [$1] } | |
810 | | d_ident TComma d_ident_list { $1::$3 } | |
811 | ||
812 | ctype_list: ctype { [$1] } | |
813 | | ctype TComma ctype_list { $1::$3 } | |
814 | ||
815 | pure_ident_or_meta_ident_list: | |
816 | pure_ident_or_meta_ident | |
817 | { [id2name $1] } | |
818 | | pure_ident_or_meta_ident TComma pure_ident_or_meta_ident_list | |
819 | { (id2name $1)::$3 } | |
820 | ||
821 | decl_list: | |
822 | decl_list_start | |
823 | { if List.exists (function Ast0.Pcircles(_) -> true | _ -> false) $1 | |
824 | then Ast0.CIRCLES($1) | |
825 | else Ast0.DOTS($1) } | |
826 | ||
827 | decl_list_start: | |
828 | decl { [$1] } | |
829 | | TMetaParamList | |
830 | { let (nm,clt) = $1 in [Ast0.MetaParamList(clt2mcode nm clt)] } | |
831 | | TEllipsis | |
832 | { [Ast0.Pdots(clt2mcode "..." $1)] } | |
833 | | TCircles | |
834 | { [Ast0.Pcircles(clt2mcode "ooo" $1)] } | |
835 | | decl TComma decl_list_start | |
836 | { $1::Ast0.PComma(clt2mcode "," $2)::$3 } | |
837 | | TMetaParamList TComma decl_list_start | |
838 | { let (nm,clt) = $1 in | |
839 | Ast0.MetaParamList(clt2mcode nm clt):: | |
840 | Ast0.PComma(clt2mcode "," $2)::$3 } | |
841 | | TEllipsis TComma decl_list_dots | |
842 | { Ast0.Pdots(clt2mcode "..." $1):: | |
843 | Ast0.PComma(clt2mcode "," $2):: | |
844 | $3 } | |
845 | | TCircles TComma decl_list_circles | |
846 | { Ast0.Pcircles(clt2mcode "ooo" $1):: | |
847 | Ast0.PComma(clt2mcode "," $2):: | |
848 | $3 } | |
849 | ||
850 | decl_list_dots: | |
851 | decl { [$1] } | |
852 | | TMetaParamList | |
853 | { let (nm,clt) = $1 in [Ast0.MetaParamList(clt2mcode nm clt)] } | |
854 | | TEllipsis | |
855 | { [Ast0.Pdots(clt2mcode "..." $1)] } | |
856 | | decl TComma decl_list_dots | |
857 | { $1::Ast0.PComma(clt2mcode "," $2)::$3 } | |
858 | | TMetaParamList TComma decl_list_dots | |
859 | { let (nm,clt) = $1 in | |
860 | Ast0.MetaParamList(clt2mcode nm clt):: | |
861 | Ast0.PComma(clt2mcode "," $2)::$3 } | |
862 | | TEllipsis TComma decl_list_dots | |
863 | { Ast0.Pdots(clt2mcode "..." $1)::Ast0.PComma(clt2mcode "," $2):: | |
864 | $3 } | |
865 | ||
866 | decl_list_circles: | |
867 | decl { [$1] } | |
868 | | TMetaParamList | |
869 | { let (nm,clt) = $1 in [Ast0.MetaParamList(clt2mcode nm clt)] } | |
870 | | TCircles | |
871 | { [Ast0.Pcircles(clt2mcode "ooo" $1)] } | |
872 | | decl TComma decl_list_circles | |
873 | { $1::Ast0.PComma(clt2mcode "," $2)::$3 } | |
874 | | TMetaParamList TComma decl_list_circles | |
875 | { let (nm,clt) = $1 in | |
876 | Ast0.MetaParamList(clt2mcode nm clt):: | |
877 | Ast0.PComma(clt2mcode "," $2)::$3 } | |
878 | | TCircles TComma decl_list_circles | |
879 | { Ast0.Pcircles(clt2mcode "ooo" $1):: | |
880 | Ast0.PComma(clt2mcode "," $2):: | |
881 | $3 } | |
882 | ||
883 | /* must be a single statement */ | |
884 | statement_mid: | |
885 | statement { [Ast0.DOTS([$1])] } | |
886 | | statement TMid0 statement_mid { Ast0.DOTS([$1])::$3 } | |
887 | ||
888 | /* must be a list of declarations or statements, with no ... or expressions | |
889 | for "and" case */ | |
890 | pure_decl_statement_list: | |
891 | decl_statement { $1 } | |
892 | | decl_statement pure_decl_statement_list { $1@$2 } | |
893 | ||
894 | /* as above, but allows a single expression - for "or" case */ | |
895 | exp_decl_statement_list: | |
896 | expr { [Ast0.Exp($1)] } | |
897 | | decl_statement { $1 } | |
898 | | decl_statement pure_decl_statement_list { $1@$2 } | |
899 | ||
900 | fun_exp_decl_statement_list: | |
901 | expr | |
902 | { [Ast0.OTHER(Ast0.Exp($1))] } | |
903 | | decl_statement | |
904 | { List.map (function x -> Ast0.OTHER x) $1 } | |
905 | | fundecl | |
906 | { [Ast0.FUNCTION($1)] } | |
907 | | TInclude | |
908 | { [Ast0.INCLUDE(clt2mcode "#include" (id2clt $1),id2mcode $1)] } | |
909 | | TMinusFile TPlusFile | |
910 | { [Ast0.FILEINFO(id2mcode $1,id2mcode $2)] } | |
911 | | decl_statement fun_exp_decl_statement_list | |
912 | { (List.map (function x -> Ast0.OTHER x) $1)@$2 } | |
913 | | fundecl fun_exp_decl_statement_list | |
914 | { Ast0.FUNCTION($1)::$2 } | |
915 | | TInclude fun_exp_decl_statement_list | |
916 | { Ast0.INCLUDE(clt2mcode "#include" (id2clt $1),id2mcode $1)::$2 } | |
917 | | TMinusFile TPlusFile fun_exp_decl_statement_list | |
918 | { Ast0.FILEINFO(id2mcode $1,id2mcode $2)::$3 } | |
919 | ||
920 | /* ---------------------------------------------------------------------- */ | |
921 | ||
922 | error_words: | |
923 | TError TWords TEq TOCro dotless_eexpr_list TCCro | |
924 | { Ast0.ERRORWORDS($5) } | |
925 | ||
926 | /* ---------------------------------------------------------------------- */ | |
927 | /* sequences of statements and expressions */ | |
928 | ||
929 | /* a mix of declarations, statements and expressions. an expression may | |
930 | appear by itself. always nonempty and cannot just be dots. */ | |
931 | ||
932 | function_decl_statement_or_expression: | |
933 | error_words /* only at the end */ | |
934 | { [$1] } | |
935 | | fun_exp_decl_statement_list | |
936 | { $1 } | |
937 | | fun_exp_decl_statement_list TEllipsis | |
938 | function_decl_statement_or_expression_dots | |
939 | { $1@Ast0.OTHER(Ast0.Dots(clt2mcode "..." $2,None))::$3 } | |
940 | | TEllipsis function_decl_statement_or_expression_dots | |
941 | { Ast0.OTHER(Ast0.Dots(clt2mcode "..." $1,None))::$2 } | |
942 | | fun_exp_decl_statement_list TEllipsis | |
943 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
944 | function_decl_statement_or_expression_dots | |
945 | { $1@Ast0.OTHER(Ast0.Dots(clt2mcode "..." $2,Some $5))::$7 } | |
946 | | TEllipsis TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
947 | function_decl_statement_or_expression_dots | |
948 | { Ast0.OTHER(Ast0.Dots(clt2mcode "..." $2,Some $4))::$6 } | |
949 | | fun_exp_decl_statement_list TCircles | |
950 | function_decl_statement_or_expression_circles | |
951 | { $1@Ast0.OTHER(Ast0.Circles(clt2mcode "ooo" $2,None))::$3 } | |
952 | | TCircles function_decl_statement_or_expression_circles | |
953 | { Ast0.OTHER(Ast0.Circles(clt2mcode "ooo" $1,None))::$2 } | |
954 | | fun_exp_decl_statement_list TCircles | |
955 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
956 | function_decl_statement_or_expression_circles | |
957 | { $1@Ast0.OTHER(Ast0.Circles(clt2mcode "ooo" $2,Some $5))::$7 } | |
958 | | TCircles TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
959 | function_decl_statement_or_expression_circles | |
960 | { Ast0.OTHER(Ast0.Circles(clt2mcode "ooo" $1,Some $4))::$6 } | |
961 | | fun_exp_decl_statement_list TStars | |
962 | function_decl_statement_or_expression_stars | |
963 | { $1@Ast0.OTHER(Ast0.Stars(clt2mcode "***" $2,None))::$3 } | |
964 | | TStars function_decl_statement_or_expression_stars | |
965 | { Ast0.OTHER(Ast0.Stars(clt2mcode "***" $1,None))::$2 } | |
966 | | fun_exp_decl_statement_list TStars | |
967 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
968 | function_decl_statement_or_expression_stars | |
969 | { $1@Ast0.OTHER(Ast0.Stars(clt2mcode "***" $2,Some $5))::$7 } | |
970 | | TStars TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
971 | function_decl_statement_or_expression_stars | |
972 | { Ast0.OTHER(Ast0.Stars(clt2mcode "***" $1,Some $4))::$6 } | |
973 | ||
974 | function_decl_statement_or_expression_dots: | |
975 | /* empty */ { [] } | |
976 | | fun_exp_decl_statement_list | |
977 | { $1 } | |
978 | | fun_exp_decl_statement_list TEllipsis | |
979 | function_decl_statement_or_expression_dots | |
980 | { $1@Ast0.OTHER(Ast0.Dots(clt2mcode "..." $2,None))::$3 } | |
981 | | fun_exp_decl_statement_list TEllipsis | |
982 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
983 | function_decl_statement_or_expression_dots | |
984 | { $1@Ast0.OTHER(Ast0.Dots(clt2mcode "..." $2,Some $5))::$7 } | |
985 | ||
986 | function_decl_statement_or_expression_circles: | |
987 | /* empty */ { [] } | |
988 | | fun_exp_decl_statement_list | |
989 | { $1 } | |
990 | | fun_exp_decl_statement_list TCircles | |
991 | function_decl_statement_or_expression_circles | |
992 | { $1@Ast0.OTHER(Ast0.Circles(clt2mcode "ooo" $2,None))::$3 } | |
993 | | fun_exp_decl_statement_list TCircles | |
994 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
995 | function_decl_statement_or_expression_circles | |
996 | { $1@Ast0.OTHER(Ast0.Circles(clt2mcode "ooo" $2,Some $5))::$7 } | |
997 | ||
998 | function_decl_statement_or_expression_stars: | |
999 | /* empty */ { [] } | |
1000 | | fun_exp_decl_statement_list | |
1001 | { $1 } | |
1002 | | fun_exp_decl_statement_list TStars | |
1003 | function_decl_statement_or_expression_stars | |
1004 | { $1@Ast0.OTHER(Ast0.Stars(clt2mcode "***" $2,None))::$3 } | |
1005 | | fun_exp_decl_statement_list TStars | |
1006 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1007 | function_decl_statement_or_expression_stars | |
1008 | { $1@Ast0.OTHER(Ast0.Stars(clt2mcode "***" $2,Some $5))::$7 } | |
1009 | ||
1010 | decl_statement_or_expression_dots: | |
1011 | exp_decl_statement_list | |
1012 | { $1 } | |
1013 | | exp_decl_statement_list TEllipsis decl_statement_or_expression_dots | |
1014 | { $1@Ast0.Dots(clt2mcode "..." $2,None)::$3 } | |
1015 | | exp_decl_statement_list TEllipsis | |
1016 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1017 | decl_statement_or_expression_dots | |
1018 | { $1@Ast0.Dots(clt2mcode "..." $2,Some $5)::$7 } | |
1019 | ||
1020 | decl_statement_or_expression_circles: | |
1021 | exp_decl_statement_list | |
1022 | { $1 } | |
1023 | | exp_decl_statement_list TCircles decl_statement_or_expression_circles | |
1024 | { $1@Ast0.Dots(clt2mcode "..." $2,None)::$3 } | |
1025 | | exp_decl_statement_list TCircles | |
1026 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1027 | decl_statement_or_expression_circles | |
1028 | { $1@Ast0.Dots(clt2mcode "..." $2,Some $5)::$7 } | |
1029 | ||
1030 | decl_statement_or_expression_stars: | |
1031 | exp_decl_statement_list | |
1032 | { $1 } | |
1033 | | exp_decl_statement_list TStars decl_statement_or_expression_stars | |
1034 | { $1@Ast0.Stars(clt2mcode "***" $2,None)::$3 } | |
1035 | | exp_decl_statement_list TStars | |
1036 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1037 | decl_statement_or_expression_stars | |
1038 | { $1@Ast0.Stars(clt2mcode "***" $2,Some $5)::$7 } | |
1039 | ||
1040 | post_decl_statement_or_expression: | |
1041 | exp_decl_statement_list | |
1042 | { $1 } | |
1043 | | exp_decl_statement_list TEllipsis | |
1044 | { $1@[Ast0.Dots(clt2mcode "..." $2,None)] } | |
1045 | | exp_decl_statement_list TEllipsis | |
1046 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1047 | { $1@[Ast0.Dots(clt2mcode "..." $2,Some $5)] } | |
1048 | | exp_decl_statement_list TCircles | |
1049 | { $1@[Ast0.Circles(clt2mcode "ooo" $2,None)] } | |
1050 | | exp_decl_statement_list TCircles | |
1051 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1052 | { $1@[Ast0.Circles(clt2mcode "ooo" $2,Some $5)] } | |
1053 | | exp_decl_statement_list TStars | |
1054 | { $1@[Ast0.Stars(clt2mcode "***" $2,None)] } | |
1055 | | exp_decl_statement_list TStars | |
1056 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1057 | { $1@[Ast0.Stars(clt2mcode "***" $2,Some $5)] } | |
1058 | | exp_decl_statement_list TEllipsis post_decl_statement_or_expression_dots | |
1059 | { $1@Ast0.Dots(clt2mcode "..." $2,None)::$3 } | |
1060 | | exp_decl_statement_list TEllipsis | |
1061 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1062 | post_decl_statement_or_expression_dots | |
1063 | { $1@Ast0.Dots(clt2mcode "..." $2,Some $5)::$7 } | |
1064 | | exp_decl_statement_list TCircles post_decl_statement_or_expression_dots | |
1065 | { $1@Ast0.Circles(clt2mcode "ooo" $2,None)::$3 } | |
1066 | | exp_decl_statement_list TCircles | |
1067 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1068 | post_decl_statement_or_expression_dots | |
1069 | { $1@Ast0.Circles(clt2mcode "ooo" $2,Some $5)::$7 } | |
1070 | | exp_decl_statement_list TStars post_decl_statement_or_expression_dots | |
1071 | { $1@Ast0.Stars(clt2mcode "***" $2,None)::$3 } | |
1072 | | exp_decl_statement_list TStars | |
1073 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1074 | post_decl_statement_or_expression_dots | |
1075 | { $1@Ast0.Stars(clt2mcode "***" $2,Some $5)::$7 } | |
1076 | ||
1077 | post_decl_statement_or_expression_dots: | |
1078 | exp_decl_statement_list | |
1079 | { $1 } | |
1080 | | exp_decl_statement_list TEllipsis | |
1081 | { $1@[Ast0.Dots(clt2mcode "..." $2,None)] } | |
1082 | | exp_decl_statement_list TEllipsis | |
1083 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1084 | { $1@[Ast0.Dots(clt2mcode "..." $2,Some $5)] } | |
1085 | | exp_decl_statement_list TEllipsis post_decl_statement_or_expression_dots | |
1086 | { $1@Ast0.Dots(clt2mcode "..." $2,None)::$3 } | |
1087 | | exp_decl_statement_list TEllipsis | |
1088 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1089 | post_decl_statement_or_expression_dots | |
1090 | { $1@Ast0.Dots(clt2mcode "..." $2,Some $5)::$7 } | |
1091 | ||
1092 | post_decl_statement_or_expression_circles: | |
1093 | exp_decl_statement_list | |
1094 | { $1 } | |
1095 | | exp_decl_statement_list TCircles | |
1096 | { $1@[Ast0.Circles(clt2mcode "ooo" $2,None)] } | |
1097 | | exp_decl_statement_list TCircles | |
1098 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1099 | { $1@[Ast0.Circles(clt2mcode "ooo" $2,Some $5)] } | |
1100 | | exp_decl_statement_list TCircles post_decl_statement_or_expression_circles | |
1101 | { $1@Ast0.Circles(clt2mcode "ooo" $2,None)::$3 } | |
1102 | | exp_decl_statement_list TCircles | |
1103 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1104 | post_decl_statement_or_expression_circles | |
1105 | { $1@Ast0.Circles(clt2mcode "ooo" $2,Some $5)::$7 } | |
1106 | ||
1107 | post_decl_statement_or_expression_stars: | |
1108 | exp_decl_statement_list | |
1109 | { $1 } | |
1110 | | exp_decl_statement_list TEllipsis | |
1111 | { $1@[Ast0.Stars(clt2mcode "***" $2,None)] } | |
1112 | | exp_decl_statement_list TEllipsis | |
1113 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1114 | { $1@[Ast0.Stars(clt2mcode "***" $2,Some $5)] } | |
1115 | | exp_decl_statement_list TEllipsis post_decl_statement_or_expression_stars | |
1116 | { $1@Ast0.Stars(clt2mcode "***" $2,None)::$3 } | |
1117 | | exp_decl_statement_list TEllipsis | |
1118 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1119 | post_decl_statement_or_expression_stars | |
1120 | { $1@Ast0.Stars(clt2mcode "***" $2,Some $5)::$7 } | |
1121 | ||
1122 | pre_post_decl_statement_or_expression: | |
1123 | post_decl_statement_or_expression | |
1124 | { if List.exists (function Ast0.Circles(_) -> true | _ -> false) $1 | |
1125 | then Ast0.CIRCLES($1) | |
1126 | else if List.exists (function Ast0.Stars(_) -> true | _ -> false) $1 | |
1127 | then Ast0.STARS($1) | |
1128 | else Ast0.DOTS($1) } | |
1129 | | TEllipsis post_decl_statement_or_expression_dots | |
1130 | { Ast0.DOTS(Ast0.Dots(clt2mcode "..." $1,None)::$2) } | |
1131 | | TEllipsis TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1132 | post_decl_statement_or_expression_dots | |
1133 | { Ast0.DOTS(Ast0.Dots(clt2mcode "..." $1,Some $4)::$6) } | |
1134 | | TCircles post_decl_statement_or_expression_circles | |
1135 | { Ast0.CIRCLES(Ast0.Circles(clt2mcode "ooo" $1,None)::$2) } | |
1136 | | TCircles TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1137 | post_decl_statement_or_expression_circles | |
1138 | { Ast0.CIRCLES(Ast0.Circles(clt2mcode "ooo" $1,Some $4)::$6) } | |
1139 | | TStars post_decl_statement_or_expression_stars | |
1140 | { Ast0.STARS(Ast0.Stars(clt2mcode "***" $1,None)::$2) } | |
1141 | | TStars TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1142 | post_decl_statement_or_expression_stars | |
1143 | { Ast0.STARS(Ast0.Stars(clt2mcode "***" $1,Some $4)::$6) } | |
1144 | ||
1145 | /* a mix of declarations, statements and expressions. an expression must | |
1146 | be surrounded by ... */ | |
1147 | ||
1148 | post_decl_statement_and_expression_dots: | |
1149 | /* empty */ { [] } | |
1150 | | pure_decl_statement_list { $1 } | |
1151 | | expr TEllipsis post_decl_statement_and_expression_dots | |
1152 | { Ast0.Exp($1)::Ast0.Dots(clt2mcode "..." $2,None)::$3 } | |
1153 | | expr TEllipsis | |
1154 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1155 | post_decl_statement_and_expression_dots | |
1156 | { Ast0.Exp($1)::Ast0.Dots(clt2mcode "..." $2,Some $5)::$7 } | |
1157 | | pure_decl_statement_list TEllipsis post_decl_statement_and_expression_dots | |
1158 | { $1@Ast0.Dots(clt2mcode "..." $2,None)::$3 } | |
1159 | | pure_decl_statement_list TEllipsis | |
1160 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1161 | post_decl_statement_and_expression_dots | |
1162 | { $1@Ast0.Dots(clt2mcode "..." $2,Some $5)::$7 } | |
1163 | ||
1164 | post_decl_statement_and_expression_circles: | |
1165 | /* empty */ { [] } | |
1166 | | pure_decl_statement_list { $1 } | |
1167 | | expr TCircles post_decl_statement_and_expression_circles | |
1168 | { Ast0.Exp($1)::Ast0.Circles(clt2mcode "ooo" $2,None)::$3 } | |
1169 | | expr TCircles | |
1170 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1171 | post_decl_statement_and_expression_circles | |
1172 | { Ast0.Exp($1)::Ast0.Circles(clt2mcode "ooo" $2,Some $5)::$7 } | |
1173 | | pure_decl_statement_list TCircles | |
1174 | post_decl_statement_and_expression_circles | |
1175 | { $1@Ast0.Circles(clt2mcode "ooo" $2,None)::$3 } | |
1176 | | pure_decl_statement_list TCircles | |
1177 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1178 | post_decl_statement_and_expression_circles | |
1179 | { $1@Ast0.Circles(clt2mcode "ooo" $2,Some $5)::$7 } | |
1180 | ||
1181 | post_decl_statement_and_expression_stars: | |
1182 | /* empty */ { [] } | |
1183 | | pure_decl_statement_list { $1 } | |
1184 | | expr TStars post_decl_statement_and_expression_stars | |
1185 | { Ast0.Exp($1)::Ast0.Stars(clt2mcode "***" $2,None)::$3 } | |
1186 | | expr TStars | |
1187 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1188 | post_decl_statement_and_expression_stars | |
1189 | { Ast0.Exp($1)::Ast0.Stars(clt2mcode "***" $2,Some $5)::$7 } | |
1190 | | pure_decl_statement_list TStars post_decl_statement_and_expression_stars | |
1191 | { $1@Ast0.Stars(clt2mcode "***" $2,None)::$3 } | |
1192 | | pure_decl_statement_list TStars | |
1193 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1194 | post_decl_statement_and_expression_stars | |
1195 | { $1@Ast0.Stars(clt2mcode "***" $2,Some $5)::$7 } | |
1196 | ||
1197 | pre_post_decl_statement_and_expression: | |
1198 | pure_decl_statement_list | |
1199 | { top_dots $1 } | |
1200 | | pure_decl_statement_list TEllipsis post_decl_statement_and_expression_dots | |
1201 | { Ast0.DOTS($1@Ast0.Dots(clt2mcode "..." $2,None)::$3) } | |
1202 | | pure_decl_statement_list TEllipsis | |
1203 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1204 | post_decl_statement_and_expression_dots | |
1205 | { Ast0.DOTS($1@Ast0.Dots(clt2mcode "..." $2,Some $5)::$7) } | |
1206 | | pure_decl_statement_list TCircles | |
1207 | post_decl_statement_and_expression_circles | |
1208 | { Ast0.CIRCLES($1@Ast0.Circles(clt2mcode "ooo" $2,None)::$3) } | |
1209 | | pure_decl_statement_list TCircles | |
1210 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1211 | post_decl_statement_and_expression_circles | |
1212 | { Ast0.CIRCLES($1@Ast0.Circles(clt2mcode "ooo" $2,Some $5)::$7) } | |
1213 | | pure_decl_statement_list TStars post_decl_statement_and_expression_stars | |
1214 | { Ast0.STARS($1@Ast0.Stars(clt2mcode "***" $2,None)::$3) } | |
1215 | | pure_decl_statement_list TStars | |
1216 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1217 | post_decl_statement_and_expression_stars | |
1218 | { Ast0.STARS($1@Ast0.Stars(clt2mcode "***" $2,Some $5)::$7) } | |
1219 | | TEllipsis post_decl_statement_and_expression_dots | |
1220 | { Ast0.DOTS(Ast0.Dots(clt2mcode "..." $1,None)::$2) } | |
1221 | | TEllipsis | |
1222 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1223 | post_decl_statement_and_expression_dots | |
1224 | { Ast0.DOTS(Ast0.Dots(clt2mcode "..." $1,Some $4)::$6) } | |
1225 | | TCircles post_decl_statement_and_expression_circles | |
1226 | { Ast0.CIRCLES(Ast0.Circles(clt2mcode "ooo" $1,None)::$2) } | |
1227 | | TCircles | |
1228 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1229 | post_decl_statement_and_expression_circles | |
1230 | { Ast0.CIRCLES(Ast0.Circles(clt2mcode "ooo" $1,Some $4)::$6) } | |
1231 | | TStars post_decl_statement_and_expression_stars | |
1232 | { Ast0.STARS(Ast0.Stars(clt2mcode "***" $1,None)::$2) } | |
1233 | | TStars | |
1234 | TWhen TNotEq pre_post_decl_statement_or_expression TLineEnd | |
1235 | post_decl_statement_and_expression_stars | |
1236 | { Ast0.STARS(Ast0.Stars(clt2mcode "***" $1,Some $4)::$6) } | |
1237 | ||
1238 | pre_post_decl_statement_and_expression_opt: | |
1239 | /* empty */ { Ast0.DOTS([]) } | |
1240 | | pre_post_decl_statement_and_expression { $1 } | |
1241 | ||
1242 | pre_post_decl_statement_and_expression_opt_mid: | |
1243 | pre_post_decl_statement_and_expression { [$1] } | |
1244 | | /* empty */ { [Ast0.DOTS([])] } | |
1245 | | pre_post_decl_statement_and_expression TMid0 | |
1246 | pre_post_decl_statement_and_expression_opt_mid { $1::$3 } | |
1247 | | TMid0 | |
1248 | pre_post_decl_statement_and_expression_opt_mid { Ast0.DOTS([])::$2 } | |
1249 | ||
1250 | /* ---------------------------------------------------------------------- */ | |
1251 | ||
1252 | dotless_eexpr_list: | |
1253 | dexpr | |
1254 | { [$1] } | |
1255 | | dexpr TComma dotless_eexpr_list | |
1256 | { $1::Ast0.EComma(clt2mcode "," $2)::$3 } | |
1257 | ||
1258 | eexpr_list: | |
1259 | eexpr_list_start | |
1260 | { if List.exists (function Ast0.Ecircles(_) -> true | _ -> false) $1 | |
1261 | then Ast0.CIRCLES($1) | |
1262 | else if List.exists (function Ast0.Estars(_) -> true | _ -> false) $1 | |
1263 | then Ast0.STARS($1) | |
1264 | else Ast0.DOTS($1) } | |
1265 | ||
1266 | eexpr_list_start: | |
1267 | dexpr | |
1268 | { [$1] } | |
1269 | | TMetaExpList | |
1270 | { let (nm,clt) = $1 in [Ast0.MetaExprList(clt2mcode nm clt)] } | |
1271 | | TEllipsis | |
1272 | { [Ast0.Edots(clt2mcode "..." $1,None)] } | |
1273 | | TEllipsis TWhen TNotEq eexpr TLineEnd | |
1274 | { [Ast0.Edots(clt2mcode "..." $1,Some $4)] } | |
1275 | | TCircles | |
1276 | { [Ast0.Ecircles(clt2mcode "ooo" $1,None)] } | |
1277 | | TCircles TWhen TNotEq eexpr TLineEnd | |
1278 | { [Ast0.Ecircles(clt2mcode "ooo" $1,Some $4)] } | |
1279 | | TStars | |
1280 | { [Ast0.Estars(clt2mcode "***" $1,None)] } | |
1281 | | TStars TWhen TNotEq eexpr TLineEnd | |
1282 | { [Ast0.Estars(clt2mcode "***" $1,Some $4)] } | |
1283 | | dexpr TComma eexpr_list_start | |
1284 | { $1::Ast0.EComma(clt2mcode "," $2)::$3 } | |
1285 | | TMetaExpList TComma eexpr_list_start | |
1286 | { let (nm,clt) = $1 in | |
1287 | Ast0.MetaExprList(clt2mcode nm clt)::Ast0.EComma(clt2mcode "," $2)::$3 } | |
1288 | | TEllipsis TComma eexpr_list_dots | |
1289 | { Ast0.Edots(clt2mcode "..." $1,None):: | |
1290 | Ast0.EComma(clt2mcode "," $2)::$3 } | |
1291 | | TEllipsis TWhen TNotEq eexpr TLineEnd TComma eexpr_list_dots | |
1292 | { Ast0.Edots(clt2mcode "..." $1,Some $4):: | |
1293 | Ast0.EComma(clt2mcode "," $6)::$7 } | |
1294 | | TCircles TComma eexpr_list_circles | |
1295 | { Ast0.Ecircles(clt2mcode "ooo" $1,None):: | |
1296 | Ast0.EComma(clt2mcode "," $2)::$3 } | |
1297 | | TCircles TWhen TNotEq eexpr TLineEnd TComma eexpr_list_circles | |
1298 | { Ast0.Ecircles(clt2mcode "ooo" $1,Some $4):: | |
1299 | Ast0.EComma(clt2mcode "," $6)::$7 } | |
1300 | | TStars TComma eexpr_list_stars | |
1301 | { Ast0.Estars(clt2mcode "***" $1,None):: | |
1302 | Ast0.EComma(clt2mcode "," $2)::$3 } | |
1303 | | TStars TWhen TNotEq eexpr TLineEnd TComma eexpr_list_stars | |
1304 | { Ast0.Estars(clt2mcode "***" $1,Some $4):: | |
1305 | Ast0.EComma(clt2mcode "," $6)::$7 } | |
1306 | ||
1307 | eexpr_list_dots: | |
1308 | dexpr | |
1309 | { [$1] } | |
1310 | | TMetaExpList | |
1311 | { let (nm,clt) = $1 in [Ast0.MetaExprList(clt2mcode nm clt)] } | |
1312 | | TEllipsis | |
1313 | { [Ast0.Edots(clt2mcode "..." $1,None)] } | |
1314 | | TEllipsis TWhen TNotEq eexpr TLineEnd | |
1315 | { [Ast0.Edots(clt2mcode "..." $1,Some $4)] } | |
1316 | | dexpr TComma eexpr_list_dots | |
1317 | { $1::Ast0.EComma(clt2mcode "," $2)::$3 } | |
1318 | | TMetaExpList TComma eexpr_list_dots | |
1319 | { let (nm,clt) = $1 in | |
1320 | Ast0.MetaExprList(clt2mcode nm clt)::Ast0.EComma(clt2mcode "," $2)::$3 } | |
1321 | | TEllipsis TComma eexpr_list_dots | |
1322 | { Ast0.Edots(clt2mcode "..." $1,None):: | |
1323 | Ast0.EComma(clt2mcode "," $2)::$3 } | |
1324 | | TEllipsis TWhen TNotEq eexpr TLineEnd TComma eexpr_list_dots | |
1325 | { Ast0.Edots(clt2mcode "..." $1,Some $4):: | |
1326 | Ast0.EComma(clt2mcode "," $6)::$7 } | |
1327 | ||
1328 | eexpr_list_circles: | |
1329 | dexpr | |
1330 | { [$1] } | |
1331 | | TMetaExpList | |
1332 | { let (nm,clt) = $1 in [Ast0.MetaExprList(clt2mcode nm clt)] } | |
1333 | | TCircles | |
1334 | { [Ast0.Ecircles(clt2mcode "ooo" $1,None)] } | |
1335 | | TCircles TWhen TNotEq eexpr TLineEnd | |
1336 | { [Ast0.Ecircles(clt2mcode "ooo" $1,Some $4)] } | |
1337 | | dexpr TComma eexpr_list_circles | |
1338 | { $1::Ast0.EComma(clt2mcode "," $2)::$3 } | |
1339 | | TMetaExpList TComma eexpr_list_circles | |
1340 | { let (nm,clt) = $1 in | |
1341 | Ast0.MetaExprList(clt2mcode nm clt)::Ast0.EComma(clt2mcode "," $2)::$3 } | |
1342 | | TCircles TComma eexpr_list_circles | |
1343 | { Ast0.Ecircles(clt2mcode "ooo" $1,None):: | |
1344 | Ast0.EComma(clt2mcode "," $2)::$3 } | |
1345 | | TCircles TWhen TNotEq eexpr TLineEnd TComma eexpr_list_circles | |
1346 | { Ast0.Ecircles(clt2mcode "ooo" $1,Some $4):: | |
1347 | Ast0.EComma(clt2mcode "," $6)::$7 } | |
1348 | ||
1349 | eexpr_list_stars: | |
1350 | dexpr | |
1351 | { [$1] } | |
1352 | | TMetaExpList | |
1353 | { let (nm,clt) = $1 in [Ast0.MetaExprList(clt2mcode nm clt)] } | |
1354 | | TStars | |
1355 | { [Ast0.Estars(clt2mcode "***" $1,None)] } | |
1356 | | TStars TWhen TNotEq eexpr TLineEnd | |
1357 | { [Ast0.Estars(clt2mcode "***" $1,Some $4)] } | |
1358 | | dexpr TComma eexpr_list_stars | |
1359 | { $1::Ast0.EComma(clt2mcode "," $2)::$3 } | |
1360 | | TMetaExpList TComma eexpr_list_stars | |
1361 | { let (nm,clt) = $1 in | |
1362 | Ast0.MetaExprList(clt2mcode nm clt)::Ast0.EComma(clt2mcode "," $2)::$3 } | |
1363 | | TStars TComma eexpr_list_stars | |
1364 | { Ast0.Estars(clt2mcode "***" $1,None):: | |
1365 | Ast0.EComma(clt2mcode "," $2)::$3 } | |
1366 | | TStars TWhen TNotEq eexpr TLineEnd TComma eexpr_list_stars | |
1367 | { Ast0.Estars(clt2mcode "***" $1,Some $4):: | |
1368 | Ast0.EComma(clt2mcode "," $6)::$7 } | |
1369 | ||
1370 | eexpr_list_opt: eexpr_list { $1 } | |
1371 | | /* empty */ { Ast0.DOTS([]) } | |
1372 | ||
1373 | expr_mid: | |
1374 | expr { [$1] } | |
1375 | | expr TMid0 expr_mid { $1::$3 } | |
1376 | ||
1377 | eexpr_mid: | |
1378 | eexpr { [$1] } | |
1379 | | eexpr TMid0 eexpr_mid { $1::$3 } | |
1380 | ||
1381 | eexpr_opt: eexpr { Some ($1) } | |
1382 | | /* empty */ { None } | |
1383 |