Source file pr_o.ml

# 1 "pr_o.orig.ml"
(* camlp5r *)
(* pr_o.ml,v *)
(* Copyright (c) INRIA 2007-2017 *)

(* #directory "." *)
(* #load "q_MLast.cmo" *)
(* #load "pa_extfun.cmo" *)
(* #load "pa_extprint.cmo" *)
(* #load "pa_macro.cmo" *)
(* #load "pa_macro_print.cmo" *)
(* #load "pa_pprintf.cmo" *)

open Asttools
open Pretty
open Pcaml
open Prtools
open Versdep
open Mlsyntax.Original
open Pp_debug

let flag_add_locations = ref false
let flag_comments_in_phrases = Pcaml.flag_comments_in_phrases
let flag_equilibrate_cases = Pcaml.flag_equilibrate_cases
let flag_expand_letop_syntax = Pcaml.flag_expand_letop_syntax
let flag_extensions_are_irrefutable = ref true

let flag_horiz_let_in = ref true
let flag_semi_semi = ref false

let pr_attribute_body = Eprinter.make "pr_attribute_body"

let _ =
  Eprinter.clear pr_expr;
  Eprinter.clear pr_patt;
  Eprinter.clear pr_ctyp;
  Eprinter.clear pr_str_item;
  Eprinter.clear pr_sig_item;
  Eprinter.clear pr_longident;
  Eprinter.clear pr_module_expr;
  Eprinter.clear pr_module_type;
  Eprinter.clear pr_class_sig_item;
  Eprinter.clear pr_class_str_item;
  Eprinter.clear pr_class_expr;
  Eprinter.clear pr_class_type

(* general functions *)

let error loc msg = Ploc.raise loc (Failure msg)

let is_infix =
  let infixes = Hashtbl.create 73 in
  List.iter (fun s -> Hashtbl.add infixes s true)
    ["!="; "&&"; "*"; "**"; "*."; "+"; "+."; "-"; "-."; "/"; "/."; "<"; "<=";
     "<>"; "="; "=="; ">"; ">="; "@"; "^"; "asr"; "land"; "lor"; "lsl"; "lsr";
     "lxor"; "mod"; "or"; "||"; "~-"; "~-."];
  fun s -> try Hashtbl.find infixes s with Not_found -> false

let has_special_chars s =
  if String.length s = 0 then false
  else
    match s.[0] with
      '0'..'9' | 'A'..'Z' | 'a'..'z' | '_' -> false
    | _ -> true

let ocaml_char =
  function
    "'" -> "\\'"
  | "\\" -> "\\\\"
  | c -> c

let rec is_irrefut_patt =
  function
    MLast.PaAtt (_, p, _) -> is_irrefut_patt p
  | MLast.PaLid (_, Ploc.VaVal _) -> true
  | MLast.PaLong (_, MLast.LiUid (_, Ploc.VaVal "()"), Ploc.VaVal []) -> true
  | MLast.PaAny _ -> true
  | MLast.PaPfx (_, _, y) -> is_irrefut_patt y
  | MLast.PaAli (_, x, y) -> is_irrefut_patt x && is_irrefut_patt y
  | MLast.PaRec (_, Ploc.VaVal fpl) ->
      List.for_all (fun (_, p) -> is_irrefut_patt p) fpl
  | MLast.PaTyc (_, p, _) -> is_irrefut_patt p
  | MLast.PaTup (_, Ploc.VaVal pl, Ploc.VaVal _) ->
      List.for_all is_irrefut_patt pl
  | MLast.PaNty (_, Ploc.VaVal _) -> true
  | MLast.PaUnp (_, Ploc.VaVal _, Some _) -> true
  | MLast.PaUnp (_, Ploc.VaVal _, None) -> true
  | MLast.PaLab (_, _, Ploc.VaVal _) -> true
  | MLast.PaOlb (_, _, Ploc.VaVal _) -> true
  | MLast.PaExten (_, _) -> !flag_extensions_are_irrefutable
  | _ -> false

let rec get_defined_ident =
  function
    MLast.PaPfx (_, _, p) -> get_defined_ident p
  | MLast.PaAny _ -> []
  | MLast.PaLid (_, Ploc.VaVal x) -> [x]
  | MLast.PaAli (_, p1, p2) -> get_defined_ident p1 @ get_defined_ident p2
  | MLast.PaInt (_, Ploc.VaVal _, "") -> []
  | MLast.PaFlo (_, Ploc.VaVal _) -> []
  | MLast.PaStr (_, Ploc.VaVal _) -> []
  | MLast.PaChr (_, Ploc.VaVal _) -> []
  | MLast.PaArr (_, Ploc.VaVal pl) ->
      List.flatten (List.map get_defined_ident pl)
  | MLast.PaTup (_, Ploc.VaVal pl, Ploc.VaVal _) ->
      List.flatten (List.map get_defined_ident pl)
  | MLast.PaLong (_, MLast.LiUid (_, Ploc.VaVal _), Ploc.VaVal []) -> []
  | MLast.PaVrn (_, Ploc.VaVal _) -> []
  | MLast.PaTyp (_, Ploc.VaVal _) -> []
  | MLast.PaApp (_, p1, p2) -> get_defined_ident p1 @ get_defined_ident p2
  | MLast.PaRec (_, Ploc.VaVal lpl) ->
      List.flatten (List.map (fun (lab, p) -> get_defined_ident p) lpl)
  | MLast.PaOrp (_, p1, p2) -> get_defined_ident p1 @ get_defined_ident p2
  | MLast.PaRng (_, p1, p2) -> get_defined_ident p1 @ get_defined_ident p2
  | MLast.PaTyc (_, p, _) -> get_defined_ident p
  | MLast.PaLab (_, _, Ploc.VaVal None) -> []
  | MLast.PaLab (_, _, Ploc.VaVal (Some p)) -> get_defined_ident p
  | MLast.PaOlb (_, _, Ploc.VaVal None) -> []
  | MLast.PaOlb (_, MLast.PaLid (_, Ploc.VaVal s), Ploc.VaVal (Some _)) -> [s]
  | MLast.PaOlb
      (_, _,
       Ploc.VaVal
         (Some
            (MLast.ExOlb
               (_, MLast.PaLid (_, Ploc.VaVal s), Ploc.VaVal (Some e))))) ->
      [s]
  | MLast.PaAnt (_, p) -> get_defined_ident p
  | _ -> []

let not_impl name pc x =
  let desc =
    if Obj.tag (Obj.repr x) = Obj.tag (Obj.repr "") then
      "\"" ^ Obj.magic x ^ "\""
    else if Obj.is_block (Obj.repr x) then
      "tag = " ^ string_of_int (Obj.tag (Obj.repr x))
    else "int_val = " ^ string_of_int (Obj.magic x)
  in
  Pretty.sprintf "%s\"pr_o, not impl: %s; %s\"%s" pc.Pprintf.bef name
    (String.escaped desc) pc.Pprintf.aft

(* for 'lprintf' statement  *)

let expand_lprintf pc loc f =
  if !flag_add_locations then
    let (bl, bc, el, ec, len) = Ploc.get loc in
    Pprintf.sprint_break 1 0 pc
      (fun pc ->
         Pretty.sprintf "%s(*loc: [\"%s\": %d:%d-%d %d-%d] *)" pc.Pprintf.bef
           (Ploc.file_name loc) bl bc (bc + len) el ec)
      (fun pc -> (fun pc () -> f pc) pc ())
  else f pc

let is_keyword =
  let kwdhash = O_keywords.keywords_hash in fun s -> Hashtbl.mem kwdhash s

let var_escaped_bare v =
  if v.[0] = '*' || v.[String.length v - 1] = '*' then "( " ^ v ^ " )"
  else if is_infix v || has_special_chars v || is_letop v || is_andop v then
    "(" ^ v ^ ")"
  else if is_keyword v then sprintf "\\#%s" v
  else v

let var_escaped pc (loc, v) =
  let x = var_escaped_bare v in
  expand_lprintf pc loc
    (fun pc -> Pretty.sprintf "%s%s%s" pc.Pprintf.bef x pc.Pprintf.aft)

let var_escaped_noloc pc v = var_escaped pc (Ploc.dummy, v)

let cons_escaped pc (loc, v) =
  let x =
    match v with
      "True" -> "true"
    | "False" -> "false"
    | "True_" -> "True"
    | "False_" -> "False"
    | "[]" -> "[]"
    | "()" -> "()"
    | "::" -> "( :: )"
    | _ -> v
  in
  Pretty.sprintf "%s%s%s" pc.Pprintf.bef x pc.Pprintf.aft

let rec mod_ident pc (loc, sl) =
  match sl with
    [] -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft
  | [s] -> var_escaped pc (loc, s)
  | s :: sl ->
      mod_ident
        {pc with Pprintf.bef = Pretty.sprintf "%s%s." pc.Pprintf.bef s}
        (loc, sl)

let comma_after elem pc x =
  elem {pc with Pprintf.aft = Pretty.sprintf ",%s" pc.Pprintf.aft} x
let semi_after elem pc x =
  elem
    {pc with Pprintf.aft = Pretty.sprintf ";%s" pc.Pprintf.aft;
     Pprintf.dang = ";"}
    x
let semi_semi_after elem pc x =
  elem {pc with Pprintf.aft = Pretty.sprintf ";;%s" pc.Pprintf.aft} x
let op_after elem pc (x, op) =
  elem {pc with Pprintf.aft = Pretty.sprintf "%s%s" op pc.Pprintf.aft} x

let and_before elem pc x =
  elem {pc with Pprintf.bef = Pretty.sprintf "%sand " pc.Pprintf.bef} x
let bar_before elem pc x =
  elem {pc with Pprintf.bef = Pretty.sprintf "%s| " pc.Pprintf.bef} x
let space_before elem pc x =
  elem {pc with Pprintf.bef = Pretty.sprintf "%s " pc.Pprintf.bef} x

let andop_before elem pc (andop, _ as x) =
  elem {pc with Pprintf.bef = Pretty.sprintf "%s%s " pc.Pprintf.bef andop} x

let operator pc left right sh (loc, op) x y =
  let op = if op = "" then "" else " " ^ op in
  Pprintf.sprint_break 1 2 pc (fun pc -> left {pc with Pprintf.aft = op} x)
    (fun pc -> right pc y)

let left_operator pc loc sh unfold next x =
  let xl =
    let rec loop xl x op =
      match unfold x with
        Some (x1, op1, x2) -> loop ((x2, op) :: xl) x1 op1
      | None -> (x, op) :: xl
    in
    loop [] x ""
  in
  match xl with
    [x, _] -> next pc x
  | _ ->
      horiz_vertic (fun () -> hlist (op_after next) pc xl)
        (fun () -> plist next sh pc xl)

let right_operator pc loc sh unfold next x =
  let xl =
    let rec loop xl x =
      match unfold x with
        Some (x1, op, x2) -> loop ((x1, op) :: xl) x2
      | None -> List.rev ((x, "") :: xl)
    in
    loop [] x
  in
  match xl with
    [x, _] -> next pc x
  | _ ->
      horiz_vertic (fun () -> hlist (op_after next) pc xl)
        (fun () -> plist next sh pc xl)

let uidopt_to_maybe_blank =
  function
    Some s -> Pcaml.unvala s
  | None -> "_"

(*
 * Extensible printers
 *)

let expr = Eprinter.apply pr_expr
let patt = Eprinter.apply pr_patt
let simple_patt x = Eprinter.apply_level pr_patt "simple" x
let ctyp = Eprinter.apply pr_ctyp
let ctyp_below_alg_attribute x =
  Eprinter.apply_level pr_ctyp "below_alg_attribute" x
let str_item = Eprinter.apply pr_str_item
let sig_item = Eprinter.apply pr_sig_item
let longident = Eprinter.apply pr_longident
let module_expr = Eprinter.apply pr_module_expr
let module_type = Eprinter.apply pr_module_type
let module_type_level_sig = Eprinter.apply_level pr_module_type "sig"
let expr_fun_args ge = Extfun.apply !pr_expr_fun_args ge

let simple_patt = Eprinter.apply_level pr_patt "simple"
let expr1 = Eprinter.apply_level pr_expr "expr1"
let attribute_body = Eprinter.apply pr_attribute_body
let pr_attribute atstring pc attr =
  attribute_body
    {pc with Pprintf.bef = Pretty.sprintf "%s[%s" pc.Pprintf.bef atstring;
     Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
    (Pcaml.unvala attr)
let pr_extension atstring pc attr =
  attribute_body
    {pc with Pprintf.bef = Pretty.sprintf "%s[%s" pc.Pprintf.bef atstring;
     Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
    (Pcaml.unvala attr)

let longident_lident pc (lio, id) =
  match lio with
    None -> var_escaped_noloc pc (Pcaml.unvala id)
  | Some li ->
      Pretty.sprintf "%s%s"
        (longident {pc with Pprintf.aft = "."} (Pcaml.unvala li))
        (var_escaped_noloc {pc with Pprintf.bef = ""} (Pcaml.unvala id))

let comm_bef pc loc =
  if !flag_comments_in_phrases then Prtools.comm_bef pc.ind loc else ""

let only_spaces s =
  let rec loop i =
    if i = String.length s then true
    else if s.[i] = ' ' then loop (i + 1)
    else false
  in
  loop 0

let strip_heading_spaces s =
  let rec loop i =
    if i = String.length s then ""
    else if s.[i] = ' ' then loop (i + 1)
    else String.sub s i (String.length s - i)
  in
  loop 0

let strip_char c s =
  let s = string_copy (bytes_of_string s) in
  let rec loop i j =
    if i = string_length s then string_sub s 0 j
    else if string_get s i = '_' then loop (i + 1) j
    else begin string_set s j (string_get s i); loop (i + 1) (j + 1) end
  in
  bytes_to_string (loop 0 0)

(* expression with adding the possible comment before *)
let comm_expr expr pc z =
  let loc = MLast.loc_of_expr z in
  let ccc = comm_bef pc loc in
  if ccc = "" then expr pc z
  else if only_spaces pc.bef then sprintf "%s%s" ccc (expr pc z)
  else
    expr
      {pc with bef =
        sprintf "%s%s%s" pc.bef (strip_heading_spaces ccc)
          (String.make (String.length pc.bef) ' ')}
      z

(*
value comm_expr expr pc z =
  let loc = MLast.loc_of_expr z in
  let ccc = comm_bef pc loc in
  sprintf "%s%s" ccc (expr pc z)
;
*)

(* couple pattern/anytype with adding the possible comment before *)
let comm_patt_any f pc z =
  let ccc = comm_bef pc (MLast.loc_of_patt (fst z)) in
  sprintf "%s%s" ccc (f pc z)

let patt_as pc z =
  match z with
    MLast.PaAli (loc, x, y) ->
      let pc =
        {pc with Pprintf.aft =
          let pc = {pc with Pprintf.bef = ""} in
          patt {pc with Pprintf.bef = " as "} y}
      in
      patt pc x
  | z -> patt pc z

(* utilities specific to pr_o *)

let label_patt pc p =
  match p with
    MLast.PaPfx (loc, x, MLast.PaLid (_, Ploc.VaVal y)) ->
      Pretty.sprintf "%s%s" (longident {pc with Pprintf.aft = "."} x)
        (var_escaped {pc with Pprintf.bef = ""} (loc, y))
  | MLast.PaLid (loc, Ploc.VaVal y) -> var_escaped pc (loc, y)
  | z ->
      Ploc.raise (MLast.loc_of_patt z)
        (Failure (sprintf "label_patt %d" (Obj.tag (Obj.repr z))))


(* Basic displaying of a 'binding' (let, value, expr or patt record field).
   The pretty printing is done correctly, but there are no syntax shortcuts
   (e.g. "let f = fun x -> y" is *not* shortened as "let f x = y")

   Some functions follow (some of them with '_binding' in their name) which
   use syntax or pretty printing shortcuts.
*)
let binding pelem eelem pc (p, e, attrs) =
  Pprintf.sprint_break 1 2 pc (fun pc -> pelem {pc with Pprintf.aft = " ="} p)
    (fun pc ->
       Pretty.sprintf "%s%s" (eelem {pc with Pprintf.aft = ""} e)
         (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
            (Pcaml.unvala attrs)))

let record_binding is_last pc (p, e) =
  Pprintf.sprint_break 1 2 pc
    (fun pc -> label_patt {pc with Pprintf.aft = " ="} p)
    (fun pc ->
       expr1 {pc with Pprintf.dang = if is_last then pc.dang else ";"} e)

let is_polytype_constraint =
  function
    MLast.PaTyc (_, _, MLast.TyPol (_, Ploc.VaVal _, _)) -> true
  | MLast.PaTyc (_, _, MLast.TyPot (_, Ploc.VaVal _, _)) -> true
  | _ -> false

let _ =
  pr_expr_fun_args :=
    Extfun.extend Extfun.empty
      [Extfun.Eapp
         [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExFun"];
          Extfun.Evar ();
          Extfun.Eapp
            [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
             Extfun.Eapp
               [Extfun.Eacc [Extfun.Econ "::"];
                Extfun.Etup
                  [Extfun.Evar ();
                   Extfun.Eapp
                     [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                      Extfun.Eacc [Extfun.Econ "None"]];
                   Extfun.Evar ()];
                Extfun.Eacc [Extfun.Econ "[]"]]]],
       false,
       (function
          MLast.ExFun (_, Ploc.VaVal [p, Ploc.VaVal None, e]) as z ->
            Some
              (if is_irrefut_patt p then
                 let (pl, e) = expr_fun_args e in p :: pl, e
               else [], z)
        | _ -> None);
       Extfun.Evar (), false, (fun z -> Some ([], z))]

let expr_semi pc (e, is_last) =
  if not is_last then
    comm_expr expr
      {pc with Pprintf.aft = Pretty.sprintf ";%s" pc.Pprintf.aft;
       Pprintf.dang = ";"}
      e
  else comm_expr expr pc e

let expr_with_comm_except_if_sequence pc e =
  match e with
    MLast.ExSeq (_, Ploc.VaVal _) -> expr pc e
  | _ -> comm_expr expr pc e

(* Pretty printing improvements (optional):
   - prints "let f x = e" instead of "let f = fun x -> e"
   - if "e" is a type constraint, put the constraint after the params. E.g.
        let f x y = (e : t)
     is displayed:
        let f x y : t = e
   Cancellation of all these improvements could be done by changing calls
   to this function to a call to "binding expr" above.
*)
let let_binding pc (p, e, attrs) =
  let (pl, e) =
    match p with
      MLast.PaTyc (_, _, _) -> [], e
    | _ -> expr_fun_args e
  in
  let (p, e, tyo) =
    match p, e with
      MLast.PaTyc (_, MLast.PaAny _, _), _ -> p, e, None
    | MLast.PaAny _, _ -> p, e, None
    | MLast.PaTyc (_, p0, t), _ when is_polytype_constraint p -> p0, e, Some t
    | MLast.PaTyc (_, _, _), _ -> p, e, None
    | _, MLast.ExTyc (_, e, t) -> p, e, Some t
    | _ -> p, e, None
  in
  let patt_tycon tyo pc p =
    match tyo with
      Some t ->
        Pretty.sprintf "%s%s" (simple_patt {pc with Pprintf.aft = " : "} p)
          (ctyp {pc with Pprintf.bef = ""} t)
    | None -> simple_patt pc p
  in
  let pl = p :: pl in
  let pl = List.map (fun p -> p, "") pl in
  let pc = {pc with dang = ""} in
  match pc.aft with
    "" ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           plistl simple_patt (patt_tycon tyo) 4 {pc with Pprintf.aft = " ="}
             pl)
        (fun pc ->
           Pretty.sprintf "%s%s"
             (expr_with_comm_except_if_sequence
                {pc with Pprintf.aft = ""; Pprintf.dang = ""} e)
             (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                (Pcaml.unvala attrs)))
  | "in" ->
      Pprintf.sprint_break_all false pc
        (fun pc ->
           plistl simple_patt (patt_tycon tyo) 4 {pc with Pprintf.aft = " ="}
             pl)
        [1, 2,
         (fun pc ->
            Pretty.sprintf "%s%s"
              (expr_with_comm_except_if_sequence
                 {pc with Pprintf.aft = ""; Pprintf.dang = ""} e)
              (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                 (Pcaml.unvala attrs)));
         1, 0,
         (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)]
  | _ ->
      Pprintf.sprint_break_all false pc
        (fun pc ->
           plistl simple_patt (patt_tycon tyo) 4 {pc with Pprintf.aft = " ="}
             pl)
        [1, 2,
         (fun pc ->
            Pretty.sprintf "%s%s"
              (expr_with_comm_except_if_sequence
                 {pc with Pprintf.aft = ""; Pprintf.dang = ""} e)
              (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                 (Pcaml.unvala attrs)));
         0, 0,
         (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)]

let letop_binding pc (_, (p, e, attrs)) = let_binding pc (p, e, attrs)

let match_assoc force_vertic pc ((p, w, e), is_last) =
  let expr pc =
    function
      MLast.ExUnr _ -> Pretty.sprintf "%s.%s" pc.Pprintf.bef pc.Pprintf.aft
    | e -> expr pc e
  in
  let expr_with_comm_except_if_sequence pc =
    function
      MLast.ExUnr _ -> Pretty.sprintf "%s.%s" pc.Pprintf.bef pc.Pprintf.aft
    | e -> expr_with_comm_except_if_sequence pc e
  in
  let (pc_aft, pc_dang) = if not is_last then "", "|" else pc.aft, pc.dang in
  horiz_vertic
    (fun () ->
       if force_vertic then sprintf "\n"
       else
         Pretty.sprintf "%s%s%s" (patt_as {pc with Pprintf.aft = ""} p)
           ((fun pc ->
               function
                 Ploc.VaVal (Some e) ->
                   expr
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s when " pc.Pprintf.bef}
                     e
               | _ -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
              {pc with Pprintf.bef = ""; Pprintf.aft = " -> "} w)
           (comm_expr expr {pc with Pprintf.bef = ""; Pprintf.dang = pc_dang}
              e))
    (fun () ->
       Pprintf.sprint_break_all force_vertic pc
         (fun pc ->
            (fun pc ->
               function
                 Ploc.VaVal (Some e) ->
                   Pprintf.sprint_break 1 0 pc (fun pc -> patt_as pc p)
                     (fun pc ->
                        Pprintf.sprint_break 1 2 pc
                          (fun pc -> Pretty.sprintf "%swhen" pc.Pprintf.bef)
                          (fun pc ->
                             expr
                               {pc with Pprintf.aft =
                                 Pretty.sprintf " ->%s" pc.Pprintf.aft}
                               e))
               | _ ->
                   patt_as
                     {pc with Pprintf.aft =
                       Pretty.sprintf " ->%s" pc.Pprintf.aft}
                     p)
              pc w)
         [1, 2,
          (fun pc ->
             expr_with_comm_except_if_sequence
               {pc with Pprintf.dang = pc_dang} e)])

let match_assoc_sh force_vertic pc pwe =
  match_assoc force_vertic {pc with ind = pc.ind + 2} pwe

let match_assoc_list loc pc pwel =
  if pwel = [] then Pretty.sprintf "%s[]%s" pc.Pprintf.bef pc.Pprintf.aft
  else
    let force_vertic =
      if !flag_equilibrate_cases then
        let has_vertic =
          List.exists
            (fun (p, w, e as pwe) ->
               horiz_vertic
                 (fun () ->
                    let (_ : string) =
                      bar_before (match_assoc_sh false) pc (pwe, false)
                    in
                    false)
                 (fun () -> true))
            pwel
        in
        has_vertic
      else false
    in
    vlist3 (match_assoc_sh force_vertic)
      (bar_before (match_assoc_sh force_vertic))
      {pc with Pprintf.bef = Pretty.sprintf "%s  " pc.Pprintf.bef} pwel

let raise_match_failure pc loc =
  let fname = Ploc.file_name loc in
  let line = Ploc.line_nb loc in
  let char = Ploc.first_pos loc - Ploc.bol_pos loc in
  let e =
    MLast.ExApp
      (loc, MLast.ExLid (loc, Ploc.VaVal "raise"),
       MLast.ExApp
         (loc,
          MLast.ExLong (loc, MLast.LiUid (loc, Ploc.VaVal "Match_failure")),
          MLast.ExTup
            (loc,
             Ploc.VaVal
               [MLast.ExStr (loc, Ploc.VaVal (loc, Ploc.VaVal fname));
                MLast.ExInt (loc, Ploc.VaVal (string_of_int line), "");
                MLast.ExInt (loc, Ploc.VaVal (string_of_int char), "")])))
  in
  Eprinter.apply_level pr_expr "apply" pc e

let rec make_expr_list =
  function
    MLast.ExApp
      (_,
       MLast.ExApp (_, MLast.ExLong (_, MLast.LiUid (_, Ploc.VaVal "::")), x),
       y) ->
      let (xl, c) = make_expr_list y in x :: xl, c
  | MLast.ExLong (_, MLast.LiUid (_, Ploc.VaVal "[]")) -> [], None
  | x -> [], Some x

let rec make_patt_list =
  function
    MLast.PaApp
      (_,
       MLast.PaApp
         (_,
          MLast.PaLong (_, MLast.LiUid (_, Ploc.VaVal "::"), Ploc.VaVal []),
          x),
       y) ->
      let (xl, c) = make_patt_list y in x :: xl, c
  | MLast.PaLong (_, MLast.LiUid (_, Ploc.VaVal "[]"), Ploc.VaVal []) ->
      [], None
  | x -> [], Some x

let type_var pc v =
  if String.contains v '\'' then
    Pretty.sprintf "%s' %s%s" pc.Pprintf.bef v pc.Pprintf.aft
  else if is_keyword v then
    Pretty.sprintf "%s'\\#%s%s" pc.Pprintf.bef v pc.Pprintf.aft
  else Pretty.sprintf "%s'%s%s" pc.Pprintf.bef v pc.Pprintf.aft

let tv_or_blank pc =
  function
    Some v -> type_var pc v
  | None -> Pretty.sprintf "%s_%s" pc.Pprintf.bef pc.Pprintf.aft

let type_param pc (loc, (tv, vastr)) =
  let tv = Pcaml.unvala tv in
  let vastr = Pcaml.unvala vastr in
  tv_or_blank
    {pc with Pprintf.bef = Pretty.sprintf "%s%s" pc.Pprintf.bef vastr} tv

let type_constraint pc (t1, t2) =
  Pprintf.sprint_break 1 2 pc
    (fun pc ->
       ctyp
         {pc with Pprintf.bef =
           Pretty.sprintf "%s constraint " pc.Pprintf.bef;
          Pprintf.aft = " ="}
         t1)
    (fun pc -> ctyp pc t2)

let type_params pc (loc, tvl) =
  match tvl with
    [] -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft
  | [tv] ->
      type_param {pc with Pprintf.aft = Pretty.sprintf " %s" pc.Pprintf.aft}
        (loc, tv)
  | _ ->
      let tvl = List.map (fun tv -> loc, tv) tvl in
      hlistl (comma_after type_param) type_param
        {pc with Pprintf.bef = Pretty.sprintf "%s(" pc.Pprintf.bef;
         Pprintf.aft = Pretty.sprintf ") %s" pc.Pprintf.aft}
        tvl

let mem_tvar s tpl = List.exists (fun (t, _) -> Pcaml.unvala t = Some s) tpl

let type_decl pc td =
  let ((_, tn), is_decl, tp, pf, te, cl, attrs) =
    Pcaml.unvala td.MLast.tdNam, td.MLast.tdIsDecl, td.MLast.tdPrm,
    Pcaml.unvala td.MLast.tdPrv, td.MLast.tdDef, td.MLast.tdCon,
    td.MLast.tdAttributes
  in
  let asgn = if Pcaml.unvala is_decl then "=" else ":=" in
  match te with
    MLast.TyQuo (loc, Ploc.VaVal s)
    when
      not (mem_tvar s (Pcaml.unvala tp)) &&
      not
        (List.exists
           (fun (t1, t2) ->
              Ast2pt.ctyp_mentions s t1 || Ast2pt.ctyp_mentions s t2)
           (Pcaml.unvala cl)) ->
      Pretty.sprintf "%s%s%s%s"
        (type_params {pc with Pprintf.aft = ""} (loc, Pcaml.unvala tp))
        (var_escaped {pc with Pprintf.bef = ""; Pprintf.aft = ""}
           (loc, Pcaml.unvala tn))
        (hlist type_constraint {pc with Pprintf.bef = ""; Pprintf.aft = ""}
           (Pcaml.unvala cl))
        (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
           (Pcaml.unvala attrs))
  | _ ->
      let loc = MLast.loc_of_ctyp te in
      if pc.aft = "" then
        Pprintf.sprint_break 1 2 pc
          (fun pc ->
             Pretty.sprintf "%s%s"
               (type_params {pc with Pprintf.aft = ""} (loc, Pcaml.unvala tp))
               (var_escaped
                  {pc with Pprintf.bef = "";
                   Pprintf.aft = Pretty.sprintf " %s" asgn}
                  (loc, Pcaml.unvala tn)))
          (fun pc ->
             Pretty.sprintf "%s%s%s"
               (ctyp
                  {pc with Pprintf.bef =
                    Pretty.sprintf "%s%s" pc.Pprintf.bef
                      (if pf then "private " else "");
                   Pprintf.aft = ""}
                  te)
               (hlist type_constraint
                  {pc with Pprintf.bef = ""; Pprintf.aft = ""}
                  (Pcaml.unvala cl))
               (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                  (Pcaml.unvala attrs)))
      else
        horiz_vertic
          (fun () ->
             Pretty.sprintf "%s%s%s%s%s"
               (type_params {pc with Pprintf.aft = ""} (loc, Pcaml.unvala tp))
               (var_escaped
                  {pc with Pprintf.bef = "";
                   Pprintf.aft =
                     Pretty.sprintf " %s %s" asgn
                       (if pf then "private " else "")}
                  (loc, Pcaml.unvala tn))
               (ctyp {pc with Pprintf.bef = ""; Pprintf.aft = ""} te)
               (hlist type_constraint
                  {pc with Pprintf.bef = ""; Pprintf.aft = ""}
                  (Pcaml.unvala cl))
               (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                  (Pcaml.unvala attrs)))
          (fun () ->
             Pprintf.sprint_break_all false pc
               (fun pc ->
                  Pretty.sprintf "%s%s"
                    (type_params {pc with Pprintf.aft = ""}
                       (loc, Pcaml.unvala tp))
                    (var_escaped
                       {pc with Pprintf.bef = "";
                        Pprintf.aft = Pretty.sprintf " %s" asgn}
                       (loc, Pcaml.unvala tn)))
               [1, 2,
                (fun pc ->
                   Pretty.sprintf "%s%s%s"
                     (ctyp
                        {pc with Pprintf.bef =
                          Pretty.sprintf "%s%s" pc.Pprintf.bef
                            (if pf then "private " else "");
                         Pprintf.aft = ""}
                        te)
                     (hlist type_constraint
                        {pc with Pprintf.bef = ""; Pprintf.aft = ""}
                        (Pcaml.unvala cl))
                     (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                        (Pcaml.unvala attrs)));
                1, 0,
                (fun pc ->
                   Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)])

let label_decl pc (_, l, m, t, attrs) =
  Pprintf.sprint_break 1 2 pc
    (fun pc ->
       var_escaped_noloc
         {pc with Pprintf.bef =
           Pretty.sprintf "%s%s" pc.Pprintf.bef
             (if m then "mutable " else "");
          Pprintf.aft = " :"}
         l)
    (fun pc ->
       Pretty.sprintf "%s%s"
         (ctyp_below_alg_attribute {pc with Pprintf.aft = ""} t)
         (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
            (Pcaml.unvala attrs)))

let typevars_binder pc =
  function
    [] -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft
  | l ->
      hlist type_var
        {pc with Pprintf.aft = Pretty.sprintf " . %s" pc.Pprintf.aft} l

let cons_decl pc (loc, c, tyvars, tl, rto, alg_attrs) =
  let c = Pcaml.unvala c in
  let tl = Pcaml.unvala tl in
  if tl = [] then
    match Pcaml.unvala tyvars, Pcaml.unvala rto with
      [], Some rt ->
        Pretty.sprintf "%s%s%s"
          (cons_escaped {pc with Pprintf.aft = " : "} (loc, c))
          (ctyp_below_alg_attribute
             {pc with Pprintf.bef = ""; Pprintf.aft = ""} rt)
          (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
             (Pcaml.unvala alg_attrs))
    | l, Some rt ->
        Pretty.sprintf "%s%s%s%s"
          (cons_escaped {pc with Pprintf.aft = " : "} (loc, c))
          (typevars_binder {pc with Pprintf.bef = ""; Pprintf.aft = ""} l)
          (ctyp_below_alg_attribute
             {pc with Pprintf.bef = ""; Pprintf.aft = ""} rt)
          (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
             (Pcaml.unvala alg_attrs))
    | _, None ->
        Pretty.sprintf "%s%s"
          (cons_escaped {pc with Pprintf.aft = ""} (loc, c))
          (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
             (Pcaml.unvala alg_attrs))
  else
    let ctyp_apply = Eprinter.apply_level pr_ctyp "apply" in
    let tl = List.map (fun t -> t, " *") tl in
    match Pcaml.unvala tyvars, Pcaml.unvala rto with
      [], Some rt ->
        Pprintf.sprint_break 1 4 pc
          (fun pc -> cons_escaped {pc with Pprintf.aft = " :"} (loc, c))
          (fun pc ->
             Pretty.sprintf "%s%s%s"
               (plist ctyp_apply 2 {pc with Pprintf.aft = " -> "} tl)
               (ctyp_below_alg_attribute
                  {pc with Pprintf.bef = ""; Pprintf.aft = ""} rt)
               (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
                  (Pcaml.unvala alg_attrs)))
    | l, Some rt ->
        Pprintf.sprint_break 1 4 pc
          (fun pc -> cons_escaped {pc with Pprintf.aft = " :"} (loc, c))
          (fun pc ->
             Pretty.sprintf "%s%s%s%s"
               (typevars_binder {pc with Pprintf.aft = ""} l)
               (plist ctyp_apply 2
                  {pc with Pprintf.bef = ""; Pprintf.aft = " -> "} tl)
               (ctyp_below_alg_attribute
                  {pc with Pprintf.bef = ""; Pprintf.aft = ""} rt)
               (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
                  (Pcaml.unvala alg_attrs)))
    | _, None ->
        Pprintf.sprint_break 1 4 pc
          (fun pc -> cons_escaped {pc with Pprintf.aft = " of"} (loc, c))
          (fun pc ->
             Pretty.sprintf "%s%s"
               (plist ctyp_apply 2 {pc with Pprintf.aft = ""} tl)
               (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
                  (Pcaml.unvala alg_attrs)))

let extension_constructor loc pc ec =
  match ec with
    MLast.EcTuple (_, gc) -> cons_decl pc gc
  | MLast.EcRebind (loc, Ploc.VaVal e, Ploc.VaVal li, Ploc.VaVal alg_attrs) ->
      Pprintf.sprint_break 1 2 pc (fun pc -> cons_escaped pc (loc, e))
        (fun pc ->
           Pretty.sprintf "%s%s"
             (longident
                {pc with Pprintf.bef = Pretty.sprintf "%s= " pc.Pprintf.bef;
                 Pprintf.aft = ""}
                li)
             (hlist (pr_attribute "@") {pc with Pprintf.bef = ""} alg_attrs))
  | _ -> error loc "extension_constructor: internal error"

let has_ecs_with_params vdl =
  List.exists
    (function
       MLast.EcTuple (_, (_, _, _, tl, rto, _)) ->
         begin match tl with
           Ploc.VaVal [] -> false
         | _ -> true
         end
     | MLast.EcRebind (_, _, _, _) -> true)
    vdl

let extension_constructors loc pc vdl =
  horiz_vertic
    (fun () ->
       if has_ecs_with_params vdl then sprintf "\n"
       else
         hlist2 (extension_constructor loc)
           (bar_before (extension_constructor loc)) pc vdl)
    (fun () ->
       vlist2 (extension_constructor loc)
         (bar_before (extension_constructor loc))
         {pc with Pprintf.bef = Pretty.sprintf "%s  " pc.Pprintf.bef} vdl)

let type_extension loc pc te =
  let (tn, tp, pf, ecstrs, attrs) =
    Pcaml.unvala te.MLast.teNam, te.MLast.tePrm, Pcaml.unvala te.MLast.tePrv,
    te.MLast.teECs, te.MLast.teAttributes
  in
  if pc.aft = "" then
    Pprintf.sprint_break 1 2 pc
      (fun pc ->
         Pretty.sprintf "%s%s"
           (type_params {pc with Pprintf.aft = ""} (loc, Pcaml.unvala tp))
           (longident_lident {pc with Pprintf.bef = ""; Pprintf.aft = " +="}
              tn))
      (fun pc ->
         Pretty.sprintf "%s%s"
           (extension_constructors loc
              {pc with Pprintf.bef =
                Pretty.sprintf "%s%s" pc.Pprintf.bef
                  (if pf then "private " else "");
               Pprintf.aft = ""}
              (Pcaml.unvala ecstrs))
           (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
              (Pcaml.unvala attrs)))
  else
    horiz_vertic
      (fun () ->
         Pretty.sprintf "%s%s%s%s"
           (type_params {pc with Pprintf.aft = ""} (loc, Pcaml.unvala tp))
           (longident_lident
              {pc with Pprintf.bef = "";
               Pprintf.aft =
                 Pretty.sprintf " += %s" (if pf then "private " else "")}
              tn)
           (extension_constructors loc
              {pc with Pprintf.bef = ""; Pprintf.aft = ""}
              (Pcaml.unvala ecstrs))
           (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
              (Pcaml.unvala attrs)))
      (fun () ->
         Pprintf.sprint_break_all false pc
           (fun pc ->
              Pretty.sprintf "%s%s"
                (type_params {pc with Pprintf.aft = ""}
                   (loc, Pcaml.unvala tp))
                (longident_lident
                   {pc with Pprintf.bef = ""; Pprintf.aft = " +="} tn))
           [1, 2,
            (fun pc ->
               Pretty.sprintf "%s%s"
                 (extension_constructors loc
                    {pc with Pprintf.bef =
                      Pretty.sprintf "%s%s" pc.Pprintf.bef
                        (if pf then "private " else "");
                     Pprintf.aft = ""}
                    (Pcaml.unvala ecstrs))
                 (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                    (Pcaml.unvala attrs)));
            1, 0,
            (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)])

let has_cons_with_params vdl =
  List.exists
    (fun (_, _, _, tl, rto, _) ->
       match tl with
         Ploc.VaVal [] -> false
       | _ -> true)
    vdl

let alone_in_line pc =
  let rec loop i =
    if i >= String.length pc.bef then true
    else if pc.bef.[i] = ' ' then loop (i + 1)
    else false
  in
  (pc.aft = "" || pc.aft = ";") && pc.bef <> "" && loop 0

let equality_threshold = 0.51
let are_close f x1 x2 =
  let (s1, s2) =
    (* the two strings; this code tries to prevents computing possible
       too long lines (which might slow down the program) *)
    let v = !(Pretty.line_length) in
    Pretty.line_length := 2 * v;
    let s1 = horiz_vertic (fun _ -> Some (f x1)) (fun () -> None) in
    let s2 = horiz_vertic (fun _ -> Some (f x2)) (fun () -> None) in
    Pretty.line_length := v; s1, s2
  in
  match s1, s2 with
    Some s1, Some s2 ->
      (* one string at least could hold in the line; comparing them; if
         they are "close" to each other, return True, meaning that they
         should be displayed *both* in one line or *both* in several lines *)
      let (d1, d2) =
        let a1 = Array.init (String.length s1) (String.get s1) in
        let a2 = Array.init (String.length s2) (String.get s2) in Diff.f a1 a2
      in
      let eq =
        let rec loop i eq =
          if i = Array.length d1 then eq
          else loop (i + 1) (if d1.(i) then eq else eq + 1)
        in
        loop 0 0
      in
      let r1 = float eq /. float (Array.length d1) in
      let r2 = float eq /. float (Array.length d2) in
      r1 >= equality_threshold && r2 >= equality_threshold
  | _ -> false

(* if statement *)

let rec get_else_if =
  function
    MLast.ExIfe (_, e1, e2, e3) ->
      let (eel, e3) = get_else_if e3 in (e1, e2) :: eel, e3
  | e -> [], e

let if_then force_vertic curr pc (e1, e2) =
  horiz_vertic
    (fun () ->
       if force_vertic then sprintf "\n"
       else
         Pretty.sprintf "%s%s"
           (curr
              {pc with Pprintf.bef = Pretty.sprintf "%sif " pc.Pprintf.bef;
               Pprintf.aft = " then "; Pprintf.dang = ""}
              e1)
           (curr {pc with Pprintf.bef = ""} e2))
    (fun () ->
       Pprintf.sprint_break 1 2 pc
         (fun pc ->
            Pprintf.sprint_break 1 0 pc
              (fun pc ->
                 let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 3} in
                 curr
                   {pc with Pprintf.bef =
                     Pretty.sprintf "%sif " pc.Pprintf.bef;
                    Pprintf.dang = ""}
                   e1)
              (fun pc -> Pretty.sprintf "%sthen" pc.Pprintf.bef))
         (fun pc -> expr1 pc e2))

let else_if_then force_vertic curr pc (e1, e2) =
  horiz_vertic
    (fun () ->
       if force_vertic then sprintf "\n"
       else
         Pretty.sprintf "%s%s"
           (curr
              {pc with Pprintf.bef =
                Pretty.sprintf "%selse if " pc.Pprintf.bef;
               Pprintf.aft = " then "; Pprintf.dang = ""}
              e1)
           (curr {pc with Pprintf.bef = ""} e2))
    (fun () ->
       Pprintf.sprint_break 1 2 pc
         (fun pc ->
            Pprintf.sprint_break_all force_vertic pc
              (fun pc -> Pretty.sprintf "%selse if" pc.Pprintf.bef)
              [1, 2, (fun pc -> curr {pc with Pprintf.dang = ""} e1);
               1, 0, (fun pc -> Pretty.sprintf "%sthen" pc.Pprintf.bef)])
         (fun pc -> expr1 pc e2))

let loop_else_if_no_else force_vertic curr pc eel =
  let rec loop pc =
    function
      [e1, e2] ->
        Pprintf.sprint_break_all true pc
          (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
          [1, 0, (fun pc -> else_if_then force_vertic curr pc (e1, e2))]
    | (e1, e2) :: eel ->
        Pprintf.sprint_break_all true pc
          (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
          [1, 0,
           (fun pc ->
              Pretty.sprintf "%s%s"
                (else_if_then force_vertic curr
                   {pc with Pprintf.aft = ""; Pprintf.dang = "else"} (e1, e2))
                (loop {pc with Pprintf.bef = ""} eel))]
    | [] -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft
  in
  loop pc eel

let loop_else_if_and_else force_vertic curr pc (eel, e3) =
  let rec loop pc =
    function
      (e1, e2) :: eel ->
        Pprintf.sprint_break_all true pc
          (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
          [1, 0,
           (fun pc ->
              Pretty.sprintf "%s%s"
                (else_if_then force_vertic curr
                   {pc with Pprintf.aft = ""; Pprintf.dang = "else"} (e1, e2))
                (loop {pc with Pprintf.bef = ""} eel))]
    | [] ->
        Pprintf.sprint_break_all true pc
          (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
          [1, 0,
           (fun pc ->
              Pprintf.sprint_break 1 2 pc
                (fun pc -> Pretty.sprintf "%selse" pc.Pprintf.bef)
                (fun pc -> curr pc e3))]
  in
  loop pc eel

let if_case_has_vertic curr pc e1 e2 eel e3 =
  horiz_vertic
    (fun () ->
       let (_ : string) = if_then false curr {pc with aft = ""} (e1, e2) in
       false)
    (fun () -> true) ||
  List.exists
    (fun (e1, e2) ->
       horiz_vertic
         (fun () ->
            let (_ : string) =
              else_if_then false curr {pc with bef = tab pc.ind; aft = ""}
                (e1, e2)
            in
            false)
         (fun () -> true))
    eel ||
  horiz_vertic
    (fun () ->
       let (_ : string) =
         let pc = {pc with bef = tab pc.ind} in
         comm_expr curr
           {pc with Pprintf.bef = Pretty.sprintf "%selse " pc.Pprintf.bef} e3
       in
       false)
    (fun () -> true)

(* Expressions displayed without spaces separating elements; special
   for expressions as strings or arrays indexes (x.[...] or x.(...)).
   Applied only if only containing +, -, *, /, integers and variables. *)
let expr_short pc x =
  let rec expr1 pc z =
    match z with
      MLast.ExApp
        (_, MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x), y) ->
        if op = "+" || op = "-" then
          Pretty.sprintf "%s%s" (expr1 {pc with Pprintf.aft = op} x)
            (expr2 {pc with Pprintf.bef = ""} y)
        else expr2 pc z
    | _ -> expr2 pc z
  and expr2 pc z =
    match z with
      MLast.ExApp
        (_, MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x), y) ->
        if op = "*" || op = "/" then
          Pretty.sprintf "%s%s" (expr2 {pc with Pprintf.aft = op} x)
            (expr3 {pc with Pprintf.bef = ""} y)
        else expr3 pc z
    | _ -> expr3 pc z
  and expr3 pc z =
    match z with
      MLast.ExLid (loc, Ploc.VaVal v) ->
        if is_infix v || has_special_chars v then raise Exit
        else var_escaped pc (loc, v)
    | MLast.ExInt (_, Ploc.VaVal s, "") ->
        Pretty.sprintf "%s%s%s" pc.Pprintf.bef s pc.Pprintf.aft
    | MLast.ExApp
        (_, MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), _), _) ->
        if List.mem op ["+"; "-"; "*"; "/"] then
          expr1
            {pc with Pprintf.bef = Pretty.sprintf "%s(" pc.Pprintf.bef;
             Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
            z
        else raise Exit
    | _ -> raise Exit
  in
  try horiz_vertic (fun () -> expr1 pc x) (fun () -> raise Exit) with
    Exit -> expr pc x

(* definitions of printers *)

let flatten_sequ e =
  let rec get_sequence =
    function
      MLast.ExSeq (_, Ploc.VaVal el) -> Some el
    | _ -> None
  in
  match get_sequence e with
    Some el ->
      let rec list_of_sequence =
        function
          e :: el ->
            begin match get_sequence e with
              Some el1 -> list_of_sequence (el1 @ el)
            | None -> e :: list_of_sequence el
            end
        | [] -> []
      in
      Some (list_of_sequence el)
  | None -> None

let lident pc s = Pretty.sprintf "%s%s%s" pc.Pprintf.bef s pc.Pprintf.aft
let string pc s = Pretty.sprintf "%s\"%s\"%s" pc.Pprintf.bef s pc.Pprintf.aft

let external_decl pc (loc, n, tyvars, t, sl, attrs) =
  Pprintf.sprint_break 1 2 pc
    (fun pc ->
       var_escaped
         {pc with Pprintf.bef = Pretty.sprintf "%sexternal " pc.Pprintf.bef;
          Pprintf.aft = " :"}
         (loc, n))
    (fun pc ->
       let pc =
         {pc with Pprintf.aft =
           let pc = {pc with Pprintf.bef = ""} in
           Pretty.sprintf "%s%s"
             (hlist string {pc with Pprintf.bef = " = "; Pprintf.aft = ""} sl)
             (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""} attrs)}
       in
       Pretty.sprintf "%s%s"
         (typevars_binder {pc with Pprintf.aft = ""} tyvars)
         (ctyp {pc with Pprintf.bef = ""} t))

let exception_decl pc (loc, e, tl, id, alg_attrs, item_attrs) =
  let ctyp_apply = Eprinter.apply_level pr_ctyp "apply" in
  match id with
    [] ->
      begin match tl with
        [] ->
          Pretty.sprintf "%s%s%s"
            (cons_escaped
               {pc with Pprintf.bef =
                 Pretty.sprintf "%sexception " pc.Pprintf.bef;
                Pprintf.aft = ""}
               (loc, e))
            (hlist (pr_attribute "@")
               {pc with Pprintf.bef = ""; Pprintf.aft = ""} alg_attrs)
            (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""} item_attrs)
      | tl ->
          let tl = List.map (fun t -> t, " *") tl in
          Pprintf.sprint_break 1 2 pc
            (fun pc ->
               cons_escaped
                 {pc with Pprintf.bef =
                   Pretty.sprintf "%sexception " pc.Pprintf.bef;
                  Pprintf.aft = " of"}
                 (loc, e))
            (fun pc ->
               Pretty.sprintf "%s%s%s"
                 (plist ctyp_apply 2 {pc with Pprintf.aft = ""} tl)
                 (hlist (pr_attribute "@")
                    {pc with Pprintf.bef = ""; Pprintf.aft = ""} alg_attrs)
                 (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                    item_attrs))
      end
  | id ->
      match tl with
        [] ->
          Pprintf.sprint_break 1 2 pc
            (fun pc ->
               cons_escaped
                 {pc with Pprintf.bef =
                   Pretty.sprintf "%sexception " pc.Pprintf.bef;
                  Pprintf.aft = " ="}
                 (loc, e))
            (fun pc ->
               Pretty.sprintf "%s%s%s"
                 (mod_ident {pc with Pprintf.aft = ""} (loc, id))
                 (hlist (pr_attribute "@")
                    {pc with Pprintf.bef = ""; Pprintf.aft = ""} alg_attrs)
                 (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                    item_attrs))
      | tl ->
          let tl = List.map (fun t -> t, " *") tl in
          Pprintf.sprint_break 1 2 pc
            (fun pc ->
               Pprintf.sprint_break 1 2 pc
                 (fun pc ->
                    cons_escaped
                      {pc with Pprintf.bef =
                        Pretty.sprintf "%sexception " pc.Pprintf.bef;
                       Pprintf.aft = " of"}
                      (loc, e))
                 (fun pc ->
                    plist ctyp_apply 2 {pc with Pprintf.aft = " ="} tl))
            (fun pc ->
               Pretty.sprintf "%s%s%s"
                 (mod_ident {pc with Pprintf.aft = ""} (loc, id))
                 (hlist (pr_attribute "@")
                    {pc with Pprintf.bef = ""; Pprintf.aft = ""} alg_attrs)
                 (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                    item_attrs))

let functor_parameter_unvala arg =
  match arg with
    None -> None
  | Some (idopt, mt) ->
      Some (option_map Pcaml.unvala (Pcaml.unvala idopt), mt)

let str_module pref pc (m, me, item_attrs) =
  let m =
    match m with
      None -> "_"
    | Some s -> s
  in
  let (mal, me) =
    let rec loop =
      function
        MLast.MeFun (_, Ploc.VaVal arg, me) ->
          let (mal, me) = loop me in functor_parameter_unvala arg :: mal, me
      | me -> [], me
    in
    loop me
  in
  let module_arg pc =
    function
      Some (Some s, mt) ->
        Pprintf.sprint_break 1 1 pc
          (fun pc -> Pretty.sprintf "%s(%s :" pc.Pprintf.bef s)
          (fun pc ->
             module_type
               {pc with Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft} mt)
    | Some (None, mt) ->
        Pprintf.sprint_break 1 1 pc
          (fun pc -> Pretty.sprintf "%s(_ :" pc.Pprintf.bef)
          (fun pc ->
             module_type
               {pc with Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft} mt)
    | None -> Pretty.sprintf "%s()%s" pc.Pprintf.bef pc.Pprintf.aft
  in
  let (me, mto) =
    match me with
      MLast.MeTyc (_, me, mt) -> me, Some mt
    | _ -> me, None
  in
  if pc.aft = "" then
    match mto with
      Some mt ->
        Pprintf.sprint_break 1 2 pc
          (fun pc ->
             Pprintf.sprint_break 1 2 pc
               (fun pc ->
                  hlist module_arg
                    {pc with Pprintf.bef =
                      Pretty.sprintf "%s%s %s%s" pc.Pprintf.bef pref m
                        (if mal = [] then "" else " ");
                     Pprintf.aft = " :"}
                    mal)
               (fun pc -> module_type {pc with Pprintf.aft = " ="} mt))
          (fun pc ->
             Pretty.sprintf "%s%s" (module_expr {pc with Pprintf.aft = ""} me)
               (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                  (Pcaml.unvala item_attrs)))
    | None ->
        let mal = List.map (fun ma -> ma, "") mal in
        Pprintf.sprint_break 1 2 pc
          (fun pc ->
             plistb module_arg 2
               {pc with Pprintf.bef =
                 Pretty.sprintf "%s%s %s" pc.Pprintf.bef pref m;
                Pprintf.aft = " ="}
               mal)
          (fun pc ->
             Pretty.sprintf "%s%s" (module_expr {pc with Pprintf.aft = ""} me)
               (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                  (Pcaml.unvala item_attrs)))
  else
    match mto with
      Some mt ->
        Pprintf.sprint_break 0 0 pc
          (fun pc ->
             Pprintf.sprint_break 1 2 pc
               (fun pc ->
                  Pprintf.sprint_break 1 2 pc
                    (fun pc ->
                       hlist module_arg
                         {pc with Pprintf.bef =
                           Pretty.sprintf "%s%s %s%s" pc.Pprintf.bef pref m
                             (if mal = [] then "" else " ");
                          Pprintf.aft = " :"}
                         mal)
                    (fun pc -> module_type {pc with Pprintf.aft = " ="} mt))
               (fun pc ->
                  Pretty.sprintf "%s%s"
                    (module_expr {pc with Pprintf.aft = ""} me)
                    (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                       (Pcaml.unvala item_attrs))))
          (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
    | None ->
        let mal = List.map (fun ma -> ma, "") mal in
        Pprintf.sprint_break_all false pc
          (fun pc ->
             plistb module_arg 2
               {pc with Pprintf.bef =
                 Pretty.sprintf "%s%s %s" pc.Pprintf.bef pref m;
                Pprintf.aft = " ="}
               mal)
          [1, 2,
           (fun pc ->
              Pretty.sprintf "%s%s"
                (module_expr {pc with Pprintf.aft = ""} me)
                (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                   (Pcaml.unvala item_attrs)));
           0, 0,
           (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)]

let sig_module_or_module_type pref unfun defs pc (m, mt, item_attrs) =
  let m =
    match m with
      None -> "_"
    | Some s -> s
  in
  let (mal, mt) =
    if unfun then
      let rec loop =
        function
          MLast.MtFun (_, Ploc.VaVal arg, mt2) ->
            let (mal, mt) = loop mt2 in
            functor_parameter_unvala arg :: mal, mt
        | mt -> [], mt
      in
      loop mt
    else [], mt
  in
  let module_arg pc =
    function
      Some (Some s, mt) ->
        Pprintf.sprint_break 1 1 pc
          (fun pc -> Pretty.sprintf "%s(%s :" pc.Pprintf.bef s)
          (fun pc ->
             module_type
               {pc with Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft} mt)
    | Some (None, mt) ->
        Pprintf.sprint_break 1 1 pc
          (fun pc -> Pretty.sprintf "%s(_ :" pc.Pprintf.bef)
          (fun pc ->
             module_type
               {pc with Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft} mt)
    | None -> Pretty.sprintf "%s()%s" pc.Pprintf.bef pc.Pprintf.aft
  in
  match mt with
    MLast.MtQuo (_, Ploc.VaVal s) ->
      Pretty.sprintf "%s%s"
        (hlist module_arg
           {pc with Pprintf.bef =
             Pretty.sprintf "%s%s %s%s" pc.Pprintf.bef pref m
               (if mal = [] then "" else " ");
            Pprintf.aft = ""}
           mal)
        (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
           (Pcaml.unvala item_attrs))
  | _ ->
      let mal = List.map (fun ma -> ma, "") mal in
      if pc.aft = "" then
        Pprintf.sprint_break 1 2 pc
          (fun pc ->
             plistb module_arg 2
               {pc with Pprintf.bef =
                 Pretty.sprintf "%s%s %s" pc.Pprintf.bef pref m;
                Pprintf.aft = Pretty.sprintf " %s" defs}
               mal)
          (fun pc ->
             Pretty.sprintf "%s%s"
               (module_type_level_sig {pc with Pprintf.aft = ""} mt)
               (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                  (Pcaml.unvala item_attrs)))
      else
        Pprintf.sprint_break_all false pc
          (fun pc ->
             plistb module_arg 2
               {pc with Pprintf.bef =
                 Pretty.sprintf "%s%s %s" pc.Pprintf.bef pref m;
                Pprintf.aft = Pretty.sprintf " %s" defs}
               mal)
          [1, 2,
           (fun pc ->
              Pretty.sprintf "%s%s"
                (module_type_level_sig {pc with Pprintf.aft = ""} mt)
                (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                   (Pcaml.unvala item_attrs)));
           0, 0,
           (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)]

let str_or_sig_functor pc farg module_expr_or_type met =
  match farg with
    Some (Some s, mt) ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           Pprintf.sprint_break 1 0 pc
             (fun pc ->
                Pprintf.sprint_break 1 2 pc
                  (fun pc -> Pretty.sprintf "%sfunctor" pc.Pprintf.bef)
                  (fun pc ->
                     Pprintf.sprint_break 1 1 pc
                       (fun pc -> Pretty.sprintf "%s(%s :" pc.Pprintf.bef s)
                       (fun pc ->
                          module_type {pc with Pprintf.aft = ")"} mt)))
             (fun pc -> Pretty.sprintf "%s->" pc.Pprintf.bef))
        (fun pc -> module_expr_or_type pc met)
  | Some (None, mt) ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           Pprintf.sprint_break 1 0 pc
             (fun pc ->
                Pprintf.sprint_break 1 2 pc
                  (fun pc -> Pretty.sprintf "%sfunctor" pc.Pprintf.bef)
                  (fun pc ->
                     Pprintf.sprint_break 1 1 pc
                       (fun pc -> Pretty.sprintf "%s(_ :" pc.Pprintf.bef)
                       (fun pc ->
                          module_type {pc with Pprintf.aft = ")"} mt)))
             (fun pc -> Pretty.sprintf "%s->" pc.Pprintf.bef))
        (fun pc -> module_expr_or_type pc met)
  | None ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           Pprintf.sprint_break 1 0 pc
             (fun pc ->
                Pprintf.sprint_break 1 2 pc
                  (fun pc -> Pretty.sprintf "%sfunctor" pc.Pprintf.bef)
                  (fun pc -> Pretty.sprintf "%s()" pc.Pprintf.bef))
             (fun pc -> Pretty.sprintf "%s->" pc.Pprintf.bef))
        (fun pc -> module_expr_or_type pc met)

let con_typ_pat pc (loc, sl, tpl) =
  let tpl = List.map (fun tp -> loc, tp) tpl in
  match tpl with
    [] -> longident_lident pc sl
  | [tp] ->
      Pretty.sprintf "%s%s" (type_param {pc with Pprintf.aft = " "} tp)
        (longident_lident {pc with Pprintf.bef = ""} sl)
  | _ ->
      Pretty.sprintf "%s%s"
        (hlistl (comma_after type_param) type_param
           {pc with Pprintf.bef = Pretty.sprintf "%s(" pc.Pprintf.bef;
            Pprintf.aft = ") "}
           tpl)
        (longident_lident {pc with Pprintf.bef = ""} sl)

let with_constraint pc wc =
  match wc with
    MLast.WcTyp (loc, Ploc.VaVal sl, Ploc.VaVal tpl, Ploc.VaVal pf, t) ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           con_typ_pat
             {pc with Pprintf.bef = Pretty.sprintf "%stype " pc.Pprintf.bef;
              Pprintf.aft = " ="}
             (loc, sl, tpl))
        (fun pc ->
           ctyp
             {pc with Pprintf.bef =
               Pretty.sprintf "%s%s" pc.Pprintf.bef
                 (if pf then "private " else "")}
             t)
  | MLast.WcTys (loc, Ploc.VaVal sl, Ploc.VaVal tpl, t) ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           con_typ_pat
             {pc with Pprintf.bef = Pretty.sprintf "%stype " pc.Pprintf.bef;
              Pprintf.aft = " :="}
             (loc, sl, tpl))
        (fun pc -> ctyp pc t)
  | MLast.WcMod (loc, Ploc.VaVal sl, me) ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           longident
             {pc with Pprintf.bef = Pretty.sprintf "%smodule " pc.Pprintf.bef;
              Pprintf.aft = " ="}
             sl)
        (fun pc -> module_expr pc me)
  | MLast.WcMos (loc, Ploc.VaVal sl, me) ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           longident
             {pc with Pprintf.bef = Pretty.sprintf "%smodule " pc.Pprintf.bef;
              Pprintf.aft = " :="}
             sl)
        (fun pc -> module_expr pc me)
  | MLast.WcMty (loc, Ploc.VaVal sl, mt) ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           longident
             {pc with Pprintf.bef =
               Pretty.sprintf "%smodule type " pc.Pprintf.bef;
              Pprintf.aft = " ="}
             sl)
        (fun pc -> module_type pc mt)
  | MLast.WcMts (loc, Ploc.VaVal sl, mt) ->
      Pprintf.sprint_break 1 2 pc
        (fun pc ->
           longident
             {pc with Pprintf.bef =
               Pretty.sprintf "%smodule type " pc.Pprintf.bef;
              Pprintf.aft = " :="}
             sl)
        (fun pc -> module_type pc mt)
  | x -> not_impl "with_constraint" pc x

let is_unary =
  function
    "-" | "-." -> true
  | _ -> false

let unary op_pred expr pc x =
  match x with
    MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal f), _) when op_pred f ->
      expr
        {pc with Pprintf.bef = Pretty.sprintf "%s(" pc.Pprintf.bef;
         Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
        x
  | MLast.ExFle (_, _, Ploc.VaVal (None, Ploc.VaVal "val")) ->
      expr
        {pc with Pprintf.bef = Pretty.sprintf "%s(" pc.Pprintf.bef;
         Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
        x
  | x -> expr pc x
let map_option f =
  function
    Some x -> Some (f x)
  | None -> None

let pr_letlike letop pc loc rf pel e =
  horiz_vertic
    (fun () ->
       if not !flag_horiz_let_in then sprintf "\n"
       else if pc.dang = ";" then
         Pretty.sprintf "%s%s"
           (hlist2 letop_binding (andop_before letop_binding)
              {pc with Pprintf.bef =
                Pretty.sprintf "%s(%s%s " pc.Pprintf.bef letop
                  (if rf then " rec" else "");
               Pprintf.aft = " in "; Pprintf.dang = ""}
              pel)
           (comm_expr expr
              {pc with Pprintf.bef = "";
               Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft;
               Pprintf.dang = ""}
              e)
       else
         Pretty.sprintf "%s%s"
           (hlist2 letop_binding (andop_before letop_binding)
              {pc with Pprintf.bef =
                Pretty.sprintf "%s%s%s " pc.Pprintf.bef letop
                  (if rf then " rec" else "");
               Pprintf.aft = " in "; Pprintf.dang = ""}
              pel)
           (comm_expr expr {pc with Pprintf.bef = ""} e))
    (fun () ->
       if pc.dang = ";" then
         Pprintf.sprint_break_all false pc
           (fun pc ->
              vlist2 letop_binding (andop_before letop_binding)
                {pc with Pprintf.bef =
                  Pretty.sprintf "%sbegin %s%s " pc.Pprintf.bef letop
                    (if rf then " rec" else "");
                 Pprintf.aft = "in"; Pprintf.dang = ""}
                pel)
           [1, 2,
            (fun pc ->
               expr_with_comm_except_if_sequence {pc with Pprintf.dang = ""}
                 e);
            1, 0,
            (fun pc ->
               Pretty.sprintf "%send%s" pc.Pprintf.bef pc.Pprintf.aft)]
       else
         Pprintf.sprint_break 1 0 pc
           (fun pc ->
              vlist2 letop_binding (andop_before letop_binding)
                {pc with Pprintf.bef =
                  Pretty.sprintf "%s%s%s " pc.Pprintf.bef letop
                    (if rf then " rec" else "");
                 Pprintf.aft = "in"; Pprintf.dang = ""}
                pel)
           (fun pc ->
              (if Ploc.first_pos loc = Ploc.first_pos (MLast.loc_of_expr e)
               then
                 expr
               else expr_with_comm_except_if_sequence)
                pc e))

let _ =
  Eprinter.extend pr_attribute_body None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Etup
             [Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup [Extfun.Evar (); Extfun.Evar ()]];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaAttr"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]]]],
           false,
           (function
              Ploc.VaVal (_, id),
              MLast.PaAttr (_, Ploc.VaVal p, Some (Ploc.VaVal e)) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (space_before patt
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%s%s?" pc.Pprintf.bef id;
                           Pprintf.aft = " when "}
                          p)
                       (expr {pc with Pprintf.bef = ""} e))
            | _ -> None);
           Extfun.Etup
             [Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup [Extfun.Evar (); Extfun.Evar ()]];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaAttr"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              Ploc.VaVal (_, id), MLast.PaAttr (_, Ploc.VaVal p, None) ->
                Some
                  (fun curr next top bottom pc ->
                     space_before patt
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s%s?" pc.Pprintf.bef id}
                       p)
            | _ -> None);
           Extfun.Etup
             [Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup [Extfun.Evar (); Extfun.Evar ()]];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyAttr"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]]],
           false,
           (function
              Ploc.VaVal (_, id), MLast.TyAttr (_, Ploc.VaVal ty) ->
                Some
                  (fun curr next top bottom pc ->
                     space_before ctyp
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s%s:" pc.Pprintf.bef id}
                       ty)
            | _ -> None);
           Extfun.Etup
             [Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup [Extfun.Evar (); Extfun.Evar ()]];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SiAttr"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]]],
           false,
           (function
              Ploc.VaVal (_, id), MLast.SiAttr (_, Ploc.VaVal si) ->
                Some
                  (fun curr next top bottom pc ->
                     hlist (space_before (semi_semi_after sig_item))
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s%s:" pc.Pprintf.bef id}
                       si)
            | _ -> None);
           Extfun.Etup
             [Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup [Extfun.Evar (); Extfun.Evar ()]];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StAttr"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]]],
           false,
           (function
              Ploc.VaVal (_, id), MLast.StAttr (_, Ploc.VaVal st) ->
                Some
                  (fun curr next top bottom pc ->
                     hlist (space_before (semi_semi_after str_item))
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s%s" pc.Pprintf.bef id}
                       st)
            | _ -> None);
           Extfun.Etup
             [Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup [Extfun.Evar (); Extfun.Evar ()]];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StAttr"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "::"];
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "MLast"; Extfun.Econ "StExp"];
                          Extfun.Evar (); Extfun.Evar ();
                          Extfun.Eapp
                            [Extfun.Eacc
                               [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                             Extfun.Eacc [Extfun.Econ "[]"]]];
                       Extfun.Eacc [Extfun.Econ "[]"]]]]],
           false,
           (function
              Ploc.VaVal (_, id),
              MLast.StAttr
                (_, Ploc.VaVal [MLast.StExp (_, e, Ploc.VaVal [])]) ->
                Some
                  (fun curr next top bottom pc ->
                     space_before expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s%s" pc.Pprintf.bef id}
                       e)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_expr None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExSeq"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExSeq (loc, Ploc.VaVal el) as ge ->
                Some
                  (fun curr next top bottom pc ->
                     let el =
                       match flatten_sequ ge with
                         Some el -> el
                       | None -> el
                     in
                     horiz_vertic
                       (fun () ->
                          hlistl (semi_after (comm_expr expr))
                            (comm_expr expr) pc el)
                       (fun () -> vlist3 expr_semi expr_semi pc el))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "expr1",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExFor"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExFor (loc, v, e1, e2, Ploc.VaVal d, Ploc.VaVal el) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break_all false pc
                       (fun pc ->
                          Pprintf.sprint_break_all false pc
                            (fun pc ->
                               Pretty.sprintf "%s%s"
                                 (patt
                                    {pc with Pprintf.bef =
                                      Pretty.sprintf "%sfor " pc.Pprintf.bef;
                                     Pprintf.aft = " = "}
                                    v)
                                 (curr
                                    {pc with Pprintf.bef = "";
                                     Pprintf.aft =
                                       Pretty.sprintf " %s"
                                         (if d then "to" else "downto")}
                                    e1))
                            [1, 4, (fun pc -> curr pc e2);
                             1, 0,
                             (fun pc ->
                                Pretty.sprintf "%sdo" pc.Pprintf.bef)])
                       [1, 2,
                        (fun pc ->
                           hvlistl (semi_after curr) curr
                             {pc with Pprintf.dang = ""} el);
                        1, 0,
                        (fun pc ->
                           Pretty.sprintf "%sdone%s" pc.Pprintf.bef
                             pc.Pprintf.aft)])
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExWhi"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExWhi (loc, e1, Ploc.VaVal el) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break_all false pc
                       (fun pc ->
                          Pprintf.sprint_break_all false pc
                            (fun pc ->
                               Pretty.sprintf "%swhile" pc.Pprintf.bef)
                            [1, 2, (fun pc -> curr pc e1);
                             1, 0,
                             (fun pc ->
                                Pretty.sprintf "%sdo" pc.Pprintf.bef)])
                       [1, 2,
                        (fun pc -> hvlistl (semi_after expr) curr pc el);
                        1, 0,
                        (fun pc ->
                           Pretty.sprintf "%sdone%s" pc.Pprintf.bef
                             pc.Pprintf.aft)])
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLop"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExLop (_, Ploc.VaVal ovf, m, e) ->
                Some
                  (fun curr next top bottom pc ->
                     if pc.dang = ";" then
                       Pprintf.sprint_break 1 0 pc
                         (fun pc ->
                            let pc =
                              {pc with Pprintf.aft =
                                let pc = {pc with Pprintf.bef = ""} in
                                Pprintf.sprint_break_all false pc
                                  (fun pc ->
                                     module_expr
                                       {pc with Pprintf.bef =
                                         Pretty.sprintf "let open%s "
                                           (if ovf then "!" else "")}
                                       m)
                                  [1, 0, (fun pc -> "in")]}
                            in
                            Pretty.sprintf "%s(%s" pc.Pprintf.bef
                              pc.Pprintf.aft)
                         (fun pc ->
                            curr
                              {pc with Pprintf.aft =
                                Pretty.sprintf ")%s" pc.Pprintf.aft}
                              e)
                     else
                       Pprintf.sprint_break 1 0 pc
                         (fun pc ->
                            Pprintf.sprint_break_all false pc
                              (fun pc ->
                                 module_expr
                                   {pc with Pprintf.bef =
                                     Pretty.sprintf "%slet open%s "
                                       pc.Pprintf.bef
                                       (if ovf then "!" else "")}
                                   m)
                              [1, 0,
                               (fun pc ->
                                  Pretty.sprintf "%sin" pc.Pprintf.bef)])
                         (fun pc -> curr pc e))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLmd"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExLmd (_, Ploc.VaVal s, me, e) ->
                Some
                  (fun curr next top bottom pc ->
                     let s = uidopt_to_maybe_blank s in
                     if pc.dang = ";" then
                       Pprintf.sprint_break 1 0 pc
                         (fun pc ->
                            let pc =
                              {pc with Pprintf.aft =
                                let pc = {pc with Pprintf.bef = ""} in
                                Pprintf.sprint_break_all false pc
                                  (fun pc ->
                                     Pretty.sprintf "let module %s =" s)
                                  [1, 2, (fun pc -> module_expr pc me);
                                   1, 0, (fun pc -> "in")]}
                            in
                            Pretty.sprintf "%s(%s" pc.Pprintf.bef
                              pc.Pprintf.aft)
                         (fun pc ->
                            curr
                              {pc with Pprintf.aft =
                                Pretty.sprintf ")%s" pc.Pprintf.aft}
                              e)
                     else
                       Pprintf.sprint_break 1 0 pc
                         (fun pc ->
                            Pprintf.sprint_break_all false pc
                              (fun pc ->
                                 Pretty.sprintf "%slet module %s ="
                                   pc.Pprintf.bef s)
                              [1, 2, (fun pc -> module_expr pc me);
                               1, 0,
                               (fun pc ->
                                  Pretty.sprintf "%sin" pc.Pprintf.bef)])
                         (fun pc -> curr pc e))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLid"];
                    Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExFun"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "::"];
                       Extfun.Etup
                         [Extfun.Evar ();
                          Extfun.Eapp
                            [Extfun.Eacc
                               [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                             Extfun.Eacc [Extfun.Econ "None"]];
                          Extfun.Evar ()];
                       Extfun.Eacc [Extfun.Econ "[]"]]]]],
           true,
           (function
              MLast.ExApp
                (_, MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal letop), arg),
                 MLast.ExFun
                   (_, Ploc.VaVal [bindpat, Ploc.VaVal None, body])) as e0
              when not !(Pcaml.flag_expand_letop_syntax) && is_letop letop ->
                Some
                  (fun curr next top bottom pc ->
                     let loc = MLast.loc_of_expr e0 in
                     let rec deconstruct_ands acc =
                       function
                         MLast.PaTup
                           (_, Ploc.VaVal [pat1; pat2], Ploc.VaVal true),
                         MLast.ExApp
                           (_,
                            MLast.ExApp
                              (_, MLast.ExLid (_, Ploc.VaVal andop), e1),
                            e2)
                         when is_andop andop ->
                           deconstruct_ands
                             ((andop, (pat2, e2, Ploc.VaVal [])) :: acc)
                             (pat1, e1)
                       | pat, exp ->
                           ("andop_unused", (pat, exp, Ploc.VaVal [])) :: acc
                     in
                     let pel = deconstruct_ands [] (bindpat, arg) in
                     pr_letlike letop pc loc false pel body)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLEx"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExLEx
                (loc, Ploc.VaVal e, Ploc.VaVal tl, x, Ploc.VaVal attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc =
                       {pc with Pprintf.bef =
                         Pprintf.sprint_break_all false pc
                           (fun pc ->
                              exception_decl
                                {pc with Pprintf.bef =
                                  Pretty.sprintf "%slet " pc.Pprintf.bef}
                                (loc, e, tl, [], attrs, []))
                           [1, 0,
                            (fun pc -> Pretty.sprintf "%sin" pc.Pprintf.bef)]}
                     in
                     curr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s " pc.Pprintf.bef}
                       x)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLet"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.ExLet (loc, Ploc.VaVal rf, Ploc.VaVal pel, e) as e0 ->
                Some
                  (fun curr next top bottom pc ->
                     let andop = "and" in
                     let pel = List.map (fun x -> andop, x) pel in
                     let loc = MLast.loc_of_expr e0 in
                     pr_letlike "let" pc loc rf pel e)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExMat"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExMat (loc, e1, Ploc.VaVal pwel) as e ->
                Some
                  (fun curr next top bottom pc ->
                     let op =
                       match e with
                         MLast.ExTry (_, _, Ploc.VaVal _) -> "try"
                       | _ -> "match"
                     in
                     match pwel with
                       [p, wo, e] ->
                         horiz_vertic
                           (fun () ->
                              if List.mem pc.dang ["|"; ";"] then
                                Pretty.sprintf "%s%s"
                                  (expr
                                     {pc with Pprintf.bef =
                                       Pretty.sprintf "%s(%s " pc.Pprintf.bef
                                         op;
                                      Pprintf.aft = " with "}
                                     e1)
                                  (match_assoc false
                                     {pc with Pprintf.bef = "";
                                      Pprintf.aft =
                                        Pretty.sprintf ")%s" pc.Pprintf.aft}
                                     ((p, wo, e), true))
                              else
                                Pretty.sprintf "%s%s"
                                  (expr
                                     {pc with Pprintf.bef =
                                       Pretty.sprintf "%s%s " pc.Pprintf.bef
                                         op;
                                      Pprintf.aft = " with "}
                                     e1)
                                  (match_assoc false
                                     {pc with Pprintf.bef = ""}
                                     ((p, wo, e), true)))
                           (fun () ->
                              if List.mem pc.dang ["|"; ";"] then
                                match
                                  horiz_vertic
                                    (fun () ->
                                       let pc = {pc with aft = ""} in
                                       Some
                                         (expr
                                            {pc with Pprintf.bef =
                                              Pretty.sprintf "%sbegin %s "
                                                pc.Pprintf.bef op;
                                             Pprintf.aft =
                                               Pretty.sprintf " with%s"
                                                 pc.Pprintf.aft;
                                             Pprintf.dang = ""}
                                            e1))
                                    (fun () -> None)
                                with
                                  Some s1 ->
                                    let pc = {pc with bef = ""} in
                                    Pprintf.sprint_break 1 0 pc
                                      (fun pc ->
                                         Pprintf.sprint_break 1 2 pc
                                           (fun pc ->
                                              Pretty.sprintf "%s%s"
                                                pc.Pprintf.bef s1)
                                           (fun pc ->
                                              match_assoc false pc
                                                ((p, wo, e), true)))
                                      (fun pc ->
                                         Pretty.sprintf "%send%s"
                                           pc.Pprintf.bef pc.Pprintf.aft)
                                | None ->
                                    Pprintf.sprint_break_all false pc
                                      (fun pc ->
                                         Pretty.sprintf "%sbegin %s"
                                           pc.Pprintf.bef op)
                                      [1, 2,
                                       (fun pc ->
                                          expr {pc with Pprintf.dang = ""}
                                            e1);
                                       1, 0,
                                       (fun pc ->
                                          match_assoc false
                                            {pc with Pprintf.bef =
                                              Pretty.sprintf "%swith "
                                                pc.Pprintf.bef}
                                            ((p, wo, e), true));
                                       1, 0,
                                       (fun pc ->
                                          Pretty.sprintf "%send%s"
                                            pc.Pprintf.bef pc.Pprintf.aft)]
                              else
                                match
                                  horiz_vertic
                                    (fun () ->
                                       let pc = {pc with aft = ""} in
                                       Some
                                         (expr
                                            {pc with Pprintf.bef =
                                              Pretty.sprintf "%s%s "
                                                pc.Pprintf.bef op;
                                             Pprintf.aft =
                                               Pretty.sprintf " with%s"
                                                 pc.Pprintf.aft;
                                             Pprintf.dang = ""}
                                            e1))
                                    (fun () -> None)
                                with
                                  Some _ ->
                                    Pprintf.sprint_break 1 2 pc
                                      (fun pc ->
                                         expr
                                           {pc with Pprintf.bef =
                                             Pretty.sprintf "%s%s "
                                               pc.Pprintf.bef op;
                                            Pprintf.aft = " with";
                                            Pprintf.dang = ""}
                                           e1)
                                      (fun pc ->
                                         match_assoc false pc
                                           ((p, wo, e), true))
                                | None ->
                                    Pprintf.sprint_break_all false pc
                                      (fun pc ->
                                         Pretty.sprintf "%s%s" pc.Pprintf.bef
                                           op)
                                      [1, 2,
                                       (fun pc ->
                                          expr {pc with Pprintf.dang = ""}
                                            e1);
                                       1, 0,
                                       (fun pc ->
                                          match_assoc false
                                            {pc with Pprintf.bef =
                                              Pretty.sprintf "%swith "
                                                pc.Pprintf.bef}
                                            ((p, wo, e), true))])
                     | [] -> raise_match_failure pc (MLast.loc_of_expr e)
                     | _ ->
                         if List.mem pc.dang ["|"; ";"] then
                           Pprintf.sprint_break 1 0 pc
                             (fun pc ->
                                Pprintf.sprint_break 1 0 pc
                                  (fun pc ->
                                     Pprintf.sprint_break_all false pc
                                       (fun pc ->
                                          Pretty.sprintf "%sbegin %s"
                                            pc.Pprintf.bef op)
                                       [1, 2, (fun pc -> expr pc e1);
                                        1, 0,
                                        (fun pc ->
                                           Pretty.sprintf "%swith"
                                             pc.Pprintf.bef)])
                                  (fun pc ->
                                     match_assoc_list loc
                                       {pc with Pprintf.dang = ""} pwel))
                             (fun pc ->
                                Pretty.sprintf "%send%s" pc.Pprintf.bef
                                  pc.Pprintf.aft)
                         else
                           Pprintf.sprint_break 1 0 pc
                             (fun pc ->
                                Pprintf.sprint_break_all false pc
                                  (fun pc ->
                                     Pretty.sprintf "%s%s" pc.Pprintf.bef op)
                                  [1, 2, (fun pc -> expr pc e1);
                                   1, 0,
                                   (fun pc ->
                                      Pretty.sprintf "%swith"
                                        pc.Pprintf.bef)])
                             (fun pc -> match_assoc_list loc pc pwel))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExTry"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExTry (loc, e1, Ploc.VaVal pwel) as e ->
                Some
                  (fun curr next top bottom pc ->
                     let op =
                       match e with
                         MLast.ExTry (_, _, Ploc.VaVal _) -> "try"
                       | _ -> "match"
                     in
                     match pwel with
                       [p, wo, e] ->
                         horiz_vertic
                           (fun () ->
                              if List.mem pc.dang ["|"; ";"] then
                                Pretty.sprintf "%s%s"
                                  (expr
                                     {pc with Pprintf.bef =
                                       Pretty.sprintf "%s(%s " pc.Pprintf.bef
                                         op;
                                      Pprintf.aft = " with "}
                                     e1)
                                  (match_assoc false
                                     {pc with Pprintf.bef = "";
                                      Pprintf.aft =
                                        Pretty.sprintf ")%s" pc.Pprintf.aft}
                                     ((p, wo, e), true))
                              else
                                Pretty.sprintf "%s%s"
                                  (expr
                                     {pc with Pprintf.bef =
                                       Pretty.sprintf "%s%s " pc.Pprintf.bef
                                         op;
                                      Pprintf.aft = " with "}
                                     e1)
                                  (match_assoc false
                                     {pc with Pprintf.bef = ""}
                                     ((p, wo, e), true)))
                           (fun () ->
                              if List.mem pc.dang ["|"; ";"] then
                                match
                                  horiz_vertic
                                    (fun () ->
                                       let pc = {pc with aft = ""} in
                                       Some
                                         (expr
                                            {pc with Pprintf.bef =
                                              Pretty.sprintf "%sbegin %s "
                                                pc.Pprintf.bef op;
                                             Pprintf.aft =
                                               Pretty.sprintf " with%s"
                                                 pc.Pprintf.aft;
                                             Pprintf.dang = ""}
                                            e1))
                                    (fun () -> None)
                                with
                                  Some s1 ->
                                    let pc = {pc with bef = ""} in
                                    Pprintf.sprint_break 1 0 pc
                                      (fun pc ->
                                         Pprintf.sprint_break 1 2 pc
                                           (fun pc ->
                                              Pretty.sprintf "%s%s"
                                                pc.Pprintf.bef s1)
                                           (fun pc ->
                                              match_assoc false pc
                                                ((p, wo, e), true)))
                                      (fun pc ->
                                         Pretty.sprintf "%send%s"
                                           pc.Pprintf.bef pc.Pprintf.aft)
                                | None ->
                                    Pprintf.sprint_break_all false pc
                                      (fun pc ->
                                         Pretty.sprintf "%sbegin %s"
                                           pc.Pprintf.bef op)
                                      [1, 2,
                                       (fun pc ->
                                          expr {pc with Pprintf.dang = ""}
                                            e1);
                                       1, 0,
                                       (fun pc ->
                                          match_assoc false
                                            {pc with Pprintf.bef =
                                              Pretty.sprintf "%swith "
                                                pc.Pprintf.bef}
                                            ((p, wo, e), true));
                                       1, 0,
                                       (fun pc ->
                                          Pretty.sprintf "%send%s"
                                            pc.Pprintf.bef pc.Pprintf.aft)]
                              else
                                match
                                  horiz_vertic
                                    (fun () ->
                                       let pc = {pc with aft = ""} in
                                       Some
                                         (expr
                                            {pc with Pprintf.bef =
                                              Pretty.sprintf "%s%s "
                                                pc.Pprintf.bef op;
                                             Pprintf.aft =
                                               Pretty.sprintf " with%s"
                                                 pc.Pprintf.aft;
                                             Pprintf.dang = ""}
                                            e1))
                                    (fun () -> None)
                                with
                                  Some _ ->
                                    Pprintf.sprint_break 1 2 pc
                                      (fun pc ->
                                         expr
                                           {pc with Pprintf.bef =
                                             Pretty.sprintf "%s%s "
                                               pc.Pprintf.bef op;
                                            Pprintf.aft = " with";
                                            Pprintf.dang = ""}
                                           e1)
                                      (fun pc ->
                                         match_assoc false pc
                                           ((p, wo, e), true))
                                | None ->
                                    Pprintf.sprint_break_all false pc
                                      (fun pc ->
                                         Pretty.sprintf "%s%s" pc.Pprintf.bef
                                           op)
                                      [1, 2,
                                       (fun pc ->
                                          expr {pc with Pprintf.dang = ""}
                                            e1);
                                       1, 0,
                                       (fun pc ->
                                          match_assoc false
                                            {pc with Pprintf.bef =
                                              Pretty.sprintf "%swith "
                                                pc.Pprintf.bef}
                                            ((p, wo, e), true))])
                     | [] -> raise_match_failure pc (MLast.loc_of_expr e)
                     | _ ->
                         if List.mem pc.dang ["|"; ";"] then
                           Pprintf.sprint_break 1 0 pc
                             (fun pc ->
                                Pprintf.sprint_break 1 0 pc
                                  (fun pc ->
                                     Pprintf.sprint_break_all false pc
                                       (fun pc ->
                                          Pretty.sprintf "%sbegin %s"
                                            pc.Pprintf.bef op)
                                       [1, 2, (fun pc -> expr pc e1);
                                        1, 0,
                                        (fun pc ->
                                           Pretty.sprintf "%swith"
                                             pc.Pprintf.bef)])
                                  (fun pc ->
                                     match_assoc_list loc
                                       {pc with Pprintf.dang = ""} pwel))
                             (fun pc ->
                                Pretty.sprintf "%send%s" pc.Pprintf.bef
                                  pc.Pprintf.aft)
                         else
                           Pprintf.sprint_break 1 0 pc
                             (fun pc ->
                                Pprintf.sprint_break_all false pc
                                  (fun pc ->
                                     Pretty.sprintf "%s%s" pc.Pprintf.bef op)
                                  [1, 2, (fun pc -> expr pc e1);
                                   1, 0,
                                   (fun pc ->
                                      Pretty.sprintf "%swith"
                                        pc.Pprintf.bef)])
                             (fun pc -> match_assoc_list loc pc pwel))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExFun"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExFun (loc, Ploc.VaVal pwel) as ge ->
                Some
                  (fun curr next top bottom pc ->
                     let use_function =
                       List.exists
                         (function
                            _, _, MLast.ExUnr _ -> true
                          | _ -> false)
                         pwel
                     in
                     let funtok =
                       if use_function then "function" else "fun"
                     in
                     match pwel with
                       [p1, Ploc.VaVal None, e1] when is_irrefut_patt p1 ->
                         let (pl, e1) = expr_fun_args e1 in
                         let pl = p1 :: pl in
                         let simple_patt =
                           Eprinter.apply_level pr_patt "simple"
                         in
                         let pl = List.map (fun p -> p, "") pl in
                         let comm_expr expr =
                           match e1 with
                             MLast.ExSeq (_, Ploc.VaVal _) -> expr
                           | MLast.ExUnr _ ->
                               (fun pc _ ->
                                  Pretty.sprintf "%s.%s" pc.Pprintf.bef
                                    pc.Pprintf.aft)
                           | _ -> comm_expr expr
                         in
                         if List.mem pc.dang ["|"; ";"] then
                           Pprintf.sprint_break 1 3 pc
                             (fun pc ->
                                plist simple_patt 4
                                  {pc with Pprintf.bef =
                                    Pretty.sprintf "%s(%s " pc.Pprintf.bef
                                      funtok;
                                   Pprintf.aft = " ->"}
                                  pl)
                             (fun pc ->
                                comm_expr expr
                                  {pc with Pprintf.aft =
                                    Pretty.sprintf ")%s" pc.Pprintf.aft;
                                   Pprintf.dang = ""}
                                  e1)
                         else
                           Pprintf.sprint_break 1 2 pc
                             (fun pc ->
                                plist simple_patt 4
                                  {pc with Pprintf.bef =
                                    Pretty.sprintf "%s%s " pc.Pprintf.bef
                                      funtok;
                                   Pprintf.aft = " ->"}
                                  pl)
                             (fun pc -> comm_expr expr pc e1)
                     | [] ->
                         let loc = MLast.loc_of_expr ge in
                         if List.mem pc.dang ["|"; ";"] then
                           Pprintf.sprint_break 1 2 pc
                             (fun pc ->
                                Pretty.sprintf "%s(fun _ ->" pc.Pprintf.bef)
                             (fun pc ->
                                raise_match_failure
                                  {pc with Pprintf.aft =
                                    Pretty.sprintf ")%s" pc.Pprintf.aft}
                                  loc)
                         else
                           Pprintf.sprint_break 1 2 pc
                             (fun pc ->
                                Pretty.sprintf "%sfun _ ->" pc.Pprintf.bef)
                             (fun pc -> raise_match_failure pc loc)
                     | pwel ->
                         if List.mem pc.dang ["|"; ";"] then
                           let pc =
                             {pc with Pprintf.ind = pc.Pprintf.ind + 1}
                           in
                           Pprintf.sprint_break 1 0 pc
                             (fun pc ->
                                Pretty.sprintf "%s(function" pc.Pprintf.bef)
                             (fun pc ->
                                match_assoc_list loc
                                  {pc with Pprintf.aft =
                                    Pretty.sprintf ")%s" pc.Pprintf.aft}
                                  pwel)
                         else
                           Pprintf.sprint_break_all true pc
                             (fun pc ->
                                Pretty.sprintf "%sfunction" pc.Pprintf.bef)
                             [1, 0, (fun pc -> match_assoc_list loc pc pwel)])
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExIfe"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExIfe (_, e1, e2, e3) as ge ->
                Some
                  (fun curr next top bottom pc ->
                     horiz_vertic
                       (fun () ->
                          match e3 with
                            MLast.ExLong
                              (_, MLast.LiUid (_, Ploc.VaVal "()")) ->
                              if pc.dang = "else" then next pc ge
                              else
                                Pretty.sprintf "%s%s"
                                  (curr
                                     {pc with Pprintf.bef =
                                       Pretty.sprintf "%sif " pc.Pprintf.bef;
                                      Pprintf.aft = " then ";
                                      Pprintf.dang = ""}
                                     e1)
                                  (curr {pc with Pprintf.bef = ""} e2)
                          | _ ->
                              Pretty.sprintf "%s%s%s"
                                (curr
                                   {pc with Pprintf.bef =
                                     Pretty.sprintf "%sif " pc.Pprintf.bef;
                                    Pprintf.aft = " then "; Pprintf.dang = ""}
                                   e1)
                                (curr
                                   {pc with Pprintf.bef = "";
                                    Pprintf.aft = " else "; Pprintf.dang = ""}
                                   e2)
                                (curr {pc with Pprintf.bef = ""} e3))
                       (fun () ->
                          let (force_vertic, eel, e3) =
                            if !flag_equilibrate_cases then
                              let (eel, e3) =
                                let then_and_else_are_close =
                                  are_close
                                    (curr {pc with bef = ""; aft = ""}) e2 e3
                                in
                                (* if "then" and "else" cases are close, don't break
                                   the "else" part into its possible "else if" in
                                   order to display "then" and "else" symmetrically *)
                                if then_and_else_are_close then [], e3
                                else get_else_if e3
                              in
                              (* if a case does not fit on line, all cases must be cut *)
                              let has_vertic =
                                if_case_has_vertic curr pc e1 e2 eel e3
                              in
                              has_vertic, eel, e3
                            else
                              let (eel, e3) = get_else_if e3 in false, eel, e3
                          in
                          match e3 with
                            MLast.ExLong
                              (_, MLast.LiUid (_, Ploc.VaVal "()")) ->
                              if pc.dang = "else" then next pc ge
                              else if eel = [] then
                                if_then force_vertic curr pc (e1, e2)
                              else
                                Pretty.sprintf "%s%s"
                                  (if_then force_vertic curr
                                     {pc with Pprintf.aft = "";
                                      Pprintf.dang = "else"}
                                     (e1, e2))
                                  (loop_else_if_no_else force_vertic curr
                                     {pc with Pprintf.bef = ""} eel)
                          | _ ->
                              Pretty.sprintf "%s%s"
                                (if_then force_vertic curr
                                   {pc with Pprintf.aft = "";
                                    Pprintf.dang = "else"}
                                   (e1, e2))
                                (loop_else_if_and_else force_vertic curr
                                   {pc with Pprintf.bef = ""} (eel, e3))))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "tuple",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExTup"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExTup (_, Ploc.VaVal el) ->
                Some
                  (fun curr next top bottom pc ->
                     let el = List.map (fun e -> e, ",") el in
                     plist next 0 pc el)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "assign",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExAss"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExAss (loc, x, y) ->
                Some
                  (fun curr next top bottom pc ->
                     operator pc next expr 2 (loc, "<-") x y)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExAss"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExFle"];
                 Extfun.Evar (); Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Etup
                      [Extfun.Eacc [Extfun.Econ "None"];
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                          Extfun.Estr "val"]]]];
              Extfun.Evar ()],
           false,
           (function
              MLast.ExAss
                (loc, MLast.ExFle (_, x, Ploc.VaVal (None, Ploc.VaVal "val")),
                 y) ->
                Some
                  (fun curr next top bottom pc ->
                     operator pc next expr 2 (loc, ":=") x y)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "or",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let unfold =
                     function
                       MLast.ExApp
                         (_,
                          MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x),
                          y) ->
                         if List.mem op ["||"; "or"] then
                           Some (x, " " ^ op, y)
                         else None
                     | _ -> None
                   in
                   let loc = MLast.loc_of_expr z in
                   right_operator pc loc 0 unfold next z))]);
     Some "and",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let unfold =
                     function
                       MLast.ExApp
                         (_,
                          MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x),
                          y) ->
                         if List.mem op ["&&"; "&"] then Some (x, " " ^ op, y)
                         else None
                     | _ -> None
                   in
                   let loc = MLast.loc_of_expr z in
                   right_operator pc loc 0 unfold next z))]);
     Some "less",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLid"];
                    Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.ExApp
                (loc, MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x),
                 y) as z ->
                Some
                  (fun curr next top bottom pc ->
                     if List.mem op
                          ["!="; "<"; "<="; "<>"; "="; "=="; ">"; ">="] ||
                        is_infixop0 op
                     then
                       operator pc next next 0 (loc, op) x y
                     else next pc z)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "concat",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let unfold =
                     function
                       MLast.ExApp
                         (_,
                          MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x),
                          y) ->
                         if List.mem op ["^"; "@"] || is_infixop1 op then
                           Some (x, " " ^ op, y)
                         else None
                     | _ -> None
                   in
                   let loc = MLast.loc_of_expr z in
                   right_operator pc loc 0 unfold next z))]);
     Some "alg_attribute",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExAtt"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExAtt (_, e, Ploc.VaVal attr) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = "[@"} e)
                       (attribute_body
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
                          attr))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "cons",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLong"];
                    Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "LiUid"];
                       Extfun.Evar ();
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                          Extfun.Estr "::"]]];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.ExApp
                (_,
                 MLast.ExApp
                   (_, MLast.ExLong (_, MLast.LiUid (_, Ploc.VaVal "::")), _),
                 _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let (xl, y) = make_expr_list z in
                     match y with
                       Some y ->
                         let xl = List.map (fun x -> x, " ::") (xl @ [y]) in
                         plist next 0 pc xl
                     | None -> next pc z)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "add",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let ops = ["+"; "+."; "-"; "-."] in
                   let unfold =
                     function
                       MLast.ExApp
                         (_,
                          MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x),
                          y) ->
                         if List.mem op ops || is_infixop2 op then
                           Some (x, " " ^ op, y)
                         else None
                     | _ -> None
                   in
                   let loc = MLast.loc_of_expr z in
                   left_operator pc loc 0 unfold next z))]);
     Some "mul",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let ops =
                     ["*"; "*."; "/"; "/."; "%"; "land"; "lor"; "lxor"; "mod"]
                   in
                   let unfold =
                     function
                       MLast.ExApp
                         (_,
                          MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x),
                          y) ->
                         if List.mem op ops || is_infixop3 op then
                           Some (x, " " ^ op, y)
                         else None
                     | _ -> None
                   in
                   let loc = MLast.loc_of_expr z in
                   left_operator pc loc 0 unfold next z))]);
     Some "pow",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let ops = ["**"; "asr"; "lsl"; "lsr"] in
                   let unfold =
                     function
                       MLast.ExApp
                         (_,
                          MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x),
                          y) ->
                         if List.mem op ops || is_infixop4 op then
                           Some (x, " " ^ op, y)
                         else None
                     | _ -> None
                   in
                   let loc = MLast.loc_of_expr z in
                   right_operator pc loc 0 unfold next z))]);
     Some "unary_minus",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLid"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]];
              Extfun.Evar ()],
           false,
           (function
              MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let ops =
                       ["-", "-"; "-.", "-."; "~+", "+"; "~+.", "+."]
                     in
                     let in_ops x = List.mem_assoc x ops in
                     if in_ops op then
                       unary in_ops curr
                         {pc with Pprintf.bef =
                           Pretty.sprintf "%s%s" pc.Pprintf.bef
                             (List.assoc op ops)}
                         x
                     else next pc z)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "apply",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExApp (loc, _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let inf =
                       match z with
                         MLast.ExApp
                           (_,
                            MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal n), _),
                            _) ->
                           is_infix n || is_infix_operator n
                       | MLast.ExApp
                           (_,
                            MLast.ExApp
                              (_,
                               MLast.ExLong
                                 (_, MLast.LiUid (_, Ploc.VaVal "::")),
                               _),
                            _) ->
                           true
                       | _ -> false
                     in
                     if inf then next pc z
                     else
                       let cons_args_opt =
                         let rec loop args =
                           function
                             MLast.ExApp (_, x, y) -> loop (y :: args) x
                           | MLast.ExLong (_, _) as e -> Some (e, args)
                           | _ -> None
                         in
                         loop [] z
                       in
                       match cons_args_opt with
                         Some (e, (_ :: _ :: _ as al)) ->
                           let expr_or = Eprinter.apply_level pr_expr "or" in
                           let al = List.map (fun a -> a, ",") al in
                           Pprintf.sprint_break 1 2 pc (fun pc -> next pc e)
                             (fun pc ->
                                let pc =
                                  {pc with Pprintf.ind = pc.Pprintf.ind + 1}
                                in
                                plist expr_or 0
                                  {pc with Pprintf.bef =
                                    Pretty.sprintf "%s(" pc.Pprintf.bef;
                                   Pprintf.aft =
                                     Pretty.sprintf ")%s" pc.Pprintf.aft}
                                  al)
                       | _ ->
                           let unfold =
                             function
                               MLast.ExApp
                                 (_,
                                  MLast.ExApp
                                    (_,
                                     MLast.ExLong
                                       (_, MLast.LiUid (_, Ploc.VaVal "::")),
                                     _),
                                  _) ->
                                 None
                             | MLast.ExApp
                                 (_,
                                  MLast.ExApp
                                    (_, MLast.ExLid (_, Ploc.VaVal n), _),
                                  _)
                               when is_infix n || is_infix_operator n ->
                                 None
                             | MLast.ExApp
                                 (_, MLast.ExLid (_, Ploc.VaVal n), _)
                               when is_unary n || is_prefixop n ->
                                 None
                             | MLast.ExApp (_, x, y) -> Some (x, "", y)
                             | e -> None
                           in
                           left_operator pc loc 2 unfold next z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLaz"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExLaz (_, e) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc -> Pretty.sprintf "%slazy" pc.Pprintf.bef)
                       (fun pc -> next pc e))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExAsr"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExAsr (_, e) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc -> Pretty.sprintf "%sassert" pc.Pprintf.bef)
                       (fun pc -> next pc e))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "dot",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExBae"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExBae (_, Ploc.VaVal op, x, Ploc.VaVal el) ->
                Some
                  (fun curr next top bottom pc ->
                     let el = List.map (fun e -> e, ";") el in
                     Pprintf.sprint_break 0 0 pc (fun pc -> curr pc x)
                       (fun pc ->
                          plist expr_short 0
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s%s{" pc.Pprintf.bef op;
                             Pprintf.aft =
                               Pretty.sprintf "}%s" pc.Pprintf.aft}
                            el))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExBae"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Estr "."];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExBae (_, Ploc.VaVal ".", e, Ploc.VaVal el) ->
                Some
                  (fun curr next top bottom pc ->
                     let el = List.map (fun e -> e, ",") el in
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = ".{"} e)
                       (plist expr_short 0
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf "}%s" pc.Pprintf.aft}
                          el))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExSte"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExSte (_, Ploc.VaVal op, x, Ploc.VaVal el) ->
                Some
                  (fun curr next top bottom pc ->
                     let el = List.map (fun e -> e, ";") el in
                     Pprintf.sprint_break 0 0 pc (fun pc -> curr pc x)
                       (fun pc ->
                          plist expr_short 0
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s%s[" pc.Pprintf.bef op;
                             Pprintf.aft =
                               Pretty.sprintf "]%s" pc.Pprintf.aft}
                            el))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExSte"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Estr "."];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "::"]; Extfun.Evar ();
                    Extfun.Eacc [Extfun.Econ "[]"]]]],
           false,
           (function
              MLast.ExSte (_, Ploc.VaVal ".", x, Ploc.VaVal [y]) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 0 0 pc (fun pc -> curr pc x)
                       (fun pc ->
                          expr_short
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s.[" pc.Pprintf.bef;
                             Pprintf.aft =
                               Pretty.sprintf "]%s" pc.Pprintf.aft}
                            y))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExAre"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExAre (_, Ploc.VaVal op, x, Ploc.VaVal el) ->
                Some
                  (fun curr next top bottom pc ->
                     let el = List.map (fun e -> e, ";") el in
                     Pprintf.sprint_break 0 0 pc (fun pc -> curr pc x)
                       (fun pc ->
                          plist expr_short 0
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s%s(" pc.Pprintf.bef op;
                             Pprintf.aft =
                               Pretty.sprintf ")%s" pc.Pprintf.aft}
                            el))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExAre"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Estr "."];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "::"]; Extfun.Evar ();
                    Extfun.Eacc [Extfun.Econ "[]"]]]],
           false,
           (function
              MLast.ExAre (_, Ploc.VaVal ".", x, Ploc.VaVal [y]) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 0 0 pc (fun pc -> curr pc x)
                       (fun pc ->
                          expr_short
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s.(" pc.Pprintf.bef;
                             Pprintf.aft =
                               Pretty.sprintf ")%s" pc.Pprintf.aft}
                            y))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLong"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExLong (_, li) ->
                Some (fun curr next top bottom pc -> longident pc li)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExFle"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExFle (_, e, Ploc.VaVal lili) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 0 0 pc
                       (fun pc -> curr {pc with Pprintf.aft = "."} e)
                       (fun pc -> longident_lident pc lili))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExFle"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup
                   [Extfun.Eacc [Extfun.Econ "None"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]]]],
           false,
           (function
              MLast.ExFle (loc, e, Ploc.VaVal (None, Ploc.VaVal v)) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 0 0 pc
                       (fun pc -> curr {pc with Pprintf.aft = "."} e)
                       (fun pc -> var_escaped pc (loc, v)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExFle"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup
                   [Extfun.Eacc [Extfun.Econ "None"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Estr "val"]]]],
           false,
           (function
              MLast.ExFle (_, x, Ploc.VaVal (None, Ploc.VaVal "val")) ->
                Some
                  (fun curr next top bottom pc ->
                     next
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s!" pc.Pprintf.bef}
                       x)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExOpen"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExOpen (_, li, e) ->
                Some
                  (fun curr next top bottom pc ->
                     match e with
                       MLast.ExLong (_, MLast.LiUid (_, Ploc.VaVal "[]")) ->
                         Pprintf.sprint_break 0 0 pc
                           (fun pc ->
                              longident {pc with Pprintf.aft = "."} li)
                           (fun pc ->
                              Pprintf.sprint_break_all false pc
                                (fun pc ->
                                   Pretty.sprintf "%s[]%s" pc.Pprintf.bef
                                     pc.Pprintf.aft)
                                [])
                     | MLast.ExApp
                         (_,
                          MLast.ExApp
                            (_,
                             MLast.ExLong
                               (_, MLast.LiUid (_, Ploc.VaVal "::")),
                             _),
                          _) ->
                         Pprintf.sprint_break 0 0 pc
                           (fun pc ->
                              longident {pc with Pprintf.aft = "."} li)
                           (fun pc -> curr pc e)
                     | MLast.ExRec (_, Ploc.VaVal _, None) ->
                         Pprintf.sprint_break 0 0 pc
                           (fun pc ->
                              longident {pc with Pprintf.aft = "."} li)
                           (fun pc -> curr pc e)
                     | MLast.ExRec (_, Ploc.VaVal _, Some _) ->
                         Pprintf.sprint_break 0 0 pc
                           (fun pc ->
                              longident {pc with Pprintf.aft = "."} li)
                           (fun pc -> curr pc e)
                     | MLast.ExLid (loc, Ploc.VaVal v) ->
                         Pprintf.sprint_break 0 0 pc
                           (fun pc ->
                              longident {pc with Pprintf.aft = "."} li)
                           (fun pc -> var_escaped pc (loc, v))
                     | e ->
                         Pprintf.sprint_break 0 0 pc
                           (fun pc ->
                              longident {pc with Pprintf.aft = "."} li)
                           (fun pc ->
                              Pprintf.sprint_break_all false pc
                                (fun pc ->
                                   expr
                                     {pc with Pprintf.bef =
                                       Pretty.sprintf "%s(" pc.Pprintf.bef;
                                      Pprintf.aft =
                                        Pretty.sprintf ")%s" pc.Pprintf.aft}
                                     e)
                                []))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "~.",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLid"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]];
              Extfun.Evar ()],
           false,
           (function
              MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), x) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let in_ops x = is_prefixop x in
                     if in_ops op then
                       unary in_ops curr
                         {pc with Pprintf.bef =
                           Pretty.sprintf "%s%s" pc.Pprintf.bef op}
                         x
                     else next pc z)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "simple",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExSeq"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExSeq (loc, Ploc.VaVal el) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with dang = ""} in
                     Pprintf.sprint_break_all false pc
                       (fun pc -> Pretty.sprintf "%sbegin" pc.Pprintf.bef)
                       [1, 2,
                        (fun pc ->
                           hvlistl (semi_after (comm_expr expr1))
                             (comm_expr expr1) pc el);
                        1, 0,
                        (fun pc ->
                           Pretty.sprintf "%send%s" pc.Pprintf.bef
                             pc.Pprintf.aft)])
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLab"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]]],
           false,
           (function
              MLast.ExLab (loc, _, Ploc.VaVal (Some _)) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in expr)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLab"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              MLast.ExLab (loc, _, Ploc.VaVal None) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in expr)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              MLast.ExOlb (loc, _, Ploc.VaVal None) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in expr)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExChr"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExChr (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s'%s'%s" pc.Pprintf.bef (ocaml_char s)
                       pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExExten (_, e) ->
                Some (fun curr next top bottom pc -> pr_extension "%" pc e)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExStr"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup
                   [Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]]]],
           false,
           (function
              MLast.ExStr (_, Ploc.VaVal (_, Ploc.VaVal s)) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s\"%s\"%s" pc.Pprintf.bef s
                       pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExVrn (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "variants not pretty printed (in expr); add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLid"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExLid (loc, Ploc.VaVal s) ->
                Some (fun curr next top bottom pc -> var_escaped pc (loc, s))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExUnr"];
              Extfun.Evar ()],
           false,
           (function
              MLast.ExUnr loc ->
                Some
                  (fun curr next top bottom pc ->
                     Ploc.raise loc
                       (Failure
                          "pr_expr of (PaUnr _) not allowed except at rhs of match-case"))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExInt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Estr "n"],
           false,
           (function
              MLast.ExInt (_, Ploc.VaVal s, "n") ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%sn)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%sn%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExInt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Estr "L"],
           false,
           (function
              MLast.ExInt (_, Ploc.VaVal s, "L") ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%sL)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%sL%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExInt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Estr "l"],
           false,
           (function
              MLast.ExInt (_, Ploc.VaVal s, "l") ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%sl)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%sl%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExFlo"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExFlo (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%s)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%s%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExInt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Estr ""],
           false,
           (function
              MLast.ExInt (_, Ploc.VaVal s, "") ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%s)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%s%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExPck"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eacc [Extfun.Econ "None"]],
           false,
           (function
              MLast.ExPck (_, me, None) ->
                Some
                  (fun curr next top bottom pc ->
                     module_expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(module " pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       me)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExPck"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]],
           false,
           (function
              MLast.ExPck (_, me, Some mt) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          module_expr
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s(module " pc.Pprintf.bef;
                             Pprintf.aft = " :"}
                            me)
                       (fun pc ->
                          module_type
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            mt))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExTyc"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExTyc (_, e, t) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          expr
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s(" pc.Pprintf.bef;
                             Pprintf.aft = " :"}
                            e)
                       (fun pc ->
                          ctyp
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            t))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLong"];
                    Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "LiUid"];
                       Extfun.Evar ();
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                          Extfun.Estr "::"]]];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.ExApp
                (_,
                 MLast.ExApp
                   (_, MLast.ExLong (_, MLast.LiUid (_, Ploc.VaVal "::")), _),
                 _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let (xl, y) = make_expr_list z in
                     match y with
                       Some _ ->
                         let pc =
                           {pc with Pprintf.ind = pc.Pprintf.ind + 1}
                         in
                         expr
                           {pc with Pprintf.bef =
                             Pretty.sprintf "%s(" pc.Pprintf.bef;
                            Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft;
                            Pprintf.dang = ""}
                           z
                     | None ->
                         let xl = List.map (fun x -> x, ";") xl in
                         let pc =
                           {pc with Pprintf.ind = pc.Pprintf.ind + 1}
                         in
                         plist (comm_expr expr1) 0
                           {pc with Pprintf.bef =
                             Pretty.sprintf "%s[" pc.Pprintf.bef;
                            Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
                           xl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExArr"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExArr (_, Ploc.VaVal el) ->
                Some
                  (fun curr next top bottom pc ->
                     if el = [] then
                       Pretty.sprintf "%s[| |]%s" pc.Pprintf.bef
                         pc.Pprintf.aft
                     else
                       let el = List.map (fun e -> e, ";") el in
                       let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 3} in
                       plist expr 0
                         {pc with Pprintf.bef =
                           Pretty.sprintf "%s[| " pc.Pprintf.bef;
                          Pprintf.aft = Pretty.sprintf " |]%s" pc.Pprintf.aft}
                         el)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExRec"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]],
           false,
           (function
              MLast.ExRec (_, Ploc.VaVal lel, Some e) ->
                Some
                  (fun curr next top bottom pc ->
                     let dot_expr = Eprinter.apply_level pr_expr "dot" in
                     let lxl = List.map (fun lx -> lx, ";") lel in
                     let pc =
                       {pc with Pprintf.bef =
                         dot_expr
                           {pc with Pprintf.bef =
                             Pretty.sprintf "%s{" pc.Pprintf.bef;
                            Pprintf.aft = " with "}
                           e}
                     in
                     plistl (comm_patt_any (record_binding false))
                       (comm_patt_any (record_binding true)) 1
                       {pc with Pprintf.aft =
                         Pretty.sprintf "}%s" pc.Pprintf.aft}
                       lxl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExRec"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eacc [Extfun.Econ "None"]],
           false,
           (function
              MLast.ExRec (_, Ploc.VaVal lel, None) ->
                Some
                  (fun curr next top bottom pc ->
                     let lxl = List.map (fun lx -> lx, ";") lel in
                     plistl (comm_patt_any (record_binding false))
                       (comm_patt_any (record_binding true)) 1
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s{" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf "}%s" pc.Pprintf.aft}
                       lxl)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "bottom",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let fail () =
                     Ploc.raise (MLast.loc_of_expr z)
                       (Failure (sprintf "pr_expr %d" (Obj.tag (Obj.repr z))))
                   in
                   let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                   bottom ~fail:fail
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s(" pc.Pprintf.bef;
                      Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft;
                      Pprintf.dang = ""}
                     z))])];
  Eprinter.extend pr_patt None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaAli"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaAli (_, x, y) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc =
                       {pc with Pprintf.aft =
                         let pc = {pc with Pprintf.bef = ""} in
                         patt {pc with Pprintf.bef = " as "} y}
                     in
                     patt pc x)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "or",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOrp"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaOrp (loc, _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let unfold =
                       function
                         MLast.PaOrp (_, x, y) -> Some (x, " |", y)
                       | _ -> None
                     in
                     left_operator pc loc 0 unfold next z)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "tuple",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaTup"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "False"]]],
           false,
           (function
              MLast.PaTup (_, Ploc.VaVal pl, Ploc.VaVal false) ->
                Some
                  (fun curr next top bottom pc ->
                     let pl = List.map (fun p -> p, ",") pl in
                     plist next 0
                       {pc with Pprintf.aft =
                         Pretty.sprintf ", ..%s" pc.Pprintf.aft}
                       pl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaTup"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "True"]]],
           false,
           (function
              MLast.PaTup (_, Ploc.VaVal pl, Ploc.VaVal true) ->
                Some
                  (fun curr next top bottom pc ->
                     let pl = List.map (fun p -> p, ",") pl in
                     plist next 0 pc pl)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "alg_attribute",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaAtt"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaAtt (_, p, Ploc.VaVal attr) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = "[@"} p)
                       (attribute_body
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
                          attr))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaEff"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaEff (_, p1, p2) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (next
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%seffect " pc.Pprintf.bef;
                           Pprintf.aft = ", "}
                          p1)
                       (simple_patt {pc with Pprintf.bef = ""} p2))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaExc"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaExc (loc, p) ->
                Some
                  (fun curr next top bottom pc ->
                     next
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%sexception " pc.Pprintf.bef}
                       p)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "range",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaRng"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaRng (_, x, y) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (next {pc with Pprintf.aft = ".."} x)
                       (next {pc with Pprintf.bef = ""} y))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "cons",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaApp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaApp"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLong"];
                    Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "LiUid"];
                       Extfun.Evar ();
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                          Extfun.Estr "::"]];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Eacc [Extfun.Econ "[]"]]];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.PaApp
                (_,
                 MLast.PaApp
                   (_,
                    MLast.PaLong
                      (_, MLast.LiUid (_, Ploc.VaVal "::"), Ploc.VaVal []),
                    _),
                 _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let (xl, y) = make_patt_list z in
                     match y with
                       Some y ->
                         let xl = List.map (fun x -> x, " ::") (xl @ [y]) in
                         plist next 0 pc xl
                     | None -> next pc z)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "apply",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaApp"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaApp (_, _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let p_pl_opt =
                       let rec loop pl =
                         function
                           MLast.PaApp (_, x, y) -> loop (y :: pl) x
                         | MLast.PaLong
                             (_, MLast.LiUid (_, Ploc.VaVal "::"),
                              Ploc.VaVal []) ->
                             None
                         | p -> Some (p, pl)
                       in
                       loop [] z
                     in
                     match p_pl_opt with
                       None -> next pc z
                     | Some (p1, [p2]) ->
                         Pprintf.sprint_break 1 2 pc (fun pc -> curr pc p1)
                           (fun pc -> next pc p2)
                     | Some (p, pl) ->
                         let patt = Eprinter.apply_level pr_patt "range" in
                         let al = List.map (fun a -> a, ",") pl in
                         Pprintf.sprint_break 1 2 pc (fun pc -> next pc p)
                           (fun pc ->
                              let pc =
                                {pc with Pprintf.ind = pc.Pprintf.ind + 1}
                              in
                              plist patt 0
                                {pc with Pprintf.bef =
                                  Pretty.sprintf "%s(" pc.Pprintf.bef;
                                 Pprintf.aft =
                                   Pretty.sprintf ")%s" pc.Pprintf.aft}
                                al))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "simple",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLong"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaLong (_, li, Ploc.VaVal l) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (longident {pc with Pprintf.aft = " (type "} li)
                       (hlist lident
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                          (List.map snd l)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLong"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "[]"]]],
           false,
           (function
              MLast.PaLong (_, li, Ploc.VaVal []) ->
                Some (fun curr next top bottom pc -> longident pc li)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaPfx"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaPfx (_, li, p) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (longident {pc with Pprintf.aft = "."} li)
                       (curr {pc with Pprintf.bef = ""} p))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaPfx"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLid"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]]],
           false,
           (function
              MLast.PaPfx (loc, li, MLast.PaLid (_, Ploc.VaVal y)) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (longident {pc with Pprintf.aft = ".("} li)
                       (var_escaped
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                          (loc, y)))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "atomic",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaVrn (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "polymorphic variants not pretty printed; add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLab"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaLab (loc, _, Ploc.VaVal _) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in patt)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]]],
           false,
           (function
              MLast.PaOlb (loc, _, Ploc.VaVal (Some _)) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in patt)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExOlb"];
                       Extfun.Evar (); Extfun.Evar ();
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                          Extfun.Eapp
                            [Extfun.Eacc [Extfun.Econ "Some"];
                             Extfun.Evar ()]]]]]],
           false,
           (function
              MLast.PaOlb
                (loc, _,
                 Ploc.VaVal
                   (Some (MLast.ExOlb (_, _, Ploc.VaVal (Some _))))) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in patt)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              MLast.PaOlb (loc, _, Ploc.VaVal None) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in patt)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]]],
           false,
           (function
              MLast.PaOlb (loc, _, Ploc.VaVal (Some _)) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in patt)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              MLast.PaOlb (loc, _, Ploc.VaVal None) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in patt)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaAny"];
              Extfun.Evar ()],
           false,
           (function
              MLast.PaAny _ ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s_%s" pc.Pprintf.bef pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaStr"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaStr (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s\"%s\"%s" pc.Pprintf.bef s
                       pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaChr"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaChr (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s'%s'%s" pc.Pprintf.bef (ocaml_char s)
                       pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLong"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "LiUid"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "[]"]]],
           false,
           (function
              MLast.PaLong
                (loc, MLast.LiUid (_, Ploc.VaVal s), Ploc.VaVal []) ->
                Some (fun curr next top bottom pc -> cons_escaped pc (loc, s))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLid"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaLid (loc, Ploc.VaVal s) ->
                Some (fun curr next top bottom pc -> var_escaped pc (loc, s))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaExten (_, e) ->
                Some (fun curr next top bottom pc -> pr_extension "%" pc e)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaInt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Estr "n"],
           false,
           (function
              MLast.PaInt (_, Ploc.VaVal s, "n") ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%sn)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%sn%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaInt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Estr "L"],
           false,
           (function
              MLast.PaInt (_, Ploc.VaVal s, "L") ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%sL)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%sL%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaInt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Estr "l"],
           false,
           (function
              MLast.PaInt (_, Ploc.VaVal s, "l") ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%sl)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%sl%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaFlo"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaFlo (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%s)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%s%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaInt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Estr ""],
           false,
           (function
              MLast.PaInt (_, Ploc.VaVal s, "") ->
                Some
                  (fun curr next top bottom pc ->
                     if String.length s > 0 && s.[0] = '-' then
                       Pretty.sprintf "%s(%s)%s" pc.Pprintf.bef s
                         pc.Pprintf.aft
                     else
                       Pretty.sprintf "%s%s%s" pc.Pprintf.bef s
                         pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaUnp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eacc [Extfun.Econ "None"]],
           false,
           (function
              MLast.PaUnp (_, Ploc.VaVal s, None) ->
                Some
                  (fun curr next top bottom pc ->
                     let s = uidopt_to_maybe_blank s in
                     Pretty.sprintf "%s(module %s)%s" pc.Pprintf.bef s
                       pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaUnp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]],
           false,
           (function
              MLast.PaUnp (_, Ploc.VaVal s, Some mt) ->
                Some
                  (fun curr next top bottom pc ->
                     let s = uidopt_to_maybe_blank s in
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          Pretty.sprintf "%s(module %s :" pc.Pprintf.bef s)
                       (fun pc ->
                          module_type
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            mt))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaNty"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaNty (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     var_escaped_noloc
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(type " pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       s)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaTyc"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaTyc (_, p, t) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 1 pc
                       (fun pc ->
                          patt
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s(" pc.Pprintf.bef;
                             Pprintf.aft = " :"}
                            p)
                       (fun pc ->
                          ctyp
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            t))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaApp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaApp"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLong"];
                    Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "LiUid"];
                       Extfun.Evar ();
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                          Extfun.Estr "::"]];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Eacc [Extfun.Econ "[]"]]];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.PaApp
                (_,
                 MLast.PaApp
                   (_,
                    MLast.PaLong
                      (_, MLast.LiUid (_, Ploc.VaVal "::"), Ploc.VaVal []),
                    _),
                 _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let (xl, y) = make_patt_list z in
                     match y with
                       Some y ->
                         let pc =
                           {pc with Pprintf.ind = pc.Pprintf.ind + 1}
                         in
                         patt
                           {pc with Pprintf.bef =
                             Pretty.sprintf "%s(" pc.Pprintf.bef;
                            Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                           z
                     | None ->
                         let xl = List.map (fun x -> x, ";") xl in
                         let pc =
                           {pc with Pprintf.ind = pc.Pprintf.ind + 1}
                         in
                         plist patt 0
                           {pc with Pprintf.bef =
                             Pretty.sprintf "%s[" pc.Pprintf.bef;
                            Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
                           xl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaArr"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaArr (_, Ploc.VaVal pl) ->
                Some
                  (fun curr next top bottom pc ->
                     if pl = [] then
                       Pretty.sprintf "%s[| |]%s" pc.Pprintf.bef
                         pc.Pprintf.aft
                     else
                       let pl = List.map (fun p -> p, ";") pl in
                       let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 3} in
                       plist patt 0
                         {pc with Pprintf.bef =
                           Pretty.sprintf "%s[| " pc.Pprintf.bef;
                          Pprintf.aft = Pretty.sprintf " |]%s" pc.Pprintf.aft}
                         pl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaRec"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaRec (_, Ploc.VaVal lpl) ->
                Some
                  (fun curr next top bottom pc ->
                     let (lpl, closed) =
                       List.fold_right
                         (fun lp (lpl, closed) ->
                            match lp with
                              MLast.PaAny _, MLast.PaAny _ -> lpl, true
                            | lp -> lp :: lpl, closed)
                         lpl ([], false)
                     in
                     let lxl =
                       List.map (fun (a, b) -> (a, b, Ploc.VaVal []), ";") lpl
                     in
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     plist (binding label_patt patt) 0
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s{" pc.Pprintf.bef;
                        Pprintf.aft =
                          Pretty.sprintf "%s}%s"
                            (if closed then "; _" else "") pc.Pprintf.aft}
                       lxl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLaz"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaLaz (_, p) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc -> Pretty.sprintf "%slazy" pc.Pprintf.bef)
                       (fun pc -> curr pc p))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "bottom",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let fail () =
                     Ploc.raise (MLast.loc_of_patt z)
                       (Failure
                          (Format.asprintf "pr_patt %d: %a"
                             (Obj.tag (Obj.repr z)) Pp_MLast.pp_patt z))
                   in
                   let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                   bottom ~fail:fail
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s(" pc.Pprintf.bef;
                      Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                     z))])];
  Eprinter.extend pr_ctyp None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyMan"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyMan (loc, x, Ploc.VaVal pf, y) ->
                Some
                  (fun curr next top bottom pc ->
                     let op = if pf then "= private" else "=" in
                     operator pc next next 2 (loc, op) x y)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "alg_attribute",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyAtt"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.TyAtt (_, ct, Ploc.VaVal attr) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = "[@"} ct)
                       (attribute_body
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
                          attr))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "below_alg_attribute",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "arrow",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyArr"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.TyArr (loc, _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let unfold =
                       function
                         MLast.TyArr (_, x, y) -> Some (x, " ->", y)
                       | _ -> None
                     in
                     right_operator pc loc 2 unfold next z)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "star",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyTup"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.TyTup (_, Ploc.VaVal tl) ->
                Some
                  (fun curr next top bottom pc ->
                     let tl = List.map (fun t -> t, " *") tl in
                     let pp1 pc (lab, ct) =
                       match Pcaml.unvala lab with
                         None -> next pc ct
                       | Some l ->
                           next
                             {pc with Pprintf.bef =
                               Pretty.sprintf "%s%s:" pc.Pprintf.bef
                                 (Pcaml.unvala l)}
                             ct
                     in
                     plist pp1 2 pc tl)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "apply",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyApp"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.TyApp (loc, t1, t2) ->
                Some
                  (fun curr next top bottom pc ->
                     match t1 with
                       MLast.TyApp (_, _, _) ->
                         let (t, tl) =
                           let rec loop args =
                             function
                               MLast.TyApp (_, x, y) -> loop (y :: args) x
                             | t -> t, args
                           in
                           loop [t2] t1
                         in
                         Pprintf.sprint_break 1 2 pc
                           (fun pc ->
                              hlistl (comma_after ctyp) ctyp
                                {pc with Pprintf.bef =
                                  Pretty.sprintf "%s(" pc.Pprintf.bef;
                                 Pprintf.aft = ")"}
                                tl)
                           (fun pc -> curr pc t)
                     | _ ->
                         match t2 with
                           MLast.TyApp (_, _, _) ->
                             Pprintf.sprint_break 1 2 pc
                               (fun pc -> curr pc t2) (fun pc -> next pc t1)
                         | t ->
                             Pprintf.sprint_break 1 2 pc
                               (fun pc -> next pc t2) (fun pc -> next pc t1))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "dot",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyOpen"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.TyOpen (_, me, t) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (longident {pc with Pprintf.aft = ".( "} me)
                       (ctyp
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf " )%s" pc.Pprintf.aft}
                          t))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyAcc"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.TyAcc (_, me, Ploc.VaVal lid) ->
                Some
                  (fun curr next top bottom pc ->
                     longident
                       {pc with Pprintf.aft =
                         Pretty.sprintf ".%s%s" lid pc.Pprintf.aft}
                       me)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "simple",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Some"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]]]],
           false,
           (function
              MLast.TyVrn (_, Ploc.VaVal _, Some (Some (Ploc.VaVal _))) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "variants not pretty printed (in type); add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Some"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Eacc [Extfun.Econ "[]"]]]]],
           false,
           (function
              MLast.TyVrn (_, Ploc.VaVal _, Some (Some (Ploc.VaVal []))) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "variants not pretty printed (in type); add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Some"];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              MLast.TyVrn (_, Ploc.VaVal _, Some None) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "variants not pretty printed (in type); add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eacc [Extfun.Econ "None"]],
           false,
           (function
              MLast.TyVrn (_, Ploc.VaVal _, None) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "variants not pretty printed (in type); add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyLab"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyLab (loc, Ploc.VaVal _, _) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in type)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyOlb"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyOlb (loc, Ploc.VaVal _, _) ->
                Some
                  (fun curr next top bottom pc ->
                     error loc "labels not pretty printed (in type)")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.TyExten (_, e) ->
                Some (fun curr next top bottom pc -> pr_extension "%" pc e)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyOpn"];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyOpn _ ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s..%s" pc.Pprintf.bef pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyAny"];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyAny _ ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s_%s" pc.Pprintf.bef pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyQuo"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.TyQuo (loc, Ploc.VaVal s) ->
                Some (fun curr next top bottom pc -> type_var pc s)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyLid"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.TyLid (loc, Ploc.VaVal t) ->
                Some (fun curr next top bottom pc -> var_escaped pc (loc, t))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyPck"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.TyPck (_, mt) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 0 pc
                       (fun pc -> Pretty.sprintf "%s(module" pc.Pprintf.bef)
                       (fun pc ->
                          module_type
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            mt))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TySum"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.TySum (loc, Ploc.VaVal vdl) ->
                Some
                  (fun curr next top bottom pc ->
                     if vdl = [] then
                       Pretty.sprintf "%s|%s" pc.Pprintf.bef pc.Pprintf.aft
                     else
                       horiz_vertic
                         (fun () ->
                            if has_cons_with_params vdl then sprintf "\n"
                            else
                              hlist2 cons_decl (bar_before cons_decl) pc vdl)
                         (fun () ->
                            vlist2 cons_decl (bar_before cons_decl)
                              {pc with Pprintf.bef =
                                Pretty.sprintf "%s  " pc.Pprintf.bef}
                              vdl))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyRec"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.TyRec (loc, Ploc.VaVal ltl) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break_all false pc
                       (fun pc ->
                          let pc =
                            {pc with Pprintf.ind = pc.Pprintf.ind + 2}
                          in
                          hvlistl (semi_after label_decl) label_decl
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s{ " pc.Pprintf.bef;
                             Pprintf.aft =
                               Pretty.sprintf " }%s" pc.Pprintf.aft}
                            ltl)
                       [])
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "bottom",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let fail () =
                     Ploc.raise (MLast.loc_of_ctyp z)
                       (Failure
                          (sprintf "[INTERNAL ERROR] pr_ctyp %d"
                             (Obj.tag (Obj.repr z))))
                   in
                   let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                   bottom ~fail:fail
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s(" pc.Pprintf.bef;
                      Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                     z))])];
  Eprinter.extend pr_str_item None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StExten"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StExten (_, e, Ploc.VaVal attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (pr_extension "%%" {pc with Pprintf.aft = ""} e)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StFlAtt"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.StFlAtt (_, attr) ->
                Some
                  (fun curr next top bottom pc -> pr_attribute "@@@" pc attr)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StUse"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.StUse (_, fn, sl) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with aft = ""} in
                     Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StCls"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StCls (_, Ploc.VaVal _) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "classes and objects not pretty printed; add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StClt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StClt (_, Ploc.VaVal _) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "classes and objects not pretty printed; add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StExp"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StExp (_, e, Ploc.VaVal attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     if pc.aft = ";;" then
                       Pretty.sprintf "%s%s"
                         (expr {pc with Pprintf.aft = ""} e)
                         (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                            attrs)
                     else
                       Pprintf.sprint_break 1 2 pc
                         (fun pc -> Pretty.sprintf "%slet _ =" pc.Pprintf.bef)
                         (fun pc ->
                            Pretty.sprintf "%s%s"
                              (expr {pc with Pprintf.aft = ""} e)
                              (hlist (pr_attribute "@@")
                                 {pc with Pprintf.bef = ""} attrs)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StVal"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StVal (loc, Ploc.VaVal rf, Ploc.VaVal pel) ->
                Some
                  (fun curr next top bottom pc ->
                     horiz_vertic
                       (fun () ->
                          hlist2 let_binding (and_before let_binding)
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%slet%s " pc.Pprintf.bef
                                (if rf then " rec" else "")}
                            pel)
                       (fun () ->
                          vlist2 let_binding (and_before let_binding)
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%slet%s " pc.Pprintf.bef
                                (if rf then " rec" else "")}
                            pel))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StTypExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.StTypExten (loc, te) ->
                Some
                  (fun curr next top bottom pc ->
                     type_extension loc
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%stype " pc.Pprintf.bef}
                       te)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StTyp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StTyp (loc, Ploc.VaVal nonrf, Ploc.VaVal tdl) ->
                Some
                  (fun curr next top bottom pc ->
                     vlist2 type_decl (and_before type_decl)
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%stype%s " pc.Pprintf.bef
                           (if nonrf then " nonrec" else "")}
                       tdl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StOpn"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.StOpn (loc, ovf, me, attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (module_expr
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%sopen%s " pc.Pprintf.bef
                              (if Pcaml.unvala ovf then "!" else "");
                           Pprintf.aft = ""}
                          me)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          (Pcaml.unvala attrs)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StMty"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtQuo"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]];
              Extfun.Evar ()],
           false,
           (function
              MLast.StMty
                (_, Ploc.VaVal m, MLast.MtQuo (_, Ploc.VaVal id),
                 item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     hlist (pr_attribute "@@")
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%smodule type %s" pc.Pprintf.bef m}
                       (Pcaml.unvala item_attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StMty"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.StMty (_, Ploc.VaVal m, mt, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     sig_module_or_module_type "module type" false "=" pc
                       (Some m, mt, item_attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StMod"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StMod (_, Ploc.VaVal rf, Ploc.VaVal mdl) ->
                Some
                  (fun curr next top bottom pc ->
                     let mdl =
                       List.map
                         (fun (m, mt, item_attrs) ->
                            map_option Pcaml.unvala (Pcaml.unvala m), mt,
                            item_attrs)
                         mdl
                     in
                     let rf = if rf then " rec" else "" in
                     vlist2 (str_module ("module" ^ rf)) (str_module "and") pc
                       mdl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StInc"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.StInc (_, me, attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (module_expr
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%sinclude " pc.Pprintf.bef;
                           Pprintf.aft = ""}
                          me)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          (Pcaml.unvala attrs)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StExt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StExt
                (loc, Ploc.VaVal n, Ploc.VaVal tyvars, t, Ploc.VaVal sl,
                 Ploc.VaVal attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     external_decl pc (loc, n, tyvars, t, sl, attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StExc"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.StExc (loc, Ploc.VaVal ec, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (extension_constructor loc
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%sexception " pc.Pprintf.bef;
                           Pprintf.aft = ""}
                          ec)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          (Pcaml.unvala item_attrs)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StDcl"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StDcl (loc, Ploc.VaVal sil) ->
                Some
                  (fun curr next top bottom pc ->
                     if sil = [] then
                       let pc = {pc with aft = ""} in
                       Pretty.sprintf "%s(* *)%s" pc.Pprintf.bef
                         pc.Pprintf.aft
                     else
                       let str_item_sep =
                         if !flag_semi_semi then semi_semi_after str_item
                         else str_item
                       in
                       vlistl str_item_sep str_item pc sil)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StDir"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]]],
           false,
           (function
              MLast.StDir (_, Ploc.VaVal s, Ploc.VaVal (Some e)) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with aft = ""} in
                     expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(* #%s " pc.Pprintf.bef s;
                        Pprintf.aft = Pretty.sprintf " *)%s" pc.Pprintf.aft}
                       e)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_sig_item None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgExten"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgExten (_, e, Ploc.VaVal attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (pr_extension "%%" {pc with Pprintf.aft = ""} e)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgFlAtt"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.SgFlAtt (_, attr) ->
                Some
                  (fun curr next top bottom pc -> pr_attribute "@@@" pc attr)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgCls"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgCls (_, Ploc.VaVal _) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "classes and objects not pretty printed; add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgClt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgClt (_, Ploc.VaVal _) ->
                Some
                  (fun curr next top bottom pc ->
                     failwith
                       "classes and objects not pretty printed; add pr_ro.cmo")
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgVal"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgVal (loc, Ploc.VaVal s, t, Ploc.VaVal attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          var_escaped
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sval " pc.Pprintf.bef;
                             Pprintf.aft = " :"}
                            (loc, s))
                       (fun pc ->
                          Pretty.sprintf "%s%s"
                            (ctyp {pc with Pprintf.aft = ""} t)
                            (hlist (pr_attribute "@@")
                               {pc with Pprintf.bef = ""} attrs)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgTypExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.SgTypExten (loc, te) ->
                Some
                  (fun curr next top bottom pc ->
                     type_extension loc
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%stype " pc.Pprintf.bef}
                       te)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgTyp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgTyp (loc, Ploc.VaVal nonrf, Ploc.VaVal tdl) ->
                Some
                  (fun curr next top bottom pc ->
                     vlist2 type_decl (and_before type_decl)
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%stype%s " pc.Pprintf.bef
                           (if nonrf then " nonrec" else "")}
                       tdl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgOpn"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.SgOpn (_, i, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (longident
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%sopen " pc.Pprintf.bef;
                           Pprintf.aft = ""}
                          i)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          (Pcaml.unvala item_attrs)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgMty"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtQuo"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]];
              Extfun.Evar ()],
           false,
           (function
              MLast.SgMty
                (_, Ploc.VaVal m, MLast.MtQuo (_, Ploc.VaVal id),
                 item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     hlist (pr_attribute "@@")
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%smodule type %s" pc.Pprintf.bef m}
                       (Pcaml.unvala item_attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgMtySubst"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.SgMtySubst (_, Ploc.VaVal m, mt, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     sig_module_or_module_type "module type" false ":=" pc
                       (Some m, mt, item_attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgMty"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.SgMty (_, Ploc.VaVal m, mt, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     sig_module_or_module_type "module type" false "=" pc
                       (Some m, mt, item_attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgMtyAlias"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgMtyAlias
                (loc, Ploc.VaVal i, Ploc.VaVal li, Ploc.VaVal item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (longident
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%smodule %s = " pc.Pprintf.bef i;
                           Pprintf.aft = ""}
                          li)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          item_attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgModSubst"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.SgModSubst (_, Ploc.VaVal i, li, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (longident
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%smodule %s := " pc.Pprintf.bef i;
                           Pprintf.aft = ""}
                          li)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          (Pcaml.unvala item_attrs)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgMod"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgMod (_, Ploc.VaVal rf, Ploc.VaVal mdl) ->
                Some
                  (fun curr next top bottom pc ->
                     let mdl =
                       List.map
                         (fun (m, mt, item_attrs) ->
                            map_option Pcaml.unvala (Pcaml.unvala m), mt,
                            item_attrs)
                         mdl
                     in
                     let rf = if rf then " rec" else "" in
                     vlist2
                       (sig_module_or_module_type ("module" ^ rf) true ":")
                       (sig_module_or_module_type "and" true ":") pc mdl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgDcl"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgDcl (loc, Ploc.VaVal sil) ->
                Some
                  (fun curr next top bottom pc ->
                     if sil = [] then
                       let pc = {pc with aft = ""} in
                       Pretty.sprintf "%s(* *)%s" pc.Pprintf.bef
                         pc.Pprintf.aft
                     else
                       let sig_item_sep =
                         if !flag_semi_semi then semi_semi_after sig_item
                         else sig_item
                       in
                       vlistl sig_item_sep sig_item pc sil)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgInc"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.SgInc (_, mt, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (module_type
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%sinclude " pc.Pprintf.bef;
                           Pprintf.aft = ""}
                          mt)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          (Pcaml.unvala item_attrs)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgExt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgExt
                (loc, Ploc.VaVal n, Ploc.VaVal tyvars, t, Ploc.VaVal sl,
                 Ploc.VaVal attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     external_decl pc (loc, n, tyvars, t, sl, attrs))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgExc"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.SgExc (_, gc, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (cons_decl
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%sexception " pc.Pprintf.bef;
                           Pprintf.aft = ""}
                          gc)
                       (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
                          (Pcaml.unvala item_attrs)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgDir"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]]],
           false,
           (function
              MLast.SgDir (_, Ploc.VaVal s, Ploc.VaVal (Some e)) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with aft = ""} in
                     expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(* #%s " pc.Pprintf.bef s;
                        Pprintf.aft = Pretty.sprintf " *)%s" pc.Pprintf.aft}
                       e)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_longident None
    [Some "dot",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "LiUid"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.LiUid (loc, Ploc.VaVal s) ->
                Some (fun curr next top bottom pc -> cons_escaped pc (loc, s))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "LiApp"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.LiApp (_, x, y) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (longident {pc with Pprintf.aft = "("} x)
                       (longident
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                          y))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "LiAcc"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.LiAcc (loc, x, Ploc.VaVal uid) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = "."} x)
                       (cons_escaped {pc with Pprintf.bef = ""} (loc, uid)))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "bottom",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   Pretty.sprintf
                     "%s[INTERNAL ERROR(pr_module_longident): unexpected longident]%s"
                     pc.Pprintf.bef pc.Pprintf.aft))])];
  Eprinter.extend pr_module_expr None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeFun"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.MeFun (_, Ploc.VaVal arg, me) ->
                Some
                  (fun curr next top bottom pc ->
                     str_or_sig_functor pc (functor_parameter_unvala arg)
                       module_expr me)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "alg_attribute",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeAtt"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.MeAtt (_, ct, Ploc.VaVal attr) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = "[@"} ct)
                       (attribute_body
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
                          attr))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeStr"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.MeStr (loc, Ploc.VaVal sil) ->
                Some
                  (fun curr next top bottom pc ->
                     let str_item_sep =
                       if !flag_semi_semi then semi_semi_after str_item
                       else str_item
                     in
                     horiz_vertic
                       (fun () ->
                          if alone_in_line pc then sprintf "\n"
                          else
                            hlist str_item_sep
                              {pc with Pprintf.bef =
                                Pretty.sprintf "%sstruct " pc.Pprintf.bef;
                               Pprintf.aft =
                                 Pretty.sprintf " end%s" pc.Pprintf.aft}
                              sil)
                       (fun () ->
                          Pprintf.sprint_break_all true pc
                            (fun pc ->
                               Pretty.sprintf "%sstruct" pc.Pprintf.bef)
                            [1, 2, (fun pc -> vlist str_item_sep pc sil);
                             1, 0,
                             (fun pc ->
                                Pretty.sprintf "%send%s" pc.Pprintf.bef
                                  pc.Pprintf.aft)]))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "apply",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeApp"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.MeApp (_, x, y) ->
                Some
                  (fun curr next top bottom pc ->
                     let mod_exp2 pc (is_first, me) =
                       if is_first then next pc me
                       else
                         module_expr
                           {pc with Pprintf.bef =
                             Pretty.sprintf "%s(" pc.Pprintf.bef;
                            Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                           me
                     in
                     let (me, mel) =
                       let rec loop mel =
                         function
                           MLast.MeApp (_, x, y) -> loop ((false, y) :: mel) x
                         | me -> (true, me), mel
                       in
                       loop [false, y] x
                     in
                     let mel = List.map (fun me -> me, "") (me :: mel) in
                     plist mod_exp2 2 pc mel)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "dot",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeAcc"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.MeAcc (_, x, y) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = "."} x)
                       (curr {pc with Pprintf.bef = ""} y))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "simple",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.MeExten (_, e) ->
                Some (fun curr next top bottom pc -> pr_extension "%" pc e)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeTyc"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.MeTyc (_, me, mt) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          module_expr
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s(" pc.Pprintf.bef;
                             Pprintf.aft = " :"}
                            me)
                       (fun pc ->
                          module_type
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            mt))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeUnp"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eacc [Extfun.Econ "None"];
              Extfun.Eacc [Extfun.Econ "None"]],
           false,
           (function
              MLast.MeUnp (_, e, None, None) ->
                Some
                  (fun curr next top bottom pc ->
                     expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(val " pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       e)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeUnp"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()];
              Extfun.Eacc [Extfun.Econ "None"]],
           false,
           (function
              MLast.MeUnp (_, e, Some mt, None) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          expr
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s(val " pc.Pprintf.bef;
                             Pprintf.aft = " :"}
                            e)
                       (fun pc ->
                          module_type
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            mt))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeUnp"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()];
              Extfun.Eapp [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]],
           false,
           (function
              MLast.MeUnp (_, e, Some mt1, Some mt2) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          Pprintf.sprint_break 1 0 pc
                            (fun pc ->
                               expr
                                 {pc with Pprintf.bef =
                                   Pretty.sprintf "%s(val " pc.Pprintf.bef;
                                  Pprintf.aft = " :"}
                                 e)
                            (fun pc ->
                               module_type {pc with Pprintf.aft = " :>"} mt1))
                       (fun pc ->
                          module_type
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            mt2))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MeUid"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.MeUid (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s%s" pc.Pprintf.bef s pc.Pprintf.aft)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let fail () =
                     Ploc.raise (MLast.loc_of_module_expr z)
                       (Failure
                          (sprintf "pr_module_expr %d"
                             (Obj.tag (Obj.repr z))))
                   in
                   let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                   bottom ~fail:fail
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s(" pc.Pprintf.bef;
                      Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                     z))])];
  Eprinter.extend pr_module_type None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtFun"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.MtFun (_, Ploc.VaVal arg, mt2) ->
                Some
                  (fun curr next top bottom pc ->
                     str_or_sig_functor pc (functor_parameter_unvala arg)
                       module_type mt2)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtTyo"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.MtTyo (_, me) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          Pretty.sprintf "%smodule type of" pc.Pprintf.bef)
                       (fun pc -> module_expr pc me))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "alg_attribute",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtAtt"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.MtAtt (_, ct, Ploc.VaVal attr) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = "[@"} ct)
                       (attribute_body
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
                          attr))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "with",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtWit"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.MtWit (_, mt, Ploc.VaVal wcl) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          module_type {pc with Pprintf.aft = " with"} mt)
                       (fun pc ->
                          vlist2 with_constraint (and_before with_constraint)
                            pc wcl))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "sig",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtSig"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.MtSig (loc, Ploc.VaVal sil) ->
                Some
                  (fun curr next top bottom pc ->
                     let sig_item_sep =
                       if !flag_semi_semi then semi_semi_after sig_item
                       else sig_item
                     in
                     horiz_vertic
                       (fun () ->
                          if alone_in_line pc then sprintf "\n"
                          else
                            hlist sig_item_sep
                              {pc with Pprintf.bef =
                                Pretty.sprintf "%ssig " pc.Pprintf.bef;
                               Pprintf.aft =
                                 Pretty.sprintf " end%s" pc.Pprintf.aft}
                              sil)
                       (fun () ->
                          Pprintf.sprint_break 1 0 pc
                            (fun pc ->
                               Pprintf.sprint_break 1 2 pc
                                 (fun pc ->
                                    Pretty.sprintf "%ssig" pc.Pprintf.bef)
                                 (fun pc -> vlist sig_item_sep pc sil))
                            (fun pc ->
                               Pretty.sprintf "%send%s" pc.Pprintf.bef
                                 pc.Pprintf.aft)))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "dot",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtLid"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.MtLid (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s%s" pc.Pprintf.bef s pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtLong"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.MtLong (_, li) ->
                Some (fun curr next top bottom pc -> longident pc li)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtLongLid"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.MtLongLid (_, li, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     longident
                       {pc with Pprintf.aft =
                         Pretty.sprintf ".%s%s" s pc.Pprintf.aft}
                       li)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "simple",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.MtExten (_, e) ->
                Some (fun curr next top bottom pc -> pr_extension "%" pc e)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "MtLong"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "LiUid"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                    Extfun.Evar ()]]],
           false,
           (function
              MLast.MtLong (_, MLast.LiUid (_, Ploc.VaVal s)) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s%s" pc.Pprintf.bef s pc.Pprintf.aft)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "bottom",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   let fail () =
                     Ploc.raise (MLast.loc_of_module_type z)
                       (Failure
                          (sprintf "pr_module_type %d"
                             (Obj.tag (Obj.repr z))))
                   in
                   bottom ~fail:fail
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s(" pc.Pprintf.bef;
                      Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                     z))])]

let space_before elem pc x =
  elem {pc with Pprintf.bef = Pretty.sprintf "%s " pc.Pprintf.bef} x
let or_before elem pc x =
  elem {pc with Pprintf.bef = Pretty.sprintf "%sor " pc.Pprintf.bef} x
let amp_after elem pc x =
  elem {pc with Pprintf.aft = Pretty.sprintf " &%s" pc.Pprintf.aft} x

let option elem pc x =
  match x with
    Some x -> elem pc x
  | None -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft

(* main part *)

let sep = Pcaml.inter_phrases

let output_string_eval oc s =
  let rec loop i =
    if i == String.length s then ()
    else if i == String.length s - 1 then output_char oc s.[i]
    else
      match s.[i], s.[i+1] with
        '\\', 'n' -> output_char oc '\n'; loop (i + 2)
      | c, _ -> output_char oc c; loop (i + 1)
  in
  loop 0

let apply_printer f (ast, eoi_loc) =
  let oc =
    match !(Pcaml.output_file) with
      Some f -> open_out_bin f
    | None -> pervasives_set_binary_mode_out stdout true; stdout
  in
  let cleanup () =
    match !(Pcaml.output_file) with
      Some f -> close_out oc
    | None -> ()
  in
  begin try
    let _ =
      List.fold_left
        (fun first (si, loc) ->
           begin match !sep with
             Some str -> if first then () else output_string_eval oc str
           | None -> output_string oc (Ploc.comment loc)
           end;
           flush oc;
           let k = if !flag_semi_semi then ";;" else "" in
           output_string oc (f {ind = 0; bef = ""; aft = k; dang = ""} si);
           false)
        true ast
    in
    output_string oc (Ploc.comment eoi_loc); flush oc
  with exn -> cleanup (); raise exn
  end;
  cleanup ()

let _ = Pcaml.print_interf := apply_printer sig_item
let _ = Pcaml.print_implem := apply_printer str_item

let is_uppercase c = char_uppercase c = c

let set_flags s =
  let rec loop i =
    if i = String.length s then ()
    else
      let is_upp = is_uppercase s.[i] in
      begin match s.[i] with
        'A' | 'a' ->
          flag_comments_in_phrases := is_upp;
          flag_equilibrate_cases := is_upp;
          flag_expand_letop_syntax := is_upp;
          flag_extensions_are_irrefutable := is_upp;
          flag_horiz_let_in := is_upp;
          flag_semi_semi := is_upp
      | 'C' | 'c' -> flag_comments_in_phrases := is_upp
      | 'E' | 'e' -> flag_equilibrate_cases := is_upp
      | 'I' | 'i' -> flag_extensions_are_irrefutable := is_uppercase s.[i]
      | 'L' | 'l' -> flag_horiz_let_in := is_upp
      | 'M' | 'm' -> flag_semi_semi := is_upp
      | 'O' | 'o' -> flag_add_locations := is_upp
      | 'X' | 'x' -> flag_expand_letop_syntax := is_upp
      | c -> failwith ("bad flag " ^ String.make 1 c)
      end;
      loop (i + 1)
  in
  loop 0

let default_flag () =
  let flag_on b t f = if b then t else "" in
  let flag_off b t f = if b then "" else f in
  let on_off flag =
    sprintf "%s%s%s%s%s%s%s" (flag !flag_comments_in_phrases "C" "c")
      (flag !flag_equilibrate_cases "E" "e")
      (flag !flag_extensions_are_irrefutable "I" "i")
      (flag !flag_horiz_let_in "L" "l") (flag !flag_semi_semi "M" "m")
      (flag !flag_add_locations "O" "o")
      (flag !flag_expand_letop_syntax "X" "x")
  in
  let on = on_off flag_on in
  let off = on_off flag_off in
  if String.length on < String.length off then sprintf "a%s" on
  else sprintf "A%s" off

let _ =
  Pcaml.add_option "-flag" (Arg.String set_flags)
    ("<str> Change pretty printing behaviour according to <str>:
       A/a enable/disable all flags
       C/c enable/disable comments in phrases
       E/e enable/disable equilibrate cases
       I/i enable/disable extensions in patterns treated as irrefutable
       L/l enable/disable allowing printing 'let..in' horizontally
       M/m enable/disable printing double semicolons
       O/o enable/disable adding location comments
       Z/z enable/disable compatibility with old versions of OCaml
       default setting is \"" ^
     default_flag () ^ "\".")

let _ =
  Pcaml.add_option "-l" (Arg.Int (fun x -> Pretty.line_length := x))
    ("<length> Maximum line length for pretty printing (default " ^
     string_of_int !(Pretty.line_length) ^ ")")

let _ =
  Pcaml.add_option "-sep_src" (Arg.Unit (fun () -> sep := None))
    "Read source file for text between phrases (default)."

let _ =
  Pcaml.add_option "-sep" (Arg.String (fun x -> sep := Some x))
    "<string> Use this string between phrases instead of reading source."

let _ =
  Pcaml.add_option "-ss" (Arg.Set flag_semi_semi)
    "(obsolete since version 4.02; use rather \"-flag M\")."

let _ =
  Pcaml.add_option "-no_ss" (Arg.Clear flag_semi_semi)
    "(obsolete since version 4.02; use rather \"-flag m\")."

let _ =
  Pcaml.add_option "-cip" (Arg.Unit (fun x -> x))
    "(obsolete since version 4.02; use rather \"-flag C\")"

let _ =
  Pcaml.add_option "-ncip" (Arg.Unit (fun x -> x))
    "(obsolete since version 4.02; use rather \"-flag c\")"

(* Pretty printing extension for objects and labels *)

let class_expr = Eprinter.apply pr_class_expr
let class_type = Eprinter.apply pr_class_type
let class_str_item = Eprinter.apply pr_class_str_item
let class_sig_item = Eprinter.apply pr_class_sig_item

let amp_before elem pc x =
  elem {pc with Pprintf.bef = Pretty.sprintf "%s& " pc.Pprintf.bef} x

let class_type_params pc (loc, ctp) =
  if ctp = [] then Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft
  else
    let ctp = List.map (fun ct -> (loc, ct), ",") ctp in
    Pprintf.sprint_break 1 2 pc
      (fun pc ->
         plist type_param 1
           {pc with Pprintf.bef = Pretty.sprintf "%s[" pc.Pprintf.bef;
            Pprintf.aft = "]"}
           ctp)
      (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)

let class_def pc ci =
  Pprintf.sprint_break 1 2 pc
    (fun pc ->
       Pretty.sprintf "%s%s"
         (class_type_params
            {pc with Pprintf.bef =
              Pretty.sprintf "%s%s" pc.Pprintf.bef
                (if Pcaml.unvala ci.MLast.ciVir then "virtual " else "");
             Pprintf.aft = ""}
            (ci.MLast.ciLoc, Pcaml.unvala (snd ci.MLast.ciPrm)))
         (var_escaped_noloc {pc with Pprintf.bef = ""; Pprintf.aft = " :"}
            (Pcaml.unvala ci.MLast.ciNam)))
    (fun pc ->
       Pretty.sprintf "%s%s"
         (class_type {pc with Pprintf.aft = ""} ci.MLast.ciExp)
         (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
            (Pcaml.unvala ci.MLast.ciAttributes)))

let class_type_decl pc ci =
  Pprintf.sprint_break 1 2 pc
    (fun pc ->
       Pretty.sprintf "%s%s"
         (class_type_params
            {pc with Pprintf.bef =
              Pretty.sprintf "%s%s" pc.Pprintf.bef
                (if Pcaml.unvala ci.MLast.ciVir then "virtual " else "");
             Pprintf.aft = ""}
            (ci.MLast.ciLoc, Pcaml.unvala (snd ci.MLast.ciPrm)))
         (var_escaped_noloc {pc with Pprintf.bef = ""; Pprintf.aft = " ="}
            (Pcaml.unvala ci.MLast.ciNam)))
    (fun pc ->
       Pretty.sprintf "%s%s"
         (class_type {pc with Pprintf.aft = ""} ci.MLast.ciExp)
         (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
            (Pcaml.unvala ci.MLast.ciAttributes)))

let class_type_decl_list pc loc cd =
  horiz_vertic
    (fun () ->
       hlist2 class_type_decl (and_before class_type_decl)
         {pc with Pprintf.bef = Pretty.sprintf "%sclass type " pc.Pprintf.bef}
         cd)
    (fun () ->
       vlist2 class_type_decl (and_before class_type_decl)
         {pc with Pprintf.bef = Pretty.sprintf "%sclass type " pc.Pprintf.bef}
         cd)

let class_type_opt pc =
  function
    Some ct ->
      Pprintf.sprint_break 1 0 pc
        (fun pc -> Pretty.sprintf "%s :" pc.Pprintf.bef)
        (fun pc -> class_type pc ct)
  | None -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft

let class_decl pc ci =
  let (pl, ce) =
    let rec loop =
      function
        MLast.CeFun (_, p, ce) as gce ->
          if is_irrefut_patt p then let (pl, ce) = loop ce in p :: pl, ce
          else [], gce
      | ce -> [], ce
    in
    loop ci.MLast.ciExp
  in
  let (ce, ct_opt) =
    match ce with
      MLast.CeTyc (_, ce, ct) -> ce, Some ct
    | ce -> ce, None
  in
  let cdef pc () =
    horiz_vertic
      (fun () ->
         Pretty.sprintf "%s%s%s%s"
           (class_type_params
              {pc with Pprintf.bef =
                Pretty.sprintf "%s%s" pc.Pprintf.bef
                  (if Pcaml.unvala ci.MLast.ciVir then "virtual " else "");
               Pprintf.aft = ""}
              (ci.MLast.ciLoc, Pcaml.unvala (snd ci.MLast.ciPrm)))
           (var_escaped_noloc
              {pc with Pprintf.bef = "";
               Pprintf.aft = if pl = [] then "" else " "}
              (Pcaml.unvala ci.MLast.ciNam))
           (hlist simple_patt {pc with Pprintf.bef = ""; Pprintf.aft = ""} pl)
           (class_type_opt
              {pc with Pprintf.bef = "";
               Pprintf.aft = Pretty.sprintf " =%s" pc.Pprintf.aft}
              ct_opt))
      (fun () ->
         let pl = List.map (fun p -> p, "") pl in
         let pc =
           {pc with bef =
             sprintf "%s%s%s%s " pc.bef
               (if Pcaml.unvala ci.MLast.ciVir then "virtual " else "")
               (class_type_params Pprintf.empty_pc
                  (ci.MLast.ciLoc, Pcaml.unvala (snd ci.MLast.ciPrm)))
               (var_escaped_bare (Pcaml.unvala ci.MLast.ciNam))}
         in
         Pretty.sprintf "%s%s"
           (plistl simple_patt simple_patt 4 {pc with Pprintf.aft = ""} pl)
           (class_type_opt
              {pc with Pprintf.bef = "";
               Pprintf.aft = Pretty.sprintf " =%s" pc.Pprintf.aft}
              ct_opt))
  in
  Pprintf.sprint_break 1 2 pc (fun pc -> cdef pc ())
    (fun pc ->
       Pretty.sprintf "%s%s" (class_expr {pc with Pprintf.aft = ""} ce)
         (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
            (Pcaml.unvala ci.MLast.ciAttributes)))

let variant_decl pc pv =
  match pv with
    MLast.PvTag
      (loc, Ploc.VaVal c, Ploc.VaVal true, Ploc.VaVal [], alg_attrs) ->
      Pretty.sprintf "%s%s"
        (var_escaped
           {pc with Pprintf.bef = Pretty.sprintf "%s`" pc.Pprintf.bef;
            Pprintf.aft = ""}
           (loc, c))
        (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
           (Pcaml.unvala alg_attrs))
  | MLast.PvTag
      (loc, Ploc.VaVal c, Ploc.VaVal ao, Ploc.VaVal tl, alg_attrs) ->
      let tl = List.map (fun t -> t, " &") tl in
      Pprintf.sprint_break 1 5 pc
        (fun pc ->
           var_escaped
             {pc with Pprintf.bef = Pretty.sprintf "%s`" pc.Pprintf.bef;
              Pprintf.aft = Pretty.sprintf " of%s" (if ao then " &" else "")}
             (loc, c))
        (fun pc ->
           Pretty.sprintf "%s%s" (plist ctyp 2 {pc with Pprintf.aft = ""} tl)
             (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
                (Pcaml.unvala alg_attrs)))
  | MLast.PvInh (_, t) -> ctyp pc t
  | _ -> failwith "Pr_ro.variant_decl"

let bquote_ident pc s =
  Pretty.sprintf "%s`%s%s" pc.Pprintf.bef s pc.Pprintf.aft

let variant_decl_list char loc pc pvl sl =
  if pvl = [] then
    Pretty.sprintf "%s[%s ]%s" pc.Pprintf.bef char pc.Pprintf.aft
  else
    horiz_vertic
      (fun () ->
         Pretty.sprintf "%s%s"
           (hlist2 variant_decl (bar_before variant_decl)
              {pc with Pprintf.bef =
                Pretty.sprintf "%s[%s " pc.Pprintf.bef char;
               Pprintf.aft = ""}
              pvl)
           ((fun pc ->
               function
                 [] -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft
               | sl ->
                   hlist bquote_ident
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s > " pc.Pprintf.bef}
                     sl)
              {pc with Pprintf.bef = "";
               Pprintf.aft = Pretty.sprintf " ]%s" pc.Pprintf.aft}
              sl))
      (fun () ->
         Pretty.sprintf "%s%s"
           (vlist2 variant_decl (bar_before variant_decl)
              {pc with Pprintf.bef =
                Pretty.sprintf "%s[%s " pc.Pprintf.bef char;
               Pprintf.aft = ""}
              pvl)
           ((fun pc ->
               function
                 [] -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft
               | sl ->
                   hlist bquote_ident
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s > " pc.Pprintf.bef}
                     sl)
              {pc with Pprintf.bef = "";
               Pprintf.aft = Pretty.sprintf " ]%s" pc.Pprintf.aft}
              sl))

let field pc =
  function
    Some s, t, attrs ->
      Pprintf.sprint_break 1 2 pc
        (fun pc -> Pretty.sprintf "%s%s :" pc.Pprintf.bef s)
        (fun pc ->
           Pretty.sprintf "%s%s" (ctyp {pc with Pprintf.aft = ""} t)
             (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
                (Pcaml.unvala attrs)))
  | None, t, attrs ->
      Pprintf.sprint_break 1 2 pc
        (fun pc -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
        (fun pc ->
           Pretty.sprintf "%s%s" (ctyp {pc with Pprintf.aft = ""} t)
             (hlist (pr_attribute "@") {pc with Pprintf.bef = ""}
                (Pcaml.unvala attrs)))

let field_expr pc (s, e) =
  Pprintf.sprint_break 1 2 pc
    (fun pc -> Pretty.sprintf "%s%s =" pc.Pprintf.bef s) (fun pc -> expr pc e)

let patt_tcon pc p =
  match p with
    MLast.PaTyc (_, p, t) ->
      Pprintf.sprint_break 1 0 pc
        (fun pc -> patt {pc with Pprintf.aft = " :"} p) (fun pc -> ctyp pc t)
  | p -> patt pc p

let typevar pc tv =
  var_escaped_noloc
    {pc with Pprintf.bef = Pretty.sprintf "%s'" pc.Pprintf.bef} tv

let class_object loc pc (csp, csl) =
  let class_str_item_sep =
    (*
        if flag_semi_semi.val then semi_semi_after class_str_item
        else *)    class_str_item
  in
  horiz_vertic
    (fun () ->
       Pretty.sprintf "%s%s"
         ((fun pc ->
             function
               Some (MLast.PaTyc (_, _, _) as p) ->
                 patt
                   {pc with Pprintf.bef = Pretty.sprintf "%s " pc.Pprintf.bef}
                   p
             | Some p ->
                 patt
                   {pc with Pprintf.bef =
                     Pretty.sprintf "%s (" pc.Pprintf.bef;
                    Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                   p
             | None -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
            {pc with Pprintf.bef = Pretty.sprintf "%sobject" pc.Pprintf.bef;
             Pprintf.aft = " "}
            csp)
         (hlist class_str_item_sep
            {pc with Pprintf.bef = "";
             Pprintf.aft = Pretty.sprintf " end%s" pc.Pprintf.aft}
            csl))
    (fun () ->
       Pprintf.sprint_break_all false pc
         (fun pc ->
            (fun pc ->
               function
                 Some (MLast.PaTyc (_, _, _) as p) ->
                   patt
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s " pc.Pprintf.bef}
                     p
               | Some p ->
                   patt
                     {pc with Pprintf.bef =
                       Pretty.sprintf "%s (" pc.Pprintf.bef;
                      Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                     p
               | None -> Pretty.sprintf "%s%s" pc.Pprintf.bef pc.Pprintf.aft)
              {pc with Pprintf.bef = Pretty.sprintf "%sobject" pc.Pprintf.bef}
              csp)
         [1, 2, (fun pc -> vlist class_str_item_sep pc csl);
          1, 0,
          (fun pc -> Pretty.sprintf "%send%s" pc.Pprintf.bef pc.Pprintf.aft)])

let simple_expr = Eprinter.apply_level pr_expr "simple"

(* *)

let label_ipatt_eq_patt curr pc (p, op) =
  match Pcaml.unvala op with
    Some p2 ->
      Pretty.sprintf "%s%s"
        (patt
           {pc with Pprintf.bef = Pretty.sprintf "%s~" pc.Pprintf.bef;
            Pprintf.aft = ":"}
           p)
        (curr {pc with Pprintf.bef = ""} p2)
  | None -> patt {pc with Pprintf.bef = Pretty.sprintf "%s~" pc.Pprintf.bef} p

let _ =
  Eprinter.extend pr_patt (Some (Eprinter.Level "simple"))
    [None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaTyp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaTyp (loc, Ploc.VaVal lili) ->
                Some
                  (fun curr next top bottom pc ->
                     longident_lident
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s#" pc.Pprintf.bef}
                       lili)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.PaVrn (loc, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     var_escaped
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s`" pc.Pprintf.bef}
                       (loc, s))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              MLast.PaOlb (_, p, Ploc.VaVal None) ->
                Some
                  (fun curr next top bottom pc ->
                     curr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s?" pc.Pprintf.bef}
                       p)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]]],
           false,
           (function
              MLast.PaOlb (_, p, Ploc.VaVal (Some e)) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          patt
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s?(" pc.Pprintf.bef;
                             Pprintf.aft = " ="}
                            p)
                       (fun pc ->
                          expr
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            e))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExOlb"];
                       Extfun.Evar (); Extfun.Evar ();
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                          Extfun.Eacc [Extfun.Econ "None"]]]]]],
           false,
           (function
              MLast.PaOlb
                (_, p1,
                 Ploc.VaVal (Some (MLast.ExOlb (_, p2, Ploc.VaVal None)))) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (patt
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%s?" pc.Pprintf.bef;
                           Pprintf.aft = ":("}
                          p1)
                       (patt
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                          p2))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExOlb"];
                       Extfun.Evar (); Extfun.Evar ();
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                          Extfun.Eapp
                            [Extfun.Eacc [Extfun.Econ "Some"];
                             Extfun.Evar ()]]]]]],
           false,
           (function
              MLast.PaOlb
                (_, p1,
                 Ploc.VaVal
                   (Some (MLast.ExOlb (_, p2, Ploc.VaVal (Some e))))) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          Pretty.sprintf "%s%s"
                            (patt
                               {pc with Pprintf.bef =
                                 Pretty.sprintf "%s?" pc.Pprintf.bef;
                                Pprintf.aft = ":("}
                               p1)
                            (patt
                               {pc with Pprintf.bef = ""; Pprintf.aft = " ="}
                               p2))
                       (fun pc ->
                          expr
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            e))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaTyc"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLid"];
                    Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]]],
           false,
           (function
              MLast.PaOlb
                (_, MLast.PaTyc (_, MLast.PaLid (_, Ploc.VaVal p), t),
                 Ploc.VaVal (Some e)) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          Pprintf.sprint_break 1 2 pc
                            (fun pc ->
                               Pretty.sprintf "%s?(%s :" pc.Pprintf.bef p)
                            (fun pc -> ctyp {pc with Pprintf.aft = " ="} t))
                       (fun pc ->
                          expr
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            e))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaOlb"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaTyc"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLid"];
                    Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              MLast.PaOlb
                (_, MLast.PaTyc (_, MLast.PaLid (_, Ploc.VaVal p), t),
                 Ploc.VaVal None) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc -> Pretty.sprintf "%s?(%s :" pc.Pprintf.bef p)
                       (fun pc ->
                          ctyp
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            t))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "PaLab"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.PaLab (_, p, po) ->
                Some
                  (fun curr next top bottom pc ->
                     label_ipatt_eq_patt curr pc (p, po))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_expr (Some (Eprinter.Level "apply"))
    [None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExObj"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExObj (loc, Ploc.VaVal csp, Ploc.VaVal csl) ->
                Some
                  (fun curr next top bottom pc ->
                     class_object loc pc (csp, csl))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExNew"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExNew (_, Ploc.VaVal lili) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc -> Pretty.sprintf "%snew" pc.Pprintf.bef)
                       (fun pc -> longident_lident pc lili))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_expr (Some (Eprinter.Level "dot"))
    [None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExApp"];
                 Extfun.Evar ();
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLid"];
                    Extfun.Evar ();
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           true,
           (function
              MLast.ExApp
                (_, MLast.ExApp (_, MLast.ExLid (_, Ploc.VaVal op), e1), e2)
              when is_hashop op ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          curr {pc with Pprintf.aft = Pretty.sprintf " %s" op}
                            e1)
                       (fun pc -> next pc e2))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExSnd"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExSnd (_, e, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 0 0 pc
                       (fun pc -> curr {pc with Pprintf.aft = "#"} e)
                       (fun pc ->
                          Pretty.sprintf "%s%s%s" pc.Pprintf.bef s
                            pc.Pprintf.aft))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_expr (Some (Eprinter.Level "simple"))
    [None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExObj"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "None"]];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExObj (_, Ploc.VaVal None, Ploc.VaVal _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExNew"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup
                   [Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Some"];
                       Extfun.Eapp
                         [Extfun.Eacc
                            [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                          Extfun.Evar ()]];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]]]],
           false,
           (function
              MLast.ExNew
                (_, Ploc.VaVal (Some (Ploc.VaVal _), Ploc.VaVal _)) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExNew"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Etup
                   [Extfun.Eacc [Extfun.Econ "None"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]]]],
           false,
           (function
              MLast.ExNew (_, Ploc.VaVal (None, Ploc.VaVal _)) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExVrn (loc, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     var_escaped
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s`" pc.Pprintf.bef}
                       (loc, s))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExOvr"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.ExOvr (_, Ploc.VaVal fel) ->
                Some
                  (fun curr next top bottom pc ->
                     if fel = [] then
                       Pretty.sprintf "%s{< >}%s" pc.Pprintf.bef
                         pc.Pprintf.aft
                     else
                       let fel = List.map (fun fe -> fe, ";") fel in
                       plist field_expr 3
                         {pc with Pprintf.bef =
                           Pretty.sprintf "%s{< " pc.Pprintf.bef;
                          Pprintf.aft = Pretty.sprintf " >}%s" pc.Pprintf.aft}
                         fel)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExCoe"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eacc [Extfun.Econ "None"]; Extfun.Evar ()],
           false,
           (function
              MLast.ExCoe (_, e, None, t) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          expr
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s(" pc.Pprintf.bef;
                             Pprintf.aft = " :>"}
                            e)
                       (fun pc ->
                          ctyp
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            t))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExCoe"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.ExCoe (_, e, Some t, t2) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break_all false pc
                       (fun pc ->
                          expr
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s(" pc.Pprintf.bef;
                             Pprintf.aft = " :"}
                            e)
                       [1, 1,
                        (fun pc -> ctyp {pc with Pprintf.aft = " :>"} t);
                        1, 1,
                        (fun pc ->
                           ctyp
                             {pc with Pprintf.aft =
                               Pretty.sprintf ")%s" pc.Pprintf.aft}
                             t2)])
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_ctyp (Some (Eprinter.After "star"))
    [Some "label",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyLab"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyLab (_, Ploc.VaVal i, t) ->
                Some
                  (fun curr next top bottom pc ->
                     curr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s%s:" pc.Pprintf.bef i}
                       t)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyOlb"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyOlb (_, Ploc.VaVal i, t) ->
                Some
                  (fun curr next top bottom pc ->
                     curr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s?%s:" pc.Pprintf.bef i}
                       t)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_ctyp (Some (Eprinter.Level "simple"))
    [None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyAli"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.TyAli (_, _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     ctyp
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Some"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Evar ()]]]],
           false,
           (function
              MLast.TyVrn
                (loc, Ploc.VaVal pvl, Some (Some (Ploc.VaVal vdl))) ->
                Some
                  (fun curr next top bottom pc ->
                     variant_decl_list "<" loc pc pvl vdl)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Some"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"];
                    Extfun.Eapp
                      [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                       Extfun.Eacc [Extfun.Econ "[]"]]]]],
           false,
           (function
              MLast.TyVrn
                (loc, Ploc.VaVal pvl, Some (Some (Ploc.VaVal []))) ->
                Some
                  (fun curr next top bottom pc ->
                     variant_decl_list "<" loc pc pvl [])
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Some"];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              MLast.TyVrn (loc, Ploc.VaVal pvl, Some None) ->
                Some
                  (fun curr next top bottom pc ->
                     variant_decl_list ">" loc pc pvl [])
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyVrn"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eacc [Extfun.Econ "None"]],
           false,
           (function
              MLast.TyVrn (loc, Ploc.VaVal pvl, None) ->
                Some
                  (fun curr next top bottom pc ->
                     let prefix =
                       match pvl with
                         [] -> ""
                       | MLast.PvInh (_, _) :: _ -> " |"
                       | _ -> ""
                     in
                     variant_decl_list prefix loc pc pvl [])
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyCls"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.TyCls (_, Ploc.VaVal lili) ->
                Some
                  (fun curr next top bottom pc ->
                     longident_lident
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s#" pc.Pprintf.bef}
                       lili)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyObj"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.TyObj (_, Ploc.VaVal ml, Ploc.VaVal v) ->
                Some
                  (fun curr next top bottom pc ->
                     if ml = [] then
                       Pretty.sprintf "%s<%s >%s" pc.Pprintf.bef
                         (if v then " .." else "") pc.Pprintf.aft
                     else
                       let ml = List.map (fun e -> e, ";") ml in
                       Pprintf.sprint_break 1 0 pc
                         (fun pc ->
                            plist field 0
                              {pc with Pprintf.bef =
                                Pretty.sprintf "%s< " pc.Pprintf.bef;
                               Pprintf.aft =
                                 Pretty.sprintf "%s >"
                                   (if v then "; .." else "")}
                              ml)
                         (fun pc ->
                            Pretty.sprintf "%s%s" pc.Pprintf.bef
                              pc.Pprintf.aft))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_sig_item (Some (Eprinter.Level "top"))
    [None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgClt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgClt (loc, Ploc.VaVal cd) ->
                Some
                  (fun curr next top bottom pc ->
                     class_type_decl_list pc loc cd)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "SgCls"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.SgCls (loc, Ploc.VaVal cd) ->
                Some
                  (fun curr next top bottom pc ->
                     horiz_vertic
                       (fun () ->
                          hlist2 class_def (and_before class_def)
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sclass " pc.Pprintf.bef}
                            cd)
                       (fun () ->
                          vlist2 class_def (and_before class_def)
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sclass " pc.Pprintf.bef}
                            cd))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_str_item (Some (Eprinter.Level "top"))
    [None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StClt"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StClt (loc, Ploc.VaVal cd) ->
                Some
                  (fun curr next top bottom pc ->
                     class_type_decl_list pc loc cd)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "StCls"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.StCls (loc, Ploc.VaVal cd) ->
                Some
                  (fun curr next top bottom pc ->
                     horiz_vertic
                       (fun () ->
                          hlist2 class_decl (and_before class_decl)
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sclass " pc.Pprintf.bef}
                            cd)
                       (fun () ->
                          vlist2 class_decl (and_before class_decl)
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sclass " pc.Pprintf.bef}
                            cd))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])]

let sig_method_or_method_virtual pc virt priv s t item_attrs =
  Pprintf.sprint_break 1 2 pc
    (fun pc ->
       var_escaped_noloc
         {pc with Pprintf.bef =
           Pretty.sprintf "%smethod%s%s " pc.Pprintf.bef virt
             (if priv then " private" else "");
          Pprintf.aft = " :"}
         s)
    (fun pc ->
       Pretty.sprintf "%s%s" (ctyp {pc with Pprintf.aft = ""} t)
         (hlist (pr_attribute "@@") {pc with Pprintf.bef = ""}
            (Pcaml.unvala item_attrs)))

let poly_type pc =
  function
    MLast.TyPol (_, Ploc.VaVal tpl, t) ->
      Pprintf.sprint_break 1 2 pc
        (fun pc -> hlist typevar {pc with Pprintf.aft = " ."} tpl)
        (fun pc -> ctyp pc t)
  | t -> ctyp pc t

let label_ipatt expr pc (p, oe) =
  match Pcaml.unvala oe with
    Some e ->
      Pretty.sprintf "%s%s"
        (patt
           {pc with Pprintf.bef = Pretty.sprintf "%s~" pc.Pprintf.bef;
            Pprintf.aft = ":"}
           p)
        (expr {pc with Pprintf.bef = ""} e)
  | None -> patt {pc with Pprintf.bef = Pretty.sprintf "%s~" pc.Pprintf.bef} p

let _ =
  Eprinter.extend pr_expr (Some (Eprinter.After "apply"))
    [Some "label",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "None"]]],
           false,
           (function
              MLast.ExOlb (_, p, Ploc.VaVal None) ->
                Some
                  (fun curr next top bottom pc ->
                     patt
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s?" pc.Pprintf.bef}
                       p)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExOlb"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eapp
                   [Extfun.Eacc [Extfun.Econ "Some"]; Extfun.Evar ()]]],
           false,
           (function
              MLast.ExOlb (_, p, Ploc.VaVal (Some e)) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (patt
                          {pc with Pprintf.bef =
                            Pretty.sprintf "%s?" pc.Pprintf.bef;
                           Pprintf.aft = ":"}
                          p)
                       (curr {pc with Pprintf.bef = ""} e))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "ExLab"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.ExLab (_, p, oe) ->
                Some
                  (fun curr next top bottom pc -> label_ipatt curr pc (p, oe))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_ctyp (Some (Eprinter.After "below_alg_attribute"))
    [Some "as",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyAli"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.TyAli (_, t1, t2) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc =
                       {pc with Pprintf.aft =
                         let pc = {pc with Pprintf.bef = ""} in
                         next {pc with Pprintf.bef = " as "} t2}
                     in
                     curr pc t1)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "poly",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyPot"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyPot (loc, Ploc.VaVal pl, t) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          hlist lident
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%stype " pc.Pprintf.bef;
                             Pprintf.aft = " ."}
                            pl)
                       (fun pc -> ctyp pc t))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyPol"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyPol (_, Ploc.VaVal _, _) as z ->
                Some (fun curr next top bottom pc -> poly_type pc z)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_ctyp (Some (Eprinter.After "arrow"))
    [Some "label",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyLab"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyLab (_, Ploc.VaVal i, t) ->
                Some
                  (fun curr next top bottom pc ->
                     curr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s%s:" pc.Pprintf.bef i}
                       t)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyOlb"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyOlb (_, Ploc.VaVal i, t) ->
                Some
                  (fun curr next top bottom pc ->
                     curr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s?%s:" pc.Pprintf.bef i}
                       t)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_ctyp (Some (Eprinter.After "bottom"))
    [Some "catch-poly",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyPot"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyPot (loc, Ploc.VaVal pl, t) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     ctyp
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "TyPol"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.TyPol (_, Ploc.VaVal _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     ctyp
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))])];
  Eprinter.extend pr_class_expr None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeLop"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CeLop (_, ovf, li, ce) ->
                Some
                  (fun curr next top bottom pc ->
                     let ovf = if Pcaml.unvala ovf then "!" else "" in
                     if pc.dang = ";" then
                       Pprintf.sprint_break 1 0 pc
                         (fun pc ->
                            let pc =
                              {pc with Pprintf.aft =
                                let pc = {pc with Pprintf.bef = ""} in
                                Pprintf.sprint_break_all false pc
                                  (fun pc ->
                                     longident
                                       {pc with Pprintf.bef =
                                         Pretty.sprintf "let open%s " ovf}
                                       li)
                                  [1, 0, (fun pc -> "in")]}
                            in
                            Pretty.sprintf "%s(%s" pc.Pprintf.bef
                              pc.Pprintf.aft)
                         (fun pc ->
                            curr
                              {pc with Pprintf.aft =
                                Pretty.sprintf ")%s" pc.Pprintf.aft}
                              ce)
                     else
                       Pprintf.sprint_break 1 0 pc
                         (fun pc ->
                            Pprintf.sprint_break_all false pc
                              (fun pc ->
                                 longident
                                   {pc with Pprintf.bef =
                                     Pretty.sprintf "%slet open%s "
                                       pc.Pprintf.bef ovf}
                                   li)
                              [1, 0,
                               (fun pc ->
                                  Pretty.sprintf "%sin" pc.Pprintf.bef)])
                         (fun pc -> curr pc ce))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeLet"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.CeLet (loc, Ploc.VaVal rf, Ploc.VaVal pel, ce) ->
                Some
                  (fun curr next top bottom pc ->
                     horiz_vertic
                       (fun () ->
                          Pretty.sprintf "%s%s"
                            (hlist2 (binding patt expr)
                               (and_before (binding patt expr))
                               {pc with Pprintf.bef =
                                 Pretty.sprintf "%slet%s " pc.Pprintf.bef
                                   (if rf then " rec" else "");
                                Pprintf.aft = " in "}
                               pel)
                            (class_expr {pc with Pprintf.bef = ""} ce))
                       (fun () ->
                          Pprintf.sprint_break 1 0 pc
                            (fun pc ->
                               vlist2 (binding patt expr)
                                 (and_before (binding patt expr))
                                 {pc with Pprintf.bef =
                                   Pretty.sprintf "%slet%s " pc.Pprintf.bef
                                     (if rf then " rec" else "");
                                  Pprintf.aft = " in"}
                                 pel)
                            (fun pc -> class_expr pc ce)))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeFun"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CeFun (_, p, ce) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          patt
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sfun " pc.Pprintf.bef;
                             Pprintf.aft = " ->"}
                            p)
                       (fun pc -> curr pc ce))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "alg_attribute",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeAtt"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.CeAtt (_, ct, Ploc.VaVal attr) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = "[@"} ct)
                       (attribute_body
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
                          attr))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CeExten (_, e) ->
                Some (fun curr next top bottom pc -> pr_extension "%" pc e)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "apply",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeApp"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CeApp (_, ce, e) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc (fun pc -> curr pc ce)
                       (fun pc -> Eprinter.apply_level pr_expr "label" pc e))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "simple",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeLop"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CeLop (_, _, _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     class_expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeLet"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.CeLet (_, Ploc.VaVal _, Ploc.VaVal _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     class_expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CeExten (_, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     class_expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeFun"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CeFun (_, _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     class_expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeApp"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CeApp (_, _, _) as z ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     class_expr
                       {pc with Pprintf.bef =
                         Pretty.sprintf "%s(" pc.Pprintf.bef;
                        Pprintf.aft = Pretty.sprintf ")%s" pc.Pprintf.aft}
                       z)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeTyc"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CeTyc (_, ce, ct) ->
                Some
                  (fun curr next top bottom pc ->
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 0 pc
                       (fun pc ->
                          class_expr
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s(" pc.Pprintf.bef;
                             Pprintf.aft = " :"}
                            ce)
                       (fun pc ->
                          class_type
                            {pc with Pprintf.aft =
                              Pretty.sprintf ")%s" pc.Pprintf.aft}
                            ct))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeStr"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.CeStr (loc, Ploc.VaVal csp, Ploc.VaVal csl) ->
                Some
                  (fun curr next top bottom pc ->
                     class_object loc pc (csp, csl))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeCon"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.CeCon (_, Ploc.VaVal lili, Ploc.VaVal ctcl) ->
                Some
                  (fun curr next top bottom pc ->
                     let ctcl = List.map (fun ct -> ct, ",") ctcl in
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          plist ctyp 0
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s[" pc.Pprintf.bef;
                             Pprintf.aft = "]"}
                            ctcl)
                       (fun pc -> longident_lident pc lili))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CeCon"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Eacc [Extfun.Econ "[]"]]],
           false,
           (function
              MLast.CeCon (_, Ploc.VaVal lili, Ploc.VaVal []) ->
                Some (fun curr next top bottom pc -> longident_lident pc lili)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "bottom",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   error (MLast.loc_of_class_expr z)
                     (sprintf "pr_class_expr %d" (Obj.tag (Obj.repr z)))))])];
  Eprinter.extend pr_class_type None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CtLop"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CtLop (_, ovf, li, ce) ->
                Some
                  (fun curr next top bottom pc ->
                     let ovf = if Pcaml.unvala ovf then "!" else "" in
                     if pc.dang = ";" then
                       Pprintf.sprint_break 1 0 pc
                         (fun pc ->
                            let pc =
                              {pc with Pprintf.aft =
                                let pc = {pc with Pprintf.bef = ""} in
                                Pprintf.sprint_break_all false pc
                                  (fun pc ->
                                     longident
                                       {pc with Pprintf.bef =
                                         Pretty.sprintf "let open%s " ovf}
                                       li)
                                  [1, 0, (fun pc -> "in")]}
                            in
                            Pretty.sprintf "%s(%s" pc.Pprintf.bef
                              pc.Pprintf.aft)
                         (fun pc ->
                            curr
                              {pc with Pprintf.aft =
                                Pretty.sprintf ")%s" pc.Pprintf.aft}
                              ce)
                     else
                       Pprintf.sprint_break 1 0 pc
                         (fun pc ->
                            Pprintf.sprint_break_all false pc
                              (fun pc ->
                                 longident
                                   {pc with Pprintf.bef =
                                     Pretty.sprintf "%slet open%s "
                                       pc.Pprintf.bef ovf}
                                   li)
                              [1, 0,
                               (fun pc ->
                                  Pretty.sprintf "%sin" pc.Pprintf.bef)])
                         (fun pc -> curr pc ce))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CtFun"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CtFun (_, t, ct) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          Eprinter.apply_level pr_ctyp "star"
                            {pc with Pprintf.aft = " ->"} t)
                       (fun pc -> curr pc ct))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "alg_attribute",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CtAtt"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.CtAtt (_, ct, Ploc.VaVal attr) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s"
                       (curr {pc with Pprintf.aft = "[@"} ct)
                       (attribute_body
                          {pc with Pprintf.bef = "";
                           Pprintf.aft = Pretty.sprintf "]%s" pc.Pprintf.aft}
                          attr))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CtCon"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.CtCon (_, ct, Ploc.VaVal ctcl) ->
                Some
                  (fun curr next top bottom pc ->
                     let ctcl = List.map (fun ct -> ct, ",") ctcl in
                     let pc = {pc with Pprintf.ind = pc.Pprintf.ind + 1} in
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          plist ctyp 0
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%s[" pc.Pprintf.bef;
                             Pprintf.aft = "]"}
                            ctcl)
                       (fun pc -> curr pc ct))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CtSig"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.CtSig (loc, Ploc.VaVal cst, Ploc.VaVal csi) ->
                Some
                  (fun curr next top bottom pc ->
                     let class_sig_item_sep =
                       (* if flag_semi_semi.val then semi_semi_after class_sig_item
                       else *)                       class_sig_item
                     in
                     horiz_vertic
                       (fun () ->
                          if alone_in_line pc then sprintf "\n"
                          else
                            Pretty.sprintf "%s%s"
                              ((fun pc ->
                                  function
                                    Some t ->
                                      ctyp
                                        {pc with Pprintf.bef =
                                          Pretty.sprintf "%s ("
                                            pc.Pprintf.bef;
                                         Pprintf.aft =
                                           Pretty.sprintf ")%s"
                                             pc.Pprintf.aft}
                                        t
                                  | None ->
                                      Pretty.sprintf "%s%s" pc.Pprintf.bef
                                        pc.Pprintf.aft)
                                 {pc with Pprintf.bef =
                                   Pretty.sprintf "%sobject" pc.Pprintf.bef;
                                  Pprintf.aft = " "}
                                 cst)
                              (hlist class_sig_item_sep
                                 {pc with Pprintf.bef = "";
                                  Pprintf.aft =
                                    Pretty.sprintf " end%s" pc.Pprintf.aft}
                                 csi))
                       (fun () ->
                          Pprintf.sprint_break_all false pc
                            (fun pc ->
                               (fun pc ->
                                  function
                                    Some t ->
                                      Pprintf.sprint_break 1 2 pc
                                        (fun pc ->
                                           Pretty.sprintf "%sobject"
                                             pc.Pprintf.bef)
                                        (fun pc ->
                                           ctyp
                                             {pc with Pprintf.bef =
                                               Pretty.sprintf "%s("
                                                 pc.Pprintf.bef;
                                              Pprintf.aft =
                                                Pretty.sprintf ")%s"
                                                  pc.Pprintf.aft}
                                             t)
                                  | None ->
                                      Pretty.sprintf "%sobject%s"
                                        pc.Pprintf.bef pc.Pprintf.aft)
                                 pc cst)
                            [1, 2,
                             (fun pc -> vlist class_sig_item_sep pc csi);
                             1, 0,
                             (fun pc ->
                                Pretty.sprintf "%send%s" pc.Pprintf.bef
                                  pc.Pprintf.aft)]))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "dot",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CtLid"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.CtLid (_, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     Pretty.sprintf "%s%s%s" pc.Pprintf.bef s pc.Pprintf.aft)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CtLongLid"];
              Extfun.Evar (); Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()]],
           false,
           (function
              MLast.CtLongLid (_, li, Ploc.VaVal s) ->
                Some
                  (fun curr next top bottom pc ->
                     longident
                       {pc with Pprintf.aft =
                         Pretty.sprintf ".%s%s" s pc.Pprintf.aft}
                       li)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     None,
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CtExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CtExten (_, e) ->
                Some (fun curr next top bottom pc -> pr_extension "%" pc e)
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "bottom",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   error (MLast.loc_of_class_type z)
                     (sprintf "pr_class_type %d" (Obj.tag (Obj.repr z)))))])];
  Eprinter.extend pr_class_sig_item None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CgExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CgExten (_, e) ->
                Some (fun curr next top bottom pc -> pr_extension "%%" pc e)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CgFlAtt"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CgFlAtt (_, attr) ->
                Some
                  (fun curr next top bottom pc -> pr_attribute "@@@" pc attr)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CgVal"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CgVal
                (loc, Ploc.VaVal mf, Ploc.VaVal vf, Ploc.VaVal s, t,
                 item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          var_escaped
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sval%s%s " pc.Pprintf.bef
                                (if mf then " mutable" else "")
                                (if vf then " virtual" else "");
                             Pprintf.aft = " :"}
                            (loc, s))
                       (fun pc ->
                          Pretty.sprintf "%s%s"
                            (ctyp {pc with Pprintf.aft = ""} t)
                            (hlist (pr_attribute "@@")
                               {pc with Pprintf.bef = ""}
                               (Pcaml.unvala item_attrs))))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CgCtr"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CgCtr (_, t1, t2, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          ctyp
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sconstraint " pc.Pprintf.bef;
                             Pprintf.aft = " ="}
                            t1)
                       (fun pc ->
                          Pretty.sprintf "%s%s"
                            (ctyp {pc with Pprintf.aft = ""} t2)
                            (hlist (pr_attribute "@@")
                               {pc with Pprintf.bef = ""}
                               (Pcaml.unvala item_attrs))))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CgVir"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CgVir (_, Ploc.VaVal priv, Ploc.VaVal s, t, attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     sig_method_or_method_virtual pc " virtual" priv s t
                       attrs)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CgMth"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CgMth (_, Ploc.VaVal priv, Ploc.VaVal s, t, attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     sig_method_or_method_virtual pc "" priv s t attrs)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CgInh"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CgInh (_, ct, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc -> Pretty.sprintf "%sinherit" pc.Pprintf.bef)
                       (fun pc ->
                          Pretty.sprintf "%s%s"
                            (class_type {pc with Pprintf.aft = ""} ct)
                            (hlist (pr_attribute "@@")
                               {pc with Pprintf.bef = ""}
                               (Pcaml.unvala item_attrs))))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "bottom",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   error (MLast.loc_of_class_sig_item z)
                     (sprintf "pr_class_sig_item %d"
                        (Obj.tag (Obj.repr z)))))])];
  Eprinter.extend pr_class_str_item None
    [Some "top",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CrExten"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CrExten (_, e) ->
                Some (fun curr next top bottom pc -> pr_extension "%%" pc e)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CrFlAtt"];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CrFlAtt (_, attr) ->
                Some
                  (fun curr next top bottom pc -> pr_attribute "@@@" pc attr)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CrVav"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CrVav (_, Ploc.VaVal mf, Ploc.VaVal s, t, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          var_escaped_noloc
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sval virtual%s " pc.Pprintf.bef
                                (if mf then " mutable" else "");
                             Pprintf.aft = " :"}
                            s)
                       (fun pc ->
                          Pretty.sprintf "%s%s"
                            (ctyp {pc with Pprintf.aft = ""} t)
                            (hlist (pr_attribute "@@")
                               {pc with Pprintf.bef = ""}
                               (Pcaml.unvala item_attrs))))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CrVal"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CrVal
                (_, Ploc.VaVal ovf, Ploc.VaVal mf, Ploc.VaVal s, e,
                 item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          var_escaped_noloc
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sval%s%s " pc.Pprintf.bef
                                (if ovf then "!" else "")
                                (if mf then " mutable" else "");
                             Pprintf.aft = " ="}
                            s)
                       (fun pc ->
                          Pretty.sprintf "%s%s"
                            (expr {pc with Pprintf.aft = ""} e)
                            (hlist (pr_attribute "@@")
                               {pc with Pprintf.bef = ""}
                               (Pcaml.unvala item_attrs))))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CrCtr"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CrCtr (_, t1, t2, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          ctyp
                            {pc with Pprintf.bef =
                              Pretty.sprintf "%sconstraint " pc.Pprintf.bef;
                             Pprintf.aft = " ="}
                            t1)
                       (fun pc ->
                          Pretty.sprintf "%s%s"
                            (ctyp {pc with Pprintf.aft = ""} t2)
                            (hlist (pr_attribute "@@")
                               {pc with Pprintf.bef = ""}
                               (Pcaml.unvala item_attrs))))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CrMth"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CrMth
                (_, Ploc.VaVal ov, Ploc.VaVal priv, Ploc.VaVal s,
                 Ploc.VaVal topt, e, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     let (pl, e) =
                       match topt with
                         Some _ -> [], e
                       | None -> expr_fun_args e
                     in
                     let simple_patt =
                       Eprinter.apply_level pr_patt "simple"
                     in
                     match topt with
                       None ->
                         Pprintf.sprint_break 1 2 pc
                           (fun pc ->
                              Pretty.sprintf "%s%s"
                                (var_escaped_noloc
                                   {pc with Pprintf.bef =
                                     Pretty.sprintf "%smethod%s%s "
                                       pc.Pprintf.bef (if ov then "!" else "")
                                       (if priv then " private" else "");
                                    Pprintf.aft = if pl = [] then "" else " "}
                                   s)
                                (hlist simple_patt
                                   {pc with Pprintf.bef = "";
                                    Pprintf.aft = " ="}
                                   pl))
                           (fun pc ->
                              Pretty.sprintf "%s%s"
                                (expr {pc with Pprintf.aft = ""} e)
                                (hlist (pr_attribute "@@")
                                   {pc with Pprintf.bef = ""}
                                   (Pcaml.unvala item_attrs)))
                     | Some t ->
                         Pprintf.sprint_break 1 2 pc
                           (fun pc ->
                              Pprintf.sprint_break 1 4 pc
                                (fun pc ->
                                   Pretty.sprintf "%s%s"
                                     (var_escaped_noloc
                                        {pc with Pprintf.bef =
                                          Pretty.sprintf "%smethod%s%s "
                                            pc.Pprintf.bef
                                            (if ov then "!" else "")
                                            (if priv then " private" else "");
                                         Pprintf.aft =
                                           if pl = [] then "" else " "}
                                        s)
                                     (hlist simple_patt
                                        {pc with Pprintf.bef = "";
                                         Pprintf.aft = " :"}
                                        pl))
                                (fun pc ->
                                   poly_type {pc with Pprintf.aft = " ="} t))
                           (fun pc ->
                              Pretty.sprintf "%s%s"
                                (expr {pc with Pprintf.aft = ""} e)
                                (hlist (pr_attribute "@@")
                                   {pc with Pprintf.bef = ""}
                                   (Pcaml.unvala item_attrs))))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CrVir"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CrVir (_, Ploc.VaVal priv, Ploc.VaVal s, t, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     sig_method_or_method_virtual pc " virtual" priv s t
                       item_attrs)
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CrIni"];
              Extfun.Evar (); Extfun.Evar (); Extfun.Evar ()],
           false,
           (function
              MLast.CrIni (_, e, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          Pretty.sprintf "%sinitializer" pc.Pprintf.bef)
                       (fun pc ->
                          Pretty.sprintf "%s%s"
                            (expr {pc with Pprintf.aft = ""} e)
                            (hlist (pr_attribute "@@")
                               {pc with Pprintf.bef = ""}
                               (Pcaml.unvala item_attrs))))
            | _ -> None);
           Extfun.Eapp
             [Extfun.Eacc [Extfun.Econ "MLast"; Extfun.Econ "CrInh"];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ();
              Extfun.Eapp
                [Extfun.Eacc [Extfun.Econ "Ploc"; Extfun.Econ "VaVal"];
                 Extfun.Evar ()];
              Extfun.Evar ()],
           false,
           (function
              MLast.CrInh
                (_, Ploc.VaVal ovf, ce, Ploc.VaVal pb, item_attrs) ->
                Some
                  (fun curr next top bottom pc ->
                     Pprintf.sprint_break 1 2 pc
                       (fun pc ->
                          Pretty.sprintf "%sinherit%s" pc.Pprintf.bef
                            (if ovf then "!" else ""))
                       (fun pc ->
                          let pc =
                            {pc with Pprintf.aft =
                              let pc = {pc with Pprintf.bef = ""} in
                              Pretty.sprintf "%s%s"
                                ((fun pc ->
                                    function
                                      Some s ->
                                        var_escaped_noloc
                                          {pc with Pprintf.bef =
                                            Pretty.sprintf "%s as "
                                              pc.Pprintf.bef}
                                          s
                                    | None ->
                                        Pretty.sprintf "%s%s" pc.Pprintf.bef
                                          pc.Pprintf.aft)
                                   {pc with Pprintf.aft = ""} pb)
                                (hlist (pr_attribute "@@")
                                   {pc with Pprintf.bef = ""}
                                   (Pcaml.unvala item_attrs))}
                          in
                          class_expr pc ce))
            | _ -> None);
           Extfun.Evar (), false,
           (fun z -> Some (fun curr next top bottom pc -> next pc z))]);
     Some "bottom",
     (fun e__ ->
        Extfun.extend e__
          [Extfun.Evar (), false,
           (fun z ->
              Some
                (fun curr next top bottom pc ->
                   error (MLast.loc_of_class_str_item z)
                     (sprintf "pr_class_str_item %d"
                        (Obj.tag (Obj.repr z)))))])]

# 3 "pr_o.cppo.ml"
let pr_o e = Eprinter.apply pr_str_item Pprintf.empty_pc e