HCoop / bpt / coccinelle.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Release coccinelle-0.2.0
[bpt/coccinelle.git] / parsing_cocci / parser_cocci.mly
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
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
37 (*let warning s v =
38 if !Flag.verbose_parsing
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
136 %token <Data.line_type * int * int> TAnd
137 %token <Data.line_type * int * int> TEqEq TNotEq
138 %token <Data.line_type * int * int> TInf TSup TInfEq TSupEq
139 %token <Data.line_type * int * int> TShl TShr
140 %token <Data.line_type * int * int> TPlus TMinus
141 %token <Data.line_type * int * int> TMul TDiv TMod
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
159 %left TAnd
160 %left TEqEq TNotEq
161 %left TInf TSup TInfEq TSupEq
162 %left TShl TShr
163 %left TPlus TMinus
164 %left TMul TDiv TMod
165
166 %start main
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))
202 $3 }
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))
208 $3 }
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))
214 $4 }
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
561 econd_expr: earith_expr { $1 }
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
653 dcond_expr: darith_expr { $1 }
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
Unnamed repository; edit this file 'description' to name the repository.