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