X-Git-Url: https://git.hcoop.net/bpt/coccinelle.git/blobdiff_plain/190f1acf3b0fa9403bea541654465a6a00bf3693..abad11c5570b7b9bbae5ff92b3050cf68fe3fd14:/parsing_cocci/ast0toast.ml

diff --git a/parsing_cocci/ast0toast.ml b/parsing_cocci/ast0toast.ml
index d254af4..820f848 100644
--- a/parsing_cocci/ast0toast.ml
+++ b/parsing_cocci/ast0toast.ml
@@ -1,5 +1,7 @@
 (*
- * Copyright 2010, INRIA, University of Copenhagen
+ * Copyright 2012, INRIA
+ * Julia Lawall, Gilles Muller
+ * Copyright 2010-2011, 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
@@ -22,6 +24,7 @@
  *)
 
 
+# 0 "./ast0toast.ml"
 (* Arities matter for the minus slice, but not for the plus slice. *)
 
 (* + only allowed on code in a nest (in_nest = true).  ? only allowed on
@@ -54,7 +57,7 @@ let inline_mcodes =
     match (Ast0.get_mcodekind e) with
       Ast0.MINUS(replacements) ->
 	(match !replacements with
-	  ([],_) -> ()
+	  (Ast.NOREPLACEMENT,_) -> ()
 	| replacements ->
 	    let minus_try = function
 		(true,mc) ->
@@ -100,8 +103,16 @@ let inline_mcodes =
 	      List.iter
 		(function
 		    Ast0.MINUS(mreplacements) ->
-		      let (mrepl,tokeninfo) = !mreplacements in
-		      mreplacements := concat bef beforeinfo mrepl tokeninfo
+		      (match !mreplacements with
+			(Ast.NOREPLACEMENT,tokeninfo) ->
+			  mreplacements :=
+			    (Ast.REPLACEMENT(bef,befit),beforeinfo)
+		      |	(Ast.REPLACEMENT(anythings,it),tokeninfo) ->
+			  let (newbef,newinfo) =
+			    concat bef beforeinfo anythings tokeninfo in
+			  let it = Ast.lub_count befit it in
+			  mreplacements :=
+			    (Ast.REPLACEMENT(newbef,it),newinfo))
 		  | Ast0.CONTEXT(mbefaft) ->
 		      (match !mbefaft with
 			(Ast.BEFORE(mbef,it),mbeforeinfo,a) ->
@@ -133,8 +144,16 @@ let inline_mcodes =
 	      List.iter
 		(function
 		    Ast0.MINUS(mreplacements) ->
-		      let (mrepl,tokeninfo) = !mreplacements in
-		      mreplacements := concat mrepl tokeninfo aft afterinfo
+		      (match !mreplacements with
+			(Ast.NOREPLACEMENT,tokeninfo) ->
+			  mreplacements :=
+			    (Ast.REPLACEMENT(aft,aftit),afterinfo)
+		      |	(Ast.REPLACEMENT(anythings,it),tokeninfo) ->
+			  let (newaft,newinfo) =
+			    concat anythings tokeninfo aft afterinfo in
+			  let it = Ast.lub_count aftit it in
+			  mreplacements :=
+			    (Ast.REPLACEMENT(newaft,it),newinfo))
 		  | Ast0.CONTEXT(mbefaft) ->
 		      (match !mbefaft with
 			(Ast.BEFORE(mbef,it),b,_) ->
@@ -178,7 +197,7 @@ let inline_mcodes =
     mcode mcode
     do_nothing do_nothing do_nothing do_nothing do_nothing do_nothing
     do_nothing do_nothing do_nothing do_nothing do_nothing do_nothing
-    do_nothing do_nothing do_nothing
+    do_nothing do_nothing do_nothing do_nothing
 
 (* --------------------------------------------------------------------- *)
 (* For function declarations.  Can't use the mcode at the root, because that
@@ -191,38 +210,48 @@ let check_allminus =
   let option_default = true in
   let mcode (_,_,_,mc,_,_) =
     match mc with
-      Ast0.MINUS(r) -> let (plusses,_) = !r in plusses = []
+      Ast0.MINUS(r) -> let (plusses,_) = !r in plusses = Ast.NOREPLACEMENT
     | _ -> false in
 
-  (* special case for disj *)
+  (* special case for disj and asExpr etc *)
   let ident r k e =
     match Ast0.unwrap e with
       Ast0.DisjId(starter,id_list,mids,ender) ->
 	List.for_all r.VT0.combiner_rec_ident id_list
+    | Ast0.AsIdent(id,asid) -> k id
     | _ -> k e in
 
   let expression r k e =
     match Ast0.unwrap e with
       Ast0.DisjExpr(starter,expr_list,mids,ender) ->
 	List.for_all r.VT0.combiner_rec_expression expr_list
+    | Ast0.AsExpr(exp,asexp) -> k exp
     | _ -> k e in
 
   let declaration r k e =
     match Ast0.unwrap e with
       Ast0.DisjDecl(starter,decls,mids,ender) ->
 	List.for_all r.VT0.combiner_rec_declaration decls
+    | Ast0.AsDecl(decl,asdecl) -> k decl
     | _ -> k e in
 
   let typeC r k e =
     match Ast0.unwrap e with
       Ast0.DisjType(starter,decls,mids,ender) ->
 	List.for_all r.VT0.combiner_rec_typeC decls
+    | Ast0.AsType(ty,asty) -> k ty
+    | _ -> k e in
+
+  let initialiser r k e =
+    match Ast0.unwrap e with
+      Ast0.AsInit(init,asinit) -> k init
     | _ -> k e in
 
   let statement r k e =
     match Ast0.unwrap e with
       Ast0.Disj(starter,statement_dots_list,mids,ender) ->
 	List.for_all r.VT0.combiner_rec_statement_dots statement_dots_list
+    | Ast0.AsStmt(stmt,asstmt) -> k stmt
     | _ -> k e in
 
   let case_line r k e =
@@ -235,8 +264,8 @@ let check_allminus =
     mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode
     mcode mcode
     donothing donothing donothing donothing donothing donothing
-    ident expression typeC donothing donothing declaration
-    statement case_line donothing
+    ident expression typeC initialiser donothing declaration
+    statement donothing case_line donothing
 
 (* --------------------------------------------------------------------- *)
 (* --------------------------------------------------------------------- *)
@@ -257,28 +286,50 @@ let convert_info info =
   { Ast.line = info.Ast0.pos_info.Ast0.line_start;
     Ast.column = info.Ast0.pos_info.Ast0.column;
     Ast.strbef = strings_to_s info.Ast0.strings_before;
-    Ast.straft = strings_to_s info.Ast0.strings_after;}
+    Ast.straft = strings_to_s info.Ast0.strings_after;
+  }
 
 let convert_mcodekind adj = function
     Ast0.MINUS(replacements) ->
       let (replacements,_) = !replacements in
-      Ast.MINUS(Ast.NoPos,[],adj,replacements)
+      Ast.MINUS(Ast.NoPos,[],Ast.ADJ adj,replacements)
   | Ast0.PLUS count -> Ast.PLUS count
   | Ast0.CONTEXT(befaft) ->
-      let (befaft,_,_) = !befaft in Ast.CONTEXT(Ast.NoPos,befaft)
+      let (befaft,_,_) = !befaft in
+      Ast.CONTEXT(Ast.NoPos,befaft)
   | Ast0.MIXED(_) -> failwith "not possible for mcode"
 
+let convert_fake_mcode (_,mc,adj) = convert_mcodekind adj mc
+
+let convert_allminus_mcodekind allminus = function
+    Ast0.CONTEXT(befaft) ->
+      let (befaft,_,_) = !befaft in
+      if allminus
+      then
+	(match befaft with
+	  Ast.NOTHING ->
+	    Ast.MINUS(Ast.NoPos,[],Ast.ALLMINUS,Ast.NOREPLACEMENT)
+	| Ast.BEFORE(a,ct) | Ast.AFTER(a,ct) ->
+	    Ast.MINUS(Ast.NoPos,[],Ast.ALLMINUS,Ast.REPLACEMENT(a,ct))
+	| Ast.BEFOREAFTER(b,a,ct) ->
+	    Ast.MINUS(Ast.NoPos,[],Ast.ALLMINUS,Ast.REPLACEMENT(b@a,ct)))
+      else Ast.CONTEXT(Ast.NoPos,befaft)
+  | _ -> failwith "convert_allminus_mcodekind: unexpected mcodekind"
+
 let pos_mcode(term,_,info,mcodekind,pos,adj) =
   (* avoids a recursion problem *)
-  (term,convert_info info,convert_mcodekind adj mcodekind,Ast.NoMetaPos)
+  (term,convert_info info,convert_mcodekind adj mcodekind,[])
 
 let mcode (term,_,info,mcodekind,pos,adj) =
   let pos =
-    match !pos with
-      Ast0.MetaPos(pos,constraints,per) ->
-	Ast.MetaPos(pos_mcode pos,constraints,per,unitary,false)
-    | _ -> Ast.NoMetaPos in
-  (term,convert_info info,convert_mcodekind adj mcodekind,pos)
+    List.fold_left
+      (function prev ->
+	function
+	    Ast0.MetaPosTag(Ast0.MetaPos(pos,constraints,per)) ->
+	      (Ast.MetaPos(pos_mcode pos,constraints,per,unitary,false))::prev
+	  | _ -> prev)
+      [] !pos in
+  (term,convert_info info,convert_mcodekind adj mcodekind,List.rev pos)
 
 (* --------------------------------------------------------------------- *)
 (* Dots *)
@@ -302,36 +353,6 @@ let dots fn d =
     | Ast0.CIRCLES(x) -> Ast.CIRCLES(List.map fn x)
     | Ast0.STARS(x) -> Ast.STARS(List.map fn x))
 
-(* commas in dotted lists, here due to polymorphism restrictions *)
-
-let add_comma is_comma make_comma itemlist =
-  match Ast0.unwrap itemlist with
-    Ast0.DOTS(x) ->
-      (match List.rev x with
-	[] -> itemlist
-      | e::es ->
-	  if is_comma e
-	  then itemlist
-	  else
-	    let comma =
-	      match Ast0.get_mcodekind e with
-		Ast0.MINUS(_) -> (Ast0.make_minus_mcode ",")
-	      |	_ -> (Ast0.make_mcode ",") in
-	    Ast0.rewrap itemlist
-	      (Ast0.DOTS
-		 (List.rev (Ast0.rewrap e (make_comma comma) :: (e::es)))))
-  | _ -> failwith "not possible"
-
-let add_exp_comma =
-  add_comma
-    (function x -> match Ast0.unwrap x with Ast0.EComma _ -> true | _ -> false)
-    (function x -> Ast0.EComma x)
-
-and add_init_comma =
-  add_comma
-    (function x -> match Ast0.unwrap x with Ast0.IComma _ -> true | _ -> false)
-    (function x -> Ast0.IComma x)
-
 (* --------------------------------------------------------------------- *)
 (* Identifier *)
 
@@ -343,12 +364,14 @@ and ident i =
       Ast0.Id(name) -> Ast.Id(mcode name)
     | Ast0.DisjId(_,id_list,_,_) ->
 	Ast.DisjId(List.map ident id_list)
-    | Ast0.MetaId(name,constraints,_) ->
+    | Ast0.MetaId(name,constraints,_,_) ->
 	Ast.MetaId(mcode name,constraints,unitary,false)
     | Ast0.MetaFunc(name,constraints,_) ->
 	Ast.MetaFunc(mcode name,constraints,unitary,false)
     | Ast0.MetaLocalFunc(name,constraints,_) ->
 	Ast.MetaLocalFunc(mcode name,constraints,unitary,false)
+    | Ast0.AsIdent(id,asid) ->
+	Ast.AsIdent(ident id,ident asid)
     | Ast0.OptIdent(id) -> Ast.OptIdent(ident id)
     | Ast0.UniqueIdent(id) -> Ast.UniqueIdent(ident id))
 
@@ -370,6 +393,8 @@ and expression e =
 	Ast.FunCall(fn,lp,args,rp)
     | Ast0.Assignment(left,op,right,simple) ->
 	Ast.Assignment(expression left,mcode op,expression right,simple)
+    | Ast0.Sequence(left,op,right) ->
+	Ast.Sequence(expression left,mcode op,expression right)
     | Ast0.CondExpr(exp1,why,exp2,colon,exp3) ->
 	let exp1 = expression exp1 in
 	let why = mcode why in
@@ -396,18 +421,27 @@ and expression e =
     | Ast0.RecordPtAccess(exp,ar,field) ->
 	Ast.RecordPtAccess(expression exp,mcode ar,ident field)
     | Ast0.Cast(lp,ty,rp,exp) ->
-	Ast.Cast(mcode lp,typeC ty,mcode rp,expression exp)
+	let allminus = check_allminus.VT0.combiner_rec_expression e in
+	Ast.Cast(mcode lp,typeC allminus ty,mcode rp,expression exp)
     | Ast0.SizeOfExpr(szf,exp) ->
 	Ast.SizeOfExpr(mcode szf,expression exp)
     | Ast0.SizeOfType(szf,lp,ty,rp) ->
-	Ast.SizeOfType(mcode szf, mcode lp,typeC ty,mcode rp)
-    | Ast0.TypeExp(ty) -> Ast.TypeExp(typeC ty)
+	let allminus = check_allminus.VT0.combiner_rec_expression e in
+	Ast.SizeOfType(mcode szf, mcode lp,typeC allminus ty,mcode rp)
+    | Ast0.TypeExp(ty) ->
+	let allminus = check_allminus.VT0.combiner_rec_expression e in
+	Ast.TypeExp(typeC allminus ty)
+    | Ast0.Constructor(lp,ty,rp,init) ->
+	let allminus = check_allminus.VT0.combiner_rec_expression e in
+	Ast.Constructor(mcode lp,typeC allminus ty,mcode rp,initialiser init)
     | Ast0.MetaErr(name,cstrts,_)  ->
 	  Ast.MetaErr(mcode name,constraints cstrts,unitary,false)
     | Ast0.MetaExpr(name,cstrts,ty,form,_)  ->
 	  Ast.MetaExpr(mcode name,constraints cstrts,unitary,ty,form,false)
     | Ast0.MetaExprList(name,lenname,_) ->
 	Ast.MetaExprList(mcode name,do_lenname lenname,unitary,false)
+    | Ast0.AsExpr(expr,asexpr) ->
+	Ast.AsExpr(expression expr,expression asexpr)
     | Ast0.EComma(cm)         -> Ast.EComma(mcode cm)
     | Ast0.DisjExpr(_,exps,_,_)     ->
 	Ast.DisjExpr(List.map expression exps)
@@ -451,7 +485,7 @@ and do_lenname = function
 
 and rewrap_iso t t1 = rewrap t (do_isos (Ast0.get_iso t)) t1
 
-and typeC t =
+and typeC allminus t =
   rewrap t (do_isos (Ast0.get_iso t))
     (match Ast0.unwrap t with
       Ast0.ConstVol(cv,ty) ->
@@ -466,7 +500,8 @@ and typeC t =
 	  List.map
 	    (function ty ->
 	      Ast.Type
-		(Some (mcode cv),rewrap_iso ty (base_typeC ty)))
+		(allminus, Some (mcode cv),
+		 rewrap_iso ty (base_typeC allminus ty)))
 	    (collect_disjs ty) in
 	(* one could worry that isos are lost because we flatten the
 	   disjunctions.  but there should not be isos on the disjunctions
@@ -479,38 +514,42 @@ and typeC t =
     | Ast0.Array(_,_,_,_) | Ast0.EnumName(_,_) | Ast0.StructUnionName(_,_)
     | Ast0.StructUnionDef(_,_,_,_) | Ast0.EnumDef(_,_,_,_)
     | Ast0.TypeName(_) | Ast0.MetaType(_,_) ->
-	Ast.Type(None,rewrap t no_isos (base_typeC t))
-    | Ast0.DisjType(_,types,_,_) -> Ast.DisjType(List.map typeC types)
-    | Ast0.OptType(ty) -> Ast.OptType(typeC ty)
-    | Ast0.UniqueType(ty) -> Ast.UniqueType(typeC ty))
-
-and base_typeC t =
+	Ast.Type(allminus,None,rewrap t no_isos (base_typeC allminus t))
+    | Ast0.DisjType(_,types,_,_) ->
+	Ast.DisjType(List.map (typeC allminus) types)
+    | Ast0.AsType(ty,asty) ->
+	Ast.AsType(typeC allminus ty,typeC allminus asty)
+    | Ast0.OptType(ty) -> Ast.OptType(typeC allminus ty)
+    | Ast0.UniqueType(ty) -> Ast.UniqueType(typeC allminus ty))
+
+and base_typeC allminus t =
   match Ast0.unwrap t with
     Ast0.BaseType(ty,strings) -> Ast.BaseType(ty,List.map mcode strings)
   | Ast0.Signed(sgn,ty) ->
-      Ast.SignedT(mcode sgn,
-		  get_option (function x -> rewrap_iso x (base_typeC x)) ty)
-  | Ast0.Pointer(ty,star) -> Ast.Pointer(typeC ty,mcode star)
+      Ast.SignedT
+	(mcode sgn,
+	 get_option (function x -> rewrap_iso x (base_typeC allminus x)) ty)
+  | Ast0.Pointer(ty,star) -> Ast.Pointer(typeC allminus ty,mcode star)
   | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) ->
       Ast.FunctionPointer
-	(typeC ty,mcode lp1,mcode star,mcode rp1,
+	(typeC allminus ty,mcode lp1,mcode star,mcode rp1,
 	 mcode lp2,parameter_list params,mcode rp2)
   | Ast0.FunctionType(ret,lp,params,rp) ->
       let allminus = check_allminus.VT0.combiner_rec_typeC t in
       Ast.FunctionType
-	(allminus,get_option typeC ret,mcode lp,
+	(allminus,get_option (typeC allminus) ret,mcode lp,
 	 parameter_list params,mcode rp)
   | Ast0.Array(ty,lb,size,rb) ->
-      Ast.Array(typeC ty,mcode lb,get_option expression size,mcode rb)
+      Ast.Array(typeC allminus ty,mcode lb,get_option expression size,
+		mcode rb)
   | Ast0.EnumName(kind,name) ->
       Ast.EnumName(mcode kind,get_option ident name)
   | Ast0.EnumDef(ty,lb,ids,rb) ->
-      let ids = add_exp_comma ids in
-      Ast.EnumDef(typeC ty,mcode lb,dots expression ids,mcode rb)
+      Ast.EnumDef(typeC allminus ty,mcode lb,dots expression ids,mcode rb)
   | Ast0.StructUnionName(kind,name) ->
       Ast.StructUnionName(mcode kind,get_option ident name)
   | Ast0.StructUnionDef(ty,lb,decls,rb) ->
-      Ast.StructUnionDef(typeC ty,mcode lb,
+      Ast.StructUnionDef(typeC allminus ty,mcode lb,
 			 dots declaration decls,
 			 mcode rb)
   | Ast0.TypeName(name) -> Ast.TypeName(mcode name)
@@ -530,9 +569,12 @@ and declaration d =
     | Ast0.MetaField(name,_) -> Ast.MetaField(mcode name,unitary,false)
     | Ast0.MetaFieldList(name,lenname,_) ->
 	Ast.MetaFieldList(mcode name,do_lenname lenname,unitary,false)
+    | Ast0.AsDecl(decl,asdecl) ->
+	Ast.AsDecl(declaration decl,declaration asdecl)
     | Ast0.Init(stg,ty,id,eq,ini,sem) ->
+	let allminus = check_allminus.VT0.combiner_rec_declaration d in
 	let stg = get_option mcode stg in
-	let ty = typeC ty in
+	let ty = typeC allminus ty in
 	let id = ident id in
 	let eq = mcode eq in
 	let ini = initialiser ini in
@@ -545,13 +587,17 @@ and declaration d =
 	    Ast.UnInit(get_option mcode stg,
 		       rewrap ty (do_isos (Ast0.get_iso ty))
 			 (Ast.Type
-			    (None,
+			    (allminus,None,
 			     rewrap ty no_isos
 			       (Ast.FunctionType
-				  (allminus,get_option typeC tyx,mcode lp1,
+				  (allminus,get_option (typeC allminus) tyx,
+				   mcode lp1,
 				   parameter_list params,mcode rp1)))),
 		       ident id,mcode sem)
-	| _ -> Ast.UnInit(get_option mcode stg,typeC ty,ident id,mcode sem))
+	| _ ->
+	    let allminus = check_allminus.VT0.combiner_rec_declaration d in
+	    Ast.UnInit(get_option mcode stg,typeC allminus ty,ident id,
+		       mcode sem))
     | Ast0.MacroDecl(name,lp,args,rp,sem) ->
 	let name = ident name in
 	let lp = mcode lp in
@@ -559,12 +605,24 @@ and declaration d =
 	let rp = mcode rp in
 	let sem = mcode sem in
 	Ast.MacroDecl(name,lp,args,rp,sem)
-    | Ast0.TyDecl(ty,sem) -> Ast.TyDecl(typeC ty,mcode sem)
+    | Ast0.MacroDeclInit(name,lp,args,rp,eq,ini,sem) ->
+	let name = ident name in
+	let lp = mcode lp in
+	let args = dots expression args in
+	let rp = mcode rp in
+	let eq = mcode eq in
+	let ini = initialiser ini in
+	let sem = mcode sem in
+	Ast.MacroDeclInit(name,lp,args,rp,eq,ini,sem)
+    | Ast0.TyDecl(ty,sem) ->
+	let allminus = check_allminus.VT0.combiner_rec_declaration d in
+	Ast.TyDecl(typeC allminus ty,mcode sem)
     | Ast0.Typedef(stg,ty,id,sem) ->
-	let id = typeC id in
+	let allminus = check_allminus.VT0.combiner_rec_declaration d in
+	let id = typeC allminus id in
 	(match Ast.unwrap id with
-	  Ast.Type(None,id) -> (* only MetaType or Id *)
-	    Ast.Typedef(mcode stg,typeC ty,id,mcode sem)
+	  Ast.Type(_,None,id) -> (* only MetaType or Id *)
+	    Ast.Typedef(mcode stg,typeC allminus ty,id,mcode sem)
 	| _ -> failwith "bad typedef")
     | Ast0.DisjDecl(_,decls,_,_) -> Ast.DisjDecl(List.map declaration decls)
     | Ast0.Ddots(dots,whencode) ->
@@ -607,7 +665,7 @@ and strip_idots initlist =
 	      |	Ast0.Idots(dots,None) ->
 		  let (restwhen,restinit,dotinfo) = loop rest in
 		  (restwhen, restinit, (isminus dots)::dotinfo)
-	      |	_ -> 
+	      |	_ ->
 		  let (restwhen,restinit,dotinfo) = loop rest in
 		  (restwhen,x::restinit,dotinfo)) in
 	loop l in
@@ -625,12 +683,14 @@ and initialiser i =
   rewrap i no_isos
     (match Ast0.unwrap i with
       Ast0.MetaInit(name,_) -> Ast.MetaInit(mcode name,unitary,false)
+    | Ast0.MetaInitList(name,lenname,_) ->
+	Ast.MetaInitList(mcode name,do_lenname lenname,unitary,false)
+    | Ast0.AsInit(init,asinit) ->
+	Ast.AsInit(initialiser init,initialiser asinit)
     | Ast0.InitExpr(exp) -> Ast.InitExpr(expression exp)
     | Ast0.InitList(lb,initlist,rb,true) ->
-	let initlist = add_init_comma initlist in
 	Ast.ArInitList(mcode lb,dots initialiser initlist,mcode rb)
     | Ast0.InitList(lb,initlist,rb,false) ->
-	let initlist = add_init_comma initlist in
 	let (whencode,initlist,allminus) = strip_idots initlist in
 	Ast.StrInitList
 	  (allminus,mcode lb,List.map initialiser initlist,mcode rb,
@@ -662,8 +722,10 @@ and designator = function
 and parameterTypeDef p =
   rewrap p no_isos
     (match Ast0.unwrap p with
-      Ast0.VoidParam(ty) -> Ast.VoidParam(typeC ty)
-    | Ast0.Param(ty,id) -> Ast.Param(typeC ty,get_option ident id)
+      Ast0.VoidParam(ty) -> Ast.VoidParam(typeC false ty)
+    | Ast0.Param(ty,id) ->
+	let allminus = check_allminus.VT0.combiner_rec_parameter p in
+	Ast.Param(typeC allminus ty,get_option ident id)
     | Ast0.MetaParam(name,_) ->
 	Ast.MetaParam(mcode name,unitary,false)
     | Ast0.MetaParamList(name,lenname,_) ->
@@ -695,10 +757,10 @@ and statement s =
     rewrap_stmt s
       (match Ast0.unwrap s with
 	Ast0.Decl((_,bef),decl) ->
+	  let allminus = check_allminus.VT0.combiner_rec_statement s in
 	  Ast.Atomic(rewrap_rule_elem s
-		       (Ast.Decl(convert_mcodekind (-1) bef,
-				 check_allminus.VT0.combiner_rec_statement s,
-				 declaration decl)))
+		       (Ast.Decl(convert_allminus_mcodekind allminus bef,
+				 allminus,declaration decl)))
       | Ast0.Seq(lbrace,body,rbrace) ->
 	  let lbrace = mcode lbrace in
 	  let body = dots (statement seqible) body in
@@ -709,14 +771,15 @@ and statement s =
 		  tokenwrap rbrace s (Ast.SeqEnd(rbrace)))
       | Ast0.ExprStatement(exp,sem) ->
 	  Ast.Atomic(rewrap_rule_elem s
-		       (Ast.ExprStatement(expression exp,mcode sem)))
-      | Ast0.IfThen(iff,lp,exp,rp,branch,(_,aft)) ->
+		       (Ast.ExprStatement
+			  (get_option expression exp,mcode sem)))
+      | Ast0.IfThen(iff,lp,exp,rp,branch,aft) ->
 	  Ast.IfThen
 	    (rewrap_rule_elem s
 	       (Ast.IfHeader(mcode iff,mcode lp,expression exp,mcode rp)),
 	     statement Ast.NotSequencible branch,
-	     ([],[],[],convert_mcodekind (-1) aft))
-      | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(_,aft)) ->
+	     ([],[],[],convert_fake_mcode aft))
+      | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) ->
 	  let els = mcode els in
 	  Ast.IfThenElse
 	    (rewrap_rule_elem s
@@ -724,13 +787,13 @@ and statement s =
 	     statement Ast.NotSequencible branch1,
 	     tokenwrap els s (Ast.Else(els)),
 	     statement Ast.NotSequencible branch2,
-	     ([],[],[],convert_mcodekind (-1) aft))
-      | Ast0.While(wh,lp,exp,rp,body,(_,aft)) ->
+	     ([],[],[],convert_fake_mcode aft))
+      | Ast0.While(wh,lp,exp,rp,body,aft) ->
 	  Ast.While(rewrap_rule_elem s
 		      (Ast.WhileHeader
 			 (mcode wh,mcode lp,expression exp,mcode rp)),
 		    statement Ast.NotSequencible body,
-		    ([],[],[],convert_mcodekind (-1) aft))
+		    ([],[],[],convert_fake_mcode aft))
       | Ast0.Do(d,body,wh,lp,exp,rp,sem) ->
 	  let wh = mcode wh in
 	  Ast.Do(rewrap_rule_elem s (Ast.DoHeader(mcode d)),
@@ -738,27 +801,26 @@ and statement s =
 		 tokenwrap wh s
 		   (Ast.WhileTail(wh,mcode lp,expression exp,mcode rp,
 				  mcode sem)))
-      | Ast0.For(fr,lp,exp1,sem1,exp2,sem2,exp3,rp,body,(_,aft)) ->
+      | Ast0.For(fr,lp,first,exp2,sem2,exp3,rp,body,aft) ->
 	  let fr = mcode fr in
 	  let lp = mcode lp in
-	  let exp1 = get_option expression exp1 in
-	  let sem1 = mcode sem1 in
+	  let first = forinfo first in
 	  let exp2 = get_option expression exp2 in
 	  let sem2= mcode sem2 in
 	  let exp3 = get_option expression exp3 in
 	  let rp = mcode rp in
 	  let body = statement Ast.NotSequencible body in
 	  Ast.For(rewrap_rule_elem s
-		    (Ast.ForHeader(fr,lp,exp1,sem1,exp2,sem2,exp3,rp)),
-		  body,([],[],[],convert_mcodekind (-1) aft))
-      | Ast0.Iterator(nm,lp,args,rp,body,(_,aft)) ->
+		    (Ast.ForHeader(fr,lp,first,exp2,sem2,exp3,rp)),
+		  body,([],[],[],convert_fake_mcode aft))
+      | Ast0.Iterator(nm,lp,args,rp,body,aft) ->
 	  Ast.Iterator(rewrap_rule_elem s
 		      (Ast.IteratorHeader
 			 (ident nm,mcode lp,
 			  dots expression args,
 			  mcode rp)),
 		    statement Ast.NotSequencible body,
-		    ([],[],[],convert_mcodekind (-1) aft))
+		    ([],[],[],convert_fake_mcode aft))
       |	Ast0.Switch(switch,lp,exp,rp,lb,decls,cases,rb) ->
 	  let switch = mcode switch in
 	  let lp = mcode lp in
@@ -793,6 +855,8 @@ and statement s =
       | Ast0.MetaStmtList(name,_) ->
 	  Ast.Atomic(rewrap_rule_elem s
 		       (Ast.MetaStmtList(mcode name,unitary,false)))
+      | Ast0.AsStmt(stmt,asstmt) ->
+	  Ast.AsStmt(statement seqible stmt,statement seqible asstmt)
       | Ast0.TopExp(exp) ->
 	  Ast.Atomic(rewrap_rule_elem s (Ast.TopExp(expression exp)))
       | Ast0.Exp(exp) ->
@@ -800,7 +864,8 @@ and statement s =
       | Ast0.TopInit(init) ->
 	  Ast.Atomic(rewrap_rule_elem s (Ast.TopInit(initialiser init)))
       | Ast0.Ty(ty) ->
-	  Ast.Atomic(rewrap_rule_elem s (Ast.Ty(typeC ty)))
+	  let allminus = check_allminus.VT0.combiner_rec_statement s in
+	  Ast.Atomic(rewrap_rule_elem s (Ast.Ty(typeC allminus ty)))
       | Ast0.Disj(_,rule_elem_dots_list,_,_) ->
 	  Ast.Disj(List.map (function x -> statement_dots seqible x)
 		     rule_elem_dots_list)
@@ -848,8 +913,9 @@ and statement s =
 	  let rbrace = mcode rbrace in
 	  let allminus = check_allminus.VT0.combiner_rec_statement s in
 	  Ast.FunDecl(rewrap_rule_elem s
-			(Ast.FunHeader(convert_mcodekind (-1) bef,
-				       allminus,fi,name,lp,params,rp)),
+			(Ast.FunHeader
+			   (convert_allminus_mcodekind allminus bef,
+			    allminus,fi,name,lp,params,rp)),
 		      tokenwrap lbrace s (Ast.SeqStart(lbrace)),
 		      body,
 		      tokenwrap rbrace s (Ast.SeqEnd(rbrace)))
@@ -976,9 +1042,21 @@ and statement s =
 
   statement Ast.Sequencible s
 
+and forinfo fi =
+  match Ast0.unwrap fi with
+    Ast0.ForExp(exp1,sem1) ->
+      let exp1 = get_option expression exp1 in
+      let sem1 = mcode sem1 in
+      Ast.ForExp(exp1,sem1)
+  | Ast0.ForDecl ((_,bef),decl) ->
+      let allminus =
+	check_allminus.VT0.combiner_rec_declaration decl in
+      Ast.ForDecl (convert_allminus_mcodekind allminus bef,
+		   allminus, declaration decl)
+
 and fninfo = function
     Ast0.FStorage(stg) -> Ast.FStorage(mcode stg)
-  | Ast0.FType(ty) -> Ast.FType(typeC ty)
+  | Ast0.FType(ty) -> Ast.FType(typeC false ty)
   | Ast0.FInline(inline) -> Ast.FInline(mcode inline)
   | Ast0.FAttr(attr) -> Ast.FAttr(mcode attr)
 
@@ -1022,17 +1100,19 @@ and anything = function
   | Ast0.ExprTag(d) -> Ast.ExpressionTag(expression d)
   | Ast0.ArgExprTag(d) | Ast0.TestExprTag(d) ->
      failwith "only in isos, not converted to ast"
-  | Ast0.TypeCTag(d) -> Ast.FullTypeTag(typeC d)
+  | Ast0.TypeCTag(d) -> Ast.FullTypeTag(typeC false d)
   | Ast0.ParamTag(d) -> Ast.ParamTag(parameterTypeDef d)
   | Ast0.InitTag(d) -> Ast.InitTag(initialiser d)
   | Ast0.DeclTag(d) -> Ast.DeclarationTag(declaration d)
   | Ast0.StmtTag(d) -> Ast.StatementTag(statement d)
+  | Ast0.ForInfoTag(d) -> Ast.ForInfoTag(forinfo d)
   | Ast0.CaseLineTag(d) -> Ast.CaseLineTag(case_line d)
   | Ast0.TopTag(d) -> Ast.Code(top_level d)
   | Ast0.IsoWhenTag(_) -> failwith "not possible"
   | Ast0.IsoWhenTTag(_) -> failwith "not possible"
   | Ast0.IsoWhenFTag(_) -> failwith "not possible"
   | Ast0.MetaPosTag _ -> failwith "not possible"
+  | Ast0.HiddenVarTag _ -> failwith "not possible"
 
 (* --------------------------------------------------------------------- *)
 (* Function declaration *)
@@ -1043,11 +1123,10 @@ and top_level t =
     (match Ast0.unwrap t with
       Ast0.FILEINFO(old_file,new_file) ->
 	Ast.FILEINFO(mcode old_file,mcode new_file)
-    | Ast0.DECL(stmt) -> Ast.DECL(statement stmt)
-    | Ast0.CODE(rule_elem_dots) ->
-	Ast.CODE(statement_dots rule_elem_dots)
+    | Ast0.NONDECL(stmt) -> Ast.NONDECL(statement stmt)
+    | Ast0.CODE(rule_elem_dots) -> Ast.CODE(statement_dots rule_elem_dots)
     | Ast0.ERRORWORDS(exps) -> Ast.ERRORWORDS(List.map expression exps)
-    | Ast0.OTHER(_) -> failwith "eliminated by top_level")
+    | Ast0.OTHER(_) | Ast0.TOPCODE(_) -> failwith "eliminated by top_level")
 
 (* --------------------------------------------------------------------- *)
 (* Entry point for minus code *)