Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Fix PR#6417: sprintf broken when local module named Pervasives is in …

…scope

(Backport from Jacques' commit 4.02@14921)

git-svn-id: http://caml.inria.fr/svn/ocaml/trunk@14972 f963ae5c-01c2-4b8c-9fe0-0dff7051ff02
  • Loading branch information...
commit bb313fa192eb11593e720c39164a9866092c4f99 1 parent c24c9ac
Gabriel Scherer authored
View
BIN  boot/ocamlc
Binary file not shown
View
2  otherlibs/threads/Makefile
@@ -27,7 +27,7 @@ CAML_OBJS=thread.cmo mutex.cmo condition.cmo event.cmo threadUnix.cmo
LIB=../../stdlib
-LIB_OBJS=pervasives.cmo \
+LIB_OBJS=$(LIB)/camlinternalFormatBasics.cmo pervasives.cmo \
$(LIB)/array.cmo $(LIB)/list.cmo $(LIB)/char.cmo $(LIB)/string.cmo \
$(LIB)/sys.cmo $(LIB)/sort.cmo marshal.cmo $(LIB)/obj.cmo \
$(LIB)/int32.cmo $(LIB)/int64.cmo $(LIB)/nativeint.cmo \
View
478 otherlibs/threads/pervasives.ml
@@ -546,484 +546,6 @@ module LargeFile =
(* Formats *)
-module CamlinternalFormatBasics = struct
-(* Type of a block used by the Format pretty-printer. *)
-type block_type =
- | Pp_hbox (* Horizontal block no line breaking *)
- | Pp_vbox (* Vertical block each break leads to a new line *)
- | Pp_hvbox (* Horizontal-vertical block: same as vbox, except if this block
- is small enough to fit on a single line *)
- | Pp_hovbox (* Horizontal or Vertical block: breaks lead to new line
- only when necessary to print the content of the block *)
- | Pp_box (* Horizontal or Indent block: breaks lead to new line
- only when necessary to print the content of the block, or
- when it leads to a new indentation of the current line *)
- | Pp_fits (* Internal usage: when a block fits on a single line *)
-
-(* Formatting element used by the Format pretty-printter. *)
-type formatting =
- | Open_box of string * block_type * int (* @[ *)
- | Close_box (* @] *)
- | Open_tag of string * string (* @{ *)
- | Close_tag (* @} *)
- | Break of string * int * int (* @, | @ | @; | @;<> *)
- | FFlush (* @? *)
- | Force_newline (* @\n *)
- | Flush_newline (* @. *)
- | Magic_size of string * int (* @<n> *)
- | Escaped_at (* @@ *)
- | Escaped_percent (* @%% *)
- | Scan_indic of char (* @X *)
-
-(***)
-
-(* Padding position. *)
-type padty =
- | Left (* Text is left justified ('-' option). *)
- | Right (* Text is right justified (no '-' option). *)
- | Zeros (* Text is right justified by zeros (see '0' option). *)
-
-(***)
-
-(* Integer conversion. *)
-type int_conv =
- | Int_d | Int_pd | Int_sd (* %d | %+d | % d *)
- | Int_i | Int_pi | Int_si (* %i | %+i | % i *)
- | Int_x | Int_Cx (* %x | %#x *)
- | Int_X | Int_CX (* %X | %#X *)
- | Int_o | Int_Co (* %o | %#o *)
- | Int_u (* %u *)
-
-(* Float conversion. *)
-type float_conv =
- | Float_f | Float_pf | Float_sf (* %f | %+f | % f *)
- | Float_e | Float_pe | Float_se (* %e | %+e | % e *)
- | Float_E | Float_pE | Float_sE (* %E | %+E | % E *)
- | Float_g | Float_pg | Float_sg (* %g | %+g | % g *)
- | Float_G | Float_pG | Float_sG (* %G | %+G | % G *)
- | Float_F (* %F *)
-
-(***)
-
-(* Char sets (see %[...]) are bitmaps implemented as 32-char strings. *)
-type char_set = string
-
-(***)
-
-(* Counter used in Scanf. *)
-type counter =
- | Line_counter (* %l *)
- | Char_counter (* %n *)
- | Token_counter (* %N, %L *)
-
-(***)
-
-(* Padding of strings and numbers. *)
-type ('a, 'b) padding =
- (* No padding (ex: "%d") *)
- | No_padding : ('a, 'a) padding
- (* Literal padding (ex: "%8d") *)
- | Lit_padding : padty * int -> ('a, 'a) padding
- (* Padding as extra argument (ex: "%*d") *)
- | Arg_padding : padty -> (int -> 'a, 'a) padding
-
-(* Some formats, such as %_d,
- only accept an optional number as padding option (no extra argument) *)
-type pad_option = int option
-
-(* Precision of floats and '0'-padding of integers. *)
-type ('a, 'b) precision =
- (* No precision (ex: "%f") *)
- | No_precision : ('a, 'a) precision
- (* Literal precision (ex: "%.3f") *)
- | Lit_precision : int -> ('a, 'a) precision
- (* Precision as extra argument (ex: "%.*f") *)
- | Arg_precision : (int -> 'a, 'a) precision
-
-(* Some formats, such as %_f,
- only accept an optional number as precision option (no extra argument) *)
-type prec_option = int option
-
-(***)
-
-(* List of format type elements. *)
-(* In particular used to represent %(...%) and %{...%} contents. *)
-type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =
- ('a, 'b, 'c, 'd, 'e, 'f,
- 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel
-and ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel =
- | Char_ty : (* %c *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | String_ty : (* %s *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (string -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- string -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Int_ty : (* %d *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (int -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- int -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Int32_ty : (* %ld *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (int32 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- int32 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Nativeint_ty : (* %nd *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (nativeint -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- nativeint -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Int64_ty : (* %Ld *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (int64 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- int64 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Float_ty : (* %f *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (float -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- float -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Bool_ty : (* %B *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (bool -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- bool -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
-
- | Format_arg_ty : (* %{...%} *)
- ('g, 'h, 'i, 'j, 'k, 'l) fmtty *
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Format_subst_ty : (* %(...%) *)
- ('g, 'h, 'i, 'j, 'k, 'l,
- 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *
- ('g, 'h, 'i, 'j, 'k, 'l,
- 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,
- ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel
-
- (* Printf and Format specific constructors. *)
- | Alpha_ty : (* %a *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (('b1 -> 'x -> 'c1) -> 'x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- ('b2 -> 'x -> 'c2) -> 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Theta_ty : (* %t *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (('b1 -> 'c1) -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- ('b2 -> 'c2) -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
-
- (* Scanf specific constructor. *)
- | Reader_ty : (* %r *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- ('x -> 'a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,
- 'x -> 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel
- | Ignored_reader_ty : (* %_r *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- ('a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel
-
- | End_of_fmtty :
- ('f1, 'b1, 'c1, 'd1, 'd1, 'f1,
- 'f2, 'b2, 'c2, 'd2, 'd2, 'f2) fmtty_rel
-
-(***)
-
-(* List of format elements. *)
-and ('a, 'b, 'c, 'd, 'e, 'f) fmt =
- | Char : (* %c *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Caml_char : (* %C *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | String : (* %s *)
- ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Caml_string : (* %S *)
- ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Int : (* %[dixXuo] *)
- int_conv * ('x, 'y) padding * ('y, int -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Int32 : (* %l[dixXuo] *)
- int_conv * ('x, 'y) padding * ('y, int32 -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Nativeint : (* %n[dixXuo] *)
- int_conv * ('x, 'y) padding * ('y, nativeint -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Int64 : (* %L[dixXuo] *)
- int_conv * ('x, 'y) padding * ('y, int64 -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Float : (* %[feEgGF] *)
- float_conv * ('x, 'y) padding * ('y, float -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Bool : (* %[bB] *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (bool -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Flush : (* %! *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
-
- | String_literal : (* abc *)
- string * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
- | Char_literal : (* x *)
- char * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
-
- | Format_arg : (* %{...%} *)
- pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Format_subst : (* %(...%) *)
- pad_option *
- ('g, 'h, 'i, 'j, 'k, 'l,
- 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt
-
- (* Printf and Format specific constructor. *)
- | Alpha : (* %a *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (('b -> 'x -> 'c) -> 'x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Theta : (* %t *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (('b -> 'c) -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
-
- (* Format specific constructor: *)
- | Formatting : (* @_ *)
- formatting * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
-
- (* Scanf specific constructors: *)
- | Reader : (* %r *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x -> 'a, 'b, 'c, ('b -> 'x) -> 'd, 'e, 'f) fmt
- | Scan_char_set : (* %[...] *)
- pad_option * char_set * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (string -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Scan_get_counter : (* %[nlNL] *)
- counter * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (int -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Ignored_param : (* %_ *)
- ('a, 'b, 'c, 'd, 'y, 'x) ignored * ('x, 'b, 'c, 'y, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
-
- | End_of_format :
- ('f, 'b, 'c, 'e, 'e, 'f) fmt
-
-(***)
-
-(* Type for ignored parameters (see "%_"). *)
-and ('a, 'b, 'c, 'd, 'e, 'f) ignored =
- | Ignored_char : (* %_c *)
- ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_caml_char : (* %_C *)
- ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_string : (* %_s *)
- pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_caml_string : (* %_S *)
- pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_int : (* %_d *)
- int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_int32 : (* %_ld *)
- int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_nativeint : (* %_nd *)
- int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_int64 : (* %_Ld *)
- int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_float : (* %_f *)
- pad_option * prec_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_bool : (* %_B *)
- ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_format_arg : (* %_{...%} *)
- pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty ->
- ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_format_subst : (* %_(...%) *)
- pad_option * ('a, 'b, 'c, 'd, 'e, 'f) fmtty ->
- ('a, 'b, 'c, 'd, 'e, 'f) ignored
- | Ignored_reader : (* %_r *)
- ('a, 'b, 'c, ('b -> 'x) -> 'd, 'd, 'a) ignored
- | Ignored_scan_char_set : (* %_[...] *)
- pad_option * char_set -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_scan_get_counter : (* %_[nlNL] *)
- counter -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
-
-and ('a, 'b, 'c, 'd, 'e, 'f) format6 =
- Format of ('a, 'b, 'c, 'd, 'e, 'f) fmt * string
-
-let rec erase_rel : type a b c d e f g h i j k l .
- (a, b, c, d, e, f,
- g, h, i, j, k, l) fmtty_rel -> (a, b, c, d, e, f) fmtty
-= function
- | Char_ty rest ->
- Char_ty (erase_rel rest)
- | String_ty rest ->
- String_ty (erase_rel rest)
- | Int_ty rest ->
- Int_ty (erase_rel rest)
- | Int32_ty rest ->
- Int32_ty (erase_rel rest)
- | Int64_ty rest ->
- Int64_ty (erase_rel rest)
- | Nativeint_ty rest ->
- Nativeint_ty (erase_rel rest)
- | Float_ty rest ->
- Float_ty (erase_rel rest)
- | Bool_ty rest ->
- Bool_ty (erase_rel rest)
- | Format_arg_ty (ty, rest) ->
- Format_arg_ty (ty, erase_rel rest)
- | Format_subst_ty (ty1, ty2, rest) ->
- Format_subst_ty (ty1, ty1, erase_rel rest)
- | Alpha_ty rest ->
- Alpha_ty (erase_rel rest)
- | Theta_ty rest ->
- Theta_ty (erase_rel rest)
- | Reader_ty rest ->
- Reader_ty (erase_rel rest)
- | Ignored_reader_ty rest ->
- Ignored_reader_ty (erase_rel rest)
- | End_of_fmtty -> End_of_fmtty
-
-(******************************************************************************)
- (* Format type concatenation *)
-
-(* Concatenate two format types. *)
-(* Used by:
- * reader_nb_unifier_of_fmtty to count readers in an fmtty,
- * Scanf.take_fmtty_format_readers to extract readers inside %(...%),
- * CamlinternalFormat.fmtty_of_ignored_format to extract format type. *)
-
-(*
-let rec concat_fmtty : type a b c d e f g h .
- (a, b, c, d, e, f) fmtty ->
- (f, b, c, e, g, h) fmtty ->
- (a, b, c, d, g, h) fmtty =
-*)
-let rec concat_fmtty :
- type a1 b1 c1 d1 e1 f1
- a2 b2 c2 d2 e2 f2
- g1 j1 g2 j2
- .
- (g1, b1, c1, j1, d1, a1,
- g2, b2, c2, j2, d2, a2) fmtty_rel ->
- (a1, b1, c1, d1, e1, f1,
- a2, b2, c2, d2, e2, f2) fmtty_rel ->
- (g1, b1, c1, j1, e1, f1,
- g2, b2, c2, j2, e2, f2) fmtty_rel =
-fun fmtty1 fmtty2 -> match fmtty1 with
- | Char_ty rest ->
- Char_ty (concat_fmtty rest fmtty2)
- | String_ty rest ->
- String_ty (concat_fmtty rest fmtty2)
- | Int_ty rest ->
- Int_ty (concat_fmtty rest fmtty2)
- | Int32_ty rest ->
- Int32_ty (concat_fmtty rest fmtty2)
- | Nativeint_ty rest ->
- Nativeint_ty (concat_fmtty rest fmtty2)
- | Int64_ty rest ->
- Int64_ty (concat_fmtty rest fmtty2)
- | Float_ty rest ->
- Float_ty (concat_fmtty rest fmtty2)
- | Bool_ty rest ->
- Bool_ty (concat_fmtty rest fmtty2)
- | Alpha_ty rest ->
- Alpha_ty (concat_fmtty rest fmtty2)
- | Theta_ty rest ->
- Theta_ty (concat_fmtty rest fmtty2)
- | Reader_ty rest ->
- Reader_ty (concat_fmtty rest fmtty2)
- | Ignored_reader_ty rest ->
- Ignored_reader_ty (concat_fmtty rest fmtty2)
- | Format_arg_ty (ty, rest) ->
- Format_arg_ty (ty, concat_fmtty rest fmtty2)
- | Format_subst_ty (ty1, ty2, rest) ->
- Format_subst_ty (ty1, ty2, concat_fmtty rest fmtty2)
- | End_of_fmtty -> fmtty2
-
-(******************************************************************************)
- (* Format concatenation *)
-
-(* Concatenate two formats. *)
-let rec concat_fmt : type a b c d e f g h .
- (a, b, c, d, e, f) fmt ->
- (f, b, c, e, g, h) fmt ->
- (a, b, c, d, g, h) fmt =
-fun fmt1 fmt2 -> match fmt1 with
- | String (pad, rest) ->
- String (pad, concat_fmt rest fmt2)
- | Caml_string (pad, rest) ->
- Caml_string (pad, concat_fmt rest fmt2)
-
- | Int (iconv, pad, prec, rest) ->
- Int (iconv, pad, prec, concat_fmt rest fmt2)
- | Int32 (iconv, pad, prec, rest) ->
- Int32 (iconv, pad, prec, concat_fmt rest fmt2)
- | Nativeint (iconv, pad, prec, rest) ->
- Nativeint (iconv, pad, prec, concat_fmt rest fmt2)
- | Int64 (iconv, pad, prec, rest) ->
- Int64 (iconv, pad, prec, concat_fmt rest fmt2)
- | Float (fconv, pad, prec, rest) ->
- Float (fconv, pad, prec, concat_fmt rest fmt2)
-
- | Char (rest) ->
- Char (concat_fmt rest fmt2)
- | Caml_char rest ->
- Caml_char (concat_fmt rest fmt2)
- | Bool rest ->
- Bool (concat_fmt rest fmt2)
- | Alpha rest ->
- Alpha (concat_fmt rest fmt2)
- | Theta rest ->
- Theta (concat_fmt rest fmt2)
- | Reader rest ->
- Reader (concat_fmt rest fmt2)
- | Flush rest ->
- Flush (concat_fmt rest fmt2)
-
- | String_literal (str, rest) ->
- String_literal (str, concat_fmt rest fmt2)
- | Char_literal (chr, rest) ->
- Char_literal (chr, concat_fmt rest fmt2)
-
- | Format_arg (pad, fmtty, rest) ->
- Format_arg (pad, fmtty, concat_fmt rest fmt2)
- | Format_subst (pad, fmtty, rest) ->
- Format_subst (pad, fmtty, concat_fmt rest fmt2)
-
- | Scan_char_set (width_opt, char_set, rest) ->
- Scan_char_set (width_opt, char_set, concat_fmt rest fmt2)
- | Scan_get_counter (counter, rest) ->
- Scan_get_counter (counter, concat_fmt rest fmt2)
- | Ignored_param (ign, rest) ->
- Ignored_param (ign, concat_fmt rest fmt2)
-
- | Formatting (fmting, rest) ->
- Formatting (fmting, concat_fmt rest fmt2)
-
- | End_of_format ->
- fmt2
-end
-
type ('a, 'b, 'c, 'd, 'e, 'f) format6
= ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6
= Format of ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmt
View
73 stdlib/.depend
@@ -5,7 +5,8 @@ buffer.cmi :
bytes.cmi :
bytesLabels.cmi :
callback.cmi :
-camlinternalFormat.cmi : buffer.cmi
+camlinternalFormat.cmi : camlinternalFormatBasics.cmi buffer.cmi
+camlinternalFormatBasics.cmi :
camlinternalLazy.cmi :
camlinternalMod.cmi : obj.cmi
camlinternalOO.cmi : obj.cmi
@@ -30,7 +31,7 @@ nativeint.cmi :
obj.cmi : int32.cmi
oo.cmi : camlinternalOO.cmi
parsing.cmi : obj.cmi lexing.cmi
-pervasives.cmi :
+pervasives.cmi : camlinternalFormatBasics.cmi
printexc.cmi :
printf.cmi : buffer.cmi
queue.cmi :
@@ -62,10 +63,12 @@ bytesLabels.cmo : bytes.cmi bytesLabels.cmi
bytesLabels.cmx : bytes.cmx bytesLabels.cmi
callback.cmo : obj.cmi callback.cmi
callback.cmx : obj.cmx callback.cmi
-camlinternalFormat.cmo : sys.cmi string.cmi char.cmi bytes.cmi buffer.cmi \
- camlinternalFormat.cmi
-camlinternalFormat.cmx : sys.cmx string.cmx char.cmx bytes.cmx buffer.cmx \
- camlinternalFormat.cmi
+camlinternalFormat.cmo : sys.cmi string.cmi char.cmi \
+ camlinternalFormatBasics.cmi bytes.cmi buffer.cmi camlinternalFormat.cmi
+camlinternalFormat.cmx : sys.cmx string.cmx char.cmx \
+ camlinternalFormatBasics.cmx bytes.cmx buffer.cmx camlinternalFormat.cmi
+camlinternalFormatBasics.cmo : camlinternalFormatBasics.cmi
+camlinternalFormatBasics.cmx : camlinternalFormatBasics.cmi
camlinternalLazy.cmo : obj.cmi camlinternalLazy.cmi
camlinternalLazy.cmx : obj.cmx camlinternalLazy.cmi
camlinternalMod.cmo : obj.cmi camlinternalOO.cmi array.cmi \
@@ -86,10 +89,10 @@ filename.cmo : sys.cmi string.cmi random.cmi printf.cmi lazy.cmi buffer.cmi \
filename.cmi
filename.cmx : sys.cmx string.cmx random.cmx printf.cmx lazy.cmx buffer.cmx \
filename.cmi
-format.cmo : string.cmi pervasives.cmi camlinternalFormat.cmi buffer.cmi \
- format.cmi
-format.cmx : string.cmx pervasives.cmx camlinternalFormat.cmx buffer.cmx \
- format.cmi
+format.cmo : string.cmi pervasives.cmi camlinternalFormatBasics.cmi \
+ camlinternalFormat.cmi buffer.cmi format.cmi
+format.cmx : string.cmx pervasives.cmx camlinternalFormatBasics.cmx \
+ camlinternalFormat.cmx buffer.cmx format.cmi
gc.cmo : sys.cmi printf.cmi gc.cmi
gc.cmx : sys.cmx printf.cmx gc.cmi
genlex.cmo : string.cmi stream.cmi list.cmi hashtbl.cmi char.cmi bytes.cmi \
@@ -126,14 +129,16 @@ oo.cmo : camlinternalOO.cmi oo.cmi
oo.cmx : camlinternalOO.cmx oo.cmi
parsing.cmo : obj.cmi lexing.cmi array.cmi parsing.cmi
parsing.cmx : obj.cmx lexing.cmx array.cmx parsing.cmi
-pervasives.cmo : pervasives.cmi
-pervasives.cmx : pervasives.cmi
+pervasives.cmo : camlinternalFormatBasics.cmi pervasives.cmi
+pervasives.cmx : camlinternalFormatBasics.cmx pervasives.cmi
printexc.cmo : printf.cmi pervasives.cmi obj.cmi buffer.cmi array.cmi \
printexc.cmi
printexc.cmx : printf.cmx pervasives.cmx obj.cmx buffer.cmx array.cmx \
printexc.cmi
-printf.cmo : camlinternalFormat.cmi buffer.cmi printf.cmi
-printf.cmx : camlinternalFormat.cmx buffer.cmx printf.cmi
+printf.cmo : camlinternalFormatBasics.cmi camlinternalFormat.cmi buffer.cmi \
+ printf.cmi
+printf.cmx : camlinternalFormatBasics.cmx camlinternalFormat.cmx buffer.cmx \
+ printf.cmi
queue.cmo : obj.cmi queue.cmi
queue.cmx : obj.cmx queue.cmi
random.cmo : string.cmi pervasives.cmi nativeint.cmi int64.cmi int32.cmi \
@@ -141,9 +146,11 @@ random.cmo : string.cmi pervasives.cmi nativeint.cmi int64.cmi int32.cmi \
random.cmx : string.cmx pervasives.cmx nativeint.cmx int64.cmx int32.cmx \
digest.cmx char.cmx array.cmx random.cmi
scanf.cmo : string.cmi printf.cmi pervasives.cmi list.cmi \
- camlinternalFormat.cmi bytes.cmi buffer.cmi scanf.cmi
+ camlinternalFormatBasics.cmi camlinternalFormat.cmi bytes.cmi buffer.cmi \
+ scanf.cmi
scanf.cmx : string.cmx printf.cmx pervasives.cmx list.cmx \
- camlinternalFormat.cmx bytes.cmx buffer.cmx scanf.cmi
+ camlinternalFormatBasics.cmx camlinternalFormat.cmx bytes.cmx buffer.cmx \
+ scanf.cmi
set.cmo : list.cmi set.cmi
set.cmx : list.cmx set.cmi
sort.cmo : array.cmi sort.cmi
@@ -182,10 +189,12 @@ bytesLabels.cmo : bytes.cmi bytesLabels.cmi
bytesLabels.p.cmx : bytes.p.cmx bytesLabels.cmi
callback.cmo : obj.cmi callback.cmi
callback.p.cmx : obj.p.cmx callback.cmi
-camlinternalFormat.cmo : sys.cmi string.cmi char.cmi bytes.cmi buffer.cmi \
- camlinternalFormat.cmi
-camlinternalFormat.p.cmx : sys.p.cmx string.p.cmx char.p.cmx bytes.p.cmx buffer.p.cmx \
- camlinternalFormat.cmi
+camlinternalFormat.cmo : sys.cmi string.cmi char.cmi \
+ camlinternalFormatBasics.cmi bytes.cmi buffer.cmi camlinternalFormat.cmi
+camlinternalFormat.p.cmx : sys.p.cmx string.p.cmx char.p.cmx \
+ camlinternalFormatBasics.p.cmx bytes.p.cmx buffer.p.cmx camlinternalFormat.cmi
+camlinternalFormatBasics.cmo : camlinternalFormatBasics.cmi
+camlinternalFormatBasics.p.cmx : camlinternalFormatBasics.cmi
camlinternalLazy.cmo : obj.cmi camlinternalLazy.cmi
camlinternalLazy.p.cmx : obj.p.cmx camlinternalLazy.cmi
camlinternalMod.cmo : obj.cmi camlinternalOO.cmi array.cmi \
@@ -206,10 +215,10 @@ filename.cmo : sys.cmi string.cmi random.cmi printf.cmi lazy.cmi buffer.cmi \
filename.cmi
filename.p.cmx : sys.p.cmx string.p.cmx random.p.cmx printf.p.cmx lazy.p.cmx buffer.p.cmx \
filename.cmi
-format.cmo : string.cmi pervasives.cmi camlinternalFormat.cmi buffer.cmi \
- format.cmi
-format.p.cmx : string.p.cmx pervasives.p.cmx camlinternalFormat.p.cmx buffer.p.cmx \
- format.cmi
+format.cmo : string.cmi pervasives.cmi camlinternalFormatBasics.cmi \
+ camlinternalFormat.cmi buffer.cmi format.cmi
+format.p.cmx : string.p.cmx pervasives.p.cmx camlinternalFormatBasics.p.cmx \
+ camlinternalFormat.p.cmx buffer.p.cmx format.cmi
gc.cmo : sys.cmi printf.cmi gc.cmi
gc.p.cmx : sys.p.cmx printf.p.cmx gc.cmi
genlex.cmo : string.cmi stream.cmi list.cmi hashtbl.cmi char.cmi bytes.cmi \
@@ -246,14 +255,16 @@ oo.cmo : camlinternalOO.cmi oo.cmi
oo.p.cmx : camlinternalOO.p.cmx oo.cmi
parsing.cmo : obj.cmi lexing.cmi array.cmi parsing.cmi
parsing.p.cmx : obj.p.cmx lexing.p.cmx array.p.cmx parsing.cmi
-pervasives.cmo : pervasives.cmi
-pervasives.p.cmx : pervasives.cmi
+pervasives.cmo : camlinternalFormatBasics.cmi pervasives.cmi
+pervasives.p.cmx : camlinternalFormatBasics.p.cmx pervasives.cmi
printexc.cmo : printf.cmi pervasives.cmi obj.cmi buffer.cmi array.cmi \
printexc.cmi
printexc.p.cmx : printf.p.cmx pervasives.p.cmx obj.p.cmx buffer.p.cmx array.p.cmx \
printexc.cmi
-printf.cmo : camlinternalFormat.cmi buffer.cmi printf.cmi
-printf.p.cmx : camlinternalFormat.p.cmx buffer.p.cmx printf.cmi
+printf.cmo : camlinternalFormatBasics.cmi camlinternalFormat.cmi buffer.cmi \
+ printf.cmi
+printf.p.cmx : camlinternalFormatBasics.p.cmx camlinternalFormat.p.cmx buffer.p.cmx \
+ printf.cmi
queue.cmo : obj.cmi queue.cmi
queue.p.cmx : obj.p.cmx queue.cmi
random.cmo : string.cmi pervasives.cmi nativeint.cmi int64.cmi int32.cmi \
@@ -261,9 +272,11 @@ random.cmo : string.cmi pervasives.cmi nativeint.cmi int64.cmi int32.cmi \
random.p.cmx : string.p.cmx pervasives.p.cmx nativeint.p.cmx int64.p.cmx int32.p.cmx \
digest.p.cmx char.p.cmx array.p.cmx random.cmi
scanf.cmo : string.cmi printf.cmi pervasives.cmi list.cmi \
- camlinternalFormat.cmi bytes.cmi buffer.cmi scanf.cmi
+ camlinternalFormatBasics.cmi camlinternalFormat.cmi bytes.cmi buffer.cmi \
+ scanf.cmi
scanf.p.cmx : string.p.cmx printf.p.cmx pervasives.p.cmx list.p.cmx \
- camlinternalFormat.p.cmx bytes.p.cmx buffer.p.cmx scanf.cmi
+ camlinternalFormatBasics.p.cmx camlinternalFormat.p.cmx bytes.p.cmx buffer.p.cmx \
+ scanf.cmi
set.cmo : list.cmi set.cmi
set.p.cmx : list.p.cmx set.cmi
sort.cmo : array.cmi sort.cmi
View
1  stdlib/Compflags
@@ -20,6 +20,7 @@ case $1 in
# make sure add_char is inlined (PR#5872)
buffer.cm[io]) echo ' -w A';;
camlinternalFormat.cm[io]) echo ' -w Ae';;
+ camlinternalFormatBasics*.cm[iox]) echo ' -nopervasives';;
printf.cm[io]|format.cm[io]|scanf.cm[io]) echo ' -w Ae';;
scanf.cmx|scanf.p.cmx) echo ' -inline 9';;
*Labels.cm[ox]|*Labels.p.cmx) echo ' -nolabels -no-alias-deps';;
View
4 stdlib/Makefile.shared
@@ -21,7 +21,7 @@ OPTCOMPILER=../ocamlopt
CAMLOPT=$(RUNTIME) $(OPTCOMPILER)
CAMLDEP=../boot/ocamlrun ../tools/ocamldep
-OBJS=pervasives.cmo $(OTHERS)
+OBJS=camlinternalFormatBasics.cmo pervasives.cmo $(OTHERS)
OTHERS=array.cmo list.cmo char.cmo bytes.cmo string.cmo sys.cmo \
sort.cmo marshal.cmo obj.cmo \
int32.cmo int64.cmo nativeint.cmo \
@@ -88,7 +88,7 @@ $(OBJS:.cmo=.cmx) std_exit.cmx: $(OPTCOMPILER)
$(OBJS:.cmo=.p.cmx) std_exit.p.cmx: $(OPTCOMPILER)
# Dependencies on Pervasives (not tracked by ocamldep)
-$(OBJS) std_exit.cmo: pervasives.cmi
+$(OTHERS) std_exit.cmo: pervasives.cmi
$(OTHERS:.cmo=.cmi) std_exit.cmi: pervasives.cmi
$(OBJS:.cmo=.cmx) std_exit.cmx: pervasives.cmi
$(OBJS:.cmo=.p.cmx) std_exit.p.cmx: pervasives.cmi
View
604 stdlib/camlinternalFormatBasics.ml
@@ -0,0 +1,604 @@
+(* Type of a block used by the Format pretty-printer. *)
+type block_type =
+ | Pp_hbox (* Horizontal block no line breaking *)
+ | Pp_vbox (* Vertical block each break leads to a new line *)
+ | Pp_hvbox (* Horizontal-vertical block: same as vbox, except if this block
+ is small enough to fit on a single line *)
+ | Pp_hovbox (* Horizontal or Vertical block: breaks lead to new line
+ only when necessary to print the content of the block *)
+ | Pp_box (* Horizontal or Indent block: breaks lead to new line
+ only when necessary to print the content of the block, or
+ when it leads to a new indentation of the current line *)
+ | Pp_fits (* Internal usage: when a block fits on a single line *)
+
+(* Formatting element used by the Format pretty-printter. *)
+type formatting =
+ | Open_box of string * block_type * int (* @[ *)
+ | Close_box (* @] *)
+ | Open_tag of string * string (* @{ *)
+ | Close_tag (* @} *)
+ | Break of string * int * int (* @, | @ | @; | @;<> *)
+ | FFlush (* @? *)
+ | Force_newline (* @\n *)
+ | Flush_newline (* @. *)
+ | Magic_size of string * int (* @<n> *)
+ | Escaped_at (* @@ *)
+ | Escaped_percent (* @%% *)
+ | Scan_indic of char (* @X *)
+
+(***)
+
+(* Padding position. *)
+type padty =
+ | Left (* Text is left justified ('-' option). *)
+ | Right (* Text is right justified (no '-' option). *)
+ | Zeros (* Text is right justified by zeros (see '0' option). *)
+
+(***)
+
+(* Integer conversion. *)
+type int_conv =
+ | Int_d | Int_pd | Int_sd (* %d | %+d | % d *)
+ | Int_i | Int_pi | Int_si (* %i | %+i | % i *)
+ | Int_x | Int_Cx (* %x | %#x *)
+ | Int_X | Int_CX (* %X | %#X *)
+ | Int_o | Int_Co (* %o | %#o *)
+ | Int_u (* %u *)
+
+(* Float conversion. *)
+type float_conv =
+ | Float_f | Float_pf | Float_sf (* %f | %+f | % f *)
+ | Float_e | Float_pe | Float_se (* %e | %+e | % e *)
+ | Float_E | Float_pE | Float_sE (* %E | %+E | % E *)
+ | Float_g | Float_pg | Float_sg (* %g | %+g | % g *)
+ | Float_G | Float_pG | Float_sG (* %G | %+G | % G *)
+ | Float_F (* %F *)
+
+(***)
+
+(* Char sets (see %[...]) are bitmaps implemented as 32-char strings. *)
+type char_set = string
+
+(***)
+
+(* Counter used in Scanf. *)
+type counter =
+ | Line_counter (* %l *)
+ | Char_counter (* %n *)
+ | Token_counter (* %N, %L *)
+
+(***)
+
+(* Padding of strings and numbers. *)
+type ('a, 'b) padding =
+ (* No padding (ex: "%d") *)
+ | No_padding : ('a, 'a) padding
+ (* Literal padding (ex: "%8d") *)
+ | Lit_padding : padty * int -> ('a, 'a) padding
+ (* Padding as extra argument (ex: "%*d") *)
+ | Arg_padding : padty -> (int -> 'a, 'a) padding
+
+(* Some formats, such as %_d,
+ only accept an optional number as padding option (no extra argument) *)
+type pad_option = int option
+
+(* Precision of floats and '0'-padding of integers. *)
+type ('a, 'b) precision =
+ (* No precision (ex: "%f") *)
+ | No_precision : ('a, 'a) precision
+ (* Literal precision (ex: "%.3f") *)
+ | Lit_precision : int -> ('a, 'a) precision
+ (* Precision as extra argument (ex: "%.*f") *)
+ | Arg_precision : (int -> 'a, 'a) precision
+
+(* Some formats, such as %_f,
+ only accept an optional number as precision option (no extra argument) *)
+type prec_option = int option
+
+(***)
+
+(* Relational format types
+
+In the first format+gadts implementation, the type for %(..%) in the
+fmt GADT was as follows:
+
+| Format_subst : (* %(...%) *)
+ pad_option * ('d1, 'q1, 'd2, 'q2) reader_nb_unifier *
+ ('x, 'b, 'c, 'd1, 'q1, 'u) fmtty *
+ ('u, 'b, 'c, 'q1, 'e1, 'f) fmt ->
+ (('x, 'b, 'c, 'd2, 'q2, 'u) format6 -> 'x, 'b, 'c, 'd1, 'e1, 'f) fmt
+
+Notice that the 'u parameter in 'f position in the format argument
+(('x, .., 'u) format6 -> ..) is equal to the 'u parameter in 'a
+position in the format tail (('u, .., 'f) fmt). This means that the
+type of the expected format parameter depends of where the %(...%)
+are in the format string:
+
+ # Printf.printf "%(%)";;
+ - : (unit, out_channel, unit, '_a, '_a, unit)
+ CamlinternalFormatBasics.format6 -> unit
+ = <fun>
+ # Printf.printf "%(%)%d";;
+ - : (int -> unit, out_channel, unit, '_a, '_a, int -> unit)
+ CamlinternalFormatBasics.format6 -> int -> unit
+ = <fun>
+
+On the contrary, the legacy typer gives a clever type that does not
+depend on the position of %(..%) in the format string. For example,
+%(%) will have the polymorphic type ('a, 'b, 'c, 'd, 'd, 'a): it can
+be concatenated to any format type, and only enforces the constraint
+that its 'a and 'f parameters are equal (no format arguments) and 'd
+and 'e are equal (no reader argument).
+
+The weakening of this parameter type in the GADT version broke user
+code (in fact it essentially made %(...%) unusable except at the last
+position of a format). In particular, the following would not work
+anymore:
+
+ fun sep ->
+ Format.printf "foo%(%)bar%(%)baz" sep sep
+
+As the type-checker would require two *incompatible* types for the %(%)
+in different positions.
+
+The solution to regain a general type for %(..%) is to generalize this
+technique, not only on the 'd, 'e parameters, but on all six
+parameters of a format: we introduce a "relational" type
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+whose values are proofs that ('a1, .., 'f1) and ('a2, .., 'f2) morally
+correspond to the same format type: 'a1 is obtained from 'f1,'b1,'c1
+in the exact same way that 'a2 is obtained from 'f2,'b2,'c2, etc.
+
+For example, the relation between two format types beginning with a Char
+parameter is as follows:
+
+| Char_ty : (* %c *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+
+In the general case, the term structure of fmtty_rel is (almost¹)
+isomorphic to the fmtty of the previous implementation: every
+constructor is re-read with a binary, relational type, instead of the
+previous unary typing. fmtty can then be re-defined as the diagonal of
+fmtty_rel:
+
+ type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =
+ ('a, 'b, 'c, 'd, 'e, 'f,
+ 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel
+
+Once we have this fmtty_rel type in place, we can give the more
+general type to %(...%):
+
+| Format_subst : (* %(...%) *)
+ pad_option *
+ ('g, 'h, 'i, 'j, 'k, 'l,
+ 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt
+
+We accept any format (('g, 'h, 'i, 'j, 'k, 'l) format6) (this is
+completely unrelated to the type of the current format), but also
+require a proof that this format is in relation to another format that
+is concatenable to the format tail. When executing a %(...%) format
+(in camlinternalFormat.ml:make_printf or scanf.ml:make_scanf), we
+transtype the format along this relation using the 'recast' function
+to transpose between related format types.
+
+ val recast :
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1) fmt
+ -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmt
+
+NOTE ¹: the typing of Format_subst_ty requires not one format type, but
+two, one to establish the link between the format argument and the
+first six parameters, and the other for the link between the format
+argumant and the last six parameters.
+
+| Format_subst_ty : (* %(...%) *)
+ ('g, 'h, 'i, 'j, 'k, 'l,
+ 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *
+ ('g, 'h, 'i, 'j, 'k, 'l,
+ 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,
+ ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel
+
+When we generate a format AST, we generate exactly the same witness
+for both relations, and the witness-conversion functions in
+camlinternalFormat do rely on this invariant. For example, the
+function that proves that the relation is transitive
+
+ val trans :
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2,
+ 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel
+ -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel
+
+does assume that the two input have exactly the same term structure
+(and is only every used for argument witnesses of the
+Format_subst_ty constructor).
+*)
+
+(* List of format type elements. *)
+(* In particular used to represent %(...%) and %{...%} contents. *)
+type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =
+ ('a, 'b, 'c, 'd, 'e, 'f,
+ 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel
+and ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel =
+ | Char_ty : (* %c *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | String_ty : (* %s *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (string -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ string -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Int_ty : (* %d *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (int -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ int -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Int32_ty : (* %ld *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (int32 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ int32 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Nativeint_ty : (* %nd *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (nativeint -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ nativeint -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Int64_ty : (* %Ld *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (int64 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ int64 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Float_ty : (* %f *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (float -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ float -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Bool_ty : (* %B *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (bool -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ bool -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+
+ | Format_arg_ty : (* %{...%} *)
+ ('g, 'h, 'i, 'j, 'k, 'l) fmtty *
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Format_subst_ty : (* %(...%) *)
+ ('g, 'h, 'i, 'j, 'k, 'l,
+ 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *
+ ('g, 'h, 'i, 'j, 'k, 'l,
+ 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,
+ ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel
+
+ (* Printf and Format specific constructors. *)
+ | Alpha_ty : (* %a *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('b1 -> 'x -> 'c1) -> 'x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ ('b2 -> 'x -> 'c2) -> 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Theta_ty : (* %t *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('b1 -> 'c1) -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ ('b2 -> 'c2) -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+
+ (* Scanf specific constructor. *)
+ | Reader_ty : (* %r *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ ('x -> 'a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,
+ 'x -> 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel
+ | Ignored_reader_ty : (* %_r *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ ('a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel
+
+ | End_of_fmtty :
+ ('f1, 'b1, 'c1, 'd1, 'd1, 'f1,
+ 'f2, 'b2, 'c2, 'd2, 'd2, 'f2) fmtty_rel
+
+(***)
+
+(* List of format elements. *)
+and ('a, 'b, 'c, 'd, 'e, 'f) fmt =
+ | Char : (* %c *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Caml_char : (* %C *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | String : (* %s *)
+ ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Caml_string : (* %S *)
+ ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Int : (* %[dixXuo] *)
+ int_conv * ('x, 'y) padding * ('y, int -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Int32 : (* %l[dixXuo] *)
+ int_conv * ('x, 'y) padding * ('y, int32 -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Nativeint : (* %n[dixXuo] *)
+ int_conv * ('x, 'y) padding * ('y, nativeint -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Int64 : (* %L[dixXuo] *)
+ int_conv * ('x, 'y) padding * ('y, int64 -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Float : (* %[feEgGF] *)
+ float_conv * ('x, 'y) padding * ('y, float -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Bool : (* %[bB] *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (bool -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Flush : (* %! *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ | String_literal : (* abc *)
+ string * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Char_literal : (* x *)
+ char * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ | Format_arg : (* %{...%} *)
+ pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Format_subst : (* %(...%) *)
+ pad_option *
+ ('g, 'h, 'i, 'j, 'k, 'l,
+ 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt
+
+ (* Printf and Format specific constructor. *)
+ | Alpha : (* %a *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (('b -> 'x -> 'c) -> 'x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Theta : (* %t *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (('b -> 'c) -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ (* Format specific constructor: *)
+ | Formatting : (* @_ *)
+ formatting * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ (* Scanf specific constructors: *)
+ | Reader : (* %r *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x -> 'a, 'b, 'c, ('b -> 'x) -> 'd, 'e, 'f) fmt
+ | Scan_char_set : (* %[...] *)
+ pad_option * char_set * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (string -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Scan_get_counter : (* %[nlNL] *)
+ counter * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (int -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Ignored_param : (* %_ *)
+ ('a, 'b, 'c, 'd, 'y, 'x) ignored * ('x, 'b, 'c, 'y, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ | End_of_format :
+ ('f, 'b, 'c, 'e, 'e, 'f) fmt
+
+(***)
+
+(* Type for ignored parameters (see "%_"). *)
+and ('a, 'b, 'c, 'd, 'e, 'f) ignored =
+ | Ignored_char : (* %_c *)
+ ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_caml_char : (* %_C *)
+ ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_string : (* %_s *)
+ pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_caml_string : (* %_S *)
+ pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_int : (* %_d *)
+ int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_int32 : (* %_ld *)
+ int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_nativeint : (* %_nd *)
+ int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_int64 : (* %_Ld *)
+ int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_float : (* %_f *)
+ pad_option * prec_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_bool : (* %_B *)
+ ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_format_arg : (* %_{...%} *)
+ pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty ->
+ ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_format_subst : (* %_(...%) *)
+ pad_option * ('a, 'b, 'c, 'd, 'e, 'f) fmtty ->
+ ('a, 'b, 'c, 'd, 'e, 'f) ignored
+ | Ignored_reader : (* %_r *)
+ ('a, 'b, 'c, ('b -> 'x) -> 'd, 'd, 'a) ignored
+ | Ignored_scan_char_set : (* %_[...] *)
+ pad_option * char_set -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_scan_get_counter : (* %_[nlNL] *)
+ counter -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+
+and ('a, 'b, 'c, 'd, 'e, 'f) format6 =
+ Format of ('a, 'b, 'c, 'd, 'e, 'f) fmt * string
+
+let rec erase_rel : type a b c d e f g h i j k l .
+ (a, b, c, d, e, f,
+ g, h, i, j, k, l) fmtty_rel -> (a, b, c, d, e, f) fmtty
+= function
+ | Char_ty rest ->
+ Char_ty (erase_rel rest)
+ | String_ty rest ->
+ String_ty (erase_rel rest)
+ | Int_ty rest ->
+ Int_ty (erase_rel rest)
+ | Int32_ty rest ->
+ Int32_ty (erase_rel rest)
+ | Int64_ty rest ->
+ Int64_ty (erase_rel rest)
+ | Nativeint_ty rest ->
+ Nativeint_ty (erase_rel rest)
+ | Float_ty rest ->
+ Float_ty (erase_rel rest)
+ | Bool_ty rest ->
+ Bool_ty (erase_rel rest)
+ | Format_arg_ty (ty, rest) ->
+ Format_arg_ty (ty, erase_rel rest)
+ | Format_subst_ty (ty1, ty2, rest) ->
+ Format_subst_ty (ty1, ty1, erase_rel rest)
+ | Alpha_ty rest ->
+ Alpha_ty (erase_rel rest)
+ | Theta_ty rest ->
+ Theta_ty (erase_rel rest)
+ | Reader_ty rest ->
+ Reader_ty (erase_rel rest)
+ | Ignored_reader_ty rest ->
+ Ignored_reader_ty (erase_rel rest)
+ | End_of_fmtty -> End_of_fmtty
+
+(******************************************************************************)
+ (* Format type concatenation *)
+
+(* Concatenate two format types. *)
+(* Used by:
+ * reader_nb_unifier_of_fmtty to count readers in an fmtty,
+ * Scanf.take_fmtty_format_readers to extract readers inside %(...%),
+ * CamlinternalFormat.fmtty_of_ignored_format to extract format type. *)
+
+(*
+let rec concat_fmtty : type a b c d e f g h .
+ (a, b, c, d, e, f) fmtty ->
+ (f, b, c, e, g, h) fmtty ->
+ (a, b, c, d, g, h) fmtty =
+*)
+let rec concat_fmtty :
+ type a1 b1 c1 d1 e1 f1
+ a2 b2 c2 d2 e2 f2
+ g1 j1 g2 j2
+ .
+ (g1, b1, c1, j1, d1, a1,
+ g2, b2, c2, j2, d2, a2) fmtty_rel ->
+ (a1, b1, c1, d1, e1, f1,
+ a2, b2, c2, d2, e2, f2) fmtty_rel ->
+ (g1, b1, c1, j1, e1, f1,
+ g2, b2, c2, j2, e2, f2) fmtty_rel =
+fun fmtty1 fmtty2 -> match fmtty1 with
+ | Char_ty rest ->
+ Char_ty (concat_fmtty rest fmtty2)
+ | String_ty rest ->
+ String_ty (concat_fmtty rest fmtty2)
+ | Int_ty rest ->
+ Int_ty (concat_fmtty rest fmtty2)
+ | Int32_ty rest ->
+ Int32_ty (concat_fmtty rest fmtty2)
+ | Nativeint_ty rest ->
+ Nativeint_ty (concat_fmtty rest fmtty2)
+ | Int64_ty rest ->
+ Int64_ty (concat_fmtty rest fmtty2)
+ | Float_ty rest ->
+ Float_ty (concat_fmtty rest fmtty2)
+ | Bool_ty rest ->
+ Bool_ty (concat_fmtty rest fmtty2)
+ | Alpha_ty rest ->
+ Alpha_ty (concat_fmtty rest fmtty2)
+ | Theta_ty rest ->
+ Theta_ty (concat_fmtty rest fmtty2)
+ | Reader_ty rest ->
+ Reader_ty (concat_fmtty rest fmtty2)
+ | Ignored_reader_ty rest ->
+ Ignored_reader_ty (concat_fmtty rest fmtty2)
+ | Format_arg_ty (ty, rest) ->
+ Format_arg_ty (ty, concat_fmtty rest fmtty2)
+ | Format_subst_ty (ty1, ty2, rest) ->
+ Format_subst_ty (ty1, ty2, concat_fmtty rest fmtty2)
+ | End_of_fmtty -> fmtty2
+
+(******************************************************************************)
+ (* Format concatenation *)
+
+(* Concatenate two formats. *)
+let rec concat_fmt : type a b c d e f g h .
+ (a, b, c, d, e, f) fmt ->
+ (f, b, c, e, g, h) fmt ->
+ (a, b, c, d, g, h) fmt =
+fun fmt1 fmt2 -> match fmt1 with
+ | String (pad, rest) ->
+ String (pad, concat_fmt rest fmt2)
+ | Caml_string (pad, rest) ->
+ Caml_string (pad, concat_fmt rest fmt2)
+
+ | Int (iconv, pad, prec, rest) ->
+ Int (iconv, pad, prec, concat_fmt rest fmt2)
+ | Int32 (iconv, pad, prec, rest) ->
+ Int32 (iconv, pad, prec, concat_fmt rest fmt2)
+ | Nativeint (iconv, pad, prec, rest) ->
+ Nativeint (iconv, pad, prec, concat_fmt rest fmt2)
+ | Int64 (iconv, pad, prec, rest) ->
+ Int64 (iconv, pad, prec, concat_fmt rest fmt2)
+ | Float (fconv, pad, prec, rest) ->
+ Float (fconv, pad, prec, concat_fmt rest fmt2)
+
+ | Char (rest) ->
+ Char (concat_fmt rest fmt2)
+ | Caml_char rest ->
+ Caml_char (concat_fmt rest fmt2)
+ | Bool rest ->
+ Bool (concat_fmt rest fmt2)
+ | Alpha rest ->
+ Alpha (concat_fmt rest fmt2)
+ | Theta rest ->
+ Theta (concat_fmt rest fmt2)
+ | Reader rest ->
+ Reader (concat_fmt rest fmt2)
+ | Flush rest ->
+ Flush (concat_fmt rest fmt2)
+
+ | String_literal (str, rest) ->
+ String_literal (str, concat_fmt rest fmt2)
+ | Char_literal (chr, rest) ->
+ Char_literal (chr, concat_fmt rest fmt2)
+
+ | Format_arg (pad, fmtty, rest) ->
+ Format_arg (pad, fmtty, concat_fmt rest fmt2)
+ | Format_subst (pad, fmtty, rest) ->
+ Format_subst (pad, fmtty, concat_fmt rest fmt2)
+
+ | Scan_char_set (width_opt, char_set, rest) ->
+ Scan_char_set (width_opt, char_set, concat_fmt rest fmt2)
+ | Scan_get_counter (counter, rest) ->
+ Scan_get_counter (counter, concat_fmt rest fmt2)
+ | Ignored_param (ign, rest) ->
+ Ignored_param (ign, concat_fmt rest fmt2)
+
+ | Formatting (fmting, rest) ->
+ Formatting (fmting, concat_fmt rest fmt2)
+
+ | End_of_format ->
+ fmt2
View
280 stdlib/camlinternalFormatBasics.mli
@@ -0,0 +1,280 @@
+(* No comments, OCaml stdlib internal use only. *)
+
+type block_type = Pp_hbox | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits
+
+type formatting =
+ | Open_box of string * block_type * int
+ | Close_box
+ | Open_tag of string * string
+ | Close_tag
+ | Break of string * int * int
+ | FFlush
+ | Force_newline
+ | Flush_newline
+ | Magic_size of string * int
+ | Escaped_at
+ | Escaped_percent
+ | Scan_indic of char
+
+type padty = Left | Right | Zeros
+
+type int_conv =
+ | Int_d | Int_pd | Int_sd | Int_i | Int_pi | Int_si
+ | Int_x | Int_Cx | Int_X | Int_CX | Int_o | Int_Co | Int_u
+
+type float_conv =
+ | Float_f | Float_pf | Float_sf | Float_e | Float_pe | Float_se
+ | Float_E | Float_pE | Float_sE | Float_g | Float_pg | Float_sg
+ | Float_G | Float_pG | Float_sG | Float_F
+
+type char_set = string
+
+type counter = Line_counter | Char_counter | Token_counter
+
+type ('a, 'b) padding =
+ | No_padding : ('a, 'a) padding
+ | Lit_padding : padty * int -> ('a, 'a) padding
+ | Arg_padding : padty -> (int -> 'a, 'a) padding
+
+type pad_option = int option
+
+type ('a, 'b) precision =
+ | No_precision : ('a, 'a) precision
+ | Lit_precision : int -> ('a, 'a) precision
+ | Arg_precision : (int -> 'a, 'a) precision
+
+type prec_option = int option
+
+type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =
+ ('a, 'b, 'c, 'd, 'e, 'f,
+ 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel
+and ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel =
+ | Char_ty : (* %c *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | String_ty : (* %s *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (string -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ string -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Int_ty : (* %d *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (int -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ int -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Int32_ty : (* %ld *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (int32 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ int32 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Nativeint_ty : (* %nd *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (nativeint -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ nativeint -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Int64_ty : (* %Ld *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (int64 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ int64 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Float_ty : (* %f *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (float -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ float -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Bool_ty : (* %B *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (bool -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ bool -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Format_arg_ty : (* %{...%} *)
+ ('g, 'h, 'i, 'j, 'k, 'l) fmtty *
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Format_subst_ty : (* %(...%) *)
+ ('g, 'h, 'i, 'j, 'k, 'l,
+ 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *
+ ('g, 'h, 'i, 'j, 'k, 'l,
+ 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,
+ ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel
+
+ (* Printf and Format specific constructors. *)
+ | Alpha_ty : (* %a *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('b1 -> 'x -> 'c1) -> 'x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ ('b2 -> 'x -> 'c2) -> 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+ | Theta_ty : (* %t *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ (('b1 -> 'c1) -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ ('b2 -> 'c2) -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
+
+ (* Scanf specific constructor. *)
+ | Reader_ty : (* %r *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ ('x -> 'a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,
+ 'x -> 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel
+ | Ignored_reader_ty : (* %_r *)
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ ('a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel
+
+ | End_of_fmtty :
+ ('f1, 'b1, 'c1, 'd1, 'd1, 'f1,
+ 'f2, 'b2, 'c2, 'd2, 'd2, 'f2) fmtty_rel
+
+(***)
+
+(* List of format elements. *)
+and ('a, 'b, 'c, 'd, 'e, 'f) fmt =
+ | Char : (* %c *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Caml_char : (* %C *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | String : (* %s *)
+ ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Caml_string : (* %S *)
+ ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Int : (* %[dixXuo] *)
+ int_conv * ('x, 'y) padding * ('y, int -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Int32 : (* %l[dixXuo] *)
+ int_conv * ('x, 'y) padding * ('y, int32 -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Nativeint : (* %n[dixXuo] *)
+ int_conv * ('x, 'y) padding * ('y, nativeint -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Int64 : (* %L[dixXuo] *)
+ int_conv * ('x, 'y) padding * ('y, int64 -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Float : (* %[feEgGF] *)
+ float_conv * ('x, 'y) padding * ('y, float -> 'a) precision *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x, 'b, 'c, 'd, 'e, 'f) fmt
+ | Bool : (* %[bB] *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (bool -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Flush : (* %! *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ | String_literal : (* abc *)
+ string * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Char_literal : (* x *)
+ char * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ | Format_arg : (* %{...%} *)
+ pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Format_subst : (* %(...%) *)
+ pad_option *
+ ('g, 'h, 'i, 'j, 'k, 'l,
+ 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt
+
+ (* Printf and Format specific constructor. *)
+ | Alpha : (* %a *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (('b -> 'x -> 'c) -> 'x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Theta : (* %t *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (('b -> 'c) -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ (* Format specific constructor: *)
+ | Formatting : (* @_ *)
+ formatting * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ (* Scanf specific constructors: *)
+ | Reader : (* %r *)
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('x -> 'a, 'b, 'c, ('b -> 'x) -> 'd, 'e, 'f) fmt
+ | Scan_char_set : (* %[...] *)
+ pad_option * char_set * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (string -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Scan_get_counter : (* %[nlNL] *)
+ counter * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ (int -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
+ | Ignored_param : (* %_ *)
+ ('a, 'b, 'c, 'd, 'y, 'x) ignored * ('x, 'b, 'c, 'y, 'e, 'f) fmt ->
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt
+
+ | End_of_format :
+ ('f, 'b, 'c, 'e, 'e, 'f) fmt
+
+and ('a, 'b, 'c, 'd, 'e, 'f) ignored =
+ | Ignored_char :
+ ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_caml_char :
+ ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_string :
+ pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_caml_string :
+ pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_int :
+ int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_int32 :
+ int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_nativeint :
+ int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_int64 :
+ int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_float :
+ pad_option * prec_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_bool :
+ ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_format_arg :
+ pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty ->
+ ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_format_subst :
+ pad_option * ('a, 'b, 'c, 'd, 'e, 'f) fmtty ->
+ ('a, 'b, 'c, 'd, 'e, 'f) ignored
+ | Ignored_reader :
+ ('a, 'b, 'c, ('b -> 'x) -> 'd, 'd, 'a) ignored
+ | Ignored_scan_char_set :
+ pad_option * char_set -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+ | Ignored_scan_get_counter :
+ counter -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
+
+and ('a, 'b, 'c, 'd, 'e, 'f) format6 =
+ Format of ('a, 'b, 'c, 'd, 'e, 'f) fmt * string
+
+val concat_fmtty :
+ ('g1, 'b1, 'c1, 'j1, 'd1, 'a1,
+ 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel ->
+ ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
+ 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
+ ('g1, 'b1, 'c1, 'j1, 'e1, 'f1,
+ 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel
+
+val erase_rel :
+ ('a, 'b, 'c, 'd, 'e, 'f,
+ 'g, 'h, 'i, 'j, 'k, 'l) fmtty_rel -> ('a, 'b, 'c, 'd, 'e, 'f) fmtty
+
+val concat_fmt :
+ ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
+ ('f, 'b, 'c, 'e, 'g, 'h) fmt ->
+ ('a, 'b, 'c, 'd, 'g, 'h) fmt
View
607 stdlib/pervasives.ml
@@ -448,613 +448,6 @@ module LargeFile =
(* Formats *)
-module CamlinternalFormatBasics = struct
-(* Type of a block used by the Format pretty-printer. *)
-type block_type =
- | Pp_hbox (* Horizontal block no line breaking *)
- | Pp_vbox (* Vertical block each break leads to a new line *)
- | Pp_hvbox (* Horizontal-vertical block: same as vbox, except if this block
- is small enough to fit on a single line *)
- | Pp_hovbox (* Horizontal or Vertical block: breaks lead to new line
- only when necessary to print the content of the block *)
- | Pp_box (* Horizontal or Indent block: breaks lead to new line
- only when necessary to print the content of the block, or
- when it leads to a new indentation of the current line *)
- | Pp_fits (* Internal usage: when a block fits on a single line *)
-
-(* Formatting element used by the Format pretty-printter. *)
-type formatting =
- | Open_box of string * block_type * int (* @[ *)
- | Close_box (* @] *)
- | Open_tag of string * string (* @{ *)
- | Close_tag (* @} *)
- | Break of string * int * int (* @, | @ | @; | @;<> *)
- | FFlush (* @? *)
- | Force_newline (* @\n *)
- | Flush_newline (* @. *)
- | Magic_size of string * int (* @<n> *)
- | Escaped_at (* @@ *)
- | Escaped_percent (* @%% *)
- | Scan_indic of char (* @X *)
-
-(***)
-
-(* Padding position. *)
-type padty =
- | Left (* Text is left justified ('-' option). *)
- | Right (* Text is right justified (no '-' option). *)
- | Zeros (* Text is right justified by zeros (see '0' option). *)
-
-(***)
-
-(* Integer conversion. *)
-type int_conv =
- | Int_d | Int_pd | Int_sd (* %d | %+d | % d *)
- | Int_i | Int_pi | Int_si (* %i | %+i | % i *)
- | Int_x | Int_Cx (* %x | %#x *)
- | Int_X | Int_CX (* %X | %#X *)
- | Int_o | Int_Co (* %o | %#o *)
- | Int_u (* %u *)
-
-(* Float conversion. *)
-type float_conv =
- | Float_f | Float_pf | Float_sf (* %f | %+f | % f *)
- | Float_e | Float_pe | Float_se (* %e | %+e | % e *)
- | Float_E | Float_pE | Float_sE (* %E | %+E | % E *)
- | Float_g | Float_pg | Float_sg (* %g | %+g | % g *)
- | Float_G | Float_pG | Float_sG (* %G | %+G | % G *)
- | Float_F (* %F *)
-
-(***)
-
-(* Char sets (see %[...]) are bitmaps implemented as 32-char strings. *)
-type char_set = string
-
-(***)
-
-(* Counter used in Scanf. *)
-type counter =
- | Line_counter (* %l *)
- | Char_counter (* %n *)
- | Token_counter (* %N, %L *)
-
-(***)
-
-(* Padding of strings and numbers. *)
-type ('a, 'b) padding =
- (* No padding (ex: "%d") *)
- | No_padding : ('a, 'a) padding
- (* Literal padding (ex: "%8d") *)
- | Lit_padding : padty * int -> ('a, 'a) padding
- (* Padding as extra argument (ex: "%*d") *)
- | Arg_padding : padty -> (int -> 'a, 'a) padding
-
-(* Some formats, such as %_d,
- only accept an optional number as padding option (no extra argument) *)
-type pad_option = int option
-
-(* Precision of floats and '0'-padding of integers. *)
-type ('a, 'b) precision =
- (* No precision (ex: "%f") *)
- | No_precision : ('a, 'a) precision
- (* Literal precision (ex: "%.3f") *)
- | Lit_precision : int -> ('a, 'a) precision
- (* Precision as extra argument (ex: "%.*f") *)
- | Arg_precision : (int -> 'a, 'a) precision
-
-(* Some formats, such as %_f,
- only accept an optional number as precision option (no extra argument) *)
-type prec_option = int option
-
-(***)
-
-(* Relational format types
-
-In the first format+gadts implementation, the type for %(..%) in the
-fmt GADT was as follows:
-
-| Format_subst : (* %(...%) *)
- pad_option * ('d1, 'q1, 'd2, 'q2) reader_nb_unifier *
- ('x, 'b, 'c, 'd1, 'q1, 'u) fmtty *
- ('u, 'b, 'c, 'q1, 'e1, 'f) fmt ->
- (('x, 'b, 'c, 'd2, 'q2, 'u) format6 -> 'x, 'b, 'c, 'd1, 'e1, 'f) fmt
-
-Notice that the 'u parameter in 'f position in the format argument
-(('x, .., 'u) format6 -> ..) is equal to the 'u parameter in 'a
-position in the format tail (('u, .., 'f) fmt). This means that the
-type of the expected format parameter depends of where the %(...%)
-are in the format string:
-
- # Printf.printf "%(%)";;
- - : (unit, out_channel, unit, '_a, '_a, unit)
- CamlinternalFormatBasics.format6 -> unit
- = <fun>
- # Printf.printf "%(%)%d";;
- - : (int -> unit, out_channel, unit, '_a, '_a, int -> unit)
- CamlinternalFormatBasics.format6 -> int -> unit
- = <fun>
-
-On the contrary, the legacy typer gives a clever type that does not
-depend on the position of %(..%) in the format string. For example,
-%(%) will have the polymorphic type ('a, 'b, 'c, 'd, 'd, 'a): it can
-be concatenated to any format type, and only enforces the constraint
-that its 'a and 'f parameters are equal (no format arguments) and 'd
-and 'e are equal (no reader argument).
-
-The weakening of this parameter type in the GADT version broke user
-code (in fact it essentially made %(...%) unusable except at the last
-position of a format). In particular, the following would not work
-anymore:
-
- fun sep ->
- Format.printf "foo%(%)bar%(%)baz" sep sep
-
-As the type-checker would require two *incompatible* types for the %(%)
-in different positions.
-
-The solution to regain a general type for %(..%) is to generalize this
-technique, not only on the 'd, 'e parameters, but on all six
-parameters of a format: we introduce a "relational" type
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
-whose values are proofs that ('a1, .., 'f1) and ('a2, .., 'f2) morally
-correspond to the same format type: 'a1 is obtained from 'f1,'b1,'c1
-in the exact same way that 'a2 is obtained from 'f2,'b2,'c2, etc.
-
-For example, the relation between two format types beginning with a Char
-parameter is as follows:
-
-| Char_ty : (* %c *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
-
-In the general case, the term structure of fmtty_rel is (almost¹)
-isomorphic to the fmtty of the previous implementation: every
-constructor is re-read with a binary, relational type, instead of the
-previous unary typing. fmtty can then be re-defined as the diagonal of
-fmtty_rel:
-
- type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =
- ('a, 'b, 'c, 'd, 'e, 'f,
- 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel
-
-Once we have this fmtty_rel type in place, we can give the more
-general type to %(...%):
-
-| Format_subst : (* %(...%) *)
- pad_option *
- ('g, 'h, 'i, 'j, 'k, 'l,
- 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt
-
-We accept any format (('g, 'h, 'i, 'j, 'k, 'l) format6) (this is
-completely unrelated to the type of the current format), but also
-require a proof that this format is in relation to another format that
-is concatenable to the format tail. When executing a %(...%) format
-(in camlinternalFormat.ml:make_printf or scanf.ml:make_scanf), we
-transtype the format along this relation using the 'recast' function
-to transpose between related format types.
-
- val recast :
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1) fmt
- -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmt
-
-NOTE ¹: the typing of Format_subst_ty requires not one format type, but
-two, one to establish the link between the format argument and the
-first six parameters, and the other for the link between the format
-argumant and the last six parameters.
-
-| Format_subst_ty : (* %(...%) *)
- ('g, 'h, 'i, 'j, 'k, 'l,
- 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *
- ('g, 'h, 'i, 'j, 'k, 'l,
- 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,
- ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel
-
-When we generate a format AST, we generate exactly the same witness
-for both relations, and the witness-conversion functions in
-camlinternalFormat do rely on this invariant. For example, the
-function that proves that the relation is transitive
-
- val trans :
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- -> ('a2, 'b2, 'c2, 'd2, 'e2, 'f2,
- 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel
- -> ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a3, 'b3, 'c3, 'd3, 'e3, 'f3) fmtty_rel
-
-does assume that the two input have exactly the same term structure
-(and is only every used for argument witnesses of the
-Format_subst_ty constructor).
-*)
-
-(* List of format type elements. *)
-(* In particular used to represent %(...%) and %{...%} contents. *)
-type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =
- ('a, 'b, 'c, 'd, 'e, 'f,
- 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel
-and ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel =
- | Char_ty : (* %c *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | String_ty : (* %s *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (string -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- string -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Int_ty : (* %d *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (int -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- int -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Int32_ty : (* %ld *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (int32 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- int32 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Nativeint_ty : (* %nd *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (nativeint -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- nativeint -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Int64_ty : (* %Ld *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (int64 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- int64 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Float_ty : (* %f *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (float -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- float -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Bool_ty : (* %B *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (bool -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- bool -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
-
- | Format_arg_ty : (* %{...%} *)
- ('g, 'h, 'i, 'j, 'k, 'l) fmtty *
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Format_subst_ty : (* %(...%) *)
- ('g, 'h, 'i, 'j, 'k, 'l,
- 'g1, 'b1, 'c1, 'j1, 'd1, 'a1) fmtty_rel *
- ('g, 'h, 'i, 'j, 'k, 'l,
- 'g2, 'b2, 'c2, 'j2, 'd2, 'a2) fmtty_rel *
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g1, 'b1, 'c1, 'j1, 'e1, 'f1,
- ('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b2, 'c2, 'j2, 'e2, 'f2) fmtty_rel
-
- (* Printf and Format specific constructors. *)
- | Alpha_ty : (* %a *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (('b1 -> 'x -> 'c1) -> 'x -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- ('b2 -> 'x -> 'c2) -> 'x -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Theta_ty : (* %t *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (('b1 -> 'c1) -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- ('b2 -> 'c2) -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
-
- (* Scanf specific constructor. *)
- | Reader_ty : (* %r *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- ('x -> 'a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,
- 'x -> 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel
- | Ignored_reader_ty : (* %_r *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- ('a1, 'b1, 'c1, ('b1 -> 'x) -> 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, ('b2 -> 'x) -> 'd2, 'e2, 'f2) fmtty_rel
-
- | End_of_fmtty :
- ('f1, 'b1, 'c1, 'd1, 'd1, 'f1,
- 'f2, 'b2, 'c2, 'd2, 'd2, 'f2) fmtty_rel
-
-(***)
-
-(* List of format elements. *)
-and ('a, 'b, 'c, 'd, 'e, 'f) fmt =
- | Char : (* %c *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Caml_char : (* %C *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (char -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | String : (* %s *)
- ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Caml_string : (* %S *)
- ('x, string -> 'a) padding * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Int : (* %[dixXuo] *)
- int_conv * ('x, 'y) padding * ('y, int -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Int32 : (* %l[dixXuo] *)
- int_conv * ('x, 'y) padding * ('y, int32 -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Nativeint : (* %n[dixXuo] *)
- int_conv * ('x, 'y) padding * ('y, nativeint -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Int64 : (* %L[dixXuo] *)
- int_conv * ('x, 'y) padding * ('y, int64 -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Float : (* %[feEgGF] *)
- float_conv * ('x, 'y) padding * ('y, float -> 'a) precision *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x, 'b, 'c, 'd, 'e, 'f) fmt
- | Bool : (* %[bB] *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (bool -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Flush : (* %! *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
-
- | String_literal : (* abc *)
- string * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
- | Char_literal : (* x *)
- char * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
-
- | Format_arg : (* %{...%} *)
- pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Format_subst : (* %(...%) *)
- pad_option *
- ('g, 'h, 'i, 'j, 'k, 'l,
- 'g2, 'b, 'c, 'j2, 'd, 'a) fmtty_rel *
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (('g, 'h, 'i, 'j, 'k, 'l) format6 -> 'g2, 'b, 'c, 'j2, 'e, 'f) fmt
-
- (* Printf and Format specific constructor. *)
- | Alpha : (* %a *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (('b -> 'x -> 'c) -> 'x -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Theta : (* %t *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (('b -> 'c) -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
-
- (* Format specific constructor: *)
- | Formatting : (* @_ *)
- formatting * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
-
- (* Scanf specific constructors: *)
- | Reader : (* %r *)
- ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- ('x -> 'a, 'b, 'c, ('b -> 'x) -> 'd, 'e, 'f) fmt
- | Scan_char_set : (* %[...] *)
- pad_option * char_set * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (string -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Scan_get_counter : (* %[nlNL] *)
- counter * ('a, 'b, 'c, 'd, 'e, 'f) fmt ->
- (int -> 'a, 'b, 'c, 'd, 'e, 'f) fmt
- | Ignored_param : (* %_ *)
- ('a, 'b, 'c, 'd, 'y, 'x) ignored * ('x, 'b, 'c, 'y, 'e, 'f) fmt ->
- ('a, 'b, 'c, 'd, 'e, 'f) fmt
-
- | End_of_format :
- ('f, 'b, 'c, 'e, 'e, 'f) fmt
-
-(***)
-
-(* Type for ignored parameters (see "%_"). *)
-and ('a, 'b, 'c, 'd, 'e, 'f) ignored =
- | Ignored_char : (* %_c *)
- ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_caml_char : (* %_C *)
- ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_string : (* %_s *)
- pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_caml_string : (* %_S *)
- pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_int : (* %_d *)
- int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_int32 : (* %_ld *)
- int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_nativeint : (* %_nd *)
- int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_int64 : (* %_Ld *)
- int_conv * pad_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_float : (* %_f *)
- pad_option * prec_option -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_bool : (* %_B *)
- ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_format_arg : (* %_{...%} *)
- pad_option * ('g, 'h, 'i, 'j, 'k, 'l) fmtty ->
- ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_format_subst : (* %_(...%) *)
- pad_option * ('a, 'b, 'c, 'd, 'e, 'f) fmtty ->
- ('a, 'b, 'c, 'd, 'e, 'f) ignored
- | Ignored_reader : (* %_r *)
- ('a, 'b, 'c, ('b -> 'x) -> 'd, 'd, 'a) ignored
- | Ignored_scan_char_set : (* %_[...] *)
- pad_option * char_set -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
- | Ignored_scan_get_counter : (* %_[nlNL] *)
- counter -> ('a, 'b, 'c, 'd, 'd, 'a) ignored
-
-and ('a, 'b, 'c, 'd, 'e, 'f) format6 =
- Format of ('a, 'b, 'c, 'd, 'e, 'f) fmt * string
-
-let rec erase_rel : type a b c d e f g h i j k l .
- (a, b, c, d, e, f,
- g, h, i, j, k, l) fmtty_rel -> (a, b, c, d, e, f) fmtty
-= function
- | Char_ty rest ->
- Char_ty (erase_rel rest)
- | String_ty rest ->
- String_ty (erase_rel rest)
- | Int_ty rest ->
- Int_ty (erase_rel rest)
- | Int32_ty rest ->
- Int32_ty (erase_rel rest)
- | Int64_ty rest ->
- Int64_ty (erase_rel rest)
- | Nativeint_ty rest ->
- Nativeint_ty (erase_rel rest)
- | Float_ty rest ->
- Float_ty (erase_rel rest)
- | Bool_ty rest ->
- Bool_ty (erase_rel rest)
- | Format_arg_ty (ty, rest) ->
- Format_arg_ty (ty, erase_rel rest)
- | Format_subst_ty (ty1, ty2, rest) ->
- Format_subst_ty (ty1, ty1, erase_rel rest)
- | Alpha_ty rest ->
- Alpha_ty (erase_rel rest)
- | Theta_ty rest ->
- Theta_ty (erase_rel rest)
- | Reader_ty rest ->
- Reader_ty (erase_rel rest)
- | Ignored_reader_ty rest ->
- Ignored_reader_ty (erase_rel rest)
- | End_of_fmtty -> End_of_fmtty
-
-(******************************************************************************)
- (* Format type concatenation *)
-
-(* Concatenate two format types. *)
-(* Used by:
- * reader_nb_unifier_of_fmtty to count readers in an fmtty,
- * Scanf.take_fmtty_format_readers to extract readers inside %(...%),
- * CamlinternalFormat.fmtty_of_ignored_format to extract format type. *)
-
-(*
-let rec concat_fmtty : type a b c d e f g h .
- (a, b, c, d, e, f) fmtty ->
- (f, b, c, e, g, h) fmtty ->
- (a, b, c, d, g, h) fmtty =
-*)
-let rec concat_fmtty :
- type a1 b1 c1 d1 e1 f1
- a2 b2 c2 d2 e2 f2
- g1 j1 g2 j2
- .
- (g1, b1, c1, j1, d1, a1,
- g2, b2, c2, j2, d2, a2) fmtty_rel ->
- (a1, b1, c1, d1, e1, f1,
- a2, b2, c2, d2, e2, f2) fmtty_rel ->
- (g1, b1, c1, j1, e1, f1,
- g2, b2, c2, j2, e2, f2) fmtty_rel =
-fun fmtty1 fmtty2 -> match fmtty1 with
- | Char_ty rest ->
- Char_ty (concat_fmtty rest fmtty2)
- | String_ty rest ->
- String_ty (concat_fmtty rest fmtty2)
- | Int_ty rest ->
- Int_ty (concat_fmtty rest fmtty2)
- | Int32_ty rest ->
- Int32_ty (concat_fmtty rest fmtty2)
- | Nativeint_ty rest ->
- Nativeint_ty (concat_fmtty rest fmtty2)
- | Int64_ty rest ->
- Int64_ty (concat_fmtty rest fmtty2)
- | Float_ty rest ->
- Float_ty (concat_fmtty rest fmtty2)
- | Bool_ty rest ->
- Bool_ty (concat_fmtty rest fmtty2)
- | Alpha_ty rest ->
- Alpha_ty (concat_fmtty rest fmtty2)
- | Theta_ty rest ->
- Theta_ty (concat_fmtty rest fmtty2)
- | Reader_ty rest ->
- Reader_ty (concat_fmtty rest fmtty2)
- | Ignored_reader_ty rest ->
- Ignored_reader_ty (concat_fmtty rest fmtty2)
- | Format_arg_ty (ty, rest) ->
- Format_arg_ty (ty, concat_fmtty rest fmtty2)
- | Format_subst_ty (ty1, ty2, rest) ->
- Format_subst_ty (ty1, ty2, concat_fmtty rest fmtty2)
- | End_of_fmtty -> fmtty2
-
-(******************************************************************************)
- (* Format concatenation *)
-
-(* Concatenate two formats. *)
-let rec concat_fmt : type a b c d e f g h .
- (a, b, c, d, e, f) fmt ->
- (f, b, c, e, g, h) fmt ->
- (a, b, c, d, g, h) fmt =
-fun fmt1 fmt2 -> match fmt1 with
- | String (pad, rest) ->
- String (pad, concat_fmt rest fmt2)
- | Caml_string (pad, rest) ->
- Caml_string (pad, concat_fmt rest fmt2)
-
- | Int (iconv, pad, prec, rest) ->
- Int (iconv, pad, prec, concat_fmt rest fmt2)
- | Int32 (iconv, pad, prec, rest) ->
- Int32 (iconv, pad, prec, concat_fmt rest fmt2)
- | Nativeint (iconv, pad, prec, rest) ->
- Nativeint (iconv, pad, prec, concat_fmt rest fmt2)
- | Int64 (iconv, pad, prec, rest) ->
- Int64 (iconv, pad, prec, concat_fmt rest fmt2)
- | Float (fconv, pad, prec, rest) ->
- Float (fconv, pad, prec, concat_fmt rest fmt2)
-
- | Char (rest) ->
- Char (concat_fmt rest fmt2)
- | Caml_char rest ->
- Caml_char (concat_fmt rest fmt2)
- | Bool rest ->
- Bool (concat_fmt rest fmt2)
- | Alpha rest ->
- Alpha (concat_fmt rest fmt2)
- | Theta rest ->
- Theta (concat_fmt rest fmt2)
- | Reader rest ->
- Reader (concat_fmt rest fmt2)
- | Flush rest ->
- Flush (concat_fmt rest fmt2)
-
- | String_literal (str, rest) ->
- String_literal (str, concat_fmt rest fmt2)
- | Char_literal (chr, rest) ->
- Char_literal (chr, concat_fmt rest fmt2)
-
- | Format_arg (pad, fmtty, rest) ->
- Format_arg (pad, fmtty, concat_fmt rest fmt2)
- | Format_subst (pad, fmtty, rest) ->
- Format_subst (pad, fmtty, concat_fmt rest fmt2)
-
- | Scan_char_set (width_opt, char_set, rest) ->
- Scan_char_set (width_opt, char_set, concat_fmt rest fmt2)
- | Scan_get_counter (counter, rest) ->
- Scan_get_counter (counter, concat_fmt rest fmt2)
- | Ignored_param (ign, rest) ->
- Ignored_param (ign, concat_fmt rest fmt2)
-
- | Formatting (fmting, rest) ->
- Formatting (fmting, concat_fmt rest fmt2)
-
- | End_of_format ->
- fmt2
-end
-
type ('a, 'b, 'c, 'd, 'e, 'f) format6
= ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6
= Format of ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.fmt
View
283 stdlib/pervasives.mli
@@ -966,289 +966,6 @@ external decr : int ref -> unit = "%decr"
{!Printf} and {!Format}.
*)
-module CamlinternalFormatBasics : sig
- (* No comments, OCaml stdlib internal use only. *)
-
- type block_type = Pp_hbox | Pp_vbox | Pp_hvbox | Pp_hovbox | Pp_box | Pp_fits
-
- type formatting =
- | Open_box of string * block_type * int
- | Close_box
- | Open_tag of string * string
- | Close_tag
- | Break of string * int * int
- | FFlush
- | Force_newline
- | Flush_newline
- | Magic_size of string * int
- | Escaped_at
- | Escaped_percent
- | Scan_indic of char
-
- type padty = Left | Right | Zeros
-
- type int_conv =
- | Int_d | Int_pd | Int_sd | Int_i | Int_pi | Int_si
- | Int_x | Int_Cx | Int_X | Int_CX | Int_o | Int_Co | Int_u
-
- type float_conv =
- | Float_f | Float_pf | Float_sf | Float_e | Float_pe | Float_se
- | Float_E | Float_pE | Float_sE | Float_g | Float_pg | Float_sg
- | Float_G | Float_pG | Float_sG | Float_F
-
- type char_set = string
-
- type counter = Line_counter | Char_counter | Token_counter
-
- type ('a, 'b) padding =
- | No_padding : ('a, 'a) padding
- | Lit_padding : padty * int -> ('a, 'a) padding
- | Arg_padding : padty -> (int -> 'a, 'a) padding
-
- type pad_option = int option
-
- type ('a, 'b) precision =
- | No_precision : ('a, 'a) precision
- | Lit_precision : int -> ('a, 'a) precision
- | Arg_precision : (int -> 'a, 'a) precision
-
- type prec_option = int option
-
-type ('a, 'b, 'c, 'd, 'e, 'f) fmtty =
- ('a, 'b, 'c, 'd, 'e, 'f,
- 'a, 'b, 'c, 'd, 'e, 'f) fmtty_rel
-and ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel =
- | Char_ty : (* %c *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (char -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- char -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | String_ty : (* %s *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (string -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- string -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Int_ty : (* %d *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (int -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- int -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Int32_ty : (* %ld *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (int32 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- int32 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Nativeint_ty : (* %nd *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (nativeint -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- nativeint -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Int64_ty : (* %Ld *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (int64 -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- int64 -> 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel
- | Float_ty : (* %f *)
- ('a1, 'b1, 'c1, 'd1, 'e1, 'f1,
- 'a2, 'b2, 'c2, 'd2, 'e2, 'f2) fmtty_rel ->
- (float -> 'a1, 'b1, 'c1, 'd1, 'e1, 'f1,