type pretty_printers = {
expression : Ast_c.expression printer;
arg_list : (Ast_c.argument Ast_c.wrap2 list) printer;
+ arg : Ast_c.argument printer;
statement : Ast_c.statement printer;
decl : Ast_c.declaration printer;
field : Ast_c.field printer;
+ field_list : Ast_c.field list printer;
init : Ast_c.initialiser printer;
+ init_list : (Ast_c.initialiser wrap2 list) printer;
param : Ast_c.parameterType printer;
paramlist : (Ast_c.parameterType Ast_c.wrap2 list) printer;
ty : Ast_c.fullType printer;
start_block(); f(); pr_unindent() in
-
+ let pp_list printer l =
+ l +> List.iter (fun (e, opt) ->
+ assert (List.length opt <= 1); (* opt must be a comma? *)
+ opt +> List.iter (function x -> pr_elem x; pr_space());
+ printer e) in
let rec pp_expression = fun ((exp, typ), ii) ->
(match exp, ii with
statxs +> List.iter pp_statement_seq;
pr_elem ii2;
pr_elem i2;
- | Constructor (t, xs), lp::rp::i1::i2::iicommaopt ->
+ | Constructor (t, init), [lp;rp] ->
pr_elem lp;
pp_type t;
pr_elem rp;
- pr_elem i1;
- xs +> List.iter (fun (x, ii) ->
- assert (List.length ii <= 1);
- ii +> List.iter (function x -> pr_elem x; pr_space());
- pp_init x
- );
- iicommaopt +> List.iter pr_elem;
- pr_elem i2;
+ pp_init init
| ParenExpr (e), [i1;i2] -> pr_elem i1; pp_expression e; pr_elem i2;
+ | New (t), [i1] -> pr_elem i1; pp_argument t
+ | Delete(t), [i1] -> pr_elem i1; pp_expression t
+
| (Ident (_) | Constant _ | FunCall (_,_) | CondExpr (_,_,_)
| Sequence (_,_)
| Assignment (_,_,_)
| ArrayAccess (_,_) | RecordAccess (_,_) | RecordPtAccess (_,_)
| SizeOfExpr (_) | SizeOfType (_) | Cast (_,_)
| StatementExpr (_) | Constructor _
- | ParenExpr (_)),_ -> raise Impossible
+ | ParenExpr (_) | New (_) | Delete (_)),_ -> raise Impossible
);
if !Flag_parsing_c.pretty_print_type_info
pr_elem (Ast_c.fakeInfo() +> Ast_c.rewrap_str "*/");
end
- and pp_arg_list es =
- es +> List.iter (fun (e, opt) ->
- assert (List.length opt <= 1); (* opt must be a comma? *)
- opt +> List.iter (function x -> pr_elem x; pr_space());
- pp_argument e)
+ and pp_arg_list es = pp_list pp_argument es
and pp_argument argument =
let rec pp_action (ActMisc ii) = ii +> List.iter pr_elem in
in
match ty, iity with
+ | (NoType,_) -> ()
| (Pointer t, [i]) -> pp_base_type t sto
| (ParenType t, _) -> pp_base_type t sto
| (Array (eopt, t), [i1;i2]) -> pp_base_type t sto
(* | TypeOfExpr _ | TypeOfType _ *)
), _ -> raise Impossible
+ and pp_field_list fields = fields +> Common.print_between pr_nl pp_field
and pp_field = function
DeclarationField(FieldDeclList(onefield_multivars,iiptvirg))->
(match onefield_multivars with
match ty, iity with
(* the work is to do in base_type !! *)
+ | (NoType _, iis) -> ()
| (BaseType _, iis) -> print_ident ident
| (Enum (sopt, enumt), iis) -> print_ident ident
| (StructUnion (_, sopt, fields),iis) -> print_ident ident
and (pp_type_left: fullType -> unit) =
fun ((qu, iiqu), (ty, iity)) ->
match ty, iity with
+ (NoType,_) -> failwith "pp_type_left: unexpected NoType"
| (Pointer t, [i]) ->
pr_elem i;
iiqu +> List.iter pr_elem; (* le const est forcement apres le '*' *)
and pp_type_right (((qu, iiqu), (ty, iity)) : fullType) =
match ty, iity with
+ (NoType,_) -> failwith "pp_type_right: unexpected NoType"
| (Pointer t, [i]) -> pp_type_right t
| (Array (eopt, t), [i1;i2]) ->
pp_type_with_ident
(Some (s, iis)) (Some (storage, iisto))
returnType attrs;
- iniopt +> do_option (fun (iini, init) ->
- pr_elem iini;
- pp_init init);
+ (match iniopt with
+ Ast_c.NoInit -> ()
+ | Ast_c.ValInit(iini,init) -> pr_elem iini; pp_init init
+ | Ast_c.ConstrInit((init,[lp;rp])) ->
+ pr_elem lp; pp_arg_list init; pr_elem rp
+ | Ast_c.ConstrInit _ -> raise Impossible)
| None -> pp_type returnType
);
iivirg +> List.iter pr_elem;
pp_type_with_ident_rest
(Some (s, iis)) returnType attrs;
- iniopt +> do_option (fun (iini, init) ->
- pr_elem iini; pp_init init
- );
+ (match iniopt with
+ Ast_c.NoInit -> ()
+ | Ast_c.ValInit(iini,init) -> pr_elem iini; pp_init init
+ | Ast_c.ConstrInit((init,[lp;rp])) ->
+ pr_elem lp; pp_arg_list init; pr_elem rp
+ | Ast_c.ConstrInit _ -> raise Impossible);
| x -> raise Impossible
pr_elem iivirg;
- | MacroDecl ((s, es), iis::lp::rp::iiend::ifakestart::iisto) ->
+ | MacroDecl ((s, es, true), iis::lp::rp::iiend::ifakestart::iisto) ->
pr_elem ifakestart;
iisto +> List.iter pr_elem; (* static and const *)
pr_elem iis;
pr_elem rp;
pr_elem iiend;
- | (DeclList (_, _) | (MacroDecl _)) -> raise Impossible
+ | MacroDecl ((s, es, false), iis::lp::rp::ifakestart::iisto) ->
+ pr_elem ifakestart;
+ iisto +> List.iter pr_elem; (* static and const *)
+ pr_elem iis;
+ pr_elem lp;
+ es +> List.iter (fun (e, opt) ->
+ assert (List.length opt <= 1);
+ opt +> List.iter pr_elem;
+ pp_argument e;
+ );
+ pr_elem rp;
+
+ | MacroDeclInit
+ ((s, es, ini), iis::lp::rp::eq::iiend::ifakestart::iisto) ->
+ pr_elem ifakestart;
+ iisto +> List.iter pr_elem; (* static and const *)
+ pr_elem iis;
+ pr_elem lp;
+ es +> List.iter (fun (e, opt) ->
+ assert (List.length opt <= 1);
+ opt +> List.iter pr_elem;
+ pp_argument e;
+ );
+
+ pr_elem rp;
+ pr_elem eq;
+ pp_init ini;
+ pr_elem iiend;
+
+ | (DeclList (_, _) | (MacroDecl _) | (MacroDeclInit _)) ->
+ raise Impossible
(* ---------------------- *)
and pp_init (init, iinit) =
| InitList _ | InitExpr _
), _ -> raise Impossible
-
+ and pp_init_list ini = pp_list pp_init ini
and pp_designator = function
| DesignatorField (s), [i1; i2] ->
pr_elem i2;
| _ -> raise Impossible
- and pp_param_list paramst =
- paramst +> List.iter (fun (param,iicomma) ->
- assert ((List.length iicomma) <= 1);
- iicomma +> List.iter (function x -> pr_elem x; pr_space());
- pp_param param)
+ and pp_param_list paramst = pp_list pp_param paramst
(* ---------------------- *)
| DefineTodo -> pr2 "DefineTodo"
in
(match defkind with
- | DefineVar -> ()
+ | DefineVar | Undef -> ()
| DefineFunc (params, ii) ->
let (i1,i2) = tuple_of_list2 ii in
pr_elem i1;
define_val defval;
pr_elem ieol
- | Undef (s, ii) ->
- List.iter pr_elem ii
| PragmaAndCo (ii) ->
List.iter pr_elem ii in
{ expression = pp_expression;
arg_list = pp_arg_list;
+ arg = pp_argument;
statement = pp_statement;
decl = pp_decl;
field = pp_field;
+ field_list = pp_field_list;
init = pp_init;
+ init_list = pp_init_list;
param = pp_param;
- paramlist = pp_param_list;
+ paramlist = pp_param_list;
ty = pp_type;
type_with_ident = pp_type_with_ident;
toplevel = pp_toplevel;
let pp_arg_list_gen ~pr_elem ~pr_space =
(pp_elem_sp pr_elem pr_space).arg_list
+let pp_arg_gen ~pr_elem ~pr_space =
+ (pp_elem_sp pr_elem pr_space).arg
+
let pp_statement_gen ~pr_elem ~pr_space =
(pp_elem_sp pr_elem pr_space).statement
let pp_field_gen ~pr_elem ~pr_space =
(pp_elem_sp pr_elem pr_space).field
+let pp_field_list_gen ~pr_elem ~pr_space =
+ (pp_elem_sp pr_elem pr_space).field_list
+
let pp_init_gen ~pr_elem ~pr_space =
(pp_elem_sp pr_elem pr_space).init
+let pp_init_list_gen ~pr_elem ~pr_space =
+ (pp_elem_sp pr_elem pr_space).init_list
+
let pp_param_gen ~pr_elem ~pr_space =
(pp_elem_sp pr_elem pr_space).param
HCoop / bpt / coccinelle.git / blobdiff