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 MetaInit of Ast.meta_name mcode * pure
207 | InitExpr of expression
208 | InitList of string mcode (*{*) * initialiser_list * string mcode (*}*)
210 designator list (* name *) * string mcode (*=*) *
211 initialiser (* gccext: *)
212 | InitGccName of ident (* name *) * string mcode (*:*) *
214 | IComma of string mcode (* , *)
215 | Idots of string mcode (* ... *) * initialiser option (* whencode *)
216 | OptIni of initialiser
217 | UniqueIni of initialiser
220 DesignatorField of string mcode (* . *) * ident
221 | DesignatorIndex of string mcode (* [ *) * expression * string mcode (* ] *)
223 string mcode (* [ *) * expression * string mcode (* ... *) *
224 expression * string mcode (* ] *)
226 and initialiser = base_initialiser wrap
228 and initialiser_list = initialiser dots
230 (* --------------------------------------------------------------------- *)
233 and base_parameterTypeDef =
235 | Param of typeC * ident option
236 | MetaParam of Ast.meta_name mcode * pure
237 | MetaParamList of Ast.meta_name mcode * listlen * pure
238 | PComma of string mcode
239 | Pdots of string mcode (* ... *)
240 | Pcircles of string mcode (* ooo *)
241 | OptParam of parameterTypeDef
242 | UniqueParam of parameterTypeDef
244 and parameterTypeDef = base_parameterTypeDef wrap
246 and parameter_list = parameterTypeDef dots
248 (* --------------------------------------------------------------------- *)
249 (* #define Parameters *)
251 and base_define_param =
253 | DPComma of string mcode
254 | DPdots of string mcode (* ... *)
255 | DPcircles of string mcode (* ooo *)
256 | OptDParam of define_param
257 | UniqueDParam of define_param
259 and define_param = base_define_param wrap
261 and base_define_parameters =
263 | DParams of string mcode(*( *) * define_param dots * string mcode(* )*)
265 and define_parameters = base_define_parameters wrap
267 (* --------------------------------------------------------------------- *)
271 Decl of (info * mcodekind) (* before the decl *) * declaration
272 | Seq of string mcode (* { *) * statement dots *
274 | ExprStatement of expression * string mcode (*;*)
275 | IfThen of string mcode (* if *) * string mcode (* ( *) *
276 expression * string mcode (* ) *) *
277 statement * (info * mcodekind) (* after info *)
278 | IfThenElse of string mcode (* if *) * string mcode (* ( *) *
279 expression * string mcode (* ) *) *
280 statement * string mcode (* else *) * statement *
282 | While of string mcode (* while *) * string mcode (* ( *) *
283 expression * string mcode (* ) *) *
284 statement * (info * mcodekind) (* after info *)
285 | Do of string mcode (* do *) * statement *
286 string mcode (* while *) * string mcode (* ( *) *
287 expression * string mcode (* ) *) *
289 | For of string mcode (* for *) * string mcode (* ( *) *
290 expression option * string mcode (*;*) *
291 expression option * string mcode (*;*) *
292 expression option * string mcode (* ) *) * statement *
293 (info * mcodekind) (* after info *)
294 | Iterator of ident (* name *) * string mcode (* ( *) *
295 expression dots * string mcode (* ) *) *
296 statement * (info * mcodekind) (* after info *)
297 | Switch of string mcode (* switch *) * string mcode (* ( *) *
298 expression * string mcode (* ) *) * string mcode (* { *) *
299 case_line dots * string mcode (* } *)
300 | Break of string mcode (* break *) * string mcode (* ; *)
301 | Continue of string mcode (* continue *) * string mcode (* ; *)
302 | Label of ident * string mcode (* : *)
303 | Goto of string mcode (* goto *) * ident * string mcode (* ; *)
304 | Return of string mcode (* return *) * string mcode (* ; *)
305 | ReturnExpr of string mcode (* return *) * expression *
307 | MetaStmt of Ast.meta_name mcode * pure
308 | MetaStmtList of Ast.meta_name mcode(*only in statement lists*) * pure
309 | Exp of expression (* only in dotted statement lists *)
310 | TopExp of expression (* for macros body *)
311 | Ty of typeC (* only at top level *)
312 | TopInit of initialiser (* only at top level *)
313 | Disj of string mcode * statement dots list *
314 string mcode list (* the |s *) * string mcode
315 | Nest of string mcode * statement dots * string mcode *
316 (statement dots,statement) whencode list * Ast.multi
317 | Dots of string mcode (* ... *) *
318 (statement dots,statement) whencode list
319 | Circles of string mcode (* ooo *) *
320 (statement dots,statement) whencode list
321 | Stars of string mcode (* *** *) *
322 (statement dots,statement) whencode list
323 | FunDecl of (info * mcodekind) (* before the function decl *) *
324 fninfo list * ident (* name *) *
325 string mcode (* ( *) * parameter_list * string mcode (* ) *) *
326 string mcode (* { *) * statement dots *
328 | Include of string mcode (* #include *) * Ast.inc_file mcode (* file *)
329 | Define of string mcode (* #define *) * ident (* name *) *
330 define_parameters (*params*) * statement dots
331 | OptStm of statement
332 | UniqueStm of statement
335 FStorage of Ast.storage mcode
337 | FInline of string mcode
338 | FAttr of string mcode
340 and ('a,'b) whencode =
343 | WhenModifier of Ast.when_modifier
344 | WhenNotTrue of expression
345 | WhenNotFalse of expression
347 and statement = base_statement wrap
350 Default of string mcode (* default *) * string mcode (*:*) * statement dots
351 | Case of string mcode (* case *) * expression * string mcode (*:*) *
353 | OptCase of case_line
355 and case_line = base_case_line wrap
357 (* --------------------------------------------------------------------- *)
361 MetaPos of Ast.meta_name mcode * Ast.meta_name list * Ast.meta_collect
364 (* --------------------------------------------------------------------- *)
369 | CODE of statement dots
370 | FILEINFO of string mcode (* old file *) * string mcode (* new file *)
371 | ERRORWORDS of expression list
372 | OTHER of statement (* temporary, disappears after top_level.ml *)
374 and top_level = base_top_level wrap
375 and rule = top_level list
379 (rule * Ast.metavar list *
380 (string list * string list * Ast.dependency * string * Ast.exists)) *
381 (rule * Ast.metavar list) * Ast.ruletype
383 string * Ast.dependency * (string * Ast.meta_name) list * string
385 (* --------------------------------------------------------------------- *)
388 DotsExprTag of expression dots
389 | DotsInitTag of initialiser dots
390 | DotsParamTag of parameterTypeDef dots
391 | DotsStmtTag of statement dots
392 | DotsDeclTag of declaration dots
393 | DotsCaseTag of case_line dots
395 | ExprTag of expression
396 | ArgExprTag of expression (* for isos *)
397 | TestExprTag of expression (* for isos *)
399 | ParamTag of parameterTypeDef
400 | InitTag of initialiser
401 | DeclTag of declaration
402 | StmtTag of statement
403 | CaseLineTag of case_line
404 | TopTag of top_level
405 | IsoWhenTag of Ast.when_modifier
406 | IsoWhenTTag of expression
407 | IsoWhenFTag of expression
408 | MetaPosTag of meta_pos
410 let dotsExpr x = DotsExprTag x
411 let dotsParam x = DotsParamTag x
412 let dotsInit x = DotsInitTag x
413 let dotsStmt x = DotsStmtTag x
414 let dotsDecl x = DotsDeclTag x
415 let dotsCase x = DotsCaseTag x
416 let ident x = IdentTag x
417 let expr x = ExprTag x
418 let typeC x = TypeCTag x
419 let param x = ParamTag x
420 let ini x = InitTag x
421 let decl x = DeclTag x
422 let stmt x = StmtTag x
423 let case_line x = CaseLineTag x
426 (* --------------------------------------------------------------------- *)
427 (* Avoid cluttering the parser. Calculated in compute_lines.ml. *)
429 let default_info _ = (* why is this a function? *)
430 { line_start = -1; line_end = -1;
431 logical_start = -1; logical_end = -1;
432 attachable_start = true; attachable_end = true;
433 mcode_start = []; mcode_end = [];
434 column = -1; offset = -1; strings_before = []; strings_after = [] }
436 let default_befaft _ =
437 MIXED(ref (Ast.NOTHING,default_token_info,default_token_info))
438 let context_befaft _ =
439 CONTEXT(ref (Ast.NOTHING,default_token_info,default_token_info))
443 info = default_info();
445 mcodekind = ref (default_befaft());
449 true_if_test = false;
450 true_if_test_exp = false;
454 info = default_info();
456 mcodekind = ref (context_befaft());
460 true_if_test = false;
461 true_if_test_exp = false;
463 let unwrap x = x.node
464 let unwrap_mcode (x,_,_,_,_) = x
465 let rewrap model x = { model with node = x }
466 let rewrap_mcode (_,arity,info,mcodekind,pos) x = (x,arity,info,mcodekind,pos)
467 let copywrap model x =
468 { model with node = x; index = ref !(model.index);
469 mcodekind = ref !(model.mcodekind); exp_ty = ref !(model.exp_ty)}
470 let get_pos (_,_,_,_,x) = !x
471 let get_pos_ref (_,_,_,_,x) = x
472 let set_pos pos (m,arity,info,mcodekind,_) = (m,arity,info,mcodekind,ref pos)
473 let get_info x = x.info
474 let set_info x info = {x with info = info}
475 let get_line x = x.info.line_start
476 let get_line_end x = x.info.line_end
477 let get_index x = !(x.index)
478 let set_index x i = x.index := i
479 let get_mcodekind x = !(x.mcodekind)
480 let get_mcode_mcodekind (_,_,_,mcodekind,_) = mcodekind
481 let get_mcodekind_ref x = x.mcodekind
482 let set_mcodekind x mk = x.mcodekind := mk
483 let set_type x t = x.exp_ty := t
484 let get_type x = !(x.exp_ty)
485 let get_dots_bef_aft x = x.bef_aft
486 let set_dots_bef_aft x dots_bef_aft = {x with bef_aft = dots_bef_aft}
487 let get_arg_exp x = x.true_if_arg
488 let set_arg_exp x = {x with true_if_arg = true}
489 let get_test_pos x = x.true_if_test
490 let set_test_pos x = {x with true_if_test = true}
491 let get_test_exp x = x.true_if_test_exp
492 let set_test_exp x = {x with true_if_test_exp = true}
493 let get_iso x = x.iso_info
494 let set_iso x i = if !Flag.track_iso_usage then {x with iso_info = i} else x
495 let set_mcode_data data (_,ar,info,mc,pos) = (data,ar,info,mc,pos)
497 (* --------------------------------------------------------------------- *)
499 (* unique indices, for mcode and tree nodes *)
500 let index_counter = ref 0
501 let fresh_index _ = let cur = !index_counter in index_counter := cur + 1; cur
503 (* --------------------------------------------------------------------- *)
511 (* --------------------------------------------------------------------- *)
513 let rec ast0_type_to_type ty =
515 ConstVol(cv,ty) -> Type_cocci.ConstVol(const_vol cv,ast0_type_to_type ty)
516 | BaseType(bty,strings) ->
517 Type_cocci.BaseType(baseType bty)
518 | Signed(sgn,None) ->
519 Type_cocci.SignedT(sign sgn,None)
520 | Signed(sgn,Some ty) ->
521 let bty = ast0_type_to_type ty in
522 Type_cocci.SignedT(sign sgn,Some bty)
523 | Pointer(ty,_) -> Type_cocci.Pointer(ast0_type_to_type ty)
524 | FunctionPointer(ty,_,_,_,_,params,_) ->
525 Type_cocci.FunctionPointer(ast0_type_to_type ty)
526 | FunctionType _ -> failwith "not supported"
527 | Array(ety,_,_,_) -> Type_cocci.Array(ast0_type_to_type ety)
528 | EnumName(su,tag) ->
529 (match unwrap tag with
531 Type_cocci.EnumName(false,unwrap_mcode tag)
534 "warning: enum with a metavariable name detected.\n";
536 "For type checking assuming the name of the metavariable is the name of the type\n";
537 let (rule,tag) = unwrap_mcode tag in
538 Type_cocci.EnumName(true,rule^tag))
539 | _ -> failwith "unexpected enum type name")
540 | StructUnionName(su,Some tag) ->
541 (match unwrap tag with
543 Type_cocci.StructUnionName(structUnion su,false,unwrap_mcode tag)
546 "warning: struct/union with a metavariable name detected.\n";
548 "For type checking assuming the name of the metavariable is the name of the type\n";
549 let (rule,tag) = unwrap_mcode tag in
550 Type_cocci.StructUnionName(structUnion su,true,rule^tag))
551 | _ -> failwith "unexpected struct/union type name")
552 | StructUnionName(su,None) -> failwith "nameless structure - what to do???"
553 | StructUnionDef(ty,_,_,_) -> ast0_type_to_type ty
554 | TypeName(name) -> Type_cocci.TypeName(unwrap_mcode name)
555 | MetaType(name,_) ->
556 Type_cocci.MetaType(unwrap_mcode name,Type_cocci.Unitary,false)
557 | DisjType(_,types,_,_) -> failwith "unexpected DisjType"
558 | OptType(ty) | UniqueType(ty) ->
561 and baseType = function
562 Ast.VoidType -> Type_cocci.VoidType
563 | Ast.CharType -> Type_cocci.CharType
564 | Ast.ShortType -> Type_cocci.ShortType
565 | Ast.IntType -> Type_cocci.IntType
566 | Ast.DoubleType -> Type_cocci.DoubleType
567 | Ast.FloatType -> Type_cocci.FloatType
568 | Ast.LongType -> Type_cocci.LongType
569 | Ast.LongLongType -> Type_cocci.LongLongType
572 match unwrap_mcode t with
573 Ast.Struct -> Type_cocci.Struct
574 | Ast.Union -> Type_cocci.Union
577 match unwrap_mcode t with
578 Ast.Signed -> Type_cocci.Signed
579 | Ast.Unsigned -> Type_cocci.Unsigned
582 match unwrap_mcode t with
583 Ast.Const -> Type_cocci.Const
584 | Ast.Volatile -> Type_cocci.Volatile
586 (* --------------------------------------------------------------------- *)
587 (* this function is a rather minimal attempt. the problem is that information
588 has been lost. but since it is only used for metavariable types in the isos,
589 perhaps it doesn't matter *)
590 and make_mcode x = (x,NONE,default_info(),context_befaft(),ref NoMetaPos)
591 let make_mcode_info x info = (x,NONE,info,context_befaft(),ref NoMetaPos)
595 let rec reverse_type ty =
597 Type_cocci.ConstVol(cv,ty) ->
598 ConstVol(reverse_const_vol cv,context_wrap(reverse_type ty))
599 | Type_cocci.BaseType(bty) ->
600 BaseType(reverse_baseType bty,[(* not used *)])
601 | Type_cocci.SignedT(sgn,None) -> Signed(reverse_sign sgn,None)
602 | Type_cocci.SignedT(sgn,Some bty) ->
603 Signed(reverse_sign sgn,Some (context_wrap(reverse_type ty)))
604 | Type_cocci.Pointer(ty) ->
605 Pointer(context_wrap(reverse_type ty),make_mcode "*")
606 | Type_cocci.EnumName(mv,tag) ->
612 context_wrap(MetaId(make_mcode ("",tag),[],Impure)))
614 EnumName(make_mcode "enum",context_wrap(Id(make_mcode tag)))
615 | Type_cocci.StructUnionName(su,mv,tag) ->
620 (reverse_structUnion su,
621 Some(context_wrap(MetaId(make_mcode ("",tag),[],Impure))))
624 (reverse_structUnion su,
625 Some (context_wrap(Id(make_mcode tag))))
626 | Type_cocci.TypeName(name) -> TypeName(make_mcode name)
627 | Type_cocci.MetaType(name,_,_) ->
628 MetaType(make_mcode name,Impure(*not really right*))
631 and reverse_baseType = function
632 Type_cocci.VoidType -> Ast.VoidType
633 | Type_cocci.CharType -> Ast.CharType
634 | Type_cocci.BoolType -> Ast.IntType
635 | Type_cocci.ShortType -> Ast.ShortType
636 | Type_cocci.IntType -> Ast.IntType
637 | Type_cocci.DoubleType -> Ast.DoubleType
638 | Type_cocci.FloatType -> Ast.FloatType
639 | Type_cocci.LongType -> Ast.LongType
640 | Type_cocci.LongLongType -> Ast.LongLongType
642 and reverse_structUnion t =
645 Type_cocci.Struct -> Ast.Struct
646 | Type_cocci.Union -> Ast.Union)
651 Type_cocci.Signed -> Ast.Signed
652 | Type_cocci.Unsigned -> Ast.Unsigned)
654 and reverse_const_vol t =
657 Type_cocci.Const -> Ast.Const
658 | Type_cocci.Volatile -> Ast.Volatile)
660 (* --------------------------------------------------------------------- *)
664 (Impure,_) | (_,Impure) -> Impure
665 | (Pure,Context) | (Context,Pure) -> Impure
666 | (Pure,_) | (_,Pure) -> Pure
667 | (_,Context) | (Context,_) -> Context
670 (* --------------------------------------------------------------------- *)
672 let rule_name = ref "" (* for the convenience of the parser *)