parsing_cocci/.#arity.ml.1.87

   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 (* Arities matter for the minus slice, but not for the plus slice. *)
  24
  25 (* ? only allowed on rule_elems, and on subterms if the context is ? also. *)
  26
  27 module Ast0 = Ast0_cocci
  28 module Ast = Ast_cocci
  29
  30 (* --------------------------------------------------------------------- *)
  31
  32 let warning s = Printf.printf "warning: %s\n" s
  33
  34 let fail w str =
  35   failwith
  36     (Printf.sprintf "cocci line %d: %s" ((Ast0.get_info w).Ast0.line_start)
  37        str)
  38
  39 let make_opt_unique optfn uniquefn info tgt arity term =
  40   let term = Ast0.rewrap info term in
  41   if tgt = arity
  42   then term
  43   else (* tgt must be NONE *)
  44     match arity with
  45       Ast0.OPT -> Ast0.copywrap info (optfn term)
  46     | Ast0.UNIQUE -> Ast0.copywrap info (uniquefn term)
  47     | Ast0.NONE -> failwith "tgt must be NONE"
  48
  49 let all_same opt_allowed tgt line arities =
  50   let tgt =
  51     match tgt with
  52       Ast0.NONE ->
  53         (match List.hd arities with
  54           Ast0.OPT when not opt_allowed ->
  55             failwith "opt only allowed for the elements of a statement list"
  56         | x -> x)
  57     | _ -> tgt in
  58   if not(List.for_all (function x -> x = tgt) arities)
  59   then warning (Printf.sprintf "incompatible arity found on line %d" line);
  60   tgt
  61
  62 let get_option fn = function
  63     None -> None
  64   | Some x -> Some (fn x)
  65
  66 let anyopt l fn = List.exists (function w -> fn(Ast0.unwrap w)) l
  67
  68 let allopt l fn =
  69   let rec loop = function
  70       [] -> []
  71     | x::xs ->
  72         match fn (Ast0.unwrap x) with
  73           Some x -> x :: (loop xs)
  74         | None -> [] in
  75   let res = loop l in
  76   if List.length res = List.length l then Some res else None
  77
  78 (* --------------------------------------------------------------------- *)
  79 (* --------------------------------------------------------------------- *)
  80 (* Mcode *)
  81
  82 let mcode2line (_,_,info,_,_) = info.Ast0.line_start
  83 let mcode2arity (_,arity,_,_,_) = arity
  84
  85 let mcode x = x (* nothing to do ... *)
  86
  87 (* --------------------------------------------------------------------- *)
  88 (* Dots *)
  89
  90 let dots fn d =
  91   Ast0.rewrap d
  92     (match Ast0.unwrap d with
  93       Ast0.DOTS(x) -> Ast0.DOTS(List.map fn x)
  94     | Ast0.CIRCLES(x) -> Ast0.CIRCLES(List.map fn x)
  95     | Ast0.STARS(x) -> Ast0.STARS(List.map fn x))
  96
  97 let only_dots l =
  98   not
  99     (List.exists
 100        (function x ->
 101           match Ast0.unwrap x with
 102            Ast0.Circles(_,_) | Ast0.Stars(_,_) -> true
 103          | _ -> false)
 104        l)
 105
 106 let only_circles l =
 107   not (List.exists
 108         (function x ->
 109           match Ast0.unwrap x with
 110             Ast0.Dots(_,_) | Ast0.Stars(_,_) -> true
 111           | _ -> false)
 112          l)
 113
 114 let only_stars l =
 115   not (List.exists
 116         (function x ->
 117           match Ast0.unwrap x with
 118             Ast0.Dots(_,_) | Ast0.Circles(_,_) -> true
 119           | _ -> false)
 120          l)
 121
 122 let concat_dots fn d =
 123   Ast0.rewrap d
 124     (match Ast0.unwrap d with
 125       Ast0.DOTS(x) ->
 126         let l = List.map fn x in
 127         if only_dots l
 128         then Ast0.DOTS(l)
 129         else fail d "inconsistent dots usage"
 130     | Ast0.CIRCLES(x) ->
 131         let l = List.map fn x in
 132         if only_circles l
 133         then Ast0.CIRCLES(l)
 134         else fail d "inconsistent dots usage"
 135     | Ast0.STARS(x) ->
 136         let l = List.map fn x in
 137         if only_stars l
 138         then Ast0.STARS(l)
 139         else fail d "inconsistent dots usage")
 140
 141 let flat_concat_dots fn d =
 142   match Ast0.unwrap d with
 143     Ast0.DOTS(x) -> List.map fn x
 144   | Ast0.CIRCLES(x) -> List.map fn x
 145   | Ast0.STARS(x) -> List.map fn x
 146
 147 (* --------------------------------------------------------------------- *)
 148 (* Identifier *)
 149
 150 let make_id =
 151   make_opt_unique
 152     (function x -> Ast0.OptIdent x)
 153     (function x -> Ast0.UniqueIdent x)
 154
 155 let ident opt_allowed tgt i =
 156   match Ast0.unwrap i with
 157     Ast0.Id(name) ->
 158       let arity =
 159         all_same opt_allowed tgt (mcode2line name)
 160           [mcode2arity name] in
 161       let name = mcode name in
 162       make_id i tgt arity (Ast0.Id(name))
 163   | Ast0.MetaId(name,constraints,pure) ->
 164       let arity =
 165         all_same opt_allowed tgt (mcode2line name)
 166           [mcode2arity name] in
 167       let name = mcode name in
 168       make_id i tgt arity (Ast0.MetaId(name,constraints,pure))
 169   | Ast0.MetaFunc(name,constraints,pure) ->
 170       let arity =
 171         all_same opt_allowed tgt (mcode2line name)
 172           [mcode2arity name] in
 173       let name = mcode name in
 174       make_id i tgt arity (Ast0.MetaFunc(name,constraints,pure))
 175   | Ast0.MetaLocalFunc(name,constraints,pure) ->
 176       let arity =
 177         all_same opt_allowed tgt (mcode2line name)
 178           [mcode2arity name] in
 179       let name = mcode name in
 180       make_id i tgt arity (Ast0.MetaLocalFunc(name,constraints,pure))
 181   | Ast0.OptIdent(_) | Ast0.UniqueIdent(_) ->
 182       failwith "unexpected code"
 183
 184 (* --------------------------------------------------------------------- *)
 185 (* Expression *)
 186
 187 let make_exp =
 188   make_opt_unique
 189     (function x -> Ast0.OptExp x)
 190     (function x -> Ast0.UniqueExp x)
 191
 192 let rec top_expression opt_allowed tgt expr =
 193   let exp_same = all_same opt_allowed tgt in
 194   match Ast0.unwrap expr with
 195     Ast0.Ident(id) ->
 196       let new_id = ident opt_allowed tgt id in
 197       Ast0.rewrap expr
 198         (match Ast0.unwrap new_id with
 199           Ast0.OptIdent(id) ->
 200             Ast0.OptExp(Ast0.rewrap expr (Ast0.Ident(id)))
 201         | Ast0.UniqueIdent(id) ->
 202             Ast0.UniqueExp(Ast0.rewrap expr (Ast0.Ident(id)))
 203         | _ -> Ast0.Ident(new_id))
 204   | Ast0.Constant(const) ->
 205       let arity = exp_same (mcode2line const) [mcode2arity const] in
 206       let const = mcode const in
 207       make_exp expr tgt arity (Ast0.Constant(const))
 208   | Ast0.FunCall(fn,lp,args,rp) ->
 209       let arity = exp_same (mcode2line lp) [mcode2arity lp;mcode2arity rp] in
 210       let fn = expression arity fn in
 211       let lp = mcode lp in
 212       let args = dots (expression arity) args in
 213       let rp = mcode rp in
 214       make_exp expr tgt arity (Ast0.FunCall(fn,lp,args,rp))
 215   | Ast0.Assignment(left,op,right,simple) ->
 216       let arity = exp_same (mcode2line op) [mcode2arity op] in
 217       let left = expression arity left in
 218       let op = mcode op in
 219       let right = expression arity right in
 220       make_exp expr tgt arity (Ast0.Assignment(left,op,right,simple))
 221   | Ast0.CondExpr(exp1,why,exp2,colon,exp3) ->
 222       let arity =
 223         exp_same (mcode2line why) [mcode2arity why; mcode2arity colon] in
 224       let exp1 = expression arity exp1 in
 225       let why = mcode why in
 226       let exp2 = get_option (expression arity) exp2 in
 227       let colon = mcode colon in
 228       let exp3 = expression arity exp3 in
 229       make_exp expr tgt arity (Ast0.CondExpr(exp1,why,exp2,colon,exp3))
 230   | Ast0.Postfix(exp,op) ->
 231       let arity = exp_same (mcode2line op) [mcode2arity op] in
 232       let exp = expression arity exp in
 233       let op = mcode op in
 234       make_exp expr tgt arity (Ast0.Postfix(exp,op))
 235   | Ast0.Infix(exp,op) ->
 236       let arity = exp_same (mcode2line op) [mcode2arity op] in
 237       let exp = expression arity exp in
 238       let op = mcode op in
 239       make_exp expr tgt arity (Ast0.Infix(exp,op))
 240   | Ast0.Unary(exp,op) ->
 241       let arity = exp_same (mcode2line op) [mcode2arity op] in
 242       let exp = expression arity exp in
 243       let op = mcode op in
 244       make_exp expr tgt arity (Ast0.Unary(exp,op))
 245   | Ast0.Binary(left,op,right) ->
 246       let arity = exp_same (mcode2line op) [mcode2arity op] in
 247       let left = expression arity left in
 248       let op = mcode op in
 249       let right = expression arity right in
 250       make_exp expr tgt arity (Ast0.Binary(left,op,right))
 251   | Ast0.Nested(left,op,right) -> failwith "nested in arity not possible"
 252   | Ast0.Paren(lp,exp,rp) ->
 253       let arity = exp_same (mcode2line lp) [mcode2arity lp;mcode2arity rp] in
 254       let lp = mcode lp in
 255       let exp = expression arity exp in
 256       let rp = mcode rp in
 257       make_exp expr tgt arity (Ast0.Paren(lp,exp,rp))
 258   | Ast0.ArrayAccess(exp1,lb,exp2,rb) ->
 259       let arity = exp_same (mcode2line lb) [mcode2arity lb; mcode2arity rb] in
 260       let exp1 = expression arity exp1 in
 261       let lb = mcode lb in
 262       let exp2 = expression arity exp2 in
 263       let rb = mcode rb in
 264       make_exp expr tgt arity (Ast0.ArrayAccess(exp1,lb,exp2,rb))
 265   | Ast0.RecordAccess(exp,pt,field) ->
 266       let arity = exp_same (mcode2line pt) [mcode2arity pt] in
 267       let exp = expression arity exp in
 268       let pt = mcode pt in
 269       let field = ident false arity field in
 270       make_exp expr tgt arity (Ast0.RecordAccess(exp,pt,field))
 271   | Ast0.RecordPtAccess(exp,ar,field) ->
 272       let arity = exp_same (mcode2line ar) [mcode2arity ar] in
 273       let exp = expression arity exp in
 274       let ar = mcode ar in
 275       let field = ident false arity field in
 276       make_exp expr tgt arity (Ast0.RecordPtAccess(exp,ar,field))
 277   | Ast0.Cast(lp,ty,rp,exp) ->
 278       let arity = exp_same (mcode2line lp) [mcode2arity lp;mcode2arity rp] in
 279       let lp = mcode lp in
 280       let ty = typeC arity ty in
 281       let rp = mcode rp in
 282       let exp = expression arity exp in
 283       make_exp expr tgt arity (Ast0.Cast(lp,ty,rp,exp))
 284   | Ast0.SizeOfExpr(szf,exp) ->
 285       let arity = exp_same (mcode2line szf) [mcode2arity szf] in
 286       let szf = mcode szf in
 287       let exp = expression arity exp in
 288       make_exp expr tgt arity (Ast0.SizeOfExpr(szf,exp))
 289   | Ast0.SizeOfType(szf,lp,ty,rp) ->
 290       let arity =
 291         exp_same (mcode2line szf) (List.map mcode2arity [szf;lp;rp]) in
 292       let szf = mcode szf in
 293       let lp = mcode lp in
 294       let ty = typeC arity ty in
 295       let rp = mcode rp in
 296       make_exp expr tgt arity (Ast0.SizeOfType(szf,lp,ty,rp))
 297   | Ast0.TypeExp(ty) -> Ast0.rewrap expr (Ast0.TypeExp(typeC tgt ty))
 298   | Ast0.MetaErr(name,constraints,pure)  ->
 299       let arity = exp_same (mcode2line name) [mcode2arity name] in
 300       let name = mcode name in
 301       make_exp expr tgt arity (Ast0.MetaErr(name,constraints,pure))
 302   | Ast0.MetaExpr(name,constraints,ty,form,pure)  ->
 303       let arity = exp_same (mcode2line name) [mcode2arity name] in
 304       let name = mcode name in
 305       make_exp expr tgt arity (Ast0.MetaExpr(name,constraints,ty,form,pure))
 306   | Ast0.MetaExprList(name,lenname,pure) ->
 307       let arity = exp_same (mcode2line name) [mcode2arity name] in
 308       let name = mcode name in
 309       make_exp expr tgt arity (Ast0.MetaExprList(name,lenname,pure))
 310   | Ast0.EComma(cm)         ->
 311       let arity = exp_same (mcode2line cm) [mcode2arity cm] in
 312       let cm = mcode cm in
 313       make_exp expr tgt arity (Ast0.EComma(cm))
 314   | Ast0.DisjExpr(starter,exps,mids,ender) ->
 315       let exps = List.map (top_expression opt_allowed tgt) exps in
 316       (match List.rev exps with
 317         _::xs ->
 318           if anyopt xs (function Ast0.OptExp(_) -> true | _ -> false)
 319           then fail expr "opt only allowed in the last disjunct"
 320       | _ -> ());
 321       Ast0.rewrap expr (Ast0.DisjExpr(starter,exps,mids,ender))
 322   | Ast0.NestExpr(starter,exp_dots,ender,whencode,multi) ->
 323       let res =
 324         Ast0.NestExpr(starter,
 325                       dots (top_expression true Ast0.NONE) exp_dots,
 326                       ender,whencode,multi) in
 327       Ast0.rewrap expr res
 328   | Ast0.Edots(dots,whencode) ->
 329       let arity = exp_same (mcode2line dots) [mcode2arity dots] in
 330       let dots = mcode dots in
 331       let whencode = get_option (expression Ast0.NONE) whencode in
 332       make_exp expr tgt arity (Ast0.Edots(dots,whencode))
 333   | Ast0.Ecircles(dots,whencode) ->
 334       let arity = exp_same (mcode2line dots) [mcode2arity dots] in
 335       let dots = mcode dots in
 336       let whencode = get_option (expression Ast0.NONE) whencode in
 337       make_exp expr tgt arity (Ast0.Ecircles(dots,whencode))
 338   | Ast0.Estars(dots,whencode) ->
 339       let arity = exp_same (mcode2line dots) [mcode2arity dots] in
 340       let dots = mcode dots in
 341       let whencode = get_option (expression Ast0.NONE) whencode in
 342       make_exp expr tgt arity (Ast0.Estars(dots,whencode))
 343   | Ast0.OptExp(_) | Ast0.UniqueExp(_) ->
 344       failwith "unexpected code"
 345
 346 and expression tgt exp = top_expression false tgt exp
 347
 348 (* --------------------------------------------------------------------- *)
 349 (* Types *)
 350
 351 and make_typeC =
 352   make_opt_unique
 353     (function x -> Ast0.OptType x)
 354     (function x -> Ast0.UniqueType x)
 355
 356 and top_typeC tgt opt_allowed typ =
 357   match Ast0.unwrap typ with
 358     Ast0.ConstVol(cv,ty) ->
 359       let arity = all_same opt_allowed tgt (mcode2line cv)
 360           [mcode2arity cv] in
 361       let cv = mcode cv in
 362       let ty = typeC arity ty in
 363       make_typeC typ tgt arity (Ast0.ConstVol(cv,ty))
 364   | Ast0.BaseType(ty,strings) ->
 365       let arity =
 366         all_same opt_allowed tgt (mcode2line (List.hd strings))
 367           (List.map mcode2arity strings) in
 368       let strings = List.map mcode strings in
 369       make_typeC typ tgt arity (Ast0.BaseType(ty,strings))
 370   | Ast0.Signed(sign,ty) ->
 371       let arity =
 372         all_same opt_allowed tgt (mcode2line sign) [mcode2arity sign] in
 373       let sign = mcode sign in
 374       let ty = get_option (typeC arity) ty in
 375       make_typeC typ tgt arity (Ast0.Signed(sign,ty))
 376   | Ast0.Pointer(ty,star) ->
 377       let arity =
 378         all_same opt_allowed tgt (mcode2line star) [mcode2arity star] in
 379       let ty = typeC arity ty in
 380       let star = mcode star in
 381       make_typeC typ tgt arity (Ast0.Pointer(ty,star))
 382   | Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2) ->
 383       let arity =
 384         all_same opt_allowed tgt (mcode2line lp1)
 385           (List.map mcode2arity [lp1;star;rp1;lp2;rp2]) in
 386       let ty = typeC arity ty in
 387       let params = parameter_list tgt params in
 388       make_typeC typ tgt arity
 389         (Ast0.FunctionPointer(ty,lp1,star,rp1,lp2,params,rp2))
 390   | Ast0.FunctionType(ty,lp1,params,rp1) ->
 391       let arity =
 392         all_same opt_allowed tgt (mcode2line lp1)
 393           (List.map mcode2arity [lp1;rp1]) in
 394       let ty = get_option (typeC arity) ty in
 395       let params = parameter_list tgt params in
 396       make_typeC typ tgt arity (Ast0.FunctionType(ty,lp1,params,rp1))
 397   | Ast0.Array(ty,lb,size,rb) ->
 398       let arity =
 399         all_same opt_allowed tgt (mcode2line lb)
 400           [mcode2arity lb;mcode2arity rb] in
 401       let ty = typeC arity ty in
 402       let lb = mcode lb in
 403       let size = get_option (expression arity) size in
 404       let rb = mcode rb in
 405       make_typeC typ tgt arity (Ast0.Array(ty,lb,size,rb))
 406   | Ast0.EnumName(kind,name) ->
 407       let arity =
 408         all_same opt_allowed tgt (mcode2line kind) [mcode2arity kind] in
 409       let kind = mcode kind in
 410       let name = ident false arity name in
 411       make_typeC typ tgt arity (Ast0.EnumName(kind,name))
 412   | Ast0.StructUnionName(kind,name) ->
 413       let arity =
 414         all_same opt_allowed tgt (mcode2line kind)
 415           [mcode2arity kind] in
 416       let kind = mcode kind in
 417       let name = get_option (ident false arity) name in
 418       make_typeC typ tgt arity (Ast0.StructUnionName(kind,name))
 419   | Ast0.StructUnionDef(ty,lb,decls,rb) ->
 420       let arity =
 421         all_same opt_allowed tgt (mcode2line lb)
 422           (List.map mcode2arity [lb;rb]) in
 423       let ty = typeC arity ty in
 424       let lb = mcode lb in
 425       let decls = dots (declaration tgt) decls in
 426       let rb = mcode rb in
 427       make_typeC typ tgt arity (Ast0.StructUnionDef(ty,lb,decls,rb))
 428   | Ast0.TypeName(name) ->
 429       let arity =
 430         all_same opt_allowed tgt (mcode2line name) [mcode2arity name] in
 431       let name = mcode name in
 432       make_typeC typ tgt arity (Ast0.TypeName(name))
 433   | Ast0.MetaType(name,pure) ->
 434       let arity =
 435         all_same opt_allowed tgt (mcode2line name) [mcode2arity name] in
 436       let name = mcode name in
 437       make_typeC typ tgt arity (Ast0.MetaType(name,pure))
 438   | Ast0.DisjType(starter,types,mids,ender) ->
 439       let types = List.map (typeC tgt) types in
 440       (match List.rev types with
 441         _::xs ->
 442           if anyopt xs (function Ast0.OptType(_) -> true | _ -> false)
 443           then fail typ "opt only allowed in the last disjunct"
 444       | _ -> ());
 445       let res = Ast0.DisjType(starter,types,mids,ender) in
 446       Ast0.rewrap typ res
 447   | Ast0.OptType(_) | Ast0.UniqueType(_) ->
 448       failwith "unexpected code"
 449
 450 and typeC tgt ty = top_typeC tgt false ty
 451
 452 (* --------------------------------------------------------------------- *)
 453 (* Variable declaration *)
 454 (* Even if the Cocci program specifies a list of declarations, they are
 455    split out into multiple declarations of a single variable each. *)
 456
 457 and make_decl =
 458   make_opt_unique
 459     (function x -> Ast0.OptDecl x)
 460     (function x -> Ast0.UniqueDecl x)
 461
 462 and declaration tgt decl =
 463   match Ast0.unwrap decl with
 464     Ast0.Init(stg,ty,id,eq,exp,sem) ->
 465       let arity =
 466         all_same true tgt (mcode2line eq)
 467           ((match stg with None -> [] | Some x -> [mcode2arity x]) @
 468            (List.map mcode2arity [eq;sem])) in
 469       let stg = get_option mcode stg in
 470       let ty = typeC arity ty in
 471       let id = ident false arity id in
 472       let eq = mcode eq in
 473       let exp = initialiser arity exp in
 474       let sem = mcode sem in
 475       make_decl decl tgt arity (Ast0.Init(stg,ty,id,eq,exp,sem))
 476   | Ast0.UnInit(stg,ty,id,sem) ->
 477       let arity =
 478         all_same true tgt (mcode2line sem)
 479           ((match stg with None -> [] | Some x -> [mcode2arity x]) @
 480            [mcode2arity sem]) in
 481       let stg = get_option mcode stg in
 482       let ty = typeC arity ty in
 483       let id = ident false arity id in
 484       let sem = mcode sem in
 485       make_decl decl tgt arity (Ast0.UnInit(stg,ty,id,sem))
 486   | Ast0.MacroDecl(name,lp,args,rp,sem) ->
 487       let arity =
 488         all_same true tgt (mcode2line lp) (List.map mcode2arity [lp;rp;sem]) in
 489       let name = ident false arity name in
 490       let lp = mcode lp in
 491       let args = dots (expression arity) args in
 492       let rp = mcode rp in
 493       let sem = mcode sem in
 494       make_decl decl tgt arity (Ast0.MacroDecl(name,lp,args,rp,sem))
 495   | Ast0.TyDecl(ty,sem) ->
 496       let arity =
 497         all_same true tgt (mcode2line sem) [mcode2arity sem] in
 498       let ty = typeC arity ty in
 499       let sem = mcode sem in
 500       make_decl decl tgt arity (Ast0.TyDecl(ty,sem))
 501   | Ast0.Typedef(stg,ty,id,sem) ->
 502       let arity =
 503         all_same true tgt (mcode2line sem)
 504           [mcode2arity stg;mcode2arity sem] in
 505       let stg = mcode stg in
 506       let ty = typeC arity ty in
 507       let id = typeC arity id in
 508       let sem = mcode sem in
 509       make_decl decl tgt arity (Ast0.Typedef(stg,ty,id,sem))
 510   | Ast0.DisjDecl(starter,decls,mids,ender) ->
 511       let decls = List.map (declaration tgt) decls in
 512       (match List.rev decls with
 513         _::xs ->
 514           if anyopt xs (function Ast0.OptDecl(_) -> true | _ -> false)
 515           then fail decl "opt only allowed in the last disjunct"
 516       | _ -> ());
 517       let res = Ast0.DisjDecl(starter,decls,mids,ender) in
 518       Ast0.rewrap decl res
 519   | Ast0.Ddots(dots,whencode) ->
 520       let arity = all_same true tgt (mcode2line dots) [mcode2arity dots] in
 521       let dots = mcode dots in
 522       let whencode = get_option (declaration Ast0.NONE) whencode in
 523       make_decl decl tgt arity (Ast0.Ddots(dots,whencode))
 524   | Ast0.OptDecl(_) | Ast0.UniqueDecl(_) ->
 525       failwith "unexpected code"
 526
 527 (* --------------------------------------------------------------------- *)
 528 (* Initializer *)
 529
 530 and make_init =
 531   make_opt_unique
 532     (function x -> Ast0.OptIni x)
 533     (function x -> Ast0.UniqueIni x)
 534
 535 and initialiser tgt i =
 536   let init_same = all_same true tgt in
 537   match Ast0.unwrap i with
 538     Ast0.InitExpr(exp) ->
 539       Ast0.rewrap i (Ast0.InitExpr(expression tgt exp))
 540   | Ast0.InitList(lb,initlist,rb) ->
 541       let arity = init_same (mcode2line lb) [mcode2arity lb; mcode2arity rb] in
 542       let lb = mcode lb in
 543       let initlist = dots (initialiser arity) initlist in
 544       let rb = mcode rb in
 545       make_init i tgt arity (Ast0.InitList(lb,initlist,rb))
 546   | Ast0.InitGccDotName(dot,name,eq,ini) ->
 547       let arity =
 548         init_same (mcode2line dot) [mcode2arity dot; mcode2arity eq] in
 549       let dot = mcode dot in
 550       let name = ident true arity name in
 551       let eq = mcode eq in
 552       let ini = initialiser arity ini in
 553       make_init i tgt arity (Ast0.InitGccDotName(dot,name,eq,ini))
 554   | Ast0.InitGccName(name,eq,ini) ->
 555       let arity = init_same (mcode2line eq) [mcode2arity eq] in
 556       let name = ident true arity name in
 557       let eq = mcode eq in
 558       let ini = initialiser arity ini in
 559       make_init i tgt arity (Ast0.InitGccName(name,eq,ini))
 560   | Ast0.InitGccIndex(lb,exp,rb,eq,ini) ->
 561       let arity =
 562         init_same (mcode2line lb)
 563           [mcode2arity lb; mcode2arity rb; mcode2arity eq] in
 564       let lb = mcode lb in
 565       let exp = expression arity exp in
 566       let rb = mcode rb in
 567       let eq = mcode eq in
 568       let ini = initialiser arity ini in
 569       make_init i tgt arity (Ast0.InitGccIndex(lb,exp,rb,eq,ini))
 570   | Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini) ->
 571       let arity =
 572         init_same (mcode2line lb)
 573           [mcode2arity lb; mcode2arity dots; mcode2arity rb; mcode2arity eq] in
 574       let lb = mcode lb in
 575       let exp1 = expression arity exp1 in
 576       let dots = mcode dots in
 577       let exp2 = expression arity exp2 in
 578       let rb = mcode rb in
 579       let eq = mcode eq in
 580       let ini = initialiser arity ini in
 581       make_init i tgt arity
 582         (Ast0.InitGccRange(lb,exp1,dots,exp2,rb,eq,ini))
 583   | Ast0.IComma(cm) ->
 584       let arity = init_same (mcode2line cm) [mcode2arity cm] in
 585       let cm = mcode cm in
 586       make_init i tgt arity (Ast0.IComma(cm))
 587   | Ast0.Idots(dots,whencode) ->
 588       let arity = init_same (mcode2line dots) [mcode2arity dots] in
 589       let dots = mcode dots in
 590       let whencode = get_option (initialiser Ast0.NONE) whencode in
 591       make_init i tgt arity (Ast0.Idots(dots,whencode))
 592   | Ast0.OptIni(_) | Ast0.UniqueIni(_) ->
 593       failwith "unexpected code"
 594
 595 (* --------------------------------------------------------------------- *)
 596 (* Parameter *)
 597
 598 and make_param =
 599   make_opt_unique
 600     (function x -> Ast0.OptParam x)
 601     (function x -> Ast0.UniqueParam x)
 602
 603 and parameterTypeDef tgt param =
 604   let param_same = all_same true tgt in
 605   match Ast0.unwrap param with
 606     Ast0.VoidParam(ty) -> Ast0.rewrap param (Ast0.VoidParam(typeC tgt ty))
 607   | Ast0.Param(ty,Some id) ->
 608       let ty = top_typeC tgt true ty in
 609       let id = ident true tgt id in
 610       Ast0.rewrap param
 611         (match (Ast0.unwrap ty,Ast0.unwrap id) with
 612           (Ast0.OptType(ty),Ast0.OptIdent(id)) ->
 613             Ast0.OptParam(Ast0.rewrap param (Ast0.Param(ty,Some id)))
 614         | (Ast0.UniqueType(ty),Ast0.UniqueIdent(id)) ->
 615             Ast0.UniqueParam(Ast0.rewrap param (Ast0.Param(ty,Some id)))
 616         | (Ast0.OptType(ty),_) ->
 617             fail param "arity mismatch in param declaration"
 618         | (_,Ast0.OptIdent(id)) ->
 619             fail param "arity mismatch in param declaration"
 620         | _ -> Ast0.Param(ty,Some id))
 621   | Ast0.Param(ty,None) ->
 622       let ty = top_typeC tgt true ty in
 623       Ast0.rewrap param
 624         (match Ast0.unwrap ty with
 625           Ast0.OptType(ty) ->
 626             Ast0.OptParam(Ast0.rewrap param (Ast0.Param(ty,None)))
 627         | Ast0.UniqueType(ty) ->
 628             Ast0.UniqueParam(Ast0.rewrap param (Ast0.Param(ty,None)))
 629         | _ -> Ast0.Param(ty,None))
 630   | Ast0.MetaParam(name,pure) ->
 631       let arity = param_same (mcode2line name) [mcode2arity name] in
 632       let name = mcode name in
 633       make_param param tgt arity (Ast0.MetaParam(name,pure))
 634   | Ast0.MetaParamList(name,lenname,pure) ->
 635       let arity = param_same (mcode2line name) [mcode2arity name] in
 636       let name = mcode name in
 637       make_param param tgt arity (Ast0.MetaParamList(name,lenname,pure))
 638   | Ast0.PComma(cm) ->
 639       let arity = param_same (mcode2line cm) [mcode2arity cm] in
 640       let cm = mcode cm in
 641       make_param param tgt arity (Ast0.PComma(cm))
 642   | Ast0.Pdots(dots) ->
 643       let arity = param_same (mcode2line dots) [mcode2arity dots] in
 644       let dots = mcode dots in
 645       make_param param tgt arity (Ast0.Pdots(dots))
 646   | Ast0.Pcircles(dots) ->
 647       let arity = param_same (mcode2line dots) [mcode2arity dots] in
 648       let dots = mcode dots in
 649       make_param param tgt arity (Ast0.Pcircles(dots))
 650   | Ast0.OptParam(_) | Ast0.UniqueParam(_) ->
 651       failwith "unexpected code"
 652
 653 and parameter_list tgt = dots (parameterTypeDef tgt)
 654
 655 (* --------------------------------------------------------------------- *)
 656 (* Top-level code *)
 657
 658 and make_rule_elem x =
 659   make_opt_unique
 660     (function x -> Ast0.OptStm x)
 661     (function x -> Ast0.UniqueStm x)
 662     x
 663
 664 and statement tgt stm =
 665   let stm_same = all_same true tgt in
 666   match Ast0.unwrap stm with
 667     Ast0.Decl(bef,decl) ->
 668       let new_decl = declaration tgt decl in
 669       Ast0.rewrap stm
 670         (match Ast0.unwrap new_decl with
 671           Ast0.OptDecl(decl) ->
 672             Ast0.OptStm(Ast0.rewrap stm (Ast0.Decl(bef,decl)))
 673         | Ast0.UniqueDecl(decl) ->
 674             Ast0.UniqueStm(Ast0.rewrap stm (Ast0.Decl(bef,decl)))
 675         | _ -> Ast0.Decl(bef,new_decl))
 676   | Ast0.Seq(lbrace,body,rbrace) ->
 677       let arity =
 678         stm_same (mcode2line lbrace)
 679           [mcode2arity lbrace; mcode2arity rbrace] in
 680       let lbrace = mcode lbrace in
 681       let body = dots (statement arity) body in
 682       let rbrace = mcode rbrace in
 683       make_rule_elem stm tgt arity (Ast0.Seq(lbrace,body,rbrace))
 684   | Ast0.ExprStatement(exp,sem) ->
 685       let arity = stm_same (mcode2line sem) [mcode2arity sem] in
 686       let exp = expression arity exp in
 687       let sem = mcode sem in
 688       make_rule_elem stm tgt arity (Ast0.ExprStatement(exp,sem))
 689   | Ast0.IfThen(iff,lp,exp,rp,branch,aft) ->
 690       let arity =
 691         stm_same (mcode2line iff) (List.map mcode2arity [iff;lp;rp]) in
 692       let iff = mcode iff in
 693       let lp = mcode lp in
 694       let exp = expression arity exp in
 695       let rp = mcode rp in
 696       let branch = statement arity branch in
 697       make_rule_elem stm tgt arity (Ast0.IfThen(iff,lp,exp,rp,branch,aft))
 698   | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) ->
 699       let arity =
 700         stm_same (mcode2line iff) (List.map mcode2arity [iff;lp;rp;els]) in
 701       let iff = mcode iff in
 702       let lp = mcode lp in
 703       let exp = expression arity exp in
 704       let rp = mcode rp in
 705       let branch1 = statement arity branch1 in
 706       let els = mcode els in
 707       let branch2 = statement arity branch2 in
 708       make_rule_elem stm tgt arity
 709         (Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft))
 710   | Ast0.While(wh,lp,exp,rp,body,aft) ->
 711       let arity =
 712         stm_same (mcode2line wh)
 713           (List.map mcode2arity [wh;lp;rp]) in
 714       let wh = mcode wh in
 715       let lp = mcode lp in
 716       let exp = expression arity exp in
 717       let rp = mcode rp in
 718       let body = statement arity body in
 719       make_rule_elem stm tgt arity (Ast0.While(wh,lp,exp,rp,body,aft))
 720   | Ast0.Do(d,body,wh,lp,exp,rp,sem) ->
 721       let arity =
 722         stm_same (mcode2line wh) (List.map mcode2arity [d;wh;lp;rp;sem]) in
 723       let d = mcode d in
 724       let body = statement arity body in
 725       let wh = mcode wh in
 726       let lp = mcode lp in
 727       let exp = expression arity exp in
 728       let rp = mcode rp in
 729       let sem = mcode sem in
 730       make_rule_elem stm tgt arity (Ast0.Do(d,body,wh,lp,exp,rp,sem))
 731   | Ast0.For(fr,lp,exp1,sem1,exp2,sem2,exp3,rp,body,aft) ->
 732       let arity =
 733         stm_same (mcode2line fr) (List.map mcode2arity [fr;lp;sem1;sem2;rp]) in
 734       let fr = mcode fr in
 735       let lp = mcode lp in
 736       let exp1 = get_option (expression arity) exp1 in
 737       let sem1 = mcode sem1 in
 738       let exp2 = get_option (expression arity) exp2 in
 739       let sem2= mcode sem2 in
 740       let exp3 = get_option (expression arity) exp3 in
 741       let rp = mcode rp in
 742       let body = statement arity body in
 743       make_rule_elem stm tgt arity
 744         (Ast0.For(fr,lp,exp1,sem1,exp2,sem2,exp3,rp,body,aft))
 745   | Ast0.Iterator(nm,lp,args,rp,body,aft) ->
 746       let arity = stm_same (mcode2line lp) (List.map mcode2arity [lp;rp]) in
 747       let nm = ident false arity nm in
 748       let lp = mcode lp in
 749       let args = dots (expression arity) args in
 750       let rp = mcode rp in
 751       let body = statement arity body in
 752       make_rule_elem stm tgt arity (Ast0.Iterator(nm,lp,args,rp,body,aft))
 753   | Ast0.Switch(switch,lp,exp,rp,lb,cases,rb) ->
 754       let arity =
 755         stm_same (mcode2line switch)
 756           (List.map mcode2arity [switch;lp;rp;lb;rb]) in
 757       let switch = mcode switch in
 758       let lp = mcode lp in
 759       let exp = expression arity exp in
 760       let rp = mcode rp in
 761       let lb = mcode lb in
 762       let cases = dots (case_line arity) cases in
 763       let rb = mcode rb in
 764       make_rule_elem stm tgt arity
 765         (Ast0.Switch(switch,lp,exp,rp,lb,cases,rb))
 766   | Ast0.Break(br,sem) ->
 767       let arity = stm_same (mcode2line br) (List.map mcode2arity [br;sem]) in
 768       let br = mcode br in
 769       let sem = mcode sem in
 770       make_rule_elem stm tgt arity (Ast0.Break(br,sem))
 771   | Ast0.Continue(cont,sem) ->
 772       let arity =
 773         stm_same (mcode2line cont) (List.map mcode2arity [cont;sem]) in
 774       let cont = mcode cont in
 775       let sem = mcode sem in
 776       make_rule_elem stm tgt arity (Ast0.Continue(cont,sem))
 777   | Ast0.Label(l,dd) ->
 778       let arity = mcode2arity dd in
 779       let l = ident false tgt l in
 780       let dd = mcode dd in
 781       make_rule_elem stm tgt arity (Ast0.Label(l,dd))
 782   | Ast0.Goto(goto,l,sem) ->
 783       let arity =
 784         stm_same (mcode2line goto) (List.map mcode2arity [goto;sem]) in
 785       let goto = mcode goto in
 786       let l = ident false tgt l in
 787       let sem = mcode sem in
 788       make_rule_elem stm tgt arity (Ast0.Goto(goto,l,sem))
 789   | Ast0.Return(ret,sem) ->
 790       let arity = stm_same (mcode2line ret) (List.map mcode2arity [ret;sem]) in
 791       let ret = mcode ret in
 792       let sem = mcode sem in
 793       make_rule_elem stm tgt arity (Ast0.Return(ret,sem))
 794   | Ast0.ReturnExpr(ret,exp,sem) ->
 795       let arity = stm_same (mcode2line ret) (List.map mcode2arity [ret;sem]) in
 796       let ret = mcode ret in
 797       let exp = expression arity exp in
 798       let sem = mcode sem in
 799       make_rule_elem stm tgt arity (Ast0.ReturnExpr(ret,exp,sem))
 800   | Ast0.MetaStmt(name,pure) ->
 801       let arity = stm_same (mcode2line name) [mcode2arity name] in
 802       let name = mcode name in
 803       make_rule_elem stm tgt arity (Ast0.MetaStmt(name,pure))
 804   | Ast0.MetaStmtList(name,pure) ->
 805       let arity = stm_same (mcode2line name) [mcode2arity name] in
 806       let name = mcode name in
 807       make_rule_elem stm tgt arity (Ast0.MetaStmtList(name,pure))
 808   | Ast0.Exp(exp) ->
 809       let new_exp = top_expression true tgt exp in
 810       Ast0.rewrap stm
 811         (match Ast0.unwrap new_exp with
 812           Ast0.OptExp(exp) ->
 813             Ast0.OptStm(Ast0.rewrap stm (Ast0.Exp(exp)))
 814         | Ast0.UniqueExp(exp) ->
 815             Ast0.UniqueStm(Ast0.rewrap stm (Ast0.Exp(exp)))
 816         | _ -> Ast0.Exp(new_exp))
 817   | Ast0.TopExp(exp) ->
 818       let new_exp = top_expression true tgt exp in
 819       Ast0.rewrap stm
 820         (match Ast0.unwrap new_exp with
 821           Ast0.OptExp(exp) ->
 822             Ast0.OptStm(Ast0.rewrap stm (Ast0.TopExp(exp)))
 823         | Ast0.UniqueExp(exp) ->
 824             Ast0.UniqueStm(Ast0.rewrap stm (Ast0.TopExp(exp)))
 825         | _ -> Ast0.TopExp(new_exp))
 826   | Ast0.Ty(ty) ->
 827       let new_ty = typeC tgt ty in (* opt makes no sense alone at top level *)
 828       Ast0.rewrap stm
 829         (match Ast0.unwrap new_ty with
 830           Ast0.OptType(ty) ->
 831             Ast0.OptStm(Ast0.rewrap stm (Ast0.Ty(ty)))
 832         | Ast0.UniqueType(ty) ->
 833             Ast0.UniqueStm(Ast0.rewrap stm (Ast0.Ty(ty)))
 834         | _ -> Ast0.Ty(new_ty))
 835   | Ast0.TopInit(init) ->
 836       let new_init = initialiser tgt init in
 837       Ast0.rewrap stm
 838         (match Ast0.unwrap new_init with
 839           Ast0.OptIni(init) ->
 840             Ast0.OptStm(Ast0.rewrap stm (Ast0.TopInit(init)))
 841         | Ast0.UniqueIni(init) ->
 842             Ast0.UniqueStm(Ast0.rewrap stm (Ast0.TopInit(init)))
 843         | _ -> Ast0.TopInit(new_init))
 844   | Ast0.Disj(starter,rule_elem_dots_list,mids,ender) ->
 845       let stms =
 846         List.map (function x -> concat_dots (statement tgt) x)
 847           rule_elem_dots_list in
 848       let (found_opt,unopt) =
 849         List.fold_left
 850           (function (found_opt,lines) ->
 851             function x ->
 852               let rebuild l =
 853                 (* previously just checked the last thing in the list,
 854                    but everything should be optional for the whole thing to
 855                    be optional *)
 856                 let is_opt x =
 857                   match Ast0.unwrap x with
 858                     Ast0.OptStm(x) -> true
 859                   | _ -> false in
 860                 let unopt x =
 861                   match Ast0.unwrap x with
 862                     Ast0.OptStm(x) -> x
 863                   | _ -> x in
 864                 if List.for_all is_opt l
 865                 then (true,List.map unopt l)
 866                 else (false, l) in
 867               let (l,k) =
 868                 match Ast0.unwrap x with
 869                   Ast0.DOTS(l) ->
 870                     (l,function l -> Ast0.rewrap x (Ast0.DOTS l))
 871                 | Ast0.CIRCLES(l) ->
 872                     (l,function l -> Ast0.rewrap x (Ast0.CIRCLES l))
 873                 | Ast0.STARS(l) ->
 874                     (l,function l -> Ast0.rewrap x (Ast0.STARS l)) in
 875               let (found_opt,l) = rebuild l in
 876               (found_opt,(k l)::lines))
 877           (false,[]) stms in
 878       let unopt = List.rev unopt in
 879       if found_opt
 880       then
 881         make_rule_elem stm tgt Ast0.OPT (Ast0.Disj(starter,unopt,mids,ender))
 882       else Ast0.rewrap stm (Ast0.Disj(starter,stms,mids,ender))
 883   | Ast0.Nest(starter,rule_elem_dots,ender,whn,multi) ->
 884       let new_rule_elem_dots =
 885         concat_dots (statement Ast0.NONE) rule_elem_dots in
 886       let whn =
 887         List.map
 888           (whencode (concat_dots (statement Ast0.NONE)) (statement Ast0.NONE)
 889              (expression Ast0.NONE))
 890           whn in
 891       Ast0.rewrap stm
 892         (Ast0.Nest(starter,new_rule_elem_dots,ender,whn,multi))
 893   | Ast0.Dots(dots,whn)    ->
 894       let arity = stm_same (mcode2line dots) [mcode2arity dots] in
 895       let dots = mcode dots in
 896       let whn =
 897         List.map
 898           (whencode (concat_dots (statement Ast0.NONE)) (statement Ast0.NONE)
 899              (expression Ast0.NONE))
 900           whn in
 901       make_rule_elem stm tgt arity (Ast0.Dots(dots,whn))
 902   | Ast0.Circles(dots,whn) ->
 903       let arity = stm_same (mcode2line dots) [mcode2arity dots] in
 904       let dots = mcode dots in
 905       let whn =
 906         List.map
 907           (whencode (concat_dots (statement Ast0.NONE)) (statement Ast0.NONE)
 908              (expression Ast0.NONE))
 909           whn in
 910       make_rule_elem stm tgt arity (Ast0.Circles(dots,whn))
 911   | Ast0.Stars(dots,whn)   ->
 912       let arity = stm_same (mcode2line dots) [mcode2arity dots] in
 913       let dots = mcode dots in
 914       let whn =
 915         List.map
 916           (whencode (concat_dots (statement Ast0.NONE)) (statement Ast0.NONE)
 917              (expression Ast0.NONE))
 918           whn in
 919       make_rule_elem stm tgt arity (Ast0.Stars(dots,whn))
 920   | Ast0.FunDecl(bef,fi,name,lp,params,rp,lbrace,body,rbrace) ->
 921       let arity =
 922         all_same true tgt (mcode2line lp)
 923           ((List.map mcode2arity [lp;rp;lbrace;rbrace]) @ (fninfo2arity fi)) in
 924       let fi = List.map (fninfo arity) fi in
 925       let name = ident false arity name in
 926       let lp = mcode lp in
 927       let params = parameter_list arity params in
 928       let rp = mcode rp in
 929       let lbrace = mcode lbrace in
 930       let body = dots (statement arity) body in
 931       let rbrace = mcode rbrace in
 932       make_rule_elem stm tgt arity
 933         (Ast0.FunDecl(bef,fi,name,lp,params,rp,lbrace,body,rbrace))
 934   | Ast0.Include(inc,s) ->
 935       let arity =
 936         all_same true tgt (mcode2line inc) [mcode2arity inc; mcode2arity s] in
 937       let inc = mcode inc in
 938       let s = mcode s in
 939       make_rule_elem stm tgt arity (Ast0.Include(inc,s))
 940   | Ast0.Define(def,id,params,body) ->
 941       let arity = all_same true tgt (mcode2line def) [mcode2arity def] in
 942       let def = mcode def in
 943       let id = ident false arity id in
 944       let params = define_parameters arity params in
 945       let body = dots (statement arity) body in
 946       make_rule_elem stm tgt arity (Ast0.Define(def,id,params,body))
 947   | Ast0.OptStm(_) | Ast0.UniqueStm(_) ->
 948       failwith "unexpected code"
 949
 950 and define_parameters tgt params =
 951   match Ast0.unwrap params with
 952     Ast0.NoParams -> params
 953   | Ast0.DParams(lp,params,rp) ->
 954       let arity =
 955         all_same true tgt (mcode2line lp) [mcode2arity lp;mcode2arity rp] in
 956       let lp = mcode lp in
 957       let params = dots (define_param arity) params in
 958       let rp = mcode rp in
 959       Ast0.rewrap params (Ast0.DParams(lp,params,rp))
 960
 961 and make_define_param x =
 962   make_opt_unique
 963     (function x -> Ast0.OptDParam x)
 964     (function x -> Ast0.UniqueDParam x)
 965     x
 966
 967 and define_param tgt param =
 968   match Ast0.unwrap param with
 969     Ast0.DParam(id) ->
 970       let new_id = ident true tgt id in
 971       Ast0.rewrap param
 972         (match Ast0.unwrap new_id with
 973           Ast0.OptIdent(id) ->
 974             Ast0.OptDParam(Ast0.rewrap param (Ast0.DParam(id)))
 975         | Ast0.UniqueIdent(decl) ->
 976             Ast0.UniqueDParam(Ast0.rewrap param (Ast0.DParam(id)))
 977         | _ -> Ast0.DParam(new_id))
 978   | Ast0.DPComma(cm) ->
 979       let arity =
 980         all_same true tgt (mcode2line cm) [mcode2arity cm] in
 981       let cm = mcode cm in
 982       make_define_param param tgt arity (Ast0.DPComma(cm))
 983   | Ast0.DPdots(dots) ->
 984       let arity =
 985         all_same true tgt (mcode2line dots) [mcode2arity dots] in
 986       let dots = mcode dots in
 987       make_define_param param tgt arity (Ast0.DPdots(dots))
 988   | Ast0.DPcircles(circles) ->
 989       let arity =
 990         all_same true tgt (mcode2line circles) [mcode2arity circles] in
 991       let circles = mcode circles in
 992       make_define_param param tgt arity (Ast0.DPcircles(circles))
 993   | Ast0.OptDParam(dp) | Ast0.UniqueDParam(dp) ->
 994       failwith "unexpected code"
 995
 996 and fninfo arity = function
 997     Ast0.FStorage(stg) -> Ast0.FStorage(mcode stg)
 998   | Ast0.FType(ty) -> Ast0.FType(typeC arity ty)
 999   | Ast0.FInline(inline) -> Ast0.FInline(mcode inline)
1000   | Ast0.FAttr(attr) -> Ast0.FAttr(mcode attr)
1001
1002 and fninfo2arity fninfo =
1003   List.concat
1004     (List.map
1005        (function
1006            Ast0.FStorage(stg) -> [mcode2arity stg]
1007          | Ast0.FType(ty) -> []
1008          | Ast0.FInline(inline) -> [mcode2arity inline]
1009          | Ast0.FAttr(attr) -> [mcode2arity attr])
1010        fninfo)
1011
1012 and whencode notfn alwaysfn expression = function
1013     Ast0.WhenNot a -> Ast0.WhenNot (notfn a)
1014   | Ast0.WhenAlways a -> Ast0.WhenAlways (alwaysfn a)
1015   | Ast0.WhenModifier(x) -> Ast0.WhenModifier(x)
1016   | Ast0.WhenNotTrue a -> Ast0.WhenNotTrue (expression a)
1017   | Ast0.WhenNotFalse a -> Ast0.WhenNotFalse (expression a)
1018
1019 and make_case_line =
1020   make_opt_unique
1021     (function x -> Ast0.OptCase x)
1022     (function x -> failwith "unique not allowed for case_line")
1023
1024 and case_line tgt c =
1025   match Ast0.unwrap c with
1026     Ast0.Default(def,colon,code) ->
1027       let arity =
1028         all_same true tgt (mcode2line def)
1029           [mcode2arity def; mcode2arity colon] in
1030       let def = mcode def in
1031       let colon = mcode colon in
1032       let code = dots (statement arity) code in
1033       make_case_line c tgt arity (Ast0.Default(def,colon,code))
1034   | Ast0.Case(case,exp,colon,code) ->
1035       let arity =
1036         all_same true tgt (mcode2line case)
1037           [mcode2arity case; mcode2arity colon] in
1038       let case = mcode case in
1039       let exp = expression arity exp in
1040       let colon = mcode colon in
1041       let code = dots (statement arity) code in
1042       make_case_line c tgt arity (Ast0.Case(case,exp,colon,code))
1043   | Ast0.OptCase(_) -> failwith "unexpected OptCase"
1044
1045 (* --------------------------------------------------------------------- *)
1046 (* Function declaration *)
1047 (* Haven't thought much about arity here... *)
1048
1049 let top_level tgt t =
1050   Ast0.rewrap t
1051     (match Ast0.unwrap t with
1052       Ast0.FILEINFO(old_file,new_file) ->
1053         if mcode2arity old_file = Ast0.NONE && mcode2arity new_file = Ast0.NONE
1054         then Ast0.FILEINFO(mcode old_file,mcode new_file)
1055         else fail t "unexpected arity for file info"
1056     | Ast0.DECL(stmt) ->
1057         Ast0.DECL(statement tgt stmt)
1058     | Ast0.CODE(rule_elem_dots) ->
1059         Ast0.CODE(concat_dots (statement tgt) rule_elem_dots)
1060     | Ast0.ERRORWORDS(exps) ->
1061         Ast0.ERRORWORDS(List.map (top_expression false Ast0.NONE) exps)
1062     | Ast0.OTHER(_) -> fail t "eliminated by top_level")
1063
1064 let rule tgt = List.map (top_level tgt)
1065
1066 (* --------------------------------------------------------------------- *)
1067 (* Entry points *)
1068
1069 let minus_arity code =
1070   rule Ast0.NONE code