val setmargin: int -> unit

   val margin_default: int Unsynchronized.ref

   val setmp_margin_CRITICAL: int -> ('a -> 'b) -> 'a -> 'b

   val output_buffer: T -> Buffer.T

   val output_buffer: int option -> T -> Buffer.T

   val output: T -> output

   val output: int option -> T -> output

   val string_of_margin: int -> T -> string

 fun make_margin_info m =

 val margin_default = Unsynchronized.ref 76;  (*right margin, or page width*)

  {margin = m,                   (*right margin, or page width*)

   breakgain = m div 20,         (*minimum added space required of a break*)

   emergencypos = m div 2};      (*position too far to right*)

 val margin_info = Unsynchronized.ref (make_margin_info 76);

 fun setmargin m = margin_info := make_margin_info m;

 fun setmp_margin_CRITICAL m f = setmp_CRITICAL margin_info (make_margin_info m) f;

 fun formatted e = #tx (format ([prune e], (Buffer.empty, 0), 0) empty);

 fun formatted margin input =

   let

     val breakgain = margin div 20;     (*minimum added space required of a break*)

     val emergencypos = margin div 2;   (*position too far to right*)

     (*es is list of expressions to print;

       blockin is the indentation of the current block;

       after is the width of the following context until next break.*)

     fun format ([], _, _) text = text

       | format (e :: es, block as (_, blockin), after) (text as {ind, pos, nl, ...}) =

           (case e of

             Block ((bg, en), bes, indent, _) =>

               let

                 val pos' = pos + indent;

                 val pos'' = pos' mod emergencypos;

                 val block' =

                   if pos' < emergencypos then (ind |> add_indent indent, pos')

                   else (add_indent pos'' Buffer.empty, pos'');

                 val btext: text = text

                   |> control bg

                   |> format (bes, block', breakdist (es, after))

                   |> control en;

                 (*if this block was broken then force the next break*)

                 val es' = if nl < #nl btext then forcenext es else es;

               in format (es', block, after) btext end

           | Break (force, wd) =>

               (*no break if text to next break fits on this line

                 or if breaking would add only breakgain to space*)

               format (es, block, after)

                 (if not force andalso

                     pos + wd <= Int.max (margin - breakdist (es, after), blockin + breakgain)

                   then text |> blanks wd  (*just insert wd blanks*)

                   else text |> newline |> indentation block)

           | String str => format (es, block, after) (string str text));

   in

     #tx (format ([prune input], (Buffer.empty, 0), 0) empty)

   end;

 fun output_buffer prt =

 fun output_buffer margin prt =

   else formatted prt;

   else formatted (the_default (! margin_default) margin) prt;

 val output = Buffer.content o output_buffer;

 val output = Buffer.content oo output_buffer;

 val string_of = Output.escape o output;

 fun string_of_margin margin = Output.escape o output (SOME margin);

 val string_of = Output.escape o output NONE;