parsing_cocci/visitor_ast0.ml

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