parsing_cocci/visitor_ast0.ml

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