parsing_cocci/visitor_ast0.ml

   1 (*
   2  * Copyright 2010, INRIA, University of Copenhagen
   3  * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
   4  * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
   5  * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
   6  * This file is part of Coccinelle.
   7  *
   8  * Coccinelle is free software: you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, according to version 2 of the License.
  11  *
  12  * Coccinelle is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Coccinelle.  If not, see <http://www.gnu.org/licenses/>.
  19  *
  20  * The authors reserve the right to distribute this or future versions of
  21  * Coccinelle under other licenses.
  22  *)
  23
  24
  25 (* --------------------------------------------------------------------- *)
  26 (* Generic traversal: rebuilder *)
  27
  28 module Ast = Ast_cocci
  29 module Ast0 = Ast0_cocci
  30 module VT0 = Visitor_ast0_types
  31
  32 type mode = COMBINER | REBUILDER | BOTH
  33
  34 let map_split f l = List.split(List.map f l)
  35
  36 let rewrap x (n,e) = (n,Ast0.rewrap x e)
  37
  38 let visitor mode bind option_default
  39     meta_mcode string_mcode const_mcode assign_mcode fix_mcode unary_mcode
  40     binary_mcode cv_mcode sign_mcode struct_mcode storage_mcode
  41     inc_mcode
  42     dotsexprfn dotsinitfn dotsparamfn dotsstmtfn dotsdeclfn dotscasefn
  43     identfn exprfn tyfn initfn paramfn declfn stmtfn casefn topfn =
  44   let multibind l =
  45     let rec loop = function
  46         [] -> option_default
  47       | [x] -> x
  48       | x::xs -> bind x (loop xs) in
  49     loop l in
  50   let map_split_bind f l =
  51     let (n,e) = List.split(List.map f l) in (multibind n,e) in
  52   let get_option f = function
  53       Some x -> let (n,e) = f x in (n,Some e)
  54     | None -> (option_default,None) in
  55   let do_disj starter lst mids ender processor rebuilder =
  56     let (starter_n,starter) = string_mcode starter in
  57     let (lst_n,lst) = map_split processor lst in
  58     let (mids_n,mids) = map_split string_mcode mids in
  59     let (ender_n,ender) = string_mcode ender in
  60     (multibind
  61        [starter_n;List.hd lst_n;
  62          multibind (List.map2 bind mids_n (List.tl lst_n));ender_n],
  63      rebuilder starter lst mids ender) in
  64   let rec expression_dots d =
  65     let k d =
  66       rewrap d
  67         (match Ast0.unwrap d with
  68           Ast0.DOTS(l) ->
  69             let (n,l) = map_split_bind expression l in (n,Ast0.DOTS(l))
  70         | Ast0.CIRCLES(l) ->
  71             let (n,l) = map_split_bind expression l in (n,Ast0.CIRCLES(l))
  72         | Ast0.STARS(l) ->
  73             let (n,l) = map_split_bind expression l in (n,Ast0.STARS(l))) in
  74     dotsexprfn all_functions k d
  75   and initialiser_list i =
  76     let k i =
  77       rewrap i
  78         (match Ast0.unwrap i with
  79           Ast0.DOTS(l) ->
  80             let (n,l) = map_split_bind initialiser l in (n,Ast0.DOTS(l))
  81         | Ast0.CIRCLES(l) ->
  82             let (n,l) = map_split_bind initialiser l in (n,Ast0.CIRCLES(l))
  83         | Ast0.STARS(l) ->
  84             let (n,l) = map_split_bind initialiser l in (n,Ast0.STARS(l))) in
  85     dotsinitfn all_functions k i
  86
  87   and parameter_list d =
  88     let k d =
  89       rewrap d
  90         (match Ast0.unwrap d with
  91           Ast0.DOTS(l) ->
  92             let (n,l) = map_split_bind parameterTypeDef l in
  93             (n,Ast0.DOTS(l))
  94         | Ast0.CIRCLES(l) ->
  95             let (n,l) = map_split_bind parameterTypeDef l in
  96             (n,Ast0.CIRCLES(l))
  97         | Ast0.STARS(l) ->
  98             let (n,l) = map_split_bind parameterTypeDef l in
  99             (n,Ast0.STARS(l))) in
 100     dotsparamfn all_functions k d
 101
 102   and statement_dots d =
 103     let k d =
 104       rewrap d
 105         (match Ast0.unwrap d with
 106           Ast0.DOTS(l) ->
 107             let (n,l) = map_split_bind statement l in (n,Ast0.DOTS(l))
 108         | Ast0.CIRCLES(l) ->
 109             let (n,l) = map_split_bind statement l in (n,Ast0.CIRCLES(l))
 110         | Ast0.STARS(l) ->
 111             let (n,l) = map_split_bind statement l in (n,Ast0.STARS(l))) in
 112     dotsstmtfn all_functions k d
 113
 114   and declaration_dots d =
 115     let k d =
 116       rewrap d
 117         (match Ast0.unwrap d with
 118           Ast0.DOTS(l) ->
 119             let (n,l) = map_split_bind declaration l in (n, Ast0.DOTS(l))
 120         | Ast0.CIRCLES(l) ->
 121             let (n,l) = map_split_bind declaration l in (n, Ast0.CIRCLES(l))
 122         | Ast0.STARS(l) ->
 123             let (n,l) = map_split_bind declaration l in (n, Ast0.STARS(l))) in
 124     dotsdeclfn all_functions k d
 125
 126   and case_line_dots d =
 127     let k d =
 128       rewrap d
 129         (match Ast0.unwrap d with
 130           Ast0.DOTS(l) ->
 131             let (n,l) = map_split_bind case_line l in (n, Ast0.DOTS(l))
 132         | Ast0.CIRCLES(l) ->
 133             let (n,l) = map_split_bind case_line l in (n, Ast0.CIRCLES(l))
 134         | Ast0.STARS(l) ->
 135             let (n,l) = map_split_bind case_line l in (n, Ast0.STARS(l))) in
 136     dotscasefn all_functions k d
 137
 138   and ident i =
 139     let k i =
 140       rewrap i
 141         (match Ast0.unwrap i with
 142           Ast0.Id(name) ->
 143             let (n,name) = string_mcode name in (n,Ast0.Id(name))
 144         | Ast0.MetaId(name,constraints,seed,pure) ->
 145             let (n,name) = meta_mcode name in
 146             (n,Ast0.MetaId(name,constraints,seed,pure))
 147         | Ast0.MetaFunc(name,constraints,pure) ->
 148             let (n,name) = meta_mcode name in
 149             (n,Ast0.MetaFunc(name,constraints,pure))
 150         | Ast0.MetaLocalFunc(name,constraints,pure) ->
 151             let (n,name) = meta_mcode name in
 152             (n,Ast0.MetaLocalFunc(name,constraints,pure))
 153         | Ast0.DisjId(starter,id_list,mids,ender) ->
 154             do_disj starter id_list mids ender ident
 155               (fun starter id_list mids ender ->
 156                 Ast0.DisjId(starter,id_list,mids,ender))
 157         | Ast0.OptIdent(id) ->
 158             let (n,id) = ident id in (n,Ast0.OptIdent(id))
 159         | Ast0.UniqueIdent(id) ->
 160             let (n,id) = ident id in (n,Ast0.UniqueIdent(id))) in
 161     identfn all_functions k i
 162
 163   and expression e =
 164     let k e =
 165       rewrap e
 166         (match Ast0.unwrap e with
 167           Ast0.Ident(id) ->
 168             let (n,id) = ident id in (n,Ast0.Ident(id))
 169         | Ast0.Constant(const) ->
 170             let (n,const) = const_mcode const in (n,Ast0.Constant(const))
 171         | Ast0.FunCall(fn,lp,args,rp) ->
 172             let (fn_n,fn) = expression fn in
 173             let (lp_n,lp) = string_mcode lp in
 174             let (args_n,args) = expression_dots args in
 175             let (rp_n,rp) = string_mcode rp in
 176             (multibind [fn_n;lp_n;args_n;rp_n], Ast0.FunCall(fn,lp,args,rp))
 177         | Ast0.Assignment(left,op,right,simple) ->
 178             let (left_n,left) = expression left in
 179             let (op_n,op) = assign_mcode op in
 180             let (right_n,right) = expression right in
 181             (multibind [left_n;op_n;right_n],
 182              Ast0.Assignment(left,op,right,simple))
 183         | Ast0.CondExpr(exp1,why,exp2,colon,exp3) ->
 184             let (exp1_n,exp1) = expression exp1 in
 185             let (why_n,why) = string_mcode why in
 186             let (exp2_n,exp2) = get_option expression exp2 in
 187             let (colon_n,colon) = string_mcode colon in
 188             let (exp3_n,exp3) = expression exp3 in
 189             (multibind [exp1_n;why_n;exp2_n;colon_n;exp3_n],
 190              Ast0.CondExpr(exp1,why,exp2,colon,exp3))
 191         | Ast0.Postfix(exp,op) ->
 192             let (exp_n,exp) = expression exp in
 193             let (op_n,op) = fix_mcode op in
 194             (bind exp_n op_n, Ast0.Postfix(exp,op))
 195         | Ast0.Infix(exp,op) ->
 196             let (exp_n,exp) = expression exp in
 197             let (op_n,op) = fix_mcode op in
 198             (bind op_n exp_n, Ast0.Infix(exp,op))
 199         | Ast0.Unary(exp,op) ->
 200             let (exp_n,exp) = expression exp in
 201             let (op_n,op) = unary_mcode op in
 202             (bind op_n exp_n, Ast0.Unary(exp,op))
 203         | Ast0.Binary(left,op,right) ->
 204             let (left_n,left) = expression left in
 205             let (op_n,op) = binary_mcode op in
 206             let (right_n,right) = expression right in
 207             (multibind [left_n;op_n;right_n], Ast0.Binary(left,op,right))
 208         | Ast0.Nested(left,op,right) ->
 209             let (left_n,left) = expression left in
 210             let (op_n,op) = binary_mcode op in
 211             let (right_n,right) = expression right in
 212             (multibind [left_n;op_n;right_n], Ast0.Nested(left,op,right))
 213         | Ast0.Paren(lp,exp,rp) ->
 214             let (lp_n,lp) = string_mcode lp in
 215             let (exp_n,exp) = expression exp in
 216             let (rp_n,rp) = string_mcode rp in
 217             (multibind [lp_n;exp_n;rp_n], Ast0.Paren(lp,exp,rp))
 218         | Ast0.ArrayAccess(exp1,lb,exp2,rb) ->
 219             let (exp1_n,exp1) = expression exp1 in
 220             let (lb_n,lb) = string_mcode lb in
 221             let (exp2_n,exp2) = expression exp2 in
 222             let (rb_n,rb) = string_mcode rb in
 223             (multibind [exp1_n;lb_n;exp2_n;rb_n],
 224              Ast0.ArrayAccess(exp1,lb,exp2,rb))
 225         | Ast0.RecordAccess(exp,pt,field) ->
 226             let (exp_n,exp) = expression exp in
 227             let (pt_n,pt) = string_mcode pt in
 228             let (field_n,field) = ident field in
 229             (multibind [exp_n;pt_n;field_n], Ast0.RecordAccess(exp,pt,field))
 230         | Ast0.RecordPtAccess(exp,ar,field) ->
 231             let (exp_n,exp) = expression exp in
 232             let (ar_n,ar) = string_mcode ar in
 233             let (field_n,field) = ident field in
 234             (multibind [exp_n;ar_n;field_n], Ast0.RecordPtAccess(exp,ar,field))
 235         | Ast0.Cast(lp,ty,rp,exp) ->
 236             let (lp_n,lp) = string_mcode lp in
 237             let (ty_n,ty) = typeC ty in
 238             let (rp_n,rp) = string_mcode rp in
 239             let (exp_n,exp) = expression exp in
 240             (multibind [lp_n;ty_n;rp_n;exp_n], Ast0.Cast(lp,ty,rp,exp))
 241         | Ast0.SizeOfExpr(szf,exp) ->
 242             let (szf_n,szf) = string_mcode szf in
 243             let (exp_n,exp) = expression exp in
 244             (multibind [szf_n;exp_n],Ast0.SizeOfExpr(szf,exp))
 245         | Ast0.SizeOfType(szf,lp,ty,rp) ->
 246             let (szf_n,szf) = string_mcode szf in
 247             let (lp_n,lp) = string_mcode lp in
 248             let (ty_n,ty) = typeC ty in
 249             let (rp_n,rp) = string_mcode rp in
 250             (multibind [szf_n;lp_n;ty_n;rp_n], Ast0.SizeOfType(szf,lp,ty,rp))
 251         | Ast0.TypeExp(ty) ->
 252             let (ty_n,ty) = typeC ty in
 253             (ty_n,Ast0.TypeExp(ty))
 254         | Ast0.Constructor(lp,ty,rp,init) ->
 255             let (lp_n,lp) = string_mcode lp in
 256             let (ty_n,ty) = typeC ty in
 257             let (rp_n,rp) = string_mcode rp in
 258             let (init_n,init) = initialiser init in
 259             (multibind [lp_n;ty_n;rp_n;init_n], Ast0.Constructor(lp,ty,rp,init))
 260         | Ast0.MetaErr(name,constraints,pure) ->
 261             let (name_n,name) = meta_mcode name in
 262             (name_n,Ast0.MetaErr(name,constraints,pure))
 263         | Ast0.MetaExpr(name,constraints,ty,form,pure) ->
 264             let (name_n,name) = meta_mcode name in
 265             (name_n,Ast0.MetaExpr(name,constraints,ty,form,pure))
 266         | Ast0.MetaExprList(name,lenname,pure) ->
 267             let (name_n,name) = meta_mcode name in
 268             (name_n,Ast0.MetaExprList(name,lenname,pure))
 269         | Ast0.EComma(cm) ->
 270             let (cm_n,cm) = string_mcode cm in (cm_n,Ast0.EComma(cm))
 271         | Ast0.DisjExpr(starter,expr_list,mids,ender) ->
 272             do_disj starter expr_list mids ender expression
 273               (fun starter expr_list mids ender ->
 274                 Ast0.DisjExpr(starter,expr_list,mids,ender))
 275         | Ast0.NestExpr(starter,expr_dots,ender,whencode,multi) ->
 276             let (starter_n,starter) = string_mcode starter in
 277             let (expr_dots_n,expr_dots) = expression_dots expr_dots in
 278             let (ender_n,ender) = string_mcode ender in
 279             let (whencode_n,whencode) = get_option expression whencode in
 280             (multibind [starter_n;expr_dots_n;ender_n;whencode_n],
 281              Ast0.NestExpr(starter,expr_dots,ender,whencode,multi))
 282         | Ast0.Edots(dots,whencode) ->
 283             let (dots_n,dots) = string_mcode dots in
 284             let (whencode_n,whencode) = get_option expression whencode in
 285             (bind dots_n whencode_n,Ast0.Edots(dots,whencode))
 286         | Ast0.Ecircles(dots,whencode) ->
 287             let (dots_n,dots) = string_mcode dots in
 288             let (whencode_n,whencode) = get_option expression whencode in
 289             (bind dots_n whencode_n,Ast0.Ecircles(dots,whencode))
 290         | Ast0.Estars(dots,whencode) ->
 291             let (dots_n,dots) = string_mcode dots in
 292             let (whencode_n,whencode) = get_option expression whencode in
 293             (bind dots_n whencode_n,Ast0.Estars(dots,whencode))
 294         | Ast0.OptExp(exp) ->
 295             let (exp_n,exp) = expression exp in
 296             (exp_n,Ast0.OptExp(exp))
 297         | Ast0.UniqueExp(exp) ->
 298             let (exp_n,exp) = expression exp in
 299             (exp_n,Ast0.UniqueExp(exp))) in
 300     exprfn all_functions k e
 301   and typeC t =
 302     let k t =
 303       rewrap t
 304         (match Ast0.unwrap t with
 305           Ast0.ConstVol(cv,ty) ->
 306             let (cv_n,cv) = cv_mcode cv in
 307             let (ty_n,ty) = typeC ty in
 308             (bind cv_n ty_n, Ast0.ConstVol(cv,ty))
 309         | Ast0.BaseType(ty,strings) ->
 310             let (strings_n,strings) = map_split_bind string_mcode strings in
 311             (strings_n, Ast0.BaseType(ty,strings))
 312         | Ast0.Signed(sign,ty) ->
 313             let (sign_n,sign) = sign_mcode sign in
 314             let (ty_n,ty) = get_option typeC ty in
 315             (bind sign_n ty_n, Ast0.Signed(sign,ty))
 316         | Ast0.Pointer(ty,star) ->
 317             let (ty_n,ty) = typeC ty in
 318             let (star_n,star) = string_mcode star in
 319             (bind ty_n star_n, Ast0.Pointer(ty,star))
 320         | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) ->
 321             function_pointer (ty,lp1,star,rp1,lp2,params,rp2) []
 322         | Ast0.FunctionType(ty,lp1,params,rp1) ->
 323             function_type (ty,lp1,params,rp1) []
 324         | Ast0.Array(ty,lb,size,rb) -> array_type (ty,lb,size,rb) []
 325         | Ast0.EnumName(kind,name) ->
 326             let (kind_n,kind) = string_mcode kind in
 327             let (name_n,name) = get_option ident name in
 328             (bind kind_n name_n, Ast0.EnumName(kind,name))
 329         | Ast0.EnumDef(ty,lb,ids,rb) ->
 330             let (ty_n,ty) = typeC ty in
 331             let (lb_n,lb) = string_mcode lb in
 332             let (ids_n,ids) = expression_dots ids in
 333             let (rb_n,rb) = string_mcode rb in
 334             (multibind [ty_n;lb_n;ids_n;rb_n], Ast0.EnumDef(ty,lb,ids,rb))
 335         | Ast0.StructUnionName(kind,name) ->
 336             let (kind_n,kind) = struct_mcode kind in
 337             let (name_n,name) = get_option ident name in
 338             (bind kind_n name_n, Ast0.StructUnionName(kind,name))
 339         | Ast0.StructUnionDef(ty,lb,decls,rb) ->
 340             let (ty_n,ty) = typeC ty in
 341             let (lb_n,lb) = string_mcode lb in
 342             let (decls_n,decls) = declaration_dots decls in
 343             let (rb_n,rb) = string_mcode rb in
 344             (multibind [ty_n;lb_n;decls_n;rb_n],
 345              Ast0.StructUnionDef(ty,lb,decls,rb))
 346         | Ast0.TypeName(name) ->
 347             let (name_n,name) = string_mcode name in
 348             (name_n,Ast0.TypeName(name))
 349         | Ast0.MetaType(name,pure) ->
 350             let (name_n,name) = meta_mcode name in
 351             (name_n,Ast0.MetaType(name,pure))
 352         | Ast0.DisjType(starter,types,mids,ender) ->
 353             do_disj starter types mids ender typeC
 354               (fun starter types mids ender ->
 355                 Ast0.DisjType(starter,types,mids,ender))
 356         | Ast0.OptType(ty) ->
 357             let (ty_n,ty) = typeC ty in (ty_n, Ast0.OptType(ty))
 358         | Ast0.UniqueType(ty) ->
 359             let (ty_n,ty) = typeC ty in (ty_n, Ast0.UniqueType(ty))) in
 360     tyfn all_functions k t
 361
 362   and function_pointer (ty,lp1,star,rp1,lp2,params,rp2) extra =
 363     let (ty_n,ty) = typeC ty in
 364     let (lp1_n,lp1) = string_mcode lp1 in
 365     let (star_n,star) = string_mcode star in
 366     let (rp1_n,rp1) = string_mcode rp1 in
 367     let (lp2_n,lp2) = string_mcode lp2 in
 368     let (params_n,params) = parameter_list params in
 369     let (rp2_n,rp2) = string_mcode rp2 in
 370     (* have to put the treatment of the identifier into the right position *)
 371     (multibind ([ty_n;lp1_n;star_n] @ extra @ [rp1_n;lp2_n;params_n;rp2_n]),
 372      Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2))
 373   and function_type (ty,lp1,params,rp1) extra =
 374     let (ty_n,ty) = get_option typeC ty in
 375     let (lp1_n,lp1) = string_mcode lp1 in
 376     let (params_n,params) = parameter_list params in
 377     let (rp1_n,rp1) = string_mcode rp1 in
 378     (* have to put the treatment of the identifier into the right position *)
 379     (multibind (ty_n :: extra @ [lp1_n;params_n;rp1_n]),
 380      Ast0.FunctionType(ty,lp1,params,rp1))
 381   and array_type (ty,lb,size,rb) extra =
 382     let (ty_n,ty) = typeC ty in
 383     let (lb_n,lb) = string_mcode lb in
 384     let (size_n,size) = get_option expression size in
 385     let (rb_n,rb) = string_mcode rb in
 386     (multibind (ty_n :: extra @ [lb_n;size_n;rb_n]),
 387      Ast0.Array(ty,lb,size,rb))
 388
 389   and named_type ty id =
 390     let (id_n,id) = ident id in
 391     match Ast0.unwrap ty with
 392       Ast0.FunctionPointer(rty,lp1,star,rp1,lp2,params,rp2) ->
 393         let tyres =
 394           function_pointer (rty,lp1,star,rp1,lp2,params,rp2) [id_n] in
 395         (rewrap ty tyres, id)
 396     | Ast0.FunctionType(rty,lp1,params,rp1) ->
 397         let tyres = function_type (rty,lp1,params,rp1) [id_n] in
 398         (rewrap ty tyres, id)
 399     | Ast0.Array(rty,lb,size,rb) ->
 400         let tyres = array_type (rty,lb,size,rb) [id_n] in
 401         (rewrap ty tyres, id)
 402     | _ -> let (ty_n,ty) = typeC ty in ((bind ty_n id_n, ty), id)
 403
 404   and declaration d =
 405     let k d =
 406       rewrap d
 407         (match Ast0.unwrap d with
 408           Ast0.MetaDecl(name,pure) ->
 409             let (n,name) = meta_mcode name in
 410             (n,Ast0.MetaDecl(name,pure))
 411         | Ast0.MetaField(name,pure) ->
 412             let (n,name) = meta_mcode name in
 413             (n,Ast0.MetaField(name,pure))
 414         | Ast0.MetaFieldList(name,lenname,pure) ->
 415             let (n,name) = meta_mcode name in
 416             (n,Ast0.MetaFieldList(name,lenname,pure))
 417         | Ast0.Init(stg,ty,id,eq,ini,sem) ->
 418             let (stg_n,stg) = get_option storage_mcode stg in
 419             let ((ty_id_n,ty),id) = named_type ty id in
 420             let (eq_n,eq) = string_mcode eq in
 421             let (ini_n,ini) = initialiser ini in
 422             let (sem_n,sem) = string_mcode sem in
 423             (multibind [stg_n;ty_id_n;eq_n;ini_n;sem_n],
 424              Ast0.Init(stg,ty,id,eq,ini,sem))
 425         | Ast0.UnInit(stg,ty,id,sem) ->
 426             let (stg_n,stg) = get_option storage_mcode stg in
 427             let ((ty_id_n,ty),id) = named_type ty id in
 428             let (sem_n,sem) = string_mcode sem in
 429             (multibind [stg_n;ty_id_n;sem_n], Ast0.UnInit(stg,ty,id,sem))
 430         | Ast0.MacroDecl(name,lp,args,rp,sem) ->
 431             let (name_n,name) = ident name in
 432             let (lp_n,lp) = string_mcode lp in
 433             let (args_n,args) = expression_dots args in
 434             let (rp_n,rp) = string_mcode rp in
 435             let (sem_n,sem) = string_mcode sem in
 436             (multibind [name_n;lp_n;args_n;rp_n;sem_n],
 437              Ast0.MacroDecl(name,lp,args,rp,sem))
 438         | Ast0.TyDecl(ty,sem) ->
 439             let (ty_n,ty) = typeC ty in
 440             let (sem_n,sem) = string_mcode sem in
 441             (bind ty_n sem_n, Ast0.TyDecl(ty,sem))
 442         | Ast0.Typedef(stg,ty,id,sem) ->
 443             let (stg_n,stg) = string_mcode stg in
 444             let (ty_n,ty) = typeC ty in
 445             let (id_n,id) = typeC id in
 446             let (sem_n,sem) = string_mcode sem in
 447             (multibind [stg_n;ty_n;id_n;sem_n], Ast0.Typedef(stg,ty,id,sem))
 448         | Ast0.DisjDecl(starter,decls,mids,ender) ->
 449             do_disj starter decls mids ender declaration
 450               (fun starter decls mids ender ->
 451                 Ast0.DisjDecl(starter,decls,mids,ender))
 452         | Ast0.Ddots(dots,whencode) ->
 453             let (dots_n,dots) = string_mcode dots in
 454             let (whencode_n,whencode) = get_option declaration whencode in
 455             (bind dots_n whencode_n, Ast0.Ddots(dots,whencode))
 456         | Ast0.OptDecl(decl) ->
 457             let (n,decl) = declaration decl in (n,Ast0.OptDecl(decl))
 458         | Ast0.UniqueDecl(decl) ->
 459             let (n,decl) = declaration decl in (n,Ast0.UniqueDecl(decl))) in
 460     declfn all_functions k d
 461
 462   and initialiser i =
 463     let k i =
 464       rewrap i
 465         (match Ast0.unwrap i with
 466           Ast0.MetaInit(name,pure) ->
 467             let (name_n,name) = meta_mcode name in
 468             (name_n,Ast0.MetaInit(name,pure))
 469         | Ast0.MetaInitList(name,lenname,pure) ->
 470             let (name_n,name) = meta_mcode name in
 471             (name_n,Ast0.MetaInitList(name,lenname,pure))
 472         | Ast0.InitExpr(exp) ->
 473             let (exp_n,exp) = expression exp in
 474             (exp_n,Ast0.InitExpr(exp))
 475         | Ast0.InitList(lb,initlist,rb,ordered) ->
 476             let (lb_n,lb) = string_mcode lb in
 477             let (initlist_n,initlist) = initialiser_list initlist in
 478             let (rb_n,rb) = string_mcode rb in
 479             (multibind [lb_n;initlist_n;rb_n],
 480              Ast0.InitList(lb,initlist,rb,ordered))
 481         | Ast0.InitGccExt(designators,eq,ini) ->
 482             let (dn,designators) = map_split_bind designator designators in
 483             let (eq_n,eq) = string_mcode eq in
 484             let (ini_n,ini) = initialiser ini in
 485             (multibind [dn;eq_n;ini_n], Ast0.InitGccExt(designators,eq,ini))
 486         | Ast0.InitGccName(name,eq,ini) ->
 487             let (name_n,name) = ident name in
 488             let (eq_n,eq) = string_mcode eq in
 489             let (ini_n,ini) = initialiser ini in
 490             (multibind [name_n;eq_n;ini_n], Ast0.InitGccName(name,eq,ini))
 491         | Ast0.IComma(cm) ->
 492             let (n,cm) = string_mcode cm in (n,Ast0.IComma(cm))
 493         | Ast0.Idots(d,whencode) ->
 494             let (d_n,d) = string_mcode d in
 495             let (whencode_n,whencode) = get_option initialiser whencode in
 496             (bind d_n whencode_n, Ast0.Idots(d,whencode))
 497         | Ast0.OptIni(i) ->
 498             let (n,i) = initialiser i in (n,Ast0.OptIni(i))
 499         | Ast0.UniqueIni(i) ->
 500             let (n,i) = initialiser i in (n,Ast0.UniqueIni(i))) in
 501     initfn all_functions k i
 502
 503   and designator = function
 504       Ast0.DesignatorField(dot,id) ->
 505         let (dot_n,dot) = string_mcode dot in
 506         let (id_n,id) = ident id in
 507         (bind dot_n id_n, Ast0.DesignatorField(dot,id))
 508     | Ast0.DesignatorIndex(lb,exp,rb) ->
 509         let (lb_n,lb) = string_mcode lb in
 510         let (exp_n,exp) = expression exp in
 511         let (rb_n,rb) = string_mcode rb in
 512         (multibind [lb_n;exp_n;rb_n], Ast0.DesignatorIndex(lb,exp,rb))
 513     | Ast0.DesignatorRange(lb,min,dots,max,rb) ->
 514         let (lb_n,lb) = string_mcode lb in
 515         let (min_n,min) = expression min in
 516         let (dots_n,dots) = string_mcode dots in
 517         let (max_n,max) = expression max in
 518         let (rb_n,rb) = string_mcode rb in
 519         (multibind [lb_n;min_n;dots_n;max_n;rb_n],
 520          Ast0.DesignatorRange(lb,min,dots,max,rb))
 521
 522   and parameterTypeDef p =
 523     let k p =
 524       rewrap p
 525         (match Ast0.unwrap p with
 526           Ast0.VoidParam(ty) ->
 527             let (n,ty) = typeC ty in (n,Ast0.VoidParam(ty))
 528         | Ast0.Param(ty,Some id) ->
 529             let ((ty_id_n,ty),id) = named_type ty id in
 530             (ty_id_n, Ast0.Param(ty,Some id))
 531         | Ast0.Param(ty,None) ->
 532             let (ty_n,ty) = typeC ty in
 533             (ty_n, Ast0.Param(ty,None))
 534         | Ast0.MetaParam(name,pure) ->
 535             let (n,name) = meta_mcode name in
 536             (n,Ast0.MetaParam(name,pure))
 537         | Ast0.MetaParamList(name,lenname,pure) ->
 538             let (n,name) = meta_mcode name in
 539             (n,Ast0.MetaParamList(name,lenname,pure))
 540         | Ast0.PComma(cm) ->
 541             let (n,cm) = string_mcode cm in (n,Ast0.PComma(cm))
 542         | Ast0.Pdots(dots) ->
 543             let (n,dots) = string_mcode dots in (n,Ast0.Pdots(dots))
 544         | Ast0.Pcircles(dots) ->
 545             let (n,dots) = string_mcode dots in (n,Ast0.Pcircles(dots))
 546         | Ast0.OptParam(param) ->
 547             let (n,param) = parameterTypeDef param in (n,Ast0.OptParam(param))
 548         | Ast0.UniqueParam(param) ->
 549             let (n,param) = parameterTypeDef param in
 550             (n,Ast0.UniqueParam(param))) in
 551     paramfn all_functions k p
 552
 553   (* not done for combiner, because the statement is assumed to be already
 554      represented elsewhere in the code *)
 555   (* NOTE: This is not called for combiner_rebuilder.  This is ok for its
 556      only current use. *)
 557   and process_bef_aft s =
 558     Ast0.set_dots_bef_aft s
 559       (match Ast0.get_dots_bef_aft s with
 560         Ast0.NoDots -> Ast0.NoDots
 561       | Ast0.DroppingBetweenDots(stm) ->
 562           let (_,stm) = statement stm in Ast0.DroppingBetweenDots(stm)
 563       | Ast0.AddingBetweenDots(stm) ->
 564           let (_,stm) = statement stm in Ast0.AddingBetweenDots(stm))
 565
 566   and statement s =
 567     (if mode = COMBINER then let _ = process_bef_aft s in ());
 568     let k s =
 569       rewrap s
 570         (match Ast0.unwrap s with
 571           Ast0.FunDecl(bef,fi,name,lp,params,rp,lbrace,body,rbrace) ->
 572             let (fi_n,fi) = map_split_bind fninfo fi in
 573             let (name_n,name) = ident name in
 574             let (lp_n,lp) = string_mcode lp in
 575             let (params_n,params) = parameter_list params in
 576             let (rp_n,rp) = string_mcode rp in
 577             let (lbrace_n,lbrace) = string_mcode lbrace in
 578             let (body_n,body) = statement_dots body in
 579             let (rbrace_n,rbrace) = string_mcode rbrace in
 580             (multibind
 581                [fi_n;name_n;lp_n;params_n;rp_n;lbrace_n;body_n;rbrace_n],
 582              Ast0.FunDecl(bef,fi,name,lp,params,rp,lbrace,body,rbrace))
 583         | Ast0.Decl(bef,decl) ->
 584             let (decl_n,decl) = declaration decl in
 585             (decl_n,Ast0.Decl(bef,decl))
 586         | Ast0.Seq(lbrace,body,rbrace) ->
 587             let (lbrace_n,lbrace) = string_mcode lbrace in
 588             let (body_n,body) = statement_dots body in
 589             let (rbrace_n,rbrace) = string_mcode rbrace in
 590             (multibind [lbrace_n;body_n;rbrace_n],
 591              Ast0.Seq(lbrace,body,rbrace))
 592         | Ast0.ExprStatement(exp,sem) ->
 593             let (exp_n,exp) = get_option expression exp in
 594             let (sem_n,sem) = string_mcode sem in
 595             (bind exp_n sem_n, Ast0.ExprStatement(exp,sem))
 596         | Ast0.IfThen(iff,lp,exp,rp,branch1,aft) ->
 597             let (iff_n,iff) = string_mcode iff in
 598             let (lp_n,lp) = string_mcode lp in
 599             let (exp_n,exp) = expression exp in
 600             let (rp_n,rp) = string_mcode rp in
 601             let (branch1_n,branch1) = statement branch1 in
 602             (multibind [iff_n;lp_n;exp_n;rp_n;branch1_n],
 603              Ast0.IfThen(iff,lp,exp,rp,branch1,aft))
 604         | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) ->
 605             let (iff_n,iff) = string_mcode iff in
 606             let (lp_n,lp) = string_mcode lp in
 607             let (exp_n,exp) = expression exp in
 608             let (rp_n,rp) = string_mcode rp in
 609             let (branch1_n,branch1) = statement branch1 in
 610             let (els_n,els) = string_mcode els in
 611             let (branch2_n,branch2) = statement branch2 in
 612             (multibind [iff_n;lp_n;exp_n;rp_n;branch1_n;els_n;branch2_n],
 613              Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft))
 614         | Ast0.While(whl,lp,exp,rp,body,aft) ->
 615             let (whl_n,whl) = string_mcode whl in
 616             let (lp_n,lp) = string_mcode lp in
 617             let (exp_n,exp) = expression exp in
 618             let (rp_n,rp) = string_mcode rp in
 619             let (body_n,body) = statement body in
 620             (multibind [whl_n;lp_n;exp_n;rp_n;body_n],
 621              Ast0.While(whl,lp,exp,rp,body,aft))
 622         | Ast0.Do(d,body,whl,lp,exp,rp,sem) ->
 623             let (d_n,d) = string_mcode d in
 624             let (body_n,body) = statement body in
 625             let (whl_n,whl) = string_mcode whl in
 626             let (lp_n,lp) = string_mcode lp in
 627             let (exp_n,exp) = expression exp in
 628             let (rp_n,rp) =  string_mcode rp in
 629             let (sem_n,sem) = string_mcode sem in
 630             (multibind [d_n;body_n;whl_n;lp_n;exp_n;rp_n;sem_n],
 631              Ast0.Do(d,body,whl,lp,exp,rp,sem))
 632         | Ast0.For(fr,lp,e1,sem1,e2,sem2,e3,rp,body,aft) ->
 633             let (fr_n,fr) = string_mcode fr in
 634             let (lp_n,lp) = string_mcode lp in
 635             let (e1_n,e1) = get_option expression e1 in
 636             let (sem1_n,sem1) = string_mcode sem1 in
 637             let (e2_n,e2) = get_option expression e2 in
 638             let (sem2_n,sem2) = string_mcode sem2 in
 639             let (e3_n,e3) = get_option expression e3 in
 640             let (rp_n,rp) = string_mcode rp in
 641             let (body_n,body) = statement body in
 642             (multibind [fr_n;lp_n;e1_n;sem1_n;e2_n;sem2_n;e3_n;rp_n;body_n],
 643              Ast0.For(fr,lp,e1,sem1,e2,sem2,e3,rp,body,aft))
 644         | Ast0.Iterator(nm,lp,args,rp,body,aft) ->
 645             let (nm_n,nm) = ident nm in
 646             let (lp_n,lp) = string_mcode lp in
 647             let (args_n,args) = expression_dots args in
 648             let (rp_n,rp) = string_mcode rp in
 649             let (body_n,body) = statement body in
 650             (multibind [nm_n;lp_n;args_n;rp_n;body_n],
 651              Ast0.Iterator(nm,lp,args,rp,body,aft))
 652         | Ast0.Switch(switch,lp,exp,rp,lb,decls,cases,rb) ->
 653             let (switch_n,switch) = string_mcode switch in
 654             let (lp_n,lp) = string_mcode lp in
 655             let (exp_n,exp) = expression exp in
 656             let (rp_n,rp) = string_mcode rp in
 657             let (lb_n,lb) = string_mcode lb in
 658             let (decls_n,decls) = statement_dots decls in
 659             let (cases_n,cases) = case_line_dots cases in
 660             let (rb_n,rb) = string_mcode rb in
 661             (multibind [switch_n;lp_n;exp_n;rp_n;lb_n;decls_n;cases_n;rb_n],
 662              Ast0.Switch(switch,lp,exp,rp,lb,decls,cases,rb))
 663         | Ast0.Break(br,sem) ->
 664             let (br_n,br) = string_mcode br in
 665             let (sem_n,sem) = string_mcode sem in
 666             (bind br_n sem_n, Ast0.Break(br,sem))
 667         | Ast0.Continue(cont,sem) ->
 668             let (cont_n,cont) = string_mcode cont in
 669             let (sem_n,sem) = string_mcode sem in
 670             (bind cont_n sem_n, Ast0.Continue(cont,sem))
 671         | Ast0.Label(l,dd) ->
 672             let (l_n,l) = ident l in
 673             let (dd_n,dd) = string_mcode dd in
 674             (bind l_n dd_n, Ast0.Label(l,dd))
 675         | Ast0.Goto(goto,l,sem) ->
 676             let (goto_n,goto) = string_mcode goto in
 677             let (l_n,l) = ident l in
 678             let (sem_n,sem) = string_mcode sem in
 679             (bind goto_n (bind l_n sem_n), Ast0.Goto(goto,l,sem))
 680         | Ast0.Return(ret,sem) ->
 681             let (ret_n,ret) = string_mcode ret in
 682             let (sem_n,sem) = string_mcode sem in
 683             (bind ret_n sem_n, Ast0.Return(ret,sem))
 684         | Ast0.ReturnExpr(ret,exp,sem) ->
 685             let (ret_n,ret) = string_mcode ret in
 686             let (exp_n,exp) = expression exp in
 687             let (sem_n,sem) = string_mcode sem in
 688             (multibind [ret_n;exp_n;sem_n], Ast0.ReturnExpr(ret,exp,sem))
 689         | Ast0.MetaStmt(name,pure) ->
 690             let (name_n,name) = meta_mcode name in
 691             (name_n,Ast0.MetaStmt(name,pure))
 692         | Ast0.MetaStmtList(name,pure) ->
 693             let (name_n,name) = meta_mcode name in
 694             (name_n,Ast0.MetaStmtList(name,pure))
 695         | Ast0.Disj(starter,statement_dots_list,mids,ender) ->
 696             do_disj starter statement_dots_list mids ender statement_dots
 697               (fun starter statement_dots_list mids ender ->
 698                 Ast0.Disj(starter,statement_dots_list,mids,ender))
 699         | Ast0.Nest(starter,stmt_dots,ender,whn,multi) ->
 700             let (starter_n,starter) = string_mcode starter in
 701             let (stmt_dots_n,stmt_dots) = statement_dots stmt_dots in
 702             let (ender_n,ender) = string_mcode ender in
 703             let (whn_n,whn) =
 704               map_split_bind (whencode statement_dots statement) whn in
 705             (multibind [starter_n;stmt_dots_n;ender_n;whn_n],
 706              Ast0.Nest(starter,stmt_dots,ender,whn,multi))
 707         | Ast0.Exp(exp) ->
 708             let (exp_n,exp) = expression exp in
 709             (exp_n,Ast0.Exp(exp))
 710         | Ast0.TopExp(exp) ->
 711             let (exp_n,exp) = expression exp in
 712             (exp_n,Ast0.TopExp(exp))
 713         | Ast0.Ty(ty) ->
 714             let (ty_n,ty) = typeC ty in
 715             (ty_n,Ast0.Ty(ty))
 716         | Ast0.TopInit(init) ->
 717             let (init_n,init) = initialiser init in
 718             (init_n,Ast0.TopInit(init))
 719         | Ast0.Dots(d,whn) ->
 720             let (d_n,d) = string_mcode d in
 721             let (whn_n,whn) =
 722               map_split_bind (whencode statement_dots statement) whn in
 723             (bind d_n whn_n, Ast0.Dots(d,whn))
 724         | Ast0.Circles(d,whn) ->
 725             let (d_n,d) = string_mcode d in
 726             let (whn_n,whn) =
 727               map_split_bind (whencode statement_dots statement) whn in
 728             (bind d_n whn_n, Ast0.Circles(d,whn))
 729         | Ast0.Stars(d,whn) ->
 730             let (d_n,d) = string_mcode d in
 731             let (whn_n,whn) =
 732               map_split_bind (whencode statement_dots statement) whn in
 733             (bind d_n whn_n, Ast0.Stars(d,whn))
 734         | Ast0.Include(inc,name) ->
 735             let (inc_n,inc) = string_mcode inc in
 736             let (name_n,name) = inc_mcode name in
 737             (bind inc_n name_n, Ast0.Include(inc,name))
 738         | Ast0.Undef(def,id) ->
 739             let (def_n,def) = string_mcode def in
 740             let (id_n,id) = ident id in
 741             (multibind [def_n;id_n],Ast0.Undef(def,id))
 742         | Ast0.Define(def,id,params,body) ->
 743             let (def_n,def) = string_mcode def in
 744             let (id_n,id) = ident id in
 745             let (params_n,params) = define_parameters params in
 746             let (body_n,body) = statement_dots body in
 747             (multibind [def_n;id_n;params_n;body_n],
 748              Ast0.Define(def,id,params,body))
 749         | Ast0.OptStm(re) ->
 750             let (re_n,re) = statement re in (re_n,Ast0.OptStm(re))
 751         | Ast0.UniqueStm(re) ->
 752             let (re_n,re) = statement re in (re_n,Ast0.UniqueStm(re))) in
 753     let (n,s) = stmtfn all_functions k s in
 754     (n,if mode = REBUILDER then process_bef_aft s else s)
 755
 756   (* not parameterizable for now... *)
 757   and define_parameters p =
 758     let k p =
 759       rewrap p
 760         (match Ast0.unwrap p with
 761           Ast0.NoParams -> (option_default,Ast0.NoParams)
 762         | Ast0.DParams(lp,params,rp) ->
 763             let (lp_n,lp) = string_mcode lp in
 764             let (params_n,params) = define_param_dots params in
 765             let (rp_n,rp) = string_mcode rp in
 766             (multibind [lp_n;params_n;rp_n], Ast0.DParams(lp,params,rp))) in
 767     k p
 768
 769   and define_param_dots d =
 770     let k d =
 771       rewrap d
 772         (match Ast0.unwrap d with
 773           Ast0.DOTS(l) ->
 774             let (n,l) = map_split_bind define_param l in (n,Ast0.DOTS(l))
 775         | Ast0.CIRCLES(l) ->
 776             let (n,l) = map_split_bind define_param l in (n,Ast0.CIRCLES(l))
 777         | Ast0.STARS(l) ->
 778             let (n,l) = map_split_bind define_param l in (n,Ast0.STARS(l))) in
 779     k d
 780
 781   and define_param p =
 782     let k p =
 783       rewrap p
 784         (match Ast0.unwrap p with
 785           Ast0.DParam(id) -> let (n,id) = ident id in (n,Ast0.DParam(id))
 786         | Ast0.DPComma(comma) ->
 787             let (n,comma) = string_mcode comma in (n,Ast0.DPComma(comma))
 788         | Ast0.DPdots(d) ->
 789             let (n,d) = string_mcode d in (n,Ast0.DPdots(d))
 790         | Ast0.DPcircles(c) ->
 791             let (n,c) = string_mcode c in (n,Ast0.DPcircles(c))
 792         | Ast0.OptDParam(dp) ->
 793             let (n,dp) = define_param dp in (n,Ast0.OptDParam(dp))
 794         | Ast0.UniqueDParam(dp) ->
 795             let (n,dp) = define_param dp in (n,Ast0.UniqueDParam(dp))) in
 796     k p
 797
 798   and fninfo = function
 799       Ast0.FStorage(stg) ->
 800         let (n,stg) = storage_mcode stg in (n,Ast0.FStorage(stg))
 801     | Ast0.FType(ty) -> let (n,ty) = typeC ty in (n,Ast0.FType(ty))
 802     | Ast0.FInline(inline) ->
 803         let (n,inline) = string_mcode inline in (n,Ast0.FInline(inline))
 804     | Ast0.FAttr(init) ->
 805         let (n,init) = string_mcode init in (n,Ast0.FAttr(init))
 806
 807   and whencode notfn alwaysfn = function
 808       Ast0.WhenNot a -> let (n,a) = notfn a in (n,Ast0.WhenNot(a))
 809     | Ast0.WhenAlways a -> let (n,a) = alwaysfn a in (n,Ast0.WhenAlways(a))
 810     | Ast0.WhenModifier(x) -> (option_default,Ast0.WhenModifier(x))
 811     | Ast0.WhenNotTrue(e) ->
 812         let (n,e) = expression e in (n,Ast0.WhenNotTrue(e))
 813     | Ast0.WhenNotFalse(e) ->
 814         let (n,e) = expression e in (n,Ast0.WhenNotFalse(e))
 815
 816   and case_line c =
 817     let k c =
 818       rewrap c
 819         (match Ast0.unwrap c with
 820           Ast0.Default(def,colon,code) ->
 821             let (def_n,def) = string_mcode def in
 822             let (colon_n,colon) = string_mcode colon in
 823             let (code_n,code) = statement_dots code in
 824             (multibind [def_n;colon_n;code_n], Ast0.Default(def,colon,code))
 825         | Ast0.Case(case,exp,colon,code) ->
 826             let (case_n,case) = string_mcode case in
 827             let (exp_n,exp) = expression exp in
 828             let (colon_n,colon) = string_mcode colon in
 829             let (code_n,code) = statement_dots code in
 830             (multibind [case_n;exp_n;colon_n;code_n],
 831              Ast0.Case(case,exp,colon,code))
 832         | Ast0.DisjCase(starter,case_lines,mids,ender) ->
 833             do_disj starter case_lines mids ender case_line
 834               (fun starter case_lines mids ender ->
 835                 Ast0.DisjCase(starter,case_lines,mids,ender))
 836         | Ast0.OptCase(case) ->
 837             let (n,case) = case_line case in (n,Ast0.OptCase(case))) in
 838     casefn all_functions k c
 839
 840   and top_level t =
 841     let k t =
 842       rewrap t
 843         (match Ast0.unwrap t with
 844           Ast0.FILEINFO(old_file,new_file) ->
 845             let (old_file_n,old_file) = string_mcode old_file in
 846             let (new_file_n,new_file) = string_mcode new_file in
 847             (bind old_file_n new_file_n,Ast0.FILEINFO(old_file,new_file))
 848         | Ast0.NONDECL(statement_dots) ->
 849             let (n,statement_dots) = statement statement_dots in
 850             (n,Ast0.NONDECL(statement_dots))
 851         | Ast0.CODE(stmt_dots) ->
 852             let (stmt_dots_n,stmt_dots) = statement_dots stmt_dots in
 853             (stmt_dots_n, Ast0.CODE(stmt_dots))
 854         | Ast0.TOPCODE(stmt_dots) ->
 855             let (stmt_dots_n,stmt_dots) = statement_dots stmt_dots in
 856             (stmt_dots_n, Ast0.TOPCODE(stmt_dots))
 857         | Ast0.ERRORWORDS(exps) ->
 858             let (n,exps) = map_split_bind expression exps in
 859             (n, Ast0.ERRORWORDS(exps))
 860         | Ast0.OTHER(_) -> failwith "unexpected code") in
 861     topfn all_functions k t
 862
 863   and anything a = (* for compile_iso, not parameterisable *)
 864     let k = function
 865         Ast0.DotsExprTag(exprs) ->
 866           let (exprs_n,exprs) = expression_dots exprs in
 867           (exprs_n,Ast0.DotsExprTag(exprs))
 868       | Ast0.DotsInitTag(inits) ->
 869           let (inits_n,inits) = initialiser_list inits in
 870           (inits_n,Ast0.DotsInitTag(inits))
 871       | Ast0.DotsParamTag(params) ->
 872           let (params_n,params) = parameter_list params in
 873           (params_n,Ast0.DotsParamTag(params))
 874       | Ast0.DotsStmtTag(stmts) ->
 875           let (stmts_n,stmts) = statement_dots stmts in
 876           (stmts_n,Ast0.DotsStmtTag(stmts))
 877       | Ast0.DotsDeclTag(decls) ->
 878           let (decls_n,decls) = declaration_dots decls in
 879           (decls_n,Ast0.DotsDeclTag(decls))
 880       | Ast0.DotsCaseTag(cases) ->
 881           let (cases_n,cases) = case_line_dots cases in
 882           (cases_n,Ast0.DotsCaseTag(cases))
 883       | Ast0.IdentTag(id) ->
 884           let (id_n,id) = ident id in
 885           (id_n,Ast0.IdentTag(id))
 886       | Ast0.ExprTag(exp) ->
 887           let (exp_n,exp) = expression exp in
 888           (exp_n,Ast0.ExprTag(exp))
 889       | Ast0.ArgExprTag(exp) ->
 890           let (exp_n,exp) = expression exp in
 891           (exp_n,Ast0.ArgExprTag(exp))
 892       | Ast0.TestExprTag(exp) ->
 893           let (exp_n,exp) = expression exp in
 894           (exp_n,Ast0.TestExprTag(exp))
 895       | Ast0.TypeCTag(ty) ->
 896           let (ty_n,ty) = typeC ty in
 897           (ty_n,Ast0.TypeCTag(ty))
 898       | Ast0.ParamTag(param) ->
 899           let (param_n,param) = parameterTypeDef param in
 900           (param_n,Ast0.ParamTag(param))
 901       | Ast0.InitTag(init) ->
 902           let (init_n,init) = initialiser init in
 903           (init_n,Ast0.InitTag(init))
 904       | Ast0.DeclTag(decl) ->
 905           let (decl_n,decl) = declaration decl in
 906           (decl_n,Ast0.DeclTag(decl))
 907       | Ast0.StmtTag(stmt) ->
 908           let (stmt_n,stmt) = statement stmt in
 909           (stmt_n,Ast0.StmtTag(stmt))
 910       | Ast0.CaseLineTag(c) ->
 911           let (c_n,c) = case_line c in
 912           (c_n,Ast0.CaseLineTag(c))
 913       | Ast0.TopTag(top) ->
 914           let (top_n,top) = top_level top in
 915           (top_n,Ast0.TopTag(top))
 916       | Ast0.IsoWhenTag(x) -> (option_default,Ast0.IsoWhenTag(x))
 917       | Ast0.IsoWhenTTag(e) ->
 918           let (e_n,e) = expression e in
 919           (e_n,Ast0.IsoWhenTTag(e))
 920       | Ast0.IsoWhenFTag(e) ->
 921           let (e_n,e) = expression e in
 922           (e_n,Ast0.IsoWhenFTag(e))
 923       | Ast0.MetaPosTag(var) -> failwith "not supported" in
 924     k a
 925
 926   (* not done for combiner, because the statement is assumed to be already
 927      represented elsewhere in the code *)
 928
 929   and all_functions =
 930     {VT0.ident = ident;
 931       VT0.expression = expression;
 932       VT0.typeC = typeC;
 933       VT0.declaration = declaration;
 934       VT0.initialiser = initialiser;
 935       VT0.initialiser_list = initialiser_list;
 936       VT0.parameter = parameterTypeDef;
 937       VT0.parameter_list = parameter_list;
 938       VT0.statement = statement;
 939       VT0.case_line = case_line;
 940       VT0.top_level = top_level;
 941       VT0.expression_dots = expression_dots;
 942       VT0.statement_dots = statement_dots;
 943       VT0.declaration_dots = declaration_dots;
 944       VT0.case_line_dots = case_line_dots;
 945       VT0.anything = anything} in
 946   all_functions
 947
 948 let combiner_functions =
 949   {VT0.combiner_meta_mcode = (fun opt_default mc -> opt_default);
 950    VT0.combiner_string_mcode = (fun opt_default mc -> opt_default);
 951    VT0.combiner_const_mcode = (fun opt_default mc -> opt_default);
 952    VT0.combiner_assign_mcode = (fun opt_default mc -> opt_default);
 953    VT0.combiner_fix_mcode = (fun opt_default mc -> opt_default);
 954    VT0.combiner_unary_mcode = (fun opt_default mc -> opt_default);
 955    VT0.combiner_binary_mcode = (fun opt_default mc -> opt_default);
 956    VT0.combiner_cv_mcode = (fun opt_default mc -> opt_default);
 957    VT0.combiner_sign_mcode = (fun opt_default mc -> opt_default);
 958    VT0.combiner_struct_mcode = (fun opt_default mc -> opt_default);
 959    VT0.combiner_storage_mcode = (fun opt_default mc -> opt_default);
 960    VT0.combiner_inc_mcode = (fun opt_default mc -> opt_default);
 961    VT0.combiner_dotsexprfn = (fun r k e -> k e);
 962    VT0.combiner_dotsinitfn = (fun r k e -> k e);
 963    VT0.combiner_dotsparamfn = (fun r k e -> k e);
 964    VT0.combiner_dotsstmtfn = (fun r k e -> k e);
 965    VT0.combiner_dotsdeclfn = (fun r k e -> k e);
 966    VT0.combiner_dotscasefn = (fun r k e -> k e);
 967    VT0.combiner_identfn = (fun r k e -> k e);
 968    VT0.combiner_exprfn = (fun r k e -> k e);
 969    VT0.combiner_tyfn = (fun r k e -> k e);
 970    VT0.combiner_initfn = (fun r k e -> k e);
 971    VT0.combiner_paramfn = (fun r k e -> k e);
 972    VT0.combiner_declfn = (fun r k e -> k e);
 973    VT0.combiner_stmtfn = (fun r k e -> k e);
 974    VT0.combiner_casefn = (fun r k e -> k e);
 975    VT0.combiner_topfn = (fun r k e -> k e)}
 976
 977 let combiner_dz r =
 978     {VT0.combiner_rec_ident =
 979       (function e -> let (n,_) = r.VT0.ident e in n);
 980       VT0.combiner_rec_expression =
 981       (function e -> let (n,_) = r.VT0.expression e in n);
 982       VT0.combiner_rec_typeC =
 983       (function e -> let (n,_) = r.VT0.typeC e in n);
 984       VT0.combiner_rec_declaration =
 985       (function e -> let (n,_) = r.VT0.declaration e in n);
 986       VT0.combiner_rec_initialiser =
 987       (function e -> let (n,_) = r.VT0.initialiser e in n);
 988       VT0.combiner_rec_initialiser_list =
 989       (function e -> let (n,_) = r.VT0.initialiser_list e in n);
 990       VT0.combiner_rec_parameter =
 991       (function e -> let (n,_) = r.VT0.parameter e in n);
 992       VT0.combiner_rec_parameter_list =
 993       (function e -> let (n,_) = r.VT0.parameter_list e in n);
 994       VT0.combiner_rec_statement =
 995       (function e -> let (n,_) = r.VT0.statement e in n);
 996       VT0.combiner_rec_case_line =
 997       (function e -> let (n,_) = r.VT0.case_line e in n);
 998       VT0.combiner_rec_top_level =
 999       (function e -> let (n,_) = r.VT0.top_level e in n);
1000       VT0.combiner_rec_expression_dots =
1001       (function e -> let (n,_) = r.VT0.expression_dots e in n);
1002       VT0.combiner_rec_statement_dots =
1003       (function e -> let (n,_) = r.VT0.statement_dots e in n);
1004       VT0.combiner_rec_declaration_dots =
1005       (function e -> let (n,_) = r.VT0.declaration_dots e in n);
1006       VT0.combiner_rec_case_line_dots =
1007       (function e -> let (n,_) = r.VT0.case_line_dots e in n);
1008       VT0.combiner_rec_anything =
1009       (function e -> let (n,_) = r.VT0.anything e in n)}
1010
1011 let combiner bind option_default functions =
1012   let xk k e = let (n,_) = k e in n in
1013   let dz = combiner_dz in
1014   combiner_dz
1015     (visitor COMBINER bind option_default
1016     (function mc -> (functions.VT0.combiner_meta_mcode option_default mc,mc))
1017     (function mc -> (functions.VT0.combiner_string_mcode option_default mc,mc))
1018     (function mc -> (functions.VT0.combiner_const_mcode option_default mc,mc))
1019     (function mc -> (functions.VT0.combiner_assign_mcode option_default mc,mc))
1020     (function mc -> (functions.VT0.combiner_fix_mcode option_default mc,mc))
1021     (function mc -> (functions.VT0.combiner_unary_mcode option_default mc,mc))
1022     (function mc -> (functions.VT0.combiner_binary_mcode option_default mc,mc))
1023     (function mc -> (functions.VT0.combiner_cv_mcode option_default mc,mc))
1024     (function mc -> (functions.VT0.combiner_sign_mcode option_default mc,mc))
1025     (function mc -> (functions.VT0.combiner_struct_mcode option_default mc,mc))
1026     (function mc ->
1027       (functions.VT0.combiner_storage_mcode option_default mc,mc))
1028     (function mc -> (functions.VT0.combiner_inc_mcode option_default mc,mc))
1029     (fun r k e -> (functions.VT0.combiner_dotsexprfn (dz r) (xk k) e, e))
1030     (fun r k e -> (functions.VT0.combiner_dotsinitfn (dz r) (xk k) e, e))
1031     (fun r k e -> (functions.VT0.combiner_dotsparamfn (dz r) (xk k) e, e))
1032     (fun r k e -> (functions.VT0.combiner_dotsstmtfn (dz r) (xk k) e, e))
1033     (fun r k e -> (functions.VT0.combiner_dotsdeclfn (dz r) (xk k) e, e))
1034     (fun r k e -> (functions.VT0.combiner_dotscasefn (dz r) (xk k) e, e))
1035     (fun r k e -> (functions.VT0.combiner_identfn (dz r) (xk k) e, e))
1036     (fun r k e -> (functions.VT0.combiner_exprfn (dz r) (xk k) e, e))
1037     (fun r k e -> (functions.VT0.combiner_tyfn (dz r) (xk k) e, e))
1038     (fun r k e -> (functions.VT0.combiner_initfn (dz r) (xk k) e, e))
1039     (fun r k e -> (functions.VT0.combiner_paramfn (dz r) (xk k) e, e))
1040     (fun r k e -> (functions.VT0.combiner_declfn (dz r) (xk k) e, e))
1041     (fun r k e -> (functions.VT0.combiner_stmtfn (dz r) (xk k) e, e))
1042     (fun r k e -> (functions.VT0.combiner_casefn (dz r) (xk k) e, e))
1043     (fun r k e -> (functions.VT0.combiner_topfn (dz r) (xk k) e, e)))
1044
1045 let flat_combiner bind option_default
1046     meta_mcode string_mcode const_mcode assign_mcode fix_mcode unary_mcode
1047     binary_mcode cv_mcode sign_mcode struct_mcode storage_mcode
1048     inc_mcode
1049     dotsexprfn dotsinitfn dotsparamfn dotsstmtfn dotsdeclfn dotscasefn
1050     identfn exprfn tyfn initfn paramfn declfn stmtfn casefn topfn =
1051   let dz = combiner_dz in
1052   let xk k e = let (n,_) = k e in n in
1053   combiner_dz (visitor COMBINER bind option_default
1054     (function mc -> (meta_mcode mc,mc))
1055     (function mc -> (string_mcode mc,mc))
1056     (function mc -> (const_mcode mc,mc))
1057     (function mc -> (assign_mcode mc,mc))
1058     (function mc -> (fix_mcode mc,mc))
1059     (function mc -> (unary_mcode mc,mc))
1060     (function mc -> (binary_mcode mc,mc))
1061     (function mc -> (cv_mcode mc,mc))
1062     (function mc -> (sign_mcode mc,mc))
1063     (function mc -> (struct_mcode mc,mc))
1064     (function mc -> (storage_mcode mc,mc))
1065     (function mc -> (inc_mcode mc,mc))
1066     (fun r k e -> (dotsexprfn (dz r) (xk k) e, e))
1067     (fun r k e -> (dotsinitfn (dz r) (xk k) e, e))
1068     (fun r k e -> (dotsparamfn (dz r) (xk k) e, e))
1069     (fun r k e -> (dotsstmtfn (dz r) (xk k) e, e))
1070     (fun r k e -> (dotsdeclfn (dz r) (xk k) e, e))
1071     (fun r k e -> (dotscasefn (dz r) (xk k) e, e))
1072     (fun r k e -> (identfn (dz r) (xk k) e, e))
1073     (fun r k e -> (exprfn (dz r) (xk k) e, e))
1074     (fun r k e -> (tyfn (dz r) (xk k) e, e))
1075     (fun r k e -> (initfn (dz r) (xk k) e, e))
1076     (fun r k e -> (paramfn (dz r) (xk k) e, e))
1077     (fun r k e -> (declfn (dz r) (xk k) e, e))
1078     (fun r k e -> (stmtfn (dz r) (xk k) e, e))
1079     (fun r k e -> (casefn (dz r) (xk k) e, e))
1080     (fun r k e -> (topfn (dz r) (xk k) e, e)))
1081
1082 let rebuilder_functions =
1083   {VT0.rebuilder_meta_mcode = (fun mc -> mc);
1084    VT0.rebuilder_string_mcode = (fun mc -> mc);
1085    VT0.rebuilder_const_mcode = (fun mc -> mc);
1086    VT0.rebuilder_assign_mcode = (fun mc -> mc);
1087    VT0.rebuilder_fix_mcode = (fun mc -> mc);
1088    VT0.rebuilder_unary_mcode = (fun mc -> mc);
1089    VT0.rebuilder_binary_mcode = (fun mc -> mc);
1090    VT0.rebuilder_cv_mcode = (fun mc -> mc);
1091    VT0.rebuilder_sign_mcode = (fun mc -> mc);
1092    VT0.rebuilder_struct_mcode = (fun mc -> mc);
1093    VT0.rebuilder_storage_mcode = (fun mc -> mc);
1094    VT0.rebuilder_inc_mcode = (fun mc -> mc);
1095    VT0.rebuilder_dotsexprfn = (fun r k e -> k e);
1096    VT0.rebuilder_dotsinitfn = (fun r k e -> k e);
1097    VT0.rebuilder_dotsparamfn = (fun r k e -> k e);
1098    VT0.rebuilder_dotsstmtfn = (fun r k e -> k e);
1099    VT0.rebuilder_dotsdeclfn = (fun r k e -> k e);
1100    VT0.rebuilder_dotscasefn = (fun r k e -> k e);
1101    VT0.rebuilder_identfn = (fun r k e -> k e);
1102    VT0.rebuilder_exprfn = (fun r k e -> k e);
1103    VT0.rebuilder_tyfn = (fun r k e -> k e);
1104    VT0.rebuilder_initfn = (fun r k e -> k e);
1105    VT0.rebuilder_paramfn = (fun r k e -> k e);
1106    VT0.rebuilder_declfn = (fun r k e -> k e);
1107    VT0.rebuilder_stmtfn = (fun r k e -> k e);
1108    VT0.rebuilder_casefn = (fun r k e -> k e);
1109    VT0.rebuilder_topfn = (fun r k e -> k e)}
1110
1111 let rebuilder_dz r =
1112   {VT0.rebuilder_rec_ident =
1113       (function e -> let (_,e) = r.VT0.ident e in e);
1114       VT0.rebuilder_rec_expression =
1115       (function e -> let (_,e) = r.VT0.expression e in e);
1116       VT0.rebuilder_rec_typeC =
1117       (function e -> let (_,e) = r.VT0.typeC e in e);
1118       VT0.rebuilder_rec_declaration =
1119       (function e -> let (_,e) = r.VT0.declaration e in e);
1120       VT0.rebuilder_rec_initialiser =
1121       (function e -> let (_,e) = r.VT0.initialiser e in e);
1122       VT0.rebuilder_rec_initialiser_list =
1123       (function e -> let (_,e) = r.VT0.initialiser_list e in e);
1124       VT0.rebuilder_rec_parameter =
1125       (function e -> let (_,e) = r.VT0.parameter e in e);
1126       VT0.rebuilder_rec_parameter_list =
1127       (function e -> let (_,e) = r.VT0.parameter_list e in e);
1128       VT0.rebuilder_rec_statement =
1129       (function e -> let (_,e) = r.VT0.statement e in e);
1130       VT0.rebuilder_rec_case_line =
1131       (function e -> let (_,e) = r.VT0.case_line e in e);
1132       VT0.rebuilder_rec_top_level =
1133       (function e -> let (_,e) = r.VT0.top_level e in e);
1134       VT0.rebuilder_rec_expression_dots =
1135       (function e -> let (_,e) = r.VT0.expression_dots e in e);
1136       VT0.rebuilder_rec_statement_dots =
1137       (function e -> let (_,e) = r.VT0.statement_dots e in e);
1138       VT0.rebuilder_rec_declaration_dots =
1139       (function e -> let (_,e) = r.VT0.declaration_dots e in e);
1140       VT0.rebuilder_rec_case_line_dots =
1141       (function e -> let (_,e) = r.VT0.case_line_dots e in e);
1142       VT0.rebuilder_rec_anything =
1143       (function e -> let (_,e) = r.VT0.anything e in e)}
1144
1145 let rebuilder functions =
1146   let dz = rebuilder_dz in
1147   let xk k e = let (_,e) = k e in e in
1148   rebuilder_dz
1149     (visitor REBUILDER (fun x y -> x) ()
1150     (function mc -> ((),functions.VT0.rebuilder_meta_mcode mc))
1151     (function mc -> ((),functions.VT0.rebuilder_string_mcode mc))
1152     (function mc -> ((),functions.VT0.rebuilder_const_mcode mc))
1153     (function mc -> ((),functions.VT0.rebuilder_assign_mcode mc))
1154     (function mc -> ((),functions.VT0.rebuilder_fix_mcode mc))
1155     (function mc -> ((),functions.VT0.rebuilder_unary_mcode mc))
1156     (function mc -> ((),functions.VT0.rebuilder_binary_mcode mc))
1157     (function mc -> ((),functions.VT0.rebuilder_cv_mcode mc))
1158     (function mc -> ((),functions.VT0.rebuilder_sign_mcode mc))
1159     (function mc -> ((),functions.VT0.rebuilder_struct_mcode mc))
1160     (function mc -> ((),functions.VT0.rebuilder_storage_mcode mc))
1161     (function mc -> ((),functions.VT0.rebuilder_inc_mcode mc))
1162     (fun r k e -> ((),functions.VT0.rebuilder_dotsexprfn (dz r) (xk k) e))
1163     (fun r k e -> ((),functions.VT0.rebuilder_dotsinitfn (dz r) (xk k) e))
1164     (fun r k e -> ((),functions.VT0.rebuilder_dotsparamfn (dz r) (xk k) e))
1165     (fun r k e -> ((),functions.VT0.rebuilder_dotsstmtfn (dz r) (xk k) e))
1166     (fun r k e -> ((),functions.VT0.rebuilder_dotsdeclfn (dz r) (xk k) e))
1167     (fun r k e -> ((),functions.VT0.rebuilder_dotscasefn (dz r) (xk k) e))
1168     (fun r k e -> ((),functions.VT0.rebuilder_identfn (dz r) (xk k) e))
1169     (fun r k e -> ((),functions.VT0.rebuilder_exprfn (dz r) (xk k) e))
1170     (fun r k e -> ((),functions.VT0.rebuilder_tyfn (dz r) (xk k) e))
1171     (fun r k e -> ((),functions.VT0.rebuilder_initfn (dz r) (xk k) e))
1172     (fun r k e -> ((),functions.VT0.rebuilder_paramfn (dz r) (xk k) e))
1173     (fun r k e -> ((),functions.VT0.rebuilder_declfn (dz r) (xk k) e))
1174     (fun r k e -> ((),functions.VT0.rebuilder_stmtfn (dz r) (xk k) e))
1175     (fun r k e -> ((),functions.VT0.rebuilder_casefn (dz r) (xk k) e))
1176     (fun r k e -> ((),functions.VT0.rebuilder_topfn (dz r) (xk k) e)))
1177
1178 let flat_rebuilder
1179     meta_mcode string_mcode const_mcode assign_mcode fix_mcode unary_mcode
1180     binary_mcode cv_mcode sign_mcode struct_mcode storage_mcode
1181     inc_mcode
1182     dotsexprfn dotsinitfn dotsparamfn dotsstmtfn dotsdeclfn dotscasefn
1183     identfn exprfn tyfn initfn paramfn declfn stmtfn casefn topfn =
1184   let dz = rebuilder_dz in
1185   let xk k e = let (_,e) = k e in e in
1186   rebuilder_dz
1187     (visitor REBUILDER (fun x y -> x) ()
1188     (function mc -> ((),meta_mcode mc))
1189     (function mc -> ((),string_mcode mc))
1190     (function mc -> ((),const_mcode mc))
1191     (function mc -> ((),assign_mcode mc))
1192     (function mc -> ((),fix_mcode mc))
1193     (function mc -> ((),unary_mcode mc))
1194     (function mc -> ((),binary_mcode mc))
1195     (function mc -> ((),cv_mcode mc))
1196     (function mc -> ((),sign_mcode mc))
1197     (function mc -> ((),struct_mcode mc))
1198     (function mc -> ((),storage_mcode mc))
1199     (function mc -> ((),inc_mcode mc))
1200     (fun r k e -> ((),dotsexprfn (dz r) (xk k) e))
1201     (fun r k e -> ((),dotsinitfn (dz r) (xk k) e))
1202     (fun r k e -> ((),dotsparamfn (dz r) (xk k) e))
1203     (fun r k e -> ((),dotsstmtfn (dz r) (xk k) e))
1204     (fun r k e -> ((),dotsdeclfn (dz r) (xk k) e))
1205     (fun r k e -> ((),dotscasefn (dz r) (xk k) e))
1206     (fun r k e -> ((),identfn (dz r) (xk k) e))
1207     (fun r k e -> ((),exprfn (dz r) (xk k) e))
1208     (fun r k e -> ((),tyfn (dz r) (xk k) e))
1209     (fun r k e -> ((),initfn (dz r) (xk k) e))
1210     (fun r k e -> ((),paramfn (dz r) (xk k) e))
1211     (fun r k e -> ((),declfn (dz r) (xk k) e))
1212     (fun r k e -> ((),stmtfn (dz r) (xk k) e))
1213     (fun r k e -> ((),casefn (dz r) (xk k) e))
1214     (fun r k e -> ((),topfn (dz r) (xk k) e)))
1215
1216 let combiner_rebuilder_functions =
1217   {VT0.combiner_rebuilder_meta_mcode =
1218     (fun opt_default mc -> (opt_default,mc));
1219    VT0.combiner_rebuilder_string_mcode =
1220     (fun opt_default mc -> (opt_default,mc));
1221    VT0.combiner_rebuilder_const_mcode =
1222     (fun opt_default mc -> (opt_default,mc));
1223    VT0.combiner_rebuilder_assign_mcode =
1224     (fun opt_default mc -> (opt_default,mc));
1225    VT0.combiner_rebuilder_fix_mcode =
1226     (fun opt_default mc -> (opt_default,mc));
1227    VT0.combiner_rebuilder_unary_mcode =
1228     (fun opt_default mc -> (opt_default,mc));
1229    VT0.combiner_rebuilder_binary_mcode =
1230     (fun opt_default mc -> (opt_default,mc));
1231    VT0.combiner_rebuilder_cv_mcode =
1232     (fun opt_default mc -> (opt_default,mc));
1233    VT0.combiner_rebuilder_sign_mcode =
1234     (fun opt_default mc -> (opt_default,mc));
1235    VT0.combiner_rebuilder_struct_mcode =
1236     (fun opt_default mc -> (opt_default,mc));
1237    VT0.combiner_rebuilder_storage_mcode =
1238     (fun opt_default mc -> (opt_default,mc));
1239    VT0.combiner_rebuilder_inc_mcode =
1240     (fun opt_default mc -> (opt_default,mc));
1241    VT0.combiner_rebuilder_dotsexprfn = (fun r k e -> k e);
1242    VT0.combiner_rebuilder_dotsinitfn = (fun r k e -> k e);
1243    VT0.combiner_rebuilder_dotsparamfn = (fun r k e -> k e);
1244    VT0.combiner_rebuilder_dotsstmtfn = (fun r k e -> k e);
1245    VT0.combiner_rebuilder_dotsdeclfn = (fun r k e -> k e);
1246    VT0.combiner_rebuilder_dotscasefn = (fun r k e -> k e);
1247    VT0.combiner_rebuilder_identfn = (fun r k e -> k e);
1248    VT0.combiner_rebuilder_exprfn = (fun r k e -> k e);
1249    VT0.combiner_rebuilder_tyfn = (fun r k e -> k e);
1250    VT0.combiner_rebuilder_initfn = (fun r k e -> k e);
1251    VT0.combiner_rebuilder_paramfn = (fun r k e -> k e);
1252    VT0.combiner_rebuilder_declfn = (fun r k e -> k e);
1253    VT0.combiner_rebuilder_stmtfn = (fun r k e -> k e);
1254    VT0.combiner_rebuilder_casefn = (fun r k e -> k e);
1255    VT0.combiner_rebuilder_topfn = (fun r k e -> k e)}
1256
1257 let combiner_rebuilder bind option_default functions =
1258   visitor BOTH bind option_default
1259     (functions.VT0.combiner_rebuilder_meta_mcode option_default)
1260     (functions.VT0.combiner_rebuilder_string_mcode option_default)
1261     (functions.VT0.combiner_rebuilder_const_mcode option_default)
1262     (functions.VT0.combiner_rebuilder_assign_mcode option_default)
1263     (functions.VT0.combiner_rebuilder_fix_mcode option_default)
1264     (functions.VT0.combiner_rebuilder_unary_mcode option_default)
1265     (functions.VT0.combiner_rebuilder_binary_mcode option_default)
1266     (functions.VT0.combiner_rebuilder_cv_mcode option_default)
1267     (functions.VT0.combiner_rebuilder_sign_mcode option_default)
1268     (functions.VT0.combiner_rebuilder_struct_mcode option_default)
1269     (functions.VT0.combiner_rebuilder_storage_mcode option_default)
1270     (functions.VT0.combiner_rebuilder_inc_mcode option_default)
1271     functions.VT0.combiner_rebuilder_dotsexprfn
1272     functions.VT0.combiner_rebuilder_dotsinitfn
1273     functions.VT0.combiner_rebuilder_dotsparamfn
1274     functions.VT0.combiner_rebuilder_dotsstmtfn
1275     functions.VT0.combiner_rebuilder_dotsdeclfn
1276     functions.VT0.combiner_rebuilder_dotscasefn
1277     functions.VT0.combiner_rebuilder_identfn
1278     functions.VT0.combiner_rebuilder_exprfn
1279     functions.VT0.combiner_rebuilder_tyfn
1280     functions.VT0.combiner_rebuilder_initfn
1281     functions.VT0.combiner_rebuilder_paramfn
1282     functions.VT0.combiner_rebuilder_declfn
1283     functions.VT0.combiner_rebuilder_stmtfn
1284     functions.VT0.combiner_rebuilder_casefn
1285     functions.VT0.combiner_rebuilder_topfn