parsing_cocci/visitor_ast0.ml

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