parsing_cocci/visitor_ast0.ml

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