(*
+ * Copyright 2010, INRIA, University of Copenhagen
+ * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
* Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
* Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
* This file is part of Coccinelle.
| Ast0.EComma(cm) -> Ast.EComma(mcode cm)
| Ast0.DisjExpr(_,exps,_,_) ->
Ast.DisjExpr(List.map expression exps)
- | Ast0.NestExpr(_,exp_dots,_,whencode,multi) ->
+ | Ast0.NestExpr(starter,exp_dots,ender,whencode,multi) ->
+ let starter = mcode starter in
let whencode = get_option expression whencode in
- Ast.NestExpr(dots expression exp_dots,whencode,multi)
+ let ender = mcode ender in
+ Ast.NestExpr(starter,dots expression exp_dots,ender,whencode,multi)
| Ast0.Edots(dots,whencode) ->
let dots = mcode dots in
let whencode = get_option expression whencode in
Ast0.NoConstraint -> Ast.NoConstraint
| Ast0.NotIdCstrt idctrt -> Ast.NotIdCstrt idctrt
| Ast0.NotExpCstrt exps -> Ast.NotExpCstrt (List.map expression exps)
+ | Ast0.SubExpCstrt ids -> Ast.SubExpCstrt ids
(* --------------------------------------------------------------------- *)
(* Types *)
(* Initialiser *)
and strip_idots initlist =
+ let isminus mc =
+ match Ast0.get_mcode_mcodekind mc with
+ Ast0.MINUS _ -> true
+ | _ -> false in
match Ast0.unwrap initlist with
Ast0.DOTS(x) ->
- let (whencode,init) =
+ let (whencode,init,dotinfo) =
List.fold_left
- (function (prevwhen,previnit) ->
+ (function (prevwhen,previnit,dotinfo) ->
function cur ->
match Ast0.unwrap cur with
Ast0.Idots(dots,Some whencode) ->
- (whencode :: prevwhen, previnit)
- | Ast0.Idots(dots,None) -> (prevwhen,previnit)
- | _ -> (prevwhen, cur :: previnit))
- ([],[]) x in
- (List.rev whencode, List.rev init)
+ (whencode :: prevwhen, previnit,
+ (isminus dots)::dotinfo)
+ | Ast0.Idots(dots,None) ->
+ (prevwhen, previnit, (isminus dots)::dotinfo)
+ | _ -> (prevwhen, cur :: previnit, dotinfo))
+ ([],[],[]) x in
+ let allminus =
+ if List.for_all (function x -> not x) dotinfo
+ then false (* false if no dots *)
+ else
+ if List.for_all (function x -> x) dotinfo
+ then true
+ else failwith "inconsistent annotations on initialiser list dots" in
+ (List.rev whencode, List.rev init, allminus)
| Ast0.CIRCLES(x) | Ast0.STARS(x) -> failwith "not possible for an initlist"
and initialiser i =
Ast0.MetaInit(name,_) -> Ast.MetaInit(mcode name,unitary,false)
| Ast0.InitExpr(exp) -> Ast.InitExpr(expression exp)
| Ast0.InitList(lb,initlist,rb) ->
- let (whencode,initlist) = strip_idots initlist in
- Ast.InitList(mcode lb,List.map initialiser initlist,mcode rb,
+ let (whencode,initlist,allminus) = strip_idots initlist in
+ Ast.InitList(allminus,mcode lb,List.map initialiser initlist,mcode rb,
List.map initialiser whencode)
| Ast0.InitGccExt(designators,eq,ini) ->
Ast.InitGccExt(List.map designator designators,mcode eq,
| Ast0.Disj(_,rule_elem_dots_list,_,_) ->
Ast.Disj(List.map (function x -> statement_dots seqible x)
rule_elem_dots_list)
- | Ast0.Nest(_,rule_elem_dots,_,whn,multi) ->
+ | Ast0.Nest(starter,rule_elem_dots,ender,whn,multi) ->
Ast.Nest
- (statement_dots Ast.Sequencible rule_elem_dots,
+ (mcode starter,statement_dots Ast.Sequencible rule_elem_dots,
+ mcode ender,
List.map
(whencode (statement_dots Ast.Sequencible)
(statement Ast.NotSequencible))