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