2 * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
3 * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller
4 * This file is part of Coccinelle.
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.
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.
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/>.
18 * The authors reserve the right to distribute this or future versions of
19 * Coccinelle under other licenses.
23 module Ast = Ast_cocci
25 (* --------------------------------------------------------------------- *)
28 type arity = OPT | UNIQUE | NONE
31 { tline_start : int; tline_end : int;
32 left_offset : int; right_offset : int }
33 let default_token_info =
34 { tline_start = -1; tline_end = -1; left_offset = -1; right_offset = -1 }
36 (* MIXED is like CONTEXT, since sometimes MIXED things have to revert to
37 CONTEXT - see insert_plus.ml *)
39 MINUS of (Ast.anything list list * token_info) ref
41 | CONTEXT of (Ast.anything Ast.befaft * token_info * token_info) ref
42 | MIXED of (Ast.anything Ast.befaft * token_info * token_info) ref
44 type info = { line_start : int; line_end : int;
45 logical_start : int; logical_end : int;
46 attachable_start : bool; attachable_end : bool;
47 mcode_start : mcodekind list; mcode_end : mcodekind list;
48 column : int; offset : int;
49 (* the following are only for + code *)
50 strings_before : string list; strings_after : string list }
52 type 'a mcode = 'a * arity * info * mcodekind * meta_pos ref (* pos, - only *)
53 (* int ref is an index *)
58 mcodekind : mcodekind ref;
59 exp_ty : Type_cocci.typeC option ref; (* only for expressions *)
60 bef_aft : dots_bef_aft; (* only for statements *)
61 true_if_arg : bool; (* true if "arg_exp", only for exprs *)
62 true_if_test : bool; (* true if "test position", only for exprs *)
63 true_if_test_exp : bool;(* true if "test_exp from iso", only for exprs *)
64 (*nonempty if this represents the use of an iso*)
65 iso_info : (string*anything) list }
68 NoDots | AddingBetweenDots of statement | DroppingBetweenDots of statement
70 (* for iso metavariables, true if they can only match nonmodified terms with
71 all metavariables unitary
72 for SP metavariables, true if the metavariable is unitary (valid up to
73 isomorphism phase only)
74 In SP, the only options are impure and context
76 and pure = Impure | Pure | Context | PureContext (* pure and only context *)
78 (* --------------------------------------------------------------------- *)
79 (* --------------------------------------------------------------------- *)
87 and 'a dots = 'a base_dots wrap
89 (* --------------------------------------------------------------------- *)
94 | MetaId of Ast.meta_name mcode * ident list * pure
95 | MetaFunc of Ast.meta_name mcode * ident list * pure
96 | MetaLocalFunc of Ast.meta_name mcode * ident list * pure
98 | UniqueIdent of ident
100 and ident = base_ident wrap
102 (* --------------------------------------------------------------------- *)
105 and base_expression =
107 | Constant of Ast.constant mcode
108 | FunCall of expression * string mcode (* ( *) *
109 expression dots * string mcode (* ) *)
110 | Assignment of expression * Ast.assignOp mcode * expression *
111 bool (* true if it can match an initialization *)
112 | CondExpr of expression * string mcode (* ? *) * expression option *
113 string mcode (* : *) * expression
114 | Postfix of expression * Ast.fixOp mcode
115 | Infix of expression * Ast.fixOp mcode
116 | Unary of expression * Ast.unaryOp mcode
117 | Binary of expression * Ast.binaryOp mcode * expression
118 | Nested of expression * Ast.binaryOp mcode * expression
119 | Paren of string mcode (* ( *) * expression *
121 | ArrayAccess of expression * string mcode (* [ *) * expression *
123 | RecordAccess of expression * string mcode (* . *) * ident
124 | RecordPtAccess of expression * string mcode (* -> *) * ident
125 | Cast of string mcode (* ( *) * typeC * string mcode (* ) *) *
127 | SizeOfExpr of string mcode (* sizeof *) * expression
128 | SizeOfType of string mcode (* sizeof *) * string mcode (* ( *) *
129 typeC * string mcode (* ) *)
130 | TypeExp of typeC (* type name used as an expression, only in args *)
131 | MetaErr of Ast.meta_name mcode * expression list * pure
132 | MetaExpr of Ast.meta_name mcode * expression list *
133 Type_cocci.typeC list option * Ast.form * pure
134 | MetaExprList of Ast.meta_name mcode (* only in arg lists *) *
136 | EComma of string mcode (* only in arg lists *)
137 | DisjExpr of string mcode * expression list *
138 string mcode list (* the |s *) * string mcode
139 | NestExpr of string mcode * expression dots * string mcode *
140 expression option * Ast.multi
141 | Edots of string mcode (* ... *) * expression option
142 | Ecircles of string mcode (* ooo *) * expression option
143 | Estars of string mcode (* *** *) * expression option
144 | OptExp of expression
145 | UniqueExp of expression
147 and expression = base_expression wrap
149 and listlen = Ast.meta_name mcode option
151 (* --------------------------------------------------------------------- *)
155 ConstVol of Ast.const_vol mcode * typeC
156 | BaseType of Ast.baseType * string mcode list
157 | Signed of Ast.sign mcode * typeC option
158 | Pointer of typeC * string mcode (* * *)
159 | FunctionPointer of typeC *
160 string mcode(* ( *)*string mcode(* * *)*string mcode(* ) *)*
161 string mcode (* ( *)*parameter_list*string mcode(* ) *)
162 | FunctionType of typeC option *
163 string mcode (* ( *) * parameter_list *
165 | Array of typeC * string mcode (* [ *) *
166 expression option * string mcode (* ] *)
167 | EnumName of string mcode (*enum*) * ident (* name *)
168 | StructUnionName of Ast.structUnion mcode * ident option (* name *)
169 | StructUnionDef of typeC (* either StructUnionName or metavar *) *
170 string mcode (* { *) * declaration dots * string mcode (* } *)
171 | TypeName of string mcode
172 | MetaType of Ast.meta_name mcode * pure
173 | DisjType of string mcode * typeC list * (* only after iso *)
174 string mcode list (* the |s *) * string mcode
176 | UniqueType of typeC
178 and typeC = base_typeC wrap
180 (* --------------------------------------------------------------------- *)
181 (* Variable declaration *)
182 (* Even if the Cocci program specifies a list of declarations, they are
183 split out into multiple declarations of a single variable each. *)
185 and base_declaration =
186 Init of Ast.storage mcode option * typeC * ident * string mcode (*=*) *
187 initialiser * string mcode (*;*)
188 | UnInit of Ast.storage mcode option * typeC * ident * string mcode (* ; *)
189 | TyDecl of typeC * string mcode (* ; *)
190 | MacroDecl of ident (* name *) * string mcode (* ( *) *
191 expression dots * string mcode (* ) *) * string mcode (* ; *)
192 | Typedef of string mcode (* typedef *) * typeC * typeC * string mcode (*;*)
193 | DisjDecl of string mcode * declaration list *
194 string mcode list (* the |s *) * string mcode
195 (* Ddots is for a structure declaration *)
196 | Ddots of string mcode (* ... *) * declaration option (* whencode *)
197 | OptDecl of declaration
198 | UniqueDecl of declaration
200 and declaration = base_declaration wrap
202 (* --------------------------------------------------------------------- *)
205 and base_initialiser =
206 InitExpr of expression
207 | InitList of string mcode (*{*) * initialiser_list * string mcode (*}*)
209 string mcode (*.*) * ident (* name *) * string mcode (*=*) *
210 initialiser (* gccext: *)
211 | InitGccName of ident (* name *) * string mcode (*:*) *
214 string mcode (*[*) * expression * string mcode (*]*) *
215 string mcode (*=*) * initialiser
217 string mcode (*[*) * expression * string mcode (*...*) *
218 expression * string mcode (*]*) * string mcode (*=*) * initialiser
219 | IComma of string mcode (* , *)
220 | Idots of string mcode (* ... *) * initialiser option (* whencode *)
221 | OptIni of initialiser
222 | UniqueIni of initialiser
224 and initialiser = base_initialiser wrap
226 and initialiser_list = initialiser dots
228 (* --------------------------------------------------------------------- *)
231 and base_parameterTypeDef =
233 | Param of typeC * ident option
234 | MetaParam of Ast.meta_name mcode * pure
235 | MetaParamList of Ast.meta_name mcode * listlen * pure
236 | PComma of string mcode
237 | Pdots of string mcode (* ... *)
238 | Pcircles of string mcode (* ooo *)
239 | OptParam of parameterTypeDef
240 | UniqueParam of parameterTypeDef
242 and parameterTypeDef = base_parameterTypeDef wrap
244 and parameter_list = parameterTypeDef dots
246 (* --------------------------------------------------------------------- *)
247 (* #define Parameters *)
249 and base_define_param =
251 | DPComma of string mcode
252 | DPdots of string mcode (* ... *)
253 | DPcircles of string mcode (* ooo *)
254 | OptDParam of define_param
255 | UniqueDParam of define_param
257 and define_param = base_define_param wrap
259 and base_define_parameters =
261 | DParams of string mcode(*( *) * define_param dots * string mcode(* )*)
263 and define_parameters = base_define_parameters wrap
265 (* --------------------------------------------------------------------- *)
269 Decl of (info * mcodekind) (* before the decl *) * declaration
270 | Seq of string mcode (* { *) * statement dots *
272 | ExprStatement of expression * string mcode (*;*)
273 | IfThen of string mcode (* if *) * string mcode (* ( *) *
274 expression * string mcode (* ) *) *
275 statement * (info * mcodekind) (* after info *)
276 | IfThenElse of string mcode (* if *) * string mcode (* ( *) *
277 expression * string mcode (* ) *) *
278 statement * string mcode (* else *) * statement *
280 | While of string mcode (* while *) * string mcode (* ( *) *
281 expression * string mcode (* ) *) *
282 statement * (info * mcodekind) (* after info *)
283 | Do of string mcode (* do *) * statement *
284 string mcode (* while *) * string mcode (* ( *) *
285 expression * string mcode (* ) *) *
287 | For of string mcode (* for *) * string mcode (* ( *) *
288 expression option * string mcode (*;*) *
289 expression option * string mcode (*;*) *
290 expression option * string mcode (* ) *) * statement *
291 (info * mcodekind) (* after info *)
292 | Iterator of ident (* name *) * string mcode (* ( *) *
293 expression dots * string mcode (* ) *) *
294 statement * (info * mcodekind) (* after info *)
295 | Switch of string mcode (* switch *) * string mcode (* ( *) *
296 expression * string mcode (* ) *) * string mcode (* { *) *
297 case_line dots * string mcode (* } *)
298 | Break of string mcode (* break *) * string mcode (* ; *)
299 | Continue of string mcode (* continue *) * string mcode (* ; *)
300 | Label of ident * string mcode (* : *)
301 | Goto of string mcode (* goto *) * ident * string mcode (* ; *)
302 | Return of string mcode (* return *) * string mcode (* ; *)
303 | ReturnExpr of string mcode (* return *) * expression *
305 | MetaStmt of Ast.meta_name mcode * pure
306 | MetaStmtList of Ast.meta_name mcode(*only in statement lists*) * pure
307 | Exp of expression (* only in dotted statement lists *)
308 | TopExp of expression (* for macros body *)
309 | Ty of typeC (* only at top level *)
310 | TopInit of initialiser (* only at top level *)
311 | Disj of string mcode * statement dots list *
312 string mcode list (* the |s *) * string mcode
313 | Nest of string mcode * statement dots * string mcode *
314 (statement dots,statement) whencode list * Ast.multi
315 | Dots of string mcode (* ... *) *
316 (statement dots,statement) whencode list
317 | Circles of string mcode (* ooo *) *
318 (statement dots,statement) whencode list
319 | Stars of string mcode (* *** *) *
320 (statement dots,statement) whencode list
321 | FunDecl of (info * mcodekind) (* before the function decl *) *
322 fninfo list * ident (* name *) *
323 string mcode (* ( *) * parameter_list * string mcode (* ) *) *
324 string mcode (* { *) * statement dots *
326 | Include of string mcode (* #include *) * Ast.inc_file mcode (* file *)
327 | Define of string mcode (* #define *) * ident (* name *) *
328 define_parameters (*params*) * statement dots
329 | OptStm of statement
330 | UniqueStm of statement
333 FStorage of Ast.storage mcode
335 | FInline of string mcode
336 | FAttr of string mcode
338 and ('a,'b) whencode =
341 | WhenModifier of Ast.when_modifier
342 | WhenNotTrue of expression
343 | WhenNotFalse of expression
345 and statement = base_statement wrap
348 Default of string mcode (* default *) * string mcode (*:*) * statement dots
349 | Case of string mcode (* case *) * expression * string mcode (*:*) *
351 | OptCase of case_line
353 and case_line = base_case_line wrap
355 (* --------------------------------------------------------------------- *)
359 MetaPos of Ast.meta_name mcode * Ast.meta_name list * Ast.meta_collect
362 (* --------------------------------------------------------------------- *)
367 | CODE of statement dots
368 | FILEINFO of string mcode (* old file *) * string mcode (* new file *)
369 | ERRORWORDS of expression list
370 | OTHER of statement (* temporary, disappears after top_level.ml *)
372 and top_level = base_top_level wrap
373 and rule = top_level list
377 (rule * Ast.metavar list *
378 (string list * string list * Ast.dependency * string * Ast.exists)) *
379 (rule * Ast.metavar list) * Ast.ruletype
381 string * Ast.dependency * (string * Ast.meta_name) list * string
383 (* --------------------------------------------------------------------- *)
386 DotsExprTag of expression dots
387 | DotsInitTag of initialiser dots
388 | DotsParamTag of parameterTypeDef dots
389 | DotsStmtTag of statement dots
390 | DotsDeclTag of declaration dots
391 | DotsCaseTag of case_line dots
393 | ExprTag of expression
394 | ArgExprTag of expression (* for isos *)
395 | TestExprTag of expression (* for isos *)
397 | ParamTag of parameterTypeDef
398 | InitTag of initialiser
399 | DeclTag of declaration
400 | StmtTag of statement
401 | CaseLineTag of case_line
402 | TopTag of top_level
403 | IsoWhenTag of Ast.when_modifier
404 | IsoWhenTTag of expression
405 | IsoWhenFTag of expression
406 | MetaPosTag of meta_pos
408 let dotsExpr x = DotsExprTag x
409 let dotsParam x = DotsParamTag x
410 let dotsInit x = DotsInitTag x
411 let dotsStmt x = DotsStmtTag x
412 let dotsDecl x = DotsDeclTag x
413 let dotsCase x = DotsCaseTag x
414 let ident x = IdentTag x
415 let expr x = ExprTag x
416 let typeC x = TypeCTag x
417 let param x = ParamTag x
418 let ini x = InitTag x
419 let decl x = DeclTag x
420 let stmt x = StmtTag x
421 let case_line x = CaseLineTag x
424 (* --------------------------------------------------------------------- *)
425 (* Avoid cluttering the parser. Calculated in compute_lines.ml. *)
427 let default_info _ = (* why is this a function? *)
428 { line_start = -1; line_end = -1;
429 logical_start = -1; logical_end = -1;
430 attachable_start = true; attachable_end = true;
431 mcode_start = []; mcode_end = [];
432 column = -1; offset = -1; strings_before = []; strings_after = [] }
434 let default_befaft _ =
435 MIXED(ref (Ast.NOTHING,default_token_info,default_token_info))
436 let context_befaft _ =
437 CONTEXT(ref (Ast.NOTHING,default_token_info,default_token_info))
441 info = default_info();
443 mcodekind = ref (default_befaft());
447 true_if_test = false;
448 true_if_test_exp = false;
452 info = default_info();
454 mcodekind = ref (context_befaft());
458 true_if_test = false;
459 true_if_test_exp = false;
461 let unwrap x = x.node
462 let unwrap_mcode (x,_,_,_,_) = x
463 let rewrap model x = { model with node = x }
464 let rewrap_mcode (_,arity,info,mcodekind,pos) x = (x,arity,info,mcodekind,pos)
465 let copywrap model x =
466 { model with node = x; index = ref !(model.index);
467 mcodekind = ref !(model.mcodekind); exp_ty = ref !(model.exp_ty)}
468 let get_pos (_,_,_,_,x) = !x
469 let get_pos_ref (_,_,_,_,x) = x
470 let set_pos pos (m,arity,info,mcodekind,_) = (m,arity,info,mcodekind,ref pos)
471 let get_info x = x.info
472 let set_info x info = {x with info = info}
473 let get_line x = x.info.line_start
474 let get_line_end x = x.info.line_end
475 let get_index x = !(x.index)
476 let set_index x i = x.index := i
477 let get_mcodekind x = !(x.mcodekind)
478 let get_mcode_mcodekind (_,_,_,mcodekind,_) = mcodekind
479 let get_mcodekind_ref x = x.mcodekind
480 let set_mcodekind x mk = x.mcodekind := mk
481 let set_type x t = x.exp_ty := t
482 let get_type x = !(x.exp_ty)
483 let get_dots_bef_aft x = x.bef_aft
484 let set_dots_bef_aft x dots_bef_aft = {x with bef_aft = dots_bef_aft}
485 let get_arg_exp x = x.true_if_arg
486 let set_arg_exp x = {x with true_if_arg = true}
487 let get_test_pos x = x.true_if_test
488 let set_test_pos x = {x with true_if_test = true}
489 let get_test_exp x = x.true_if_test_exp
490 let set_test_exp x = {x with true_if_test_exp = true}
491 let get_iso x = x.iso_info
492 let set_iso x i = if !Flag.track_iso_usage then {x with iso_info = i} else x
493 let set_mcode_data data (_,ar,info,mc,pos) = (data,ar,info,mc,pos)
495 (* --------------------------------------------------------------------- *)
497 (* unique indices, for mcode and tree nodes *)
498 let index_counter = ref 0
499 let fresh_index _ = let cur = !index_counter in index_counter := cur + 1; cur
501 (* --------------------------------------------------------------------- *)
509 (* --------------------------------------------------------------------- *)
511 let rec ast0_type_to_type ty =
513 ConstVol(cv,ty) -> Type_cocci.ConstVol(const_vol cv,ast0_type_to_type ty)
514 | BaseType(bty,strings) ->
515 Type_cocci.BaseType(baseType bty)
516 | Signed(sgn,None) ->
517 Type_cocci.SignedT(sign sgn,None)
518 | Signed(sgn,Some ty) ->
519 let bty = ast0_type_to_type ty in
520 Type_cocci.SignedT(sign sgn,Some bty)
521 | Pointer(ty,_) -> Type_cocci.Pointer(ast0_type_to_type ty)
522 | FunctionPointer(ty,_,_,_,_,params,_) ->
523 Type_cocci.FunctionPointer(ast0_type_to_type ty)
524 | FunctionType _ -> failwith "not supported"
525 | Array(ety,_,_,_) -> Type_cocci.Array(ast0_type_to_type ety)
526 | EnumName(su,tag) ->
527 (match unwrap tag with
529 Type_cocci.EnumName(false,unwrap_mcode tag)
532 "warning: enum with a metavariable name detected.\n";
534 "For type checking assuming the name of the metavariable is the name of the type\n";
535 let (rule,tag) = unwrap_mcode tag in
536 Type_cocci.EnumName(true,rule^tag))
537 | _ -> failwith "unexpected enum type name")
538 | StructUnionName(su,Some tag) ->
539 (match unwrap tag with
541 Type_cocci.StructUnionName(structUnion su,false,unwrap_mcode tag)
544 "warning: struct/union with a metavariable name detected.\n";
546 "For type checking assuming the name of the metavariable is the name of the type\n";
547 let (rule,tag) = unwrap_mcode tag in
548 Type_cocci.StructUnionName(structUnion su,true,rule^tag))
549 | _ -> failwith "unexpected struct/union type name")
550 | StructUnionName(su,None) -> failwith "nameless structure - what to do???"
551 | StructUnionDef(ty,_,_,_) -> ast0_type_to_type ty
552 | TypeName(name) -> Type_cocci.TypeName(unwrap_mcode name)
553 | MetaType(name,_) ->
554 Type_cocci.MetaType(unwrap_mcode name,Type_cocci.Unitary,false)
555 | DisjType(_,types,_,_) -> failwith "unexpected DisjType"
556 | OptType(ty) | UniqueType(ty) ->
559 and baseType = function
560 Ast.VoidType -> Type_cocci.VoidType
561 | Ast.CharType -> Type_cocci.CharType
562 | Ast.ShortType -> Type_cocci.ShortType
563 | Ast.IntType -> Type_cocci.IntType
564 | Ast.DoubleType -> Type_cocci.DoubleType
565 | Ast.FloatType -> Type_cocci.FloatType
566 | Ast.LongType -> Type_cocci.LongType
567 | Ast.LongLongType -> Type_cocci.LongLongType
570 match unwrap_mcode t with
571 Ast.Struct -> Type_cocci.Struct
572 | Ast.Union -> Type_cocci.Union
575 match unwrap_mcode t with
576 Ast.Signed -> Type_cocci.Signed
577 | Ast.Unsigned -> Type_cocci.Unsigned
580 match unwrap_mcode t with
581 Ast.Const -> Type_cocci.Const
582 | Ast.Volatile -> Type_cocci.Volatile
584 (* --------------------------------------------------------------------- *)
585 (* this function is a rather minimal attempt. the problem is that information
586 has been lost. but since it is only used for metavariable types in the isos,
587 perhaps it doesn't matter *)
588 and make_mcode x = (x,NONE,default_info(),context_befaft(),ref NoMetaPos)
589 let make_mcode_info x info = (x,NONE,info,context_befaft(),ref NoMetaPos)
593 let rec reverse_type ty =
595 Type_cocci.ConstVol(cv,ty) ->
596 ConstVol(reverse_const_vol cv,context_wrap(reverse_type ty))
597 | Type_cocci.BaseType(bty) ->
598 BaseType(reverse_baseType bty,[(* not used *)])
599 | Type_cocci.SignedT(sgn,None) -> Signed(reverse_sign sgn,None)
600 | Type_cocci.SignedT(sgn,Some bty) ->
601 Signed(reverse_sign sgn,Some (context_wrap(reverse_type ty)))
602 | Type_cocci.Pointer(ty) ->
603 Pointer(context_wrap(reverse_type ty),make_mcode "*")
604 | Type_cocci.EnumName(mv,tag) ->
610 context_wrap(MetaId(make_mcode ("",tag),[],Impure)))
612 EnumName(make_mcode "enum",context_wrap(Id(make_mcode tag)))
613 | Type_cocci.StructUnionName(su,mv,tag) ->
618 (reverse_structUnion su,
619 Some(context_wrap(MetaId(make_mcode ("",tag),[],Impure))))
622 (reverse_structUnion su,
623 Some (context_wrap(Id(make_mcode tag))))
624 | Type_cocci.TypeName(name) -> TypeName(make_mcode name)
625 | Type_cocci.MetaType(name,_,_) ->
626 MetaType(make_mcode name,Impure(*not really right*))
629 and reverse_baseType = function
630 Type_cocci.VoidType -> Ast.VoidType
631 | Type_cocci.CharType -> Ast.CharType
632 | Type_cocci.BoolType -> Ast.IntType
633 | Type_cocci.ShortType -> Ast.ShortType
634 | Type_cocci.IntType -> Ast.IntType
635 | Type_cocci.DoubleType -> Ast.DoubleType
636 | Type_cocci.FloatType -> Ast.FloatType
637 | Type_cocci.LongType -> Ast.LongType
638 | Type_cocci.LongLongType -> Ast.LongLongType
640 and reverse_structUnion t =
643 Type_cocci.Struct -> Ast.Struct
644 | Type_cocci.Union -> Ast.Union)
649 Type_cocci.Signed -> Ast.Signed
650 | Type_cocci.Unsigned -> Ast.Unsigned)
652 and reverse_const_vol t =
655 Type_cocci.Const -> Ast.Const
656 | Type_cocci.Volatile -> Ast.Volatile)
658 (* --------------------------------------------------------------------- *)
662 (Impure,_) | (_,Impure) -> Impure
663 | (Pure,Context) | (Context,Pure) -> Impure
664 | (Pure,_) | (_,Pure) -> Pure
665 | (_,Context) | (Context,_) -> Context
668 (* --------------------------------------------------------------------- *)
670 let rule_name = ref "" (* for the convenience of the parser *)