diff options
46 files changed, 1117 insertions, 511 deletions
diff --git a/.gitignore b/.gitignore index 3d8f237867..92429b70c2 100644 --- a/.gitignore +++ b/.gitignore @@ -32,6 +32,7 @@ *.out.dSYM *.swp _ocamltest +*.odoc # local to root directory @@ -157,6 +158,7 @@ _ocamltest /ocamldoc/ocamldoc /ocamldoc/ocamldoc.opt +/ocamldoc/odoc /ocamldoc/odoc_crc.ml /ocamldoc/odoc_lexer.ml /ocamldoc/odoc_ocamlhtml.ml @@ -167,6 +169,7 @@ _ocamltest /ocamldoc/odoc_text_parser.ml /ocamldoc/odoc_text_parser.mli /ocamldoc/stdlib_man +/ocamldoc/stdlib_non_prefixed/*.mli /ocamldoc/stdlib_html /ocamldoc/*.output /ocamldoc/test_stdlib @@ -182,7 +185,7 @@ _ocamltest /otherlibs/dynlink/extract_crc /otherlibs/threads/marshal.mli -/otherlibs/threads/pervasives.mli +/otherlibs/threads/stdlib.mli /otherlibs/threads/unix.mli /otherlibs/win32graph/graphics.ml /otherlibs/win32graph/graphics.mli @@ -1257,6 +1257,11 @@ OCaml 4.05.0 (13 Jul 2017): (François Bobot, review by Gabriel Scherer, Xavier Leroy, Damien Doligez, Frédéric Bour) +* GPR#1010: change the compilation scheme of the stdlib. Now x.ml in + compiles to stdlib__x.cm* and we add a Stdlib alias module that is + opened by default to get back the short names. + (Jeremie Dimino, review by Gabriel Radanne) + ### Manual and documentation: - MPR#6597, GPR#1030: add forward references to language extensions diff --git a/boot/ocamlc b/boot/ocamlc Binary files differindex 3f267a65c2..627e720ebd 100755 --- a/boot/ocamlc +++ b/boot/ocamlc diff --git a/boot/ocamldep b/boot/ocamldep Binary files differindex a84b9b4191..c09a049ff0 100755 --- a/boot/ocamldep +++ b/boot/ocamldep diff --git a/boot/ocamllex b/boot/ocamllex Binary files differindex 53a64dda7d..ba4fa9fcdf 100755 --- a/boot/ocamllex +++ b/boot/ocamllex diff --git a/bytecomp/translcore.ml b/bytecomp/translcore.ml index 22eee67312..eda7a7f6f2 100644 --- a/bytecomp/translcore.ml +++ b/bytecomp/translcore.ml @@ -48,6 +48,9 @@ let prim_fresh_oo_id = Pccall (Primitive.simple ~name:"caml_fresh_oo_id" ~arity:1 ~alloc:false) let transl_extension_constructor env path ext = + let path = + Stdlib.Option.map (Printtyp.rewrite_double_underscore_paths env) path + in let name = match path, !Clflags.for_package with None, _ -> Ident.name ext.ext_id diff --git a/driver/compmisc.ml b/driver/compmisc.ml index 08dc670d3d..b1bed14b54 100644 --- a/driver/compmisc.ml +++ b/driver/compmisc.ml @@ -45,13 +45,18 @@ let init_path ?(dir="") native = let initial_env () = Ident.reinit(); + let initially_opened_module = + if !Clflags.nopervasives then + None + else + Some "Stdlib" + in Typemod.initial_env ~loc:(Location.in_file "command line") ~safe_string:(Config.safe_string || not !Clflags.unsafe_string) - ~open_pervasives:(not !Clflags.nopervasives) + ~initially_opened_module ~open_implicit_modules:(!implicit_modules @ List.rev !Clflags.open_modules) - let read_color_env ppf = try match Clflags.parse_color_setting (Sys.getenv "OCAML_COLOR") with diff --git a/manual/manual/refman/exten.etex b/manual/manual/refman/exten.etex index c1dd2410fa..ea00430ea4 100644 --- a/manual/manual/refman/exten.etex +++ b/manual/manual/refman/exten.etex @@ -935,13 +935,13 @@ physically @'A'@ and @'B'@ as submodules, and with no dependencies on their respective compilation units. Here is a concrete example of a possible alternative approach: \begin{enumerate} -\item Rename the files containing @'A'@ and @'B'@ to @'Mylib_A'@ and - @'Mylib_B'@. +\item Rename the files containing @'A'@ and @'B'@ to @'Mylib__A'@ and + @'Mylib__B'@. \item Create a packing interface @'Mylib.ml'@, containing the following lines. \begin{verbatim} - module A = Mylib_A - module B = Mylib_B + module A = Mylib__A + module B = Mylib__B \end{verbatim} \item Compile @'Mylib.ml'@ using @'-no-alias-deps'@, and the other files using @'-no-alias-deps'@ and @'-open' 'Mylib'@ (the last one is @@ -949,7 +949,7 @@ Here is a concrete example of a possible alternative approach: file). \begin{verbatim} ocamlc -c -no-alias-deps Mylib.ml - ocamlc -c -no-alias-deps -open Mylib Mylib_*.mli Mylib_*.ml + ocamlc -c -no-alias-deps -open Mylib Mylib__*.mli Mylib__*.ml \end{verbatim} \item Finally, create a library containing all the compilation units, and export all the compiled interfaces. @@ -960,12 +960,21 @@ Here is a concrete example of a possible alternative approach: This approach lets you access @'A'@ and @'B'@ directly inside the library, and as @'Mylib.A'@ and @'Mylib.B'@ from outside. It also has the advantage that @'Mylib'@ is no longer monolithic: if -you use @'Mylib.A'@, only @'Mylib_A'@ will be linked in, not -@'Mylib_B'@. +you use @'Mylib.A'@, only @'Mylib__A'@ will be linked in, not +@'Mylib__B'@. %Note that in the above @'Mylib.cmo'@ is actually empty, and one could %name the interface @'Mylib.mli'@, but this would require that all %clients are compiled with the @'-no-alias-deps'@ flag. +Note the use of double underscores in @'Mylib__A'@ and +@'Mylib__B'@. These were chosen on purpose; the compiler uses the +following heuristic when printing paths: given a path @'Lib__fooBar'@, +if @'Lib.FooBar'@ exists and is an alias for @'Lib__fooBar'@, then the +compiler will always display @'Lib.FooBar'@ instead of +@'Lib__fooBar'@. This way the long @'Mylib__'@ names stay hidden and +all the user sees is the nicer dot names. This is how the OCaml +standard library is compiled. + \section{Overriding in open statements}\label{s:explicit-overriding-open} \ikwd{open.\@\texttt{open\char33}} diff --git a/ocamldoc/.depend b/ocamldoc/.depend index ab7dcf5b50..e3237ee073 100644 --- a/ocamldoc/.depend +++ b/ocamldoc/.depend @@ -274,3 +274,117 @@ generators/odoc_todo.cmx : odoc_module.cmx odoc_info.cmx odoc_html.cmx \ odoc_gen.cmx odoc_args.cmx generators/odoc_todo.cmxs : odoc_module.cmx odoc_info.cmx odoc_html.cmx \ odoc_gen.cmx odoc_args.cmx +stdlib_non_prefixed/arg.cmi : +stdlib_non_prefixed/array.cmi : +stdlib_non_prefixed/arrayLabels.cmi : +stdlib_non_prefixed/ast_helper.cmi : stdlib_non_prefixed/parsetree.cmi \ + stdlib_non_prefixed/longident.cmi stdlib_non_prefixed/location.cmi \ + stdlib_non_prefixed/docstrings.cmi stdlib_non_prefixed/asttypes.cmi +stdlib_non_prefixed/ast_invariants.cmi : stdlib_non_prefixed/parsetree.cmi +stdlib_non_prefixed/ast_iterator.cmi : stdlib_non_prefixed/parsetree.cmi \ + stdlib_non_prefixed/location.cmi +stdlib_non_prefixed/ast_mapper.cmi : stdlib_non_prefixed/parsetree.cmi \ + stdlib_non_prefixed/location.cmi +stdlib_non_prefixed/asttypes.cmi : stdlib_non_prefixed/location.cmi +stdlib_non_prefixed/attr_helper.cmi : stdlib_non_prefixed/parsetree.cmi \ + stdlib_non_prefixed/location.cmi stdlib_non_prefixed/format.cmi \ + stdlib_non_prefixed/asttypes.cmi +stdlib_non_prefixed/big_int.cmi : stdlib_non_prefixed/nat.cmi +stdlib_non_prefixed/bigarray.cmi : stdlib_non_prefixed/unix.cmi \ + stdlib_non_prefixed/complex.cmi \ + stdlib_non_prefixed/camlinternalBigarray.cmi +stdlib_non_prefixed/buffer.cmi : stdlib_non_prefixed/uchar.cmi +stdlib_non_prefixed/builtin_attributes.cmi : \ + stdlib_non_prefixed/parsetree.cmi stdlib_non_prefixed/location.cmi \ + stdlib_non_prefixed/ast_iterator.cmi +stdlib_non_prefixed/bytes.cmi : +stdlib_non_prefixed/bytesLabels.cmi : +stdlib_non_prefixed/callback.cmi : +stdlib_non_prefixed/camlinternalBigarray.cmi : \ + stdlib_non_prefixed/complex.cmi +stdlib_non_prefixed/camlinternalFormat.cmi : \ + stdlib_non_prefixed/camlinternalFormatBasics.cmi \ + stdlib_non_prefixed/buffer.cmi +stdlib_non_prefixed/camlinternalFormatBasics.cmi : +stdlib_non_prefixed/camlinternalLazy.cmi : +stdlib_non_prefixed/camlinternalMod.cmi : stdlib_non_prefixed/obj.cmi +stdlib_non_prefixed/camlinternalOO.cmi : stdlib_non_prefixed/obj.cmi +stdlib_non_prefixed/char.cmi : +stdlib_non_prefixed/complex.cmi : +stdlib_non_prefixed/depend.cmi : stdlib_non_prefixed/set.cmi \ + stdlib_non_prefixed/parsetree.cmi stdlib_non_prefixed/map.cmi \ + stdlib_non_prefixed/longident.cmi +stdlib_non_prefixed/digest.cmi : +stdlib_non_prefixed/docstrings.cmi : stdlib_non_prefixed/parsetree.cmi \ + stdlib_non_prefixed/location.cmi stdlib_non_prefixed/lexing.cmi \ + stdlib_non_prefixed/lazy.cmi +stdlib_non_prefixed/ephemeron.cmi : stdlib_non_prefixed/hashtbl.cmi +stdlib_non_prefixed/filename.cmi : +stdlib_non_prefixed/format.cmi : stdlib_non_prefixed/pervasives.cmi \ + stdlib_non_prefixed/buffer.cmi +stdlib_non_prefixed/gc.cmi : +stdlib_non_prefixed/genlex.cmi : stdlib_non_prefixed/stream.cmi +stdlib_non_prefixed/hashtbl.cmi : +stdlib_non_prefixed/int32.cmi : +stdlib_non_prefixed/int64.cmi : +stdlib_non_prefixed/lazy.cmi : +stdlib_non_prefixed/lexer.cmi : stdlib_non_prefixed/parser.cmi \ + stdlib_non_prefixed/location.cmi stdlib_non_prefixed/lexing.cmi \ + stdlib_non_prefixed/format.cmi +stdlib_non_prefixed/lexing.cmi : +stdlib_non_prefixed/list.cmi : +stdlib_non_prefixed/listLabels.cmi : +stdlib_non_prefixed/location.cmi : stdlib_non_prefixed/warnings.cmi \ + stdlib_non_prefixed/lexing.cmi stdlib_non_prefixed/format.cmi +stdlib_non_prefixed/longident.cmi : +stdlib_non_prefixed/map.cmi : +stdlib_non_prefixed/marshal.cmi : +stdlib_non_prefixed/moreLabels.cmi : stdlib_non_prefixed/set.cmi \ + stdlib_non_prefixed/map.cmi stdlib_non_prefixed/hashtbl.cmi +stdlib_non_prefixed/nat.cmi : +stdlib_non_prefixed/nativeint.cmi : +stdlib_non_prefixed/num.cmi : stdlib_non_prefixed/ratio.cmi \ + stdlib_non_prefixed/nat.cmi stdlib_non_prefixed/big_int.cmi +stdlib_non_prefixed/obj.cmi : stdlib_non_prefixed/int32.cmi +stdlib_non_prefixed/oo.cmi : stdlib_non_prefixed/camlinternalOO.cmi +stdlib_non_prefixed/parse.cmi : stdlib_non_prefixed/parsetree.cmi \ + stdlib_non_prefixed/lexing.cmi +stdlib_non_prefixed/parser.cmi : stdlib_non_prefixed/parsetree.cmi \ + stdlib_non_prefixed/location.cmi stdlib_non_prefixed/lexing.cmi \ + stdlib_non_prefixed/docstrings.cmi +stdlib_non_prefixed/parsetree.cmi : stdlib_non_prefixed/longident.cmi \ + stdlib_non_prefixed/location.cmi stdlib_non_prefixed/asttypes.cmi +stdlib_non_prefixed/parsing.cmi : stdlib_non_prefixed/obj.cmi \ + stdlib_non_prefixed/lexing.cmi +stdlib_non_prefixed/pervasives.cmi : \ + stdlib_non_prefixed/camlinternalFormatBasics.cmi +stdlib_non_prefixed/pprintast.cmi : stdlib_non_prefixed/parsetree.cmi \ + stdlib_non_prefixed/format.cmi +stdlib_non_prefixed/printast.cmi : stdlib_non_prefixed/parsetree.cmi \ + stdlib_non_prefixed/format.cmi +stdlib_non_prefixed/printexc.cmi : +stdlib_non_prefixed/printf.cmi : stdlib_non_prefixed/buffer.cmi +stdlib_non_prefixed/queue.cmi : +stdlib_non_prefixed/random.cmi : stdlib_non_prefixed/nativeint.cmi \ + stdlib_non_prefixed/int64.cmi stdlib_non_prefixed/int32.cmi +stdlib_non_prefixed/ratio.cmi : stdlib_non_prefixed/nat.cmi \ + stdlib_non_prefixed/big_int.cmi +stdlib_non_prefixed/scanf.cmi : stdlib_non_prefixed/pervasives.cmi +stdlib_non_prefixed/set.cmi : +stdlib_non_prefixed/sort.cmi : +stdlib_non_prefixed/spacetime.cmi : +stdlib_non_prefixed/stack.cmi : +stdlib_non_prefixed/stdLabels.cmi : stdlib_non_prefixed/stringLabels.cmi \ + stdlib_non_prefixed/listLabels.cmi stdlib_non_prefixed/bytesLabels.cmi \ + stdlib_non_prefixed/arrayLabels.cmi +stdlib_non_prefixed/str.cmi : +stdlib_non_prefixed/stream.cmi : +stdlib_non_prefixed/string.cmi : +stdlib_non_prefixed/stringLabels.cmi : +stdlib_non_prefixed/syntaxerr.cmi : stdlib_non_prefixed/location.cmi \ + stdlib_non_prefixed/format.cmi +stdlib_non_prefixed/sys.cmi : +stdlib_non_prefixed/uchar.cmi : +stdlib_non_prefixed/unix.cmi : stdlib_non_prefixed/camlinternalBigarray.cmi +stdlib_non_prefixed/warnings.cmi : +stdlib_non_prefixed/weak.cmi : stdlib_non_prefixed/hashtbl.cmi diff --git a/ocamldoc/Makefile b/ocamldoc/Makefile index dd45b59f46..36ed098a82 100644 --- a/ocamldoc/Makefile +++ b/ocamldoc/Makefile @@ -38,7 +38,7 @@ OCAMLLEX = $(OCAMLRUN) $(ROOTDIR)/boot/ocamllex # If they are not, then the preprocessor logic (including the # remove_DEBUG script and the debug target) could be removed. # If they are, it may be better to be able to enable them at run-time -# rather than compile-time, e.g. through a -debug command-line option. +# rather than compile-time, e.g. through a -debug command-line option. # In the following line, "sh" is useful under Windows. Without it, # the ./remove_DEBUG command would be executed by cmd.exe which would not # know how to handle it. @@ -179,12 +179,21 @@ LIBCMOFILES = $(CMOFILES) LIBCMXFILES = $(LIBCMOFILES:.cmo=.cmx) LIBCMIFILES = $(LIBCMOFILES:.cmo=.cmi) +P := +include ../stdlib/StdlibModules + +STDLIB_MODULES := pervasives $(filter-out stdlib,$(STDLIB_MODULES)) +PARSING_MLIS := $(wildcard ../parsing/*.mli) + STDLIB_MLIS=\ - ../stdlib/*.mli \ - ../parsing/*.mli \ - ../otherlibs/$(UNIXLIB)/unix.mli \ - ../otherlibs/str/str.mli \ - ../otherlibs/bigarray/bigarray.mli + $(STDLIB_MODULES:%=stdlib_non_prefixed/%.mli) \ + $(PARSING_MLIS:../parsing/%.mli=stdlib_non_prefixed/%.mli) \ + stdlib_non_prefixed/warnings.mli \ + stdlib_non_prefixed/unix.mli \ + stdlib_non_prefixed/str.mli \ + stdlib_non_prefixed/bigarray.mli + +STDLIB_CMIS=$(STDLIB_MLIS:%.mli=%.cmi) .PHONY: all all: lib exe generators manpages @@ -235,10 +244,10 @@ $(OCAMLDOC_LIBCMXA): $(LIBCMXFILES) $(OCAMLOPT) -a -o $@ $(LINKFLAGS) $^ .PHONY: manpages -manpages: stdlib_man/Pervasives.3o +manpages: stdlib_man/Stdlib.3o .PHONY: html_doc -html_doc: stdlib_html/Pervasives.html +html_doc: stdlib_html/Stdlib.html .PHONY: dot dot: ocamldoc.dot @@ -339,7 +348,7 @@ test: test_stdlib: $(MKDIR) $@ $(OCAMLDOC_RUN) -html -colorize-code -sort -d $@ $(INCLUDES) -dump $@/stdlib.odoc -keep-code \ - ../stdlib/pervasives.ml ../stdlib/*.mli \ + ../stdlib/*.mli \ ../otherlibs/$(UNIXLIB)/unix.mli \ ../otherlibs/str/str.mli @@ -382,25 +391,102 @@ test_texi: $(MKDIR) $@ $(OCAMLDOC_RUN) -texi -sort -d $@ $(INCLUDES) odoc*.ml odoc*.mli -stdlib_man/Pervasives.3o: $(OCAMLDOC) $(STDLIB_MLIS) +stdlib_man/Stdlib.3o: $(OCAMLDOC) $(STDLIB_MLIS) $(STDLIB_CMIS) $(MKDIR) stdlib_man - $(OCAMLDOC_RUN) -man -d stdlib_man $(INCLUDES) \ - -t "OCaml library" -man-mini $(STDLIB_MLIS) + $(OCAMLDOC_RUN) -man -d stdlib_man -nostdlib -I stdlib_non_prefixed \ + -t "OCaml library" -man-mini $(STDLIB_MLIS) \ + -initially-opened-module Pervasives -stdlib_html/Pervasives.html: $(STDLIB_MLIS) +stdlib_html/Stdlib.html: $(OCAMLDOC) $(STDLIB_MLIS) $(STDLIB_CMIS) $(MKDIR) stdlib_html - $(OCAMLDOC_RUN) -d stdlib_html -html $(INCLUDES) \ - -t "OCaml library" $^ + $(OCAMLDOC_RUN) -d stdlib_html -html -nostdlib -I stdlib_non_prefixed \ + -t "OCaml library" $(STDLIB_MLIS) \ + -initially-opened-module Pervasives .PHONY: autotest_stdlib autotest_stdlib: $(MKDIR) $@ $(OCAMLDOC_RUN) -g autotest/odoc_test.cmo\ $(INCLUDES) -keep-code \ - ../stdlib/pervasives.ml ../stdlib/*.mli \ + ../stdlib/*.mli \ ../otherlibs/$(UNIXLIB)/unix.mli \ ../otherlibs/str/str.mli +# stdlib non-prefixed : +####################### + +OCAMLC_SNP = $(OCAMLRUN) $(ROOTDIR)/ocamlc -nostdlib -nopervasives -I stdlib_non_prefixed + +stdlib_non_prefixed/%.mli: ../stdlib/%.mli + cp $< $@ + +stdlib_non_prefixed/camlinternalBigarray.mli: ../stdlib/camlinternalBigarray.ml + cp $< $@ + +stdlib_non_prefixed/%.mli: ../parsing/%.mli + cp $< $@ + +stdlib_non_prefixed/%.mli: ../utils/%.mli + cp $< $@ + +stdlib_non_prefixed/%.mli: ../otherlibs/$(UNIXLIB)/%.mli + cp $< $@ + +stdlib_non_prefixed/%.mli: ../otherlibs/str/%.mli + cp $< $@ + +stdlib_non_prefixed/%.mli: ../otherlibs/bigarray/%.mli + cp $< $@ + +stdlib_non_prefixed/pervasives.mli: ../stdlib/stdlib.mli stdlib_non_prefixed/extract_pervasives.awk + awk -f stdlib_non_prefixed/extract_pervasives.awk $< > $@ + +stdlib_non_prefixed/pervasives.cmi: stdlib_non_prefixed/pervasives.mli + $(OCAMLC_SNP) -c $< + +stdlib_non_prefixed/camlinternalFormatBasics.cmi: stdlib_non_prefixed/camlinternalFormatBasics.mli + $(OCAMLC_SNP) -c $< + +stdlib_non_prefixed/%.cmi: stdlib_non_prefixed/%.mli stdlib_non_prefixed/pervasives.cmi + $(OCAMLC_SNP) -c -open Pervasives $< + +# odoc rules : +############## + +.PHONY: odoc +odoc: + rm -rf odoc + $(MKDIR) odoc + # .cmti --> .odoc + for fn in ../stdlib/stdlib*.cmti; do \ + odoc compile $(INCLUDES) --package stdlib ../stdlib/$$fn; \ + done + for lib in str bigarray num; do \ + odoc compile $(INCLUDES) --package $$lib ../otherlibs/$$lib/$$lib.cmti; \ + done + odoc compile $(INCLUDES) --package unix ../otherlibs/$(UNIXLIB)/unix.cmti + for fn in ../parsing/*.cmti; do \ + odoc compile $(INCLUDES) --package parsing ../parsing/$$fn; \ + done + # .odoc --> .html + odoc html $(INCLUDES) --output-dir odoc ../stdlib/stdlib.odoc + for lib in str bigarray num $(UNIXLIB); do \ + odoc html $(INCLUDES) --output-dir odoc ../otherlibs/$$lib/$$lib.odoc; \ + done + for fn in ../parsing/*.odoc; do \ + odoc html $(INCLUDES) --output-dir odoc $$fn; \ + done + for d in odoc/*; do \ + lib=`basename $$d`; \ + cd $$d; \ + echo -e The $$lib 'library.\n\nModules\n:{!modules:' * '}' > ../../index.mld; \ + cd ../..; \ + odoc html $(INCLUDES) --output-dir odoc --index-for=$$lib index.mld; \ + rm -f index.mld; \ + done + cp odoc_index.html odoc/index.html + odoc css -o odoc + # backup, clean and depend : ############################ @@ -413,6 +499,7 @@ clean: rm -f odoc_parser.ml odoc_parser.mli odoc_text_parser.ml odoc_text_parser.mli rm -rf stdlib_man rm -f generators/*.cm[taiox] generators/*.$(A) generators/*.$(O) generators/*.cmx[as] + rm -f stdlib_non_prefixed/*.mli stdlib_non_prefixed/*.cmi .PHONY: depend depend: @@ -424,5 +511,6 @@ depend: $(OCAMLLEX) odoc_see_lexer.mll $(OCAMLDEP) $(INCLUDES_DEP) *.mll *.mly *.ml *.mli > .depend $(OCAMLDEP) $(INCLUDES_DEP) -shared generators/*.ml >> .depend + $(OCAMLDEP) -I stdlib_non_prefixed stdlib_non_prefixed/*.mli >> .depend include .depend diff --git a/ocamldoc/odoc_analyse.ml b/ocamldoc/odoc_analyse.ml index 13c128a4db..bf25648530 100644 --- a/ocamldoc/odoc_analyse.ml +++ b/ocamldoc/odoc_analyse.ml @@ -33,10 +33,17 @@ let init_path () = (** Return the initial environment in which compilation proceeds. *) let initial_env () = + let initially_opened_module = + let m = !Odoc_global.initially_opened_module in + if m = Env.get_unit_name () then + None + else + Some m + in Typemod.initial_env ~loc:(Location.in_file "ocamldoc command line") ~safe_string:(Config.safe_string || not !Clflags.unsafe_string) - ~open_pervasives:(Env.get_unit_name () <> "Pervasives") + ~initially_opened_module ~open_implicit_modules:(List.rev !Clflags.open_modules) (** Optionally preprocess a source file *) diff --git a/ocamldoc/odoc_args.ml b/ocamldoc/odoc_args.ml index ed14b4f9c5..b1ea42d6c4 100644 --- a/ocamldoc/odoc_args.ml +++ b/ocamldoc/odoc_args.ml @@ -254,6 +254,8 @@ end) (** The default option list *) let default_options = Options.list @ [ + "-initially-opened-module", Arg.Set_string Odoc_global.initially_opened_module, + M.initially_opened_module; "-text", Arg.String (fun s -> Odoc_global.files := !Odoc_global.files @ [Odoc_global.Text_file s]), M.option_text ; diff --git a/ocamldoc/odoc_global.ml b/ocamldoc/odoc_global.ml index cd528bf288..92b9308e16 100644 --- a/ocamldoc/odoc_global.ml +++ b/ocamldoc/odoc_global.ml @@ -77,3 +77,5 @@ let with_trailer = ref true let with_toc = ref true let with_index = ref true + +let initially_opened_module = ref "Stdlib" diff --git a/ocamldoc/odoc_global.mli b/ocamldoc/odoc_global.mli index 0a6ef0c7bf..509f02433f 100644 --- a/ocamldoc/odoc_global.mli +++ b/ocamldoc/odoc_global.mli @@ -102,3 +102,6 @@ val with_header : bool ref (** The flag which indicates if we must generate a trailer.*) val with_trailer : bool ref + +(** Name of the module that is initially opened. *) +val initially_opened_module : string ref diff --git a/ocamldoc/odoc_index.html b/ocamldoc/odoc_index.html new file mode 100644 index 0000000000..de9c9acfeb --- /dev/null +++ b/ocamldoc/odoc_index.html @@ -0,0 +1,40 @@ +<!DOCTYPE html> +<html xmlns="http://www.w3.org/1999/xhtml"> + <head> + <title>Libraries distributed with OCaml</title> + <link rel="stylesheet" href="odoc.css"/> + <meta charset="utf-8"/> + <meta name="viewport" content="width=device-width,initial-scale=1.0"/> + <meta name="generator" content="doc-ock-html v1.0.0-1-g1fc9bf0"/> + </head> + <body> + <p>The following libraries are distributed with the OCaml distribution.</p> + <br/> + <table class="modules"> + <tr> + <td class="module"><a href="stdlib/index.html">stdlib</a></td> + <td class="doc">The OCaml Standard library.</td> + </tr> + <tr> + <td class="module"><a href="unix/index.html">unix</a></td> + <td class="doc">System programming.</td> + </tr> + <tr> + <td class="module"><a href="parsing/index.html">bigarray</a></td> + <td class="doc">Large, multi-dimensional, numerical arrays.</td> + </tr> + <tr> + <td class="module"><a href="str/index.html">str</a></td> + <td class="doc">Regular expressions.</td> + </tr> + <tr> + <td class="module"><a href="parsing/index.html">parsing</a></td> + <td class="doc">The OCaml compiler parsing frontend.</td> + </tr> + <tr> + <td class="module"><a href="num/index.html">num</a></td> + <td class="doc">Arbitrary precision integers (deprecated).</td> + </tr> + </table> + </body> +</html> diff --git a/ocamldoc/odoc_messages.ml b/ocamldoc/odoc_messages.ml index 6e14f11634..0f72c800a6 100644 --- a/ocamldoc/odoc_messages.ml +++ b/ocamldoc/odoc_messages.ml @@ -238,6 +238,8 @@ let merge_options = merge_all ] ) +let initially_opened_module = "<module> Name of the module that is initially opened" + let help = " Display this list of options" diff --git a/ocamldoc/stdlib_non_prefixed/extract_pervasives.awk b/ocamldoc/stdlib_non_prefixed/extract_pervasives.awk new file mode 100644 index 0000000000..a8c2550f7e --- /dev/null +++ b/ocamldoc/stdlib_non_prefixed/extract_pervasives.awk @@ -0,0 +1,9 @@ +# This script extract the Pervasives submodule from stdlib.mli into +# pervasives.mli, for ocamldoc +BEGIN { state=0 } +$0 == "module Pervasives : sig" && state == 0 { state=1 } +$0 == "end" && state == 2 { state=3 } +{ + if (state == 1) state=2; + else if (state == 2) print +} diff --git a/otherlibs/threads/Makefile b/otherlibs/threads/Makefile index e6ccbf4491..01a3390fa2 100644 --- a/otherlibs/threads/Makefile +++ b/otherlibs/threads/Makefile @@ -33,22 +33,25 @@ CAML_OBJS=thread.cmo mutex.cmo condition.cmo event.cmo threadUnix.cmo LIB=../../stdlib -LIB_OBJS=$(LIB)/camlinternalFormatBasics.cmo pervasives.cmo \ - $(LIB)/array.cmo $(LIB)/list.cmo $(LIB)/char.cmo $(LIB)/bytes.cmo \ - $(LIB)/string.cmo $(LIB)/sys.cmo $(LIB)/sort.cmo marshal.cmo \ - $(LIB)/obj.cmo $(LIB)/int32.cmo $(LIB)/int64.cmo \ - $(LIB)/nativeint.cmo $(LIB)/lexing.cmo $(LIB)/parsing.cmo \ - $(LIB)/set.cmo $(LIB)/map.cmo $(LIB)/stack.cmo $(LIB)/queue.cmo \ - $(LIB)/camlinternalLazy.cmo $(LIB)/lazy.cmo $(LIB)/stream.cmo \ - $(LIB)/buffer.cmo $(LIB)/camlinternalFormat.cmo $(LIB)/printf.cmo \ - $(LIB)/arg.cmo $(LIB)/printexc.cmo $(LIB)/gc.cmo $(LIB)/digest.cmo \ - $(LIB)/random.cmo $(LIB)/hashtbl.cmo $(LIB)/format.cmo \ - $(LIB)/scanf.cmo $(LIB)/callback.cmo $(LIB)/camlinternalOO.cmo \ - $(LIB)/oo.cmo $(LIB)/camlinternalMod.cmo $(LIB)/genlex.cmo \ - $(LIB)/weak.cmo $(LIB)/ephemeron.cmo $(LIB)/filename.cmo \ - $(LIB)/complex.cmo $(LIB)/arrayLabels.cmo $(LIB)/listLabels.cmo \ - $(LIB)/bytesLabels.cmo $(LIB)/stringLabels.cmo \ - $(LIB)/moreLabels.cmo $(LIB)/stdLabels.cmo +# Object file prefix +P=stdlib__ + +LIB_OBJS=$(LIB)/camlinternalFormatBasics.cmo stdlib.cmo \ + $(LIB)/$(P)array.cmo $(LIB)/$(P)list.cmo $(LIB)/$(P)char.cmo $(LIB)/$(P)bytes.cmo \ + $(LIB)/$(P)string.cmo $(LIB)/$(P)sys.cmo $(LIB)/$(P)sort.cmo marshal.cmo \ + $(LIB)/$(P)obj.cmo $(LIB)/$(P)int32.cmo $(LIB)/$(P)int64.cmo \ + $(LIB)/$(P)nativeint.cmo $(LIB)/$(P)lexing.cmo $(LIB)/$(P)parsing.cmo \ + $(LIB)/$(P)set.cmo $(LIB)/$(P)map.cmo $(LIB)/$(P)stack.cmo $(LIB)/$(P)queue.cmo \ + $(LIB)/camlinternalLazy.cmo $(LIB)/$(P)lazy.cmo $(LIB)/$(P)stream.cmo \ + $(LIB)/$(P)buffer.cmo $(LIB)/camlinternalFormat.cmo $(LIB)/$(P)printf.cmo \ + $(LIB)/$(P)arg.cmo $(LIB)/$(P)printexc.cmo $(LIB)/$(P)gc.cmo $(LIB)/$(P)digest.cmo \ + $(LIB)/$(P)random.cmo $(LIB)/$(P)hashtbl.cmo $(LIB)/$(P)format.cmo \ + $(LIB)/$(P)scanf.cmo $(LIB)/$(P)callback.cmo $(LIB)/camlinternalOO.cmo \ + $(LIB)/$(P)oo.cmo $(LIB)/camlinternalMod.cmo $(LIB)/$(P)genlex.cmo \ + $(LIB)/$(P)weak.cmo $(LIB)/$(P)ephemeron.cmo $(LIB)/$(P)filename.cmo \ + $(LIB)/$(P)complex.cmo $(LIB)/$(P)arrayLabels.cmo $(LIB)/$(P)listLabels.cmo \ + $(LIB)/$(P)bytesLabels.cmo $(LIB)/$(P)stringLabels.cmo \ + $(LIB)/$(P)moreLabels.cmo $(LIB)/$(P)stdLabels.cmo UNIXLIB=../unix @@ -70,23 +73,24 @@ stdlib.cma: $(LIB_OBJS) unix.cma: $(UNIXLIB_OBJS) $(MKLIB) -ocamlc '$(CAMLC)' -o unix -linkall $(UNIXLIB_OBJS) -pervasives.cmo: pervasives.mli pervasives.cmi pervasives.ml - $(CAMLC) ${COMPFLAGS} -nopervasives -c pervasives.ml +stdlib.cmo: stdlib.mli stdlib.cmi stdlib.ml + $(CAMLC) ${COMPFLAGS} -nopervasives \ + -pp "awk -f $(LIB)/expand_module_aliases.awk" -o $@ -c stdlib.ml -pervasives.mli: $(LIB)/pervasives.mli - ln -s $(LIB)/pervasives.mli pervasives.mli +stdlib.mli: $(LIB)/stdlib.mli + ln -s $(LIB)/stdlib.mli stdlib.mli -pervasives.cmi: $(LIB)/pervasives.cmi - ln -s $(LIB)/pervasives.cmi pervasives.cmi +stdlib.cmi: $(LIB)/stdlib.cmi + ln -s $(LIB)/stdlib.cmi stdlib.cmi -marshal.cmo: marshal.mli marshal.cmi marshal.ml - $(CAMLC) ${COMPFLAGS} -c marshal.ml +$(P)marshal.cmo: marshal.mli $(P)marshal.cmi marshal.ml + $(CAMLC) ${COMPFLAGS} -o$@ -c marshal.ml marshal.mli: $(LIB)/marshal.mli ln -s $(LIB)/marshal.mli marshal.mli -marshal.cmi: $(LIB)/marshal.cmi - ln -s $(LIB)/marshal.cmi marshal.cmi +$(P)marshal.cmi: $(LIB)/$(P)marshal.cmi + ln -s $(LIB)/$(P)marshal.cmi $(P)marshal.cmi unix.mli: $(UNIXLIB)/unix.mli ln -s -f $(UNIXLIB)/unix.mli unix.mli @@ -102,7 +106,7 @@ partialclean: clean: partialclean rm -f libvmthreads.a dllvmthreads.so *.o - rm -f pervasives.mli marshal.mli unix.mli + rm -f stdlib.mli marshal.mli unix.mli INSTALL_LIBDIR=$(DESTDIR)$(LIBDIR) INSTALL_STUBLIBDIR=$(DESTDIR)$(STUBLIBDIR) diff --git a/otherlibs/threads/pervasives.ml b/otherlibs/threads/stdlib.ml index 470a1c5c54..a1be6645a1 100644 --- a/otherlibs/threads/pervasives.ml +++ b/otherlibs/threads/stdlib.ml @@ -13,10 +13,11 @@ (* *) (**************************************************************************) -(* Same as ../../stdlib/pervasives.ml, except that I/O functions have +(* Same as ../../stdlib/stdlib.ml, except that I/O functions have been redefined to not block the whole process, but only the calling thread. *) +module Pervasives = struct (* type 'a option = None | Some of 'a *) (* Exceptions *) @@ -634,3 +635,53 @@ let exit retcode = sys_exit retcode let _ = register_named_value "Pervasives.do_at_exit" do_at_exit +end + +include Pervasives + +(*MODULE_ALIASES*) +module Arg = Arg +module Array = Array +module ArrayLabels = ArrayLabels +module Buffer = Buffer +module Bytes = Bytes +module BytesLabels = BytesLabels +module Callback = Callback +module Char = Char +module Complex = Complex +module Digest = Digest +module Ephemeron = Ephemeron +module Filename = Filename +module Format = Format +module Gc = Gc +module Genlex = Genlex +module Hashtbl = Hashtbl +module Int32 = Int32 +module Int64 = Int64 +module Lazy = Lazy +module Lexing = Lexing +module List = List +module ListLabels = ListLabels +module Map = Map +module Marshal = Marshal +module MoreLabels = MoreLabels +module Nativeint = Nativeint +module Obj = Obj +module Oo = Oo +module Parsing = Parsing +module Printexc = Printexc +module Printf = Printf +module Queue = Queue +module Random = Random +module Scanf = Scanf +module Set = Set +module Sort = Sort +module Spacetime = Spacetime +module Stack = Stack +module StdLabels = StdLabels +module Stream = Stream +module String = String +module StringLabels = StringLabels +module Sys = Sys +module Uchar = Uchar +module Weak = Weak diff --git a/stdlib/.depend b/stdlib/.depend index 4ac015ad66..49071077d1 100644 --- a/stdlib/.depend +++ b/stdlib/.depend @@ -1,324 +1,316 @@ -arg.cmo : sys.cmi string.cmi printf.cmi list.cmi buffer.cmi array.cmi \ - arg.cmi -arg.cmx : sys.cmx string.cmx printf.cmx list.cmx buffer.cmx array.cmx \ - arg.cmi -arg.cmi : -array.cmo : array.cmi -array.cmx : array.cmi -array.cmi : -arrayLabels.cmo : array.cmi arrayLabels.cmi -arrayLabels.cmx : array.cmx arrayLabels.cmi -arrayLabels.cmi : -buffer.cmo : uchar.cmi sys.cmi string.cmi char.cmi bytes.cmi buffer.cmi -buffer.cmx : uchar.cmx sys.cmx string.cmx char.cmx bytes.cmx buffer.cmi -buffer.cmi : uchar.cmi -bytes.cmo : pervasives.cmi char.cmi bytes.cmi -bytes.cmx : pervasives.cmx char.cmx bytes.cmi -bytes.cmi : -bytesLabels.cmo : bytes.cmi bytesLabels.cmi -bytesLabels.cmx : bytes.cmx bytesLabels.cmi -bytesLabels.cmi : -callback.cmo : obj.cmi callback.cmi -callback.cmx : obj.cmx callback.cmi -callback.cmi : -camlinternalBigarray.cmo : complex.cmi -camlinternalBigarray.cmx : complex.cmx -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 -camlinternalFormat.cmi : camlinternalFormatBasics.cmi buffer.cmi +stdlib__arg.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__printf.cmi stdlib__list.cmi stdlib__buffer.cmi stdlib__array.cmi \ + stdlib__arg.cmi +stdlib__arg.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__printf.cmx stdlib__list.cmx stdlib__buffer.cmx stdlib__array.cmx \ + stdlib__arg.cmi +stdlib__arg.cmi : +stdlib__array.cmo : stdlib__array.cmi +stdlib__array.cmx : stdlib__array.cmi +stdlib__array.cmi : +stdlib__arrayLabels.cmo : stdlib__array.cmi stdlib__arrayLabels.cmi +stdlib__arrayLabels.cmx : stdlib__array.cmx stdlib__arrayLabels.cmi +stdlib__arrayLabels.cmi : +stdlib__buffer.cmo : stdlib__uchar.cmi stdlib__sys.cmi stdlib__string.cmi stdlib__char.cmi stdlib__bytes.cmi stdlib__buffer.cmi +stdlib__buffer.cmx : stdlib__uchar.cmx stdlib__sys.cmx stdlib__string.cmx stdlib__char.cmx stdlib__bytes.cmx stdlib__buffer.cmi +stdlib__buffer.cmi : stdlib__uchar.cmi +stdlib__bytes.cmo : stdlib__char.cmi stdlib__bytes.cmi +stdlib__bytes.cmx : stdlib__char.cmx stdlib__bytes.cmi +stdlib__bytes.cmi : +stdlib__bytesLabels.cmo : stdlib__bytes.cmi stdlib__bytesLabels.cmi +stdlib__bytesLabels.cmx : stdlib__bytes.cmx stdlib__bytesLabels.cmi +stdlib__bytesLabels.cmi : +stdlib__callback.cmo : stdlib__obj.cmi stdlib__callback.cmi +stdlib__callback.cmx : stdlib__obj.cmx stdlib__callback.cmi +stdlib__callback.cmi : +camlinternalBigarray.cmo : stdlib__complex.cmi +camlinternalBigarray.cmx : stdlib__complex.cmx +camlinternalFormat.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__char.cmi \ + camlinternalFormatBasics.cmi stdlib__bytes.cmi stdlib__buffer.cmi camlinternalFormat.cmi +camlinternalFormat.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__char.cmx \ + camlinternalFormatBasics.cmx stdlib__bytes.cmx stdlib__buffer.cmx camlinternalFormat.cmi +camlinternalFormat.cmi : camlinternalFormatBasics.cmi stdlib__buffer.cmi camlinternalFormatBasics.cmo : camlinternalFormatBasics.cmi camlinternalFormatBasics.cmx : camlinternalFormatBasics.cmi camlinternalFormatBasics.cmi : -camlinternalLazy.cmo : obj.cmi camlinternalLazy.cmi -camlinternalLazy.cmx : obj.cmx camlinternalLazy.cmi +camlinternalLazy.cmo : stdlib__obj.cmi camlinternalLazy.cmi +camlinternalLazy.cmx : stdlib__obj.cmx camlinternalLazy.cmi camlinternalLazy.cmi : -camlinternalMod.cmo : obj.cmi camlinternalOO.cmi array.cmi \ +camlinternalMod.cmo : stdlib__obj.cmi camlinternalOO.cmi stdlib__array.cmi \ camlinternalMod.cmi -camlinternalMod.cmx : obj.cmx camlinternalOO.cmx array.cmx \ +camlinternalMod.cmx : stdlib__obj.cmx camlinternalOO.cmx stdlib__array.cmx \ camlinternalMod.cmi -camlinternalMod.cmi : obj.cmi -camlinternalOO.cmo : sys.cmi string.cmi obj.cmi map.cmi list.cmi char.cmi \ - array.cmi camlinternalOO.cmi -camlinternalOO.cmx : sys.cmx string.cmx obj.cmx map.cmx list.cmx char.cmx \ - array.cmx camlinternalOO.cmi -camlinternalOO.cmi : obj.cmi -char.cmo : char.cmi -char.cmx : char.cmi -char.cmi : -complex.cmo : complex.cmi -complex.cmx : complex.cmi -complex.cmi : -digest.cmo : string.cmi char.cmi bytes.cmi digest.cmi -digest.cmx : string.cmx char.cmx bytes.cmx digest.cmi -digest.cmi : -ephemeron.cmo : sys.cmi random.cmi obj.cmi lazy.cmi hashtbl.cmi array.cmi \ - ephemeron.cmi -ephemeron.cmx : sys.cmx random.cmx obj.cmx lazy.cmx hashtbl.cmx array.cmx \ - ephemeron.cmi -ephemeron.cmi : hashtbl.cmi -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 -filename.cmi : -format.cmo : string.cmi pervasives.cmi list.cmi camlinternalFormatBasics.cmi \ - camlinternalFormat.cmi buffer.cmi format.cmi -format.cmx : string.cmx pervasives.cmx list.cmx camlinternalFormatBasics.cmx \ - camlinternalFormat.cmx buffer.cmx format.cmi -format.cmi : pervasives.cmi buffer.cmi -gc.cmo : sys.cmi string.cmi printf.cmi gc.cmi -gc.cmx : sys.cmx string.cmx printf.cmx gc.cmi -gc.cmi : -genlex.cmo : string.cmi stream.cmi list.cmi hashtbl.cmi char.cmi bytes.cmi \ - genlex.cmi -genlex.cmx : string.cmx stream.cmx list.cmx hashtbl.cmx char.cmx bytes.cmx \ - genlex.cmi -genlex.cmi : stream.cmi -hashtbl.cmo : sys.cmi string.cmi random.cmi obj.cmi lazy.cmi array.cmi \ - hashtbl.cmi -hashtbl.cmx : sys.cmx string.cmx random.cmx obj.cmx lazy.cmx array.cmx \ - hashtbl.cmi -hashtbl.cmi : -int32.cmo : pervasives.cmi int32.cmi -int32.cmx : pervasives.cmx int32.cmi -int32.cmi : -int64.cmo : pervasives.cmi int64.cmi -int64.cmx : pervasives.cmx int64.cmi -int64.cmi : -lazy.cmo : obj.cmi camlinternalLazy.cmi lazy.cmi -lazy.cmx : obj.cmx camlinternalLazy.cmx lazy.cmi -lazy.cmi : -lexing.cmo : sys.cmi string.cmi bytes.cmi array.cmi lexing.cmi -lexing.cmx : sys.cmx string.cmx bytes.cmx array.cmx lexing.cmi -lexing.cmi : -list.cmo : list.cmi -list.cmx : list.cmi -list.cmi : -listLabels.cmo : list.cmi listLabels.cmi -listLabels.cmx : list.cmx listLabels.cmi -listLabels.cmi : -map.cmo : map.cmi -map.cmx : map.cmi -map.cmi : -marshal.cmo : bytes.cmi marshal.cmi -marshal.cmx : bytes.cmx marshal.cmi -marshal.cmi : -moreLabels.cmo : set.cmi map.cmi hashtbl.cmi moreLabels.cmi -moreLabels.cmx : set.cmx map.cmx hashtbl.cmx moreLabels.cmi -moreLabels.cmi : set.cmi map.cmi hashtbl.cmi -nativeint.cmo : sys.cmi pervasives.cmi nativeint.cmi -nativeint.cmx : sys.cmx pervasives.cmx nativeint.cmi -nativeint.cmi : -obj.cmo : marshal.cmi int32.cmi obj.cmi -obj.cmx : marshal.cmx int32.cmx obj.cmi -obj.cmi : int32.cmi -oo.cmo : camlinternalOO.cmi oo.cmi -oo.cmx : camlinternalOO.cmx oo.cmi -oo.cmi : camlinternalOO.cmi -parsing.cmo : obj.cmi lexing.cmi array.cmi parsing.cmi -parsing.cmx : obj.cmx lexing.cmx array.cmx parsing.cmi -parsing.cmi : obj.cmi lexing.cmi -pervasives.cmo : camlinternalFormatBasics.cmi pervasives.cmi -pervasives.cmx : camlinternalFormatBasics.cmx pervasives.cmi -pervasives.cmi : camlinternalFormatBasics.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 -printexc.cmi : -printf.cmo : camlinternalFormatBasics.cmi camlinternalFormat.cmi buffer.cmi \ - printf.cmi -printf.cmx : camlinternalFormatBasics.cmx camlinternalFormat.cmx buffer.cmx \ - printf.cmi -printf.cmi : buffer.cmi -queue.cmo : queue.cmi -queue.cmx : queue.cmi -queue.cmi : -random.cmo : string.cmi pervasives.cmi nativeint.cmi int64.cmi int32.cmi \ - digest.cmi char.cmi array.cmi random.cmi -random.cmx : string.cmx pervasives.cmx nativeint.cmx int64.cmx int32.cmx \ - digest.cmx char.cmx array.cmx random.cmi -random.cmi : nativeint.cmi int64.cmi int32.cmi -scanf.cmo : string.cmi printf.cmi pervasives.cmi list.cmi \ - camlinternalFormatBasics.cmi camlinternalFormat.cmi bytes.cmi buffer.cmi \ - scanf.cmi -scanf.cmx : string.cmx printf.cmx pervasives.cmx list.cmx \ - camlinternalFormatBasics.cmx camlinternalFormat.cmx bytes.cmx buffer.cmx \ - scanf.cmi -scanf.cmi : pervasives.cmi -set.cmo : list.cmi set.cmi -set.cmx : list.cmx set.cmi -set.cmi : -sort.cmo : array.cmi sort.cmi -sort.cmx : array.cmx sort.cmi -sort.cmi : -spacetime.cmo : gc.cmi spacetime.cmi -spacetime.cmx : gc.cmx spacetime.cmi -spacetime.cmi : -stack.cmo : list.cmi stack.cmi -stack.cmx : list.cmx stack.cmi -stack.cmi : -stdLabels.cmo : stringLabels.cmi listLabels.cmi bytesLabels.cmi \ - arrayLabels.cmi stdLabels.cmi -stdLabels.cmx : stringLabels.cmx listLabels.cmx bytesLabels.cmx \ - arrayLabels.cmx stdLabels.cmi -stdLabels.cmi : stringLabels.cmi listLabels.cmi bytesLabels.cmi \ - arrayLabels.cmi +camlinternalMod.cmi : stdlib__obj.cmi +camlinternalOO.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__obj.cmi stdlib__map.cmi stdlib__list.cmi stdlib__char.cmi \ + stdlib__array.cmi camlinternalOO.cmi +camlinternalOO.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__obj.cmx stdlib__map.cmx stdlib__list.cmx stdlib__char.cmx \ + stdlib__array.cmx camlinternalOO.cmi +camlinternalOO.cmi : stdlib__obj.cmi +stdlib__char.cmo : stdlib__char.cmi +stdlib__char.cmx : stdlib__char.cmi +stdlib__char.cmi : +stdlib__complex.cmo : stdlib__complex.cmi +stdlib__complex.cmx : stdlib__complex.cmi +stdlib__complex.cmi : +stdlib__digest.cmo : stdlib__string.cmi stdlib__char.cmi stdlib__bytes.cmi stdlib__digest.cmi +stdlib__digest.cmx : stdlib__string.cmx stdlib__char.cmx stdlib__bytes.cmx stdlib__digest.cmi +stdlib__digest.cmi : +stdlib__ephemeron.cmo : stdlib__sys.cmi stdlib__random.cmi stdlib__obj.cmi stdlib__lazy.cmi stdlib__hashtbl.cmi stdlib__array.cmi \ + stdlib__ephemeron.cmi +stdlib__ephemeron.cmx : stdlib__sys.cmx stdlib__random.cmx stdlib__obj.cmx stdlib__lazy.cmx stdlib__hashtbl.cmx stdlib__array.cmx \ + stdlib__ephemeron.cmi +stdlib__ephemeron.cmi : stdlib__hashtbl.cmi +stdlib__filename.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__random.cmi stdlib__printf.cmi stdlib__lazy.cmi stdlib__buffer.cmi \ + stdlib__filename.cmi +stdlib__filename.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__random.cmx stdlib__printf.cmx stdlib__lazy.cmx stdlib__buffer.cmx \ + stdlib__filename.cmi +stdlib__filename.cmi : +stdlib__format.cmo : stdlib__string.cmi stdlib__list.cmi camlinternalFormatBasics.cmi \ + camlinternalFormat.cmi stdlib__buffer.cmi stdlib__format.cmi +stdlib__format.cmx : stdlib__string.cmx stdlib__list.cmx camlinternalFormatBasics.cmx \ + camlinternalFormat.cmx stdlib__buffer.cmx stdlib__format.cmi +stdlib__format.cmi : stdlib__buffer.cmi +stdlib__gc.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__printf.cmi stdlib__gc.cmi +stdlib__gc.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__printf.cmx stdlib__gc.cmi +stdlib__gc.cmi : +stdlib__genlex.cmo : stdlib__string.cmi stdlib__stream.cmi stdlib__list.cmi stdlib__hashtbl.cmi stdlib__char.cmi stdlib__bytes.cmi \ + stdlib__genlex.cmi +stdlib__genlex.cmx : stdlib__string.cmx stdlib__stream.cmx stdlib__list.cmx stdlib__hashtbl.cmx stdlib__char.cmx stdlib__bytes.cmx \ + stdlib__genlex.cmi +stdlib__genlex.cmi : stdlib__stream.cmi +stdlib__hashtbl.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__random.cmi stdlib__obj.cmi stdlib__lazy.cmi stdlib__array.cmi \ + stdlib__hashtbl.cmi +stdlib__hashtbl.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__random.cmx stdlib__obj.cmx stdlib__lazy.cmx stdlib__array.cmx \ + stdlib__hashtbl.cmi +stdlib__hashtbl.cmi : +stdlib__int32.cmo : stdlib__int32.cmi +stdlib__int32.cmx : stdlib__int32.cmi +stdlib__int32.cmi : +stdlib__int64.cmo : stdlib__int64.cmi +stdlib__int64.cmx : stdlib__int64.cmi +stdlib__int64.cmi : +stdlib__lazy.cmo : stdlib__obj.cmi camlinternalLazy.cmi stdlib__lazy.cmi +stdlib__lazy.cmx : stdlib__obj.cmx camlinternalLazy.cmx stdlib__lazy.cmi +stdlib__lazy.cmi : +stdlib__lexing.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__bytes.cmi stdlib__array.cmi stdlib__lexing.cmi +stdlib__lexing.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__bytes.cmx stdlib__array.cmx stdlib__lexing.cmi +stdlib__lexing.cmi : +stdlib__list.cmo : stdlib__list.cmi +stdlib__list.cmx : stdlib__list.cmi +stdlib__list.cmi : +stdlib__listLabels.cmo : stdlib__list.cmi stdlib__listLabels.cmi +stdlib__listLabels.cmx : stdlib__list.cmx stdlib__listLabels.cmi +stdlib__listLabels.cmi : +stdlib__map.cmo : stdlib__map.cmi +stdlib__map.cmx : stdlib__map.cmi +stdlib__map.cmi : +stdlib__marshal.cmo : stdlib__bytes.cmi stdlib__marshal.cmi +stdlib__marshal.cmx : stdlib__bytes.cmx stdlib__marshal.cmi +stdlib__marshal.cmi : +stdlib__moreLabels.cmo : stdlib__set.cmi stdlib__map.cmi stdlib__hashtbl.cmi stdlib__moreLabels.cmi +stdlib__moreLabels.cmx : stdlib__set.cmx stdlib__map.cmx stdlib__hashtbl.cmx stdlib__moreLabels.cmi +stdlib__moreLabels.cmi : stdlib__set.cmi stdlib__map.cmi stdlib__hashtbl.cmi +stdlib__nativeint.cmo : stdlib__sys.cmi stdlib__nativeint.cmi +stdlib__nativeint.cmx : stdlib__sys.cmx stdlib__nativeint.cmi +stdlib__nativeint.cmi : +stdlib__obj.cmo : stdlib__marshal.cmi stdlib__int32.cmi stdlib__obj.cmi +stdlib__obj.cmx : stdlib__marshal.cmx stdlib__int32.cmx stdlib__obj.cmi +stdlib__obj.cmi : stdlib__int32.cmi +stdlib__oo.cmo : camlinternalOO.cmi stdlib__oo.cmi +stdlib__oo.cmx : camlinternalOO.cmx stdlib__oo.cmi +stdlib__oo.cmi : camlinternalOO.cmi +stdlib__parsing.cmo : stdlib__obj.cmi stdlib__lexing.cmi stdlib__array.cmi stdlib__parsing.cmi +stdlib__parsing.cmx : stdlib__obj.cmx stdlib__lexing.cmx stdlib__array.cmx stdlib__parsing.cmi +stdlib__parsing.cmi : stdlib__obj.cmi stdlib__lexing.cmi +stdlib__printexc.cmo : stdlib__printf.cmi stdlib__obj.cmi stdlib__buffer.cmi stdlib__array.cmi stdlib__printexc.cmi +stdlib__printexc.cmx : stdlib__printf.cmx stdlib__obj.cmx stdlib__buffer.cmx stdlib__array.cmx stdlib__printexc.cmi +stdlib__printexc.cmi : +stdlib__printf.cmo : camlinternalFormatBasics.cmi camlinternalFormat.cmi stdlib__buffer.cmi \ + stdlib__printf.cmi +stdlib__printf.cmx : camlinternalFormatBasics.cmx camlinternalFormat.cmx stdlib__buffer.cmx \ + stdlib__printf.cmi +stdlib__printf.cmi : stdlib__buffer.cmi +stdlib__queue.cmo : stdlib__queue.cmi +stdlib__queue.cmx : stdlib__queue.cmi +stdlib__queue.cmi : +stdlib__random.cmo : stdlib__string.cmi stdlib__nativeint.cmi stdlib__int64.cmi stdlib__int32.cmi stdlib__digest.cmi \ + stdlib__char.cmi stdlib__array.cmi stdlib__random.cmi +stdlib__random.cmx : stdlib__string.cmx stdlib__nativeint.cmx stdlib__int64.cmx stdlib__int32.cmx stdlib__digest.cmx \ + stdlib__char.cmx stdlib__array.cmx stdlib__random.cmi +stdlib__random.cmi : stdlib__nativeint.cmi stdlib__int64.cmi stdlib__int32.cmi +stdlib__scanf.cmo : stdlib__string.cmi stdlib__printf.cmi stdlib__list.cmi camlinternalFormatBasics.cmi \ + camlinternalFormat.cmi stdlib__bytes.cmi stdlib__buffer.cmi stdlib__scanf.cmi +stdlib__scanf.cmx : stdlib__string.cmx stdlib__printf.cmx stdlib__list.cmx camlinternalFormatBasics.cmx \ + camlinternalFormat.cmx stdlib__bytes.cmx stdlib__buffer.cmx stdlib__scanf.cmi +stdlib__scanf.cmi : +stdlib__set.cmo : stdlib__list.cmi stdlib__set.cmi +stdlib__set.cmx : stdlib__list.cmx stdlib__set.cmi +stdlib__set.cmi : +stdlib__sort.cmo : stdlib__array.cmi stdlib__sort.cmi +stdlib__sort.cmx : stdlib__array.cmx stdlib__sort.cmi +stdlib__sort.cmi : +stdlib__spacetime.cmo : stdlib__gc.cmi stdlib__spacetime.cmi +stdlib__spacetime.cmx : stdlib__gc.cmx stdlib__spacetime.cmi +stdlib__spacetime.cmi : +stdlib__stack.cmo : stdlib__list.cmi stdlib__stack.cmi +stdlib__stack.cmx : stdlib__list.cmx stdlib__stack.cmi +stdlib__stack.cmi : +stdlib__stdLabels.cmo : stdlib__stringLabels.cmi stdlib__listLabels.cmi stdlib__bytesLabels.cmi \ + stdlib__arrayLabels.cmi stdlib__stdLabels.cmi +stdlib__stdLabels.cmx : stdlib__stringLabels.cmx stdlib__listLabels.cmx stdlib__bytesLabels.cmx \ + stdlib__arrayLabels.cmx stdlib__stdLabels.cmi +stdlib__stdLabels.cmi : stdlib__stringLabels.cmi stdlib__listLabels.cmi stdlib__bytesLabels.cmi \ + stdlib__arrayLabels.cmi std_exit.cmo : std_exit.cmx : -stream.cmo : string.cmi list.cmi lazy.cmi bytes.cmi stream.cmi -stream.cmx : string.cmx list.cmx lazy.cmx bytes.cmx stream.cmi -stream.cmi : -string.cmo : pervasives.cmi bytes.cmi string.cmi -string.cmx : pervasives.cmx bytes.cmx string.cmi -string.cmi : -stringLabels.cmo : string.cmi stringLabels.cmi -stringLabels.cmx : string.cmx stringLabels.cmi -stringLabels.cmi : -sys.cmo : sys.cmi -sys.cmx : sys.cmi -sys.cmi : -uchar.cmo : pervasives.cmi char.cmi uchar.cmi -uchar.cmx : pervasives.cmx char.cmx uchar.cmi -uchar.cmi : -weak.cmo : sys.cmi obj.cmi hashtbl.cmi array.cmi weak.cmi -weak.cmx : sys.cmx obj.cmx hashtbl.cmx array.cmx weak.cmi -weak.cmi : hashtbl.cmi -arg.cmo : sys.cmi string.cmi printf.cmi list.cmi buffer.cmi array.cmi \ - arg.cmi -arg.p.cmx : sys.cmx string.cmx printf.cmx list.cmx buffer.cmx array.cmx \ - arg.cmi -array.cmo : array.cmi -array.p.cmx : array.cmi -arrayLabels.cmo : array.cmi arrayLabels.cmi -arrayLabels.p.cmx : array.cmx arrayLabels.cmi -buffer.cmo : uchar.cmi sys.cmi string.cmi char.cmi bytes.cmi buffer.cmi -buffer.p.cmx : uchar.cmx sys.cmx string.cmx char.cmx bytes.cmx buffer.cmi -bytes.cmo : pervasives.cmi char.cmi bytes.cmi -bytes.p.cmx : pervasives.cmx char.cmx bytes.cmi -bytesLabels.cmo : bytes.cmi bytesLabels.cmi -bytesLabels.p.cmx : bytes.cmx bytesLabels.cmi -callback.cmo : obj.cmi callback.cmi -callback.p.cmx : obj.cmx callback.cmi -camlinternalBigarray.cmo : complex.cmi -camlinternalBigarray.p.cmx : complex.cmx -camlinternalFormat.cmo : sys.cmi string.cmi char.cmi \ - camlinternalFormatBasics.cmi bytes.cmi buffer.cmi camlinternalFormat.cmi -camlinternalFormat.p.cmx : sys.cmx string.cmx char.cmx \ - camlinternalFormatBasics.cmx bytes.cmx buffer.cmx camlinternalFormat.cmi +stdlib__stream.cmo : stdlib__string.cmi stdlib__list.cmi stdlib__lazy.cmi stdlib__bytes.cmi stdlib__stream.cmi +stdlib__stream.cmx : stdlib__string.cmx stdlib__list.cmx stdlib__lazy.cmx stdlib__bytes.cmx stdlib__stream.cmi +stdlib__stream.cmi : +stdlib__string.cmo : stdlib__bytes.cmi stdlib__string.cmi +stdlib__string.cmx : stdlib__bytes.cmx stdlib__string.cmi +stdlib__string.cmi : +stdlib__stringLabels.cmo : stdlib__string.cmi stdlib__stringLabels.cmi +stdlib__stringLabels.cmx : stdlib__string.cmx stdlib__stringLabels.cmi +stdlib__stringLabels.cmi : +stdlib__sys.cmo : stdlib__sys.cmi +stdlib__sys.cmx : stdlib__sys.cmi +stdlib__sys.cmi : +stdlib__uchar.cmo : stdlib__char.cmi stdlib__uchar.cmi +stdlib__uchar.cmx : stdlib__char.cmx stdlib__uchar.cmi +stdlib__uchar.cmi : +stdlib__weak.cmo : stdlib__sys.cmi stdlib__obj.cmi stdlib__hashtbl.cmi stdlib__array.cmi stdlib__weak.cmi +stdlib__weak.cmx : stdlib__sys.cmx stdlib__obj.cmx stdlib__hashtbl.cmx stdlib__array.cmx stdlib__weak.cmi +stdlib__weak.cmi : stdlib__hashtbl.cmi +stdlib.cmo : camlinternalFormatBasics.cmi stdlib.cmi +stdlib.cmx : camlinternalFormatBasics.cmx stdlib.cmi +stdlib.cmi : camlinternalFormatBasics.cmi +stdlib__arg.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__printf.cmi stdlib__list.cmi stdlib__buffer.cmi stdlib__array.cmi \ + stdlib__arg.cmi +stdlib__arg.p.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__printf.cmx stdlib__list.cmx stdlib__buffer.cmx stdlib__array.cmx \ + stdlib__arg.cmi +stdlib__array.cmo : stdlib__array.cmi +stdlib__array.p.cmx : stdlib__array.cmi +stdlib__arrayLabels.cmo : stdlib__array.cmi stdlib__arrayLabels.cmi +stdlib__arrayLabels.p.cmx : stdlib__array.cmx stdlib__arrayLabels.cmi +stdlib__buffer.cmo : stdlib__uchar.cmi stdlib__sys.cmi stdlib__string.cmi stdlib__char.cmi stdlib__bytes.cmi stdlib__buffer.cmi +stdlib__buffer.p.cmx : stdlib__uchar.cmx stdlib__sys.cmx stdlib__string.cmx stdlib__char.cmx stdlib__bytes.cmx stdlib__buffer.cmi +stdlib__bytes.cmo : stdlib__char.cmi stdlib__bytes.cmi +stdlib__bytes.p.cmx : stdlib__char.cmx stdlib__bytes.cmi +stdlib__bytesLabels.cmo : stdlib__bytes.cmi stdlib__bytesLabels.cmi +stdlib__bytesLabels.p.cmx : stdlib__bytes.cmx stdlib__bytesLabels.cmi +stdlib__callback.cmo : stdlib__obj.cmi stdlib__callback.cmi +stdlib__callback.p.cmx : stdlib__obj.cmx stdlib__callback.cmi +camlinternalBigarray.cmo : stdlib__complex.cmi +camlinternalBigarray.p.cmx : stdlib__complex.cmx +camlinternalFormat.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__char.cmi \ + camlinternalFormatBasics.cmi stdlib__bytes.cmi stdlib__buffer.cmi camlinternalFormat.cmi +camlinternalFormat.p.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__char.cmx \ + camlinternalFormatBasics.cmx stdlib__bytes.cmx stdlib__buffer.cmx camlinternalFormat.cmi camlinternalFormatBasics.cmo : camlinternalFormatBasics.cmi camlinternalFormatBasics.p.cmx : camlinternalFormatBasics.cmi -camlinternalLazy.cmo : obj.cmi camlinternalLazy.cmi -camlinternalLazy.p.cmx : obj.cmx camlinternalLazy.cmi -camlinternalMod.cmo : obj.cmi camlinternalOO.cmi array.cmi \ +camlinternalLazy.cmo : stdlib__obj.cmi camlinternalLazy.cmi +camlinternalLazy.p.cmx : stdlib__obj.cmx camlinternalLazy.cmi +camlinternalMod.cmo : stdlib__obj.cmi camlinternalOO.cmi stdlib__array.cmi \ camlinternalMod.cmi -camlinternalMod.p.cmx : obj.cmx camlinternalOO.cmx array.cmx \ +camlinternalMod.p.cmx : stdlib__obj.cmx camlinternalOO.cmx stdlib__array.cmx \ camlinternalMod.cmi -camlinternalOO.cmo : sys.cmi string.cmi obj.cmi map.cmi list.cmi char.cmi \ - array.cmi camlinternalOO.cmi -camlinternalOO.p.cmx : sys.cmx string.cmx obj.cmx map.cmx list.cmx char.cmx \ - array.cmx camlinternalOO.cmi -char.cmo : char.cmi -char.p.cmx : char.cmi -complex.cmo : complex.cmi -complex.p.cmx : complex.cmi -digest.cmo : string.cmi char.cmi bytes.cmi digest.cmi -digest.p.cmx : string.cmx char.cmx bytes.cmx digest.cmi -ephemeron.cmo : sys.cmi random.cmi obj.cmi lazy.cmi hashtbl.cmi array.cmi \ - ephemeron.cmi -ephemeron.p.cmx : sys.cmx random.cmx obj.cmx lazy.cmx hashtbl.cmx array.cmx \ - ephemeron.cmi -filename.cmo : sys.cmi string.cmi random.cmi printf.cmi lazy.cmi buffer.cmi \ - filename.cmi -filename.p.cmx : sys.cmx string.cmx random.cmx printf.cmx lazy.cmx buffer.cmx \ - filename.cmi -format.cmo : string.cmi pervasives.cmi list.cmi camlinternalFormatBasics.cmi \ - camlinternalFormat.cmi buffer.cmi format.cmi -format.p.cmx : string.cmx pervasives.cmx list.cmx camlinternalFormatBasics.cmx \ - camlinternalFormat.cmx buffer.cmx format.cmi -gc.cmo : sys.cmi string.cmi printf.cmi gc.cmi -gc.p.cmx : sys.cmx string.cmx printf.cmx gc.cmi -genlex.cmo : string.cmi stream.cmi list.cmi hashtbl.cmi char.cmi bytes.cmi \ - genlex.cmi -genlex.p.cmx : string.cmx stream.cmx list.cmx hashtbl.cmx char.cmx bytes.cmx \ - genlex.cmi -hashtbl.cmo : sys.cmi string.cmi random.cmi obj.cmi lazy.cmi array.cmi \ - hashtbl.cmi -hashtbl.p.cmx : sys.cmx string.cmx random.cmx obj.cmx lazy.cmx array.cmx \ - hashtbl.cmi -int32.cmo : pervasives.cmi int32.cmi -int32.p.cmx : pervasives.cmx int32.cmi -int64.cmo : pervasives.cmi int64.cmi -int64.p.cmx : pervasives.cmx int64.cmi -lazy.cmo : obj.cmi camlinternalLazy.cmi lazy.cmi -lazy.p.cmx : obj.cmx camlinternalLazy.cmx lazy.cmi -lexing.cmo : sys.cmi string.cmi bytes.cmi array.cmi lexing.cmi -lexing.p.cmx : sys.cmx string.cmx bytes.cmx array.cmx lexing.cmi -list.cmo : list.cmi -list.p.cmx : list.cmi -listLabels.cmo : list.cmi listLabels.cmi -listLabels.p.cmx : list.cmx listLabels.cmi -map.cmo : map.cmi -map.p.cmx : map.cmi -marshal.cmo : bytes.cmi marshal.cmi -marshal.p.cmx : bytes.cmx marshal.cmi -moreLabels.cmo : set.cmi map.cmi hashtbl.cmi moreLabels.cmi -moreLabels.p.cmx : set.cmx map.cmx hashtbl.cmx moreLabels.cmi -nativeint.cmo : sys.cmi pervasives.cmi nativeint.cmi -nativeint.p.cmx : sys.cmx pervasives.cmx nativeint.cmi -obj.cmo : marshal.cmi int32.cmi obj.cmi -obj.p.cmx : marshal.cmx int32.cmx obj.cmi -oo.cmo : camlinternalOO.cmi oo.cmi -oo.p.cmx : camlinternalOO.cmx oo.cmi -parsing.cmo : obj.cmi lexing.cmi array.cmi parsing.cmi -parsing.p.cmx : obj.cmx lexing.cmx array.cmx parsing.cmi -pervasives.cmo : camlinternalFormatBasics.cmi pervasives.cmi -pervasives.p.cmx : camlinternalFormatBasics.cmx pervasives.cmi -printexc.cmo : printf.cmi pervasives.cmi obj.cmi buffer.cmi array.cmi \ - printexc.cmi -printexc.p.cmx : printf.cmx pervasives.cmx obj.cmx buffer.cmx array.cmx \ - printexc.cmi -printf.cmo : camlinternalFormatBasics.cmi camlinternalFormat.cmi buffer.cmi \ - printf.cmi -printf.p.cmx : camlinternalFormatBasics.cmx camlinternalFormat.cmx buffer.cmx \ - printf.cmi -queue.cmo : queue.cmi -queue.p.cmx : queue.cmi -random.cmo : string.cmi pervasives.cmi nativeint.cmi int64.cmi int32.cmi \ - digest.cmi char.cmi array.cmi random.cmi -random.p.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 \ - camlinternalFormatBasics.cmi camlinternalFormat.cmi bytes.cmi buffer.cmi \ - scanf.cmi -scanf.p.cmx : string.cmx printf.cmx pervasives.cmx list.cmx \ - camlinternalFormatBasics.cmx camlinternalFormat.cmx bytes.cmx buffer.cmx \ - scanf.cmi -set.cmo : list.cmi set.cmi -set.p.cmx : list.cmx set.cmi -sort.cmo : array.cmi sort.cmi -sort.p.cmx : array.cmx sort.cmi -spacetime.cmo : gc.cmi spacetime.cmi -spacetime.p.cmx : gc.cmx spacetime.cmi -stack.cmo : list.cmi stack.cmi -stack.p.cmx : list.cmx stack.cmi -stdLabels.cmo : stringLabels.cmi listLabels.cmi bytesLabels.cmi \ - arrayLabels.cmi stdLabels.cmi -stdLabels.p.cmx : stringLabels.cmx listLabels.cmx bytesLabels.cmx \ - arrayLabels.cmx stdLabels.cmi +camlinternalOO.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__obj.cmi stdlib__map.cmi stdlib__list.cmi stdlib__char.cmi \ + stdlib__array.cmi camlinternalOO.cmi +camlinternalOO.p.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__obj.cmx stdlib__map.cmx stdlib__list.cmx stdlib__char.cmx \ + stdlib__array.cmx camlinternalOO.cmi +stdlib__char.cmo : stdlib__char.cmi +stdlib__char.p.cmx : stdlib__char.cmi +stdlib__complex.cmo : stdlib__complex.cmi +stdlib__complex.p.cmx : stdlib__complex.cmi +stdlib__digest.cmo : stdlib__string.cmi stdlib__char.cmi stdlib__bytes.cmi stdlib__digest.cmi +stdlib__digest.p.cmx : stdlib__string.cmx stdlib__char.cmx stdlib__bytes.cmx stdlib__digest.cmi +stdlib__ephemeron.cmo : stdlib__sys.cmi stdlib__random.cmi stdlib__obj.cmi stdlib__lazy.cmi stdlib__hashtbl.cmi stdlib__array.cmi \ + stdlib__ephemeron.cmi +stdlib__ephemeron.p.cmx : stdlib__sys.cmx stdlib__random.cmx stdlib__obj.cmx stdlib__lazy.cmx stdlib__hashtbl.cmx stdlib__array.cmx \ + stdlib__ephemeron.cmi +stdlib__filename.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__random.cmi stdlib__printf.cmi stdlib__lazy.cmi stdlib__buffer.cmi \ + stdlib__filename.cmi +stdlib__filename.p.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__random.cmx stdlib__printf.cmx stdlib__lazy.cmx stdlib__buffer.cmx \ + stdlib__filename.cmi +stdlib__format.cmo : stdlib__string.cmi stdlib__list.cmi camlinternalFormatBasics.cmi \ + camlinternalFormat.cmi stdlib__buffer.cmi stdlib__format.cmi +stdlib__format.p.cmx : stdlib__string.cmx stdlib__list.cmx camlinternalFormatBasics.cmx \ + camlinternalFormat.cmx stdlib__buffer.cmx stdlib__format.cmi +stdlib__gc.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__printf.cmi stdlib__gc.cmi +stdlib__gc.p.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__printf.cmx stdlib__gc.cmi +stdlib__genlex.cmo : stdlib__string.cmi stdlib__stream.cmi stdlib__list.cmi stdlib__hashtbl.cmi stdlib__char.cmi stdlib__bytes.cmi \ + stdlib__genlex.cmi +stdlib__genlex.p.cmx : stdlib__string.cmx stdlib__stream.cmx stdlib__list.cmx stdlib__hashtbl.cmx stdlib__char.cmx stdlib__bytes.cmx \ + stdlib__genlex.cmi +stdlib__hashtbl.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__random.cmi stdlib__obj.cmi stdlib__lazy.cmi stdlib__array.cmi \ + stdlib__hashtbl.cmi +stdlib__hashtbl.p.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__random.cmx stdlib__obj.cmx stdlib__lazy.cmx stdlib__array.cmx \ + stdlib__hashtbl.cmi +stdlib__int32.cmo : stdlib__int32.cmi +stdlib__int32.p.cmx : stdlib__int32.cmi +stdlib__int64.cmo : stdlib__int64.cmi +stdlib__int64.p.cmx : stdlib__int64.cmi +stdlib__lazy.cmo : stdlib__obj.cmi camlinternalLazy.cmi stdlib__lazy.cmi +stdlib__lazy.p.cmx : stdlib__obj.cmx camlinternalLazy.cmx stdlib__lazy.cmi +stdlib__lexing.cmo : stdlib__sys.cmi stdlib__string.cmi stdlib__bytes.cmi stdlib__array.cmi stdlib__lexing.cmi +stdlib__lexing.p.cmx : stdlib__sys.cmx stdlib__string.cmx stdlib__bytes.cmx stdlib__array.cmx stdlib__lexing.cmi +stdlib__list.cmo : stdlib__list.cmi +stdlib__list.p.cmx : stdlib__list.cmi +stdlib__listLabels.cmo : stdlib__list.cmi stdlib__listLabels.cmi +stdlib__listLabels.p.cmx : stdlib__list.cmx stdlib__listLabels.cmi +stdlib__map.cmo : stdlib__map.cmi +stdlib__map.p.cmx : stdlib__map.cmi +stdlib__marshal.cmo : stdlib__bytes.cmi stdlib__marshal.cmi +stdlib__marshal.p.cmx : stdlib__bytes.cmx stdlib__marshal.cmi +stdlib__moreLabels.cmo : stdlib__set.cmi stdlib__map.cmi stdlib__hashtbl.cmi stdlib__moreLabels.cmi +stdlib__moreLabels.p.cmx : stdlib__set.cmx stdlib__map.cmx stdlib__hashtbl.cmx stdlib__moreLabels.cmi +stdlib__nativeint.cmo : stdlib__sys.cmi stdlib__nativeint.cmi +stdlib__nativeint.p.cmx : stdlib__sys.cmx stdlib__nativeint.cmi +stdlib__obj.cmo : stdlib__marshal.cmi stdlib__int32.cmi stdlib__obj.cmi +stdlib__obj.p.cmx : stdlib__marshal.cmx stdlib__int32.cmx stdlib__obj.cmi +stdlib__oo.cmo : camlinternalOO.cmi stdlib__oo.cmi +stdlib__oo.p.cmx : camlinternalOO.cmx stdlib__oo.cmi +stdlib__parsing.cmo : stdlib__obj.cmi stdlib__lexing.cmi stdlib__array.cmi stdlib__parsing.cmi +stdlib__parsing.p.cmx : stdlib__obj.cmx stdlib__lexing.cmx stdlib__array.cmx stdlib__parsing.cmi +stdlib__printexc.cmo : stdlib__printf.cmi stdlib__obj.cmi stdlib__buffer.cmi stdlib__array.cmi stdlib__printexc.cmi +stdlib__printexc.p.cmx : stdlib__printf.cmx stdlib__obj.cmx stdlib__buffer.cmx stdlib__array.cmx stdlib__printexc.cmi +stdlib__printf.cmo : camlinternalFormatBasics.cmi camlinternalFormat.cmi stdlib__buffer.cmi \ + stdlib__printf.cmi +stdlib__printf.p.cmx : camlinternalFormatBasics.cmx camlinternalFormat.cmx stdlib__buffer.cmx \ + stdlib__printf.cmi +stdlib__queue.cmo : stdlib__queue.cmi +stdlib__queue.p.cmx : stdlib__queue.cmi +stdlib__random.cmo : stdlib__string.cmi stdlib__nativeint.cmi stdlib__int64.cmi stdlib__int32.cmi stdlib__digest.cmi \ + stdlib__char.cmi stdlib__array.cmi stdlib__random.cmi +stdlib__random.p.cmx : stdlib__string.cmx stdlib__nativeint.cmx stdlib__int64.cmx stdlib__int32.cmx stdlib__digest.cmx \ + stdlib__char.cmx stdlib__array.cmx stdlib__random.cmi +stdlib__scanf.cmo : stdlib__string.cmi stdlib__printf.cmi stdlib__list.cmi camlinternalFormatBasics.cmi \ + camlinternalFormat.cmi stdlib__bytes.cmi stdlib__buffer.cmi stdlib__scanf.cmi +stdlib__scanf.p.cmx : stdlib__string.cmx stdlib__printf.cmx stdlib__list.cmx camlinternalFormatBasics.cmx \ + camlinternalFormat.cmx stdlib__bytes.cmx stdlib__buffer.cmx stdlib__scanf.cmi +stdlib__set.cmo : stdlib__list.cmi stdlib__set.cmi +stdlib__set.p.cmx : stdlib__list.cmx stdlib__set.cmi +stdlib__sort.cmo : stdlib__array.cmi stdlib__sort.cmi +stdlib__sort.p.cmx : stdlib__array.cmx stdlib__sort.cmi +stdlib__spacetime.cmo : stdlib__gc.cmi stdlib__spacetime.cmi +stdlib__spacetime.p.cmx : stdlib__gc.cmx stdlib__spacetime.cmi +stdlib__stack.cmo : stdlib__list.cmi stdlib__stack.cmi +stdlib__stack.p.cmx : stdlib__list.cmx stdlib__stack.cmi +stdlib__stdLabels.cmo : stdlib__stringLabels.cmi stdlib__listLabels.cmi stdlib__bytesLabels.cmi \ + stdlib__arrayLabels.cmi stdlib__stdLabels.cmi +stdlib__stdLabels.p.cmx : stdlib__stringLabels.cmx stdlib__listLabels.cmx stdlib__bytesLabels.cmx \ + stdlib__arrayLabels.cmx stdlib__stdLabels.cmi std_exit.cmo : std_exit.cmx : -stream.cmo : string.cmi list.cmi lazy.cmi bytes.cmi stream.cmi -stream.p.cmx : string.cmx list.cmx lazy.cmx bytes.cmx stream.cmi -string.cmo : pervasives.cmi bytes.cmi string.cmi -string.p.cmx : pervasives.cmx bytes.cmx string.cmi -stringLabels.cmo : string.cmi stringLabels.cmi -stringLabels.p.cmx : string.cmx stringLabels.cmi -sys.cmo : sys.cmi -sys.p.cmx : sys.cmi -uchar.cmo : pervasives.cmi char.cmi uchar.cmi -uchar.p.cmx : pervasives.cmx char.cmx uchar.cmi -weak.cmo : sys.cmi obj.cmi hashtbl.cmi array.cmi weak.cmi -weak.p.cmx : sys.cmx obj.cmx hashtbl.cmx array.cmx weak.cmi +stdlib__stream.cmo : stdlib__string.cmi stdlib__list.cmi stdlib__lazy.cmi stdlib__bytes.cmi stdlib__stream.cmi +stdlib__stream.p.cmx : stdlib__string.cmx stdlib__list.cmx stdlib__lazy.cmx stdlib__bytes.cmx stdlib__stream.cmi +stdlib__string.cmo : stdlib__bytes.cmi stdlib__string.cmi +stdlib__string.p.cmx : stdlib__bytes.cmx stdlib__string.cmi +stdlib__stringLabels.cmo : stdlib__string.cmi stdlib__stringLabels.cmi +stdlib__stringLabels.p.cmx : stdlib__string.cmx stdlib__stringLabels.cmi +stdlib__sys.cmo : stdlib__sys.cmi +stdlib__sys.p.cmx : stdlib__sys.cmi +stdlib__uchar.cmo : stdlib__char.cmi stdlib__uchar.cmi +stdlib__uchar.p.cmx : stdlib__char.cmx stdlib__uchar.cmi +stdlib__weak.cmo : stdlib__sys.cmi stdlib__obj.cmi stdlib__hashtbl.cmi stdlib__array.cmi stdlib__weak.cmi +stdlib__weak.p.cmx : stdlib__sys.cmx stdlib__obj.cmx stdlib__hashtbl.cmx stdlib__array.cmx stdlib__weak.cmi +stdlib.cmo : camlinternalFormatBasics.cmi stdlib.cmi +stdlib.p.cmx : camlinternalFormatBasics.cmx stdlib.cmi diff --git a/stdlib/Compflags b/stdlib/Compflags index 0f7b922a1f..1c63a73ccf 100755 --- a/stdlib/Compflags +++ b/stdlib/Compflags @@ -15,16 +15,20 @@ #************************************************************************** case $1 in - pervasives.cm[iox]|pervasives.p.cmx) echo ' -nopervasives';; - camlinternalOO.cmi) echo ' -nopervasives';; + stdlib.cm[iox]|stdlib.p.cmx) + echo ' -nopervasives -no-alias-deps -w -49' \ + ' -pp "awk -f expand_module_aliases.awk"';; + stdlib__pervasives.cm[iox]|stdlib__pervasives.p.cmx) echo ' -nopervasives';; camlinternalOO.cmx|camlinternalOO.p.cmx) echo ' -inline 0';; - buffer.cmx|buffer.p.cmx) echo ' -inline 3';; + stdlib__buffer.cmx|stdlib__buffer.p.cmx) echo ' -inline 3';; # make sure add_char is inlined (PR#5872) - buffer.cm[io]) echo ' -w A';; + stdlib__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';; + stdlib__printf.cm[io]|stdlib__format.cm[io]|stdlib__scanf.cm[io]) + echo ' -w Ae';; + stdlib__scanf.cmx|stdlib__scanf.p.cmx) echo ' -inline 9';; *Labels.cm[ox]|*Labels.p.cmx) echo ' -nolabels -no-alias-deps';; + pervasives.cm[iox]|pervasives.p.cmx) echo ' -nopervasives -no-alias-deps -w -49';; *) echo ' ';; esac diff --git a/stdlib/Makefile b/stdlib/Makefile index 5f7bde13e3..c18a608557 100644 --- a/stdlib/Makefile +++ b/stdlib/Makefile @@ -32,23 +32,27 @@ OPTCOMPILER=../ocamlopt CAMLOPT=$(CAMLRUN) $(OPTCOMPILER) CAMLDEP=$(CAMLRUN) ../tools/ocamldep -OBJS=camlinternalFormatBasics.cmo pervasives.cmo $(OTHERS) -OTHERS=list.cmo char.cmo uchar.cmo bytes.cmo string.cmo sys.cmo \ - sort.cmo marshal.cmo obj.cmo array.cmo \ - int32.cmo int64.cmo nativeint.cmo \ - lexing.cmo parsing.cmo \ - set.cmo map.cmo stack.cmo queue.cmo \ - camlinternalLazy.cmo lazy.cmo stream.cmo \ - buffer.cmo camlinternalFormat.cmo printf.cmo \ - arg.cmo printexc.cmo gc.cmo \ - digest.cmo random.cmo hashtbl.cmo weak.cmo \ - format.cmo scanf.cmo callback.cmo \ - camlinternalOO.cmo oo.cmo camlinternalMod.cmo \ - genlex.cmo ephemeron.cmo \ - filename.cmo complex.cmo \ - arrayLabels.cmo listLabels.cmo bytesLabels.cmo \ - stringLabels.cmo moreLabels.cmo stdLabels.cmo \ - spacetime.cmo camlinternalBigarray.cmo +# Object file prefix +P=stdlib__ + +OBJS=camlinternalFormatBasics.cmo stdlib.cmo $(OTHERS) +OTHERS=$(P)list.cmo $(P)char.cmo $(P)uchar.cmo $(P)bytes.cmo $(P)string.cmo \ + $(P)sys.cmo $(P)sort.cmo $(P)marshal.cmo $(P)obj.cmo $(P)array.cmo \ + $(P)int32.cmo $(P)int64.cmo $(P)nativeint.cmo \ + $(P)lexing.cmo $(P)parsing.cmo \ + $(P)set.cmo $(P)map.cmo $(P)stack.cmo $(P)queue.cmo \ + camlinternalLazy.cmo $(P)lazy.cmo $(P)stream.cmo \ + $(P)buffer.cmo camlinternalFormat.cmo $(P)printf.cmo \ + $(P)arg.cmo $(P)printexc.cmo $(P)gc.cmo \ + $(P)digest.cmo $(P)random.cmo $(P)hashtbl.cmo $(P)weak.cmo \ + $(P)format.cmo $(P)scanf.cmo $(P)callback.cmo \ + camlinternalOO.cmo $(P)oo.cmo camlinternalMod.cmo \ + $(P)genlex.cmo $(P)ephemeron.cmo \ + $(P)filename.cmo $(P)complex.cmo \ + $(P)arrayLabels.cmo $(P)listLabels.cmo $(P)bytesLabels.cmo \ + $(P)stringLabels.cmo $(P)moreLabels.cmo $(P)stdLabels.cmo \ + $(P)spacetime.cmo camlinternalBigarray.cmo +PREFIXED_OBJS=$(filter stdlib__%.cmo,$(OBJS)) .PHONY: all all: stdlib.cma std_exit.cmo camlheader target_camlheader camlheader_ur @@ -197,6 +201,15 @@ stdlib.p.cmxa: $(OBJS:.cmo=.p.cmx) sys.ml: sys.mlp ../VERSION sed -e "s|%%VERSION%%|`sed -e 1q ../VERSION | tr -d '\r'`|" sys.mlp > $@ +# The user write stdlib.ml, but we don't use it as it to build +# stdlib.cmo. First we do the following rewriting via an awk +# preprocessor: +# +# [module FooBar = FooBar] --> [module FooBar = Stdlib__fooBar] +# +# This way the "Stdlib__" names stay hidden to the user and are just +# used as a compilation strategy. + .PHONY: clean clean:: rm -f sys.ml @@ -206,18 +219,32 @@ clean:: .SUFFIXES: .mli .ml .cmi .cmo .cmx .p.cmx -.mli.cmi: - $(CAMLC) $(COMPFLAGS) `sh ./Compflags $@` -c $< +%.cmi: %.mli + $(CAMLC) $(COMPFLAGS) $(shell ./Compflags $@) -c $< + +stdlib__%.cmi: %.mli + $(CAMLC) $(COMPFLAGS) $(shell ./Compflags $@) -o $@ -c $< + +%.cmo: %.ml + $(CAMLC) $(COMPFLAGS) $(shell ./Compflags $@) -c $< -.ml.cmo: - $(CAMLC) $(COMPFLAGS) `sh ./Compflags $@` -c $< +stdlib__%.cmo: %.ml + $(CAMLC) $(COMPFLAGS) $(shell ./Compflags $@) -o $@ -c $< -.ml.cmx: - $(CAMLOPT) $(COMPFLAGS) $(OPTCOMPFLAGS) `sh ./Compflags $@` -c $< +%.cmx: %.ml + $(CAMLOPT) $(COMPFLAGS) $(OPTCOMPFLAGS) $(shell ./Compflags $@) -c $< -.ml.p.cmx: - $(CAMLOPT) $(COMPFLAGS) $(OPTCOMPFLAGS) `sh ./Compflags $@` \ - -p -c -o $*.p.cmx $< +stdlib__%.cmx: %.ml + $(CAMLOPT) $(COMPFLAGS) $(OPTCOMPFLAGS) $(shell ./Compflags $@) \ + -o $@ -c $< + +%.p.cmx: %.ml + $(CAMLOPT) $(COMPFLAGS) $(OPTCOMPFLAGS) $(shell ./Compflags $@) \ + -p -c -o $@ $< + +stdlib__%.p.cmx: %.ml + $(CAMLOPT) $(COMPFLAGS) $(OPTCOMPFLAGS) $(shell ./Compflags $@) \ + -p -c -o $@ $< # Dependencies on the compiler COMPILER_DEPS=$(filter-out -use-prims, $(COMPILER)) @@ -226,25 +253,38 @@ $(OBJS:.cmo=.cmi) std_exit.cmi: $(COMPILER_DEPS) $(OBJS:.cmo=.cmx) std_exit.cmx: $(OPTCOMPILER) $(OBJS:.cmo=.p.cmx) std_exit.p.cmx: $(OPTCOMPILER) -# Dependencies on Pervasives (not tracked by ocamldep) -$(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 -$(OTHERS:.cmo=.cmx) std_exit.cmx: pervasives.cmx -$(OTHERS:.cmo=.p.cmx) std_exit.p.cmx: pervasives.cmx +# Dependencies on Stdlib (not tracked by ocamldep) +$(OTHERS) std_exit.cmo: stdlib.cmi +$(OTHERS:.cmo=.cmi) std_exit.cmi: stdlib.cmi +$(OBJS:.cmo=.cmx) std_exit.cmx: stdlib.cmi +$(OBJS:.cmo=.p.cmx) std_exit.p.cmx: stdlib.cmi +$(OTHERS:.cmo=.cmx) std_exit.cmx: stdlib.cmx +$(OTHERS:.cmo=.p.cmx) std_exit.p.cmx: stdlib.p.cmx clean:: - rm -f *.cm* *.$(O) *.$(A) + rm -f *.cm* *.$(O) *.$(A) *.odoc rm -f *~ rm -f camlheader* include .depend +EMPTY := +SPACE := $(EMPTY) $(EMPTY) + # Note that .p.cmx targets do not depend (for compilation) upon other # .p.cmx files. When the compiler imports another compilation unit, # it looks for the .cmx file (not .p.cmx). .PHONY: depend depend: - $(CAMLDEP) -slash *.mli *.ml > .depend - $(CAMLDEP) -slash *.ml | sed -e 's/\.cmx : /.p.cmx : /g' >>.depend + $(CAMLDEP) -slash $(filter-out stdlib.%,$(wildcard *.mli *.ml)) \ + > .depend.tmp + $(CAMLDEP) -slash -pp "awk -f remove_module_aliases.awk" \ + stdlib.ml stdlib.mli >> .depend.tmp + $(CAMLDEP) -slash $(filter-out stdlib.%,$(wildcard *.ml)) \ + | sed -e 's/\.cmx : /.p.cmx : /g' >>.depend.tmp + $(CAMLDEP) -slash -pp "awk -f remove_module_aliases.awk" stdlib.ml \ + | sed -e 's/\.cmx : /.p.cmx : /g' >> .depend.tmp + sed -re \ + 's#(^| )(${subst ${SPACE},|,${PREFIXED_OBJS:stdlib__%.cmo=%}})[.]#\1stdlib__\2.#g' \ + .depend.tmp > .depend + rm -f .depend.tmp diff --git a/stdlib/StdlibModules b/stdlib/StdlibModules index 2820740144..123d50594b 100644 --- a/stdlib/StdlibModules +++ b/stdlib/StdlibModules @@ -18,55 +18,58 @@ # This file lists all standard library modules. # It is used in particular to know what to expunge in toplevels. +P ?= stdlib__ + STDLIB_MODULES=\ - spacetime \ - arg \ - array \ - arrayLabels \ - buffer \ - bytes \ - bytesLabels \ - callback \ + $(P)spacetime \ + $(P)arg \ + $(P)array \ + $(P)arrayLabels \ + $(P)buffer \ + $(P)bytes \ + $(P)bytesLabels \ + $(P)callback \ + camlinternalBigarray \ camlinternalFormat \ camlinternalFormatBasics \ camlinternalLazy \ camlinternalMod \ camlinternalOO \ - char \ - complex \ - digest \ - ephemeron \ - filename \ - format \ - gc \ - genlex \ - hashtbl \ - int32 \ - int64 \ - lazy \ - lexing \ - list \ - listLabels \ - map \ - marshal \ - moreLabels \ - nativeint \ - obj \ - oo \ - parsing \ - pervasives \ - printexc \ - printf \ - queue \ - random \ - scanf \ - set \ - sort \ - stack \ - stdLabels \ - stream \ - string \ - stringLabels \ - sys \ - uchar \ - weak + $(P)char \ + $(P)complex \ + $(P)digest \ + $(P)ephemeron \ + $(P)filename \ + $(P)format \ + $(P)gc \ + $(P)genlex \ + $(P)hashtbl \ + $(P)int32 \ + $(P)int64 \ + $(P)lazy \ + $(P)lexing \ + $(P)list \ + $(P)listLabels \ + $(P)map \ + $(P)marshal \ + $(P)moreLabels \ + $(P)nativeint \ + $(P)obj \ + $(P)oo \ + $(P)parsing \ + $(P)printexc \ + $(P)printf \ + $(P)queue \ + $(P)random \ + $(P)scanf \ + $(P)set \ + $(P)sort \ + $(P)stack \ + $(P)stdLabels \ + stdlib \ + $(P)stream \ + $(P)string \ + $(P)stringLabels \ + $(P)sys \ + $(P)uchar \ + $(P)weak diff --git a/stdlib/expand_module_aliases.awk b/stdlib/expand_module_aliases.awk new file mode 100644 index 0000000000..af22dcf403 --- /dev/null +++ b/stdlib/expand_module_aliases.awk @@ -0,0 +1,13 @@ +# This script adds the Stdlib__ prefixes to the module aliases in +# stdlib.ml and stdlib.mli +BEGIN { state=0 } +NR == 1 { printf ("# 1 \"%s\"\n", FILENAME) } +$0 == "(*MODULE_ALIASES*)" { state=1 } +{ if (state==0) + print; + else if (state==1) + state=2; + else if ($1 == "module") + printf ("\n(** @canonical %s *)\nmodule %s = Stdlib__%s%s\n", + $2, $2, tolower(substr($4,1,1)), substr($4,2)); +} diff --git a/stdlib/moreLabels.mli b/stdlib/moreLabels.mli index 95efcf8c80..3e051bcfdd 100644 --- a/stdlib/moreLabels.mli +++ b/stdlib/moreLabels.mli @@ -97,8 +97,12 @@ module Hashtbl : sig val length : 'a t -> int val stats: 'a t -> statistics end - module Make : functor (H : HashedType) -> S with type key = H.t - module MakeSeeded (H : SeededHashedType) : SeededS with type key = H.t + module Make : functor (H : HashedType) -> S + with type key = H.t + and type 'a t = 'a Hashtbl.Make(H).t + module MakeSeeded (H : SeededHashedType) : SeededS + with type key = H.t + and type 'a t = 'a Hashtbl.MakeSeeded(H).t val hash : 'a -> int val seeded_hash : int -> 'a -> int val hash_param : int -> int -> 'a -> int @@ -149,7 +153,9 @@ module Map : sig val map : f:('a -> 'b) -> 'a t -> 'b t val mapi : f:(key -> 'a -> 'b) -> 'a t -> 'b t end - module Make : functor (Ord : OrderedType) -> S with type key = Ord.t + module Make : functor (Ord : OrderedType) -> S + with type key = Ord.t + and type 'a t = 'a Map.Make(Ord).t end module Set : sig @@ -194,5 +200,7 @@ module Set : sig val find_last_opt: f:(elt -> bool) -> t -> elt option val of_list: elt list -> t end - module Make : functor (Ord : OrderedType) -> S with type elt = Ord.t + module Make : functor (Ord : OrderedType) -> S + with type elt = Ord.t + and type t = Set.Make(Ord).t end diff --git a/stdlib/remove_module_aliases.awk b/stdlib/remove_module_aliases.awk new file mode 100644 index 0000000000..d3d436d7b1 --- /dev/null +++ b/stdlib/remove_module_aliases.awk @@ -0,0 +1,7 @@ +# This script remove the module aliases from stdlib.ml and stdlib.mli +# so that ocamldep doesn't register dependencies from stdlib to all +# other modules +BEGIN { in_aliases=0 } +NR == 1 { printf ("# 1 \"%s\"\n", FILENAME) } +$0 == "(*MODULE_ALIASES*)" { in_aliases=1 } +!in_aliases { print } diff --git a/stdlib/pervasives.ml b/stdlib/stdlib.ml index faa421871a..a52ac19968 100644 --- a/stdlib/pervasives.ml +++ b/stdlib/stdlib.ml @@ -13,6 +13,7 @@ (* *) (**************************************************************************) +module Pervasives = struct (* type 'a option = None | Some of 'a *) (* Exceptions *) @@ -546,3 +547,53 @@ let exit retcode = sys_exit retcode let _ = register_named_value "Pervasives.do_at_exit" do_at_exit +end + +include Pervasives + +(*MODULE_ALIASES*) +module Arg = Arg +module Array = Array +module ArrayLabels = ArrayLabels +module Buffer = Buffer +module Bytes = Bytes +module BytesLabels = BytesLabels +module Callback = Callback +module Char = Char +module Complex = Complex +module Digest = Digest +module Ephemeron = Ephemeron +module Filename = Filename +module Format = Format +module Gc = Gc +module Genlex = Genlex +module Hashtbl = Hashtbl +module Int32 = Int32 +module Int64 = Int64 +module Lazy = Lazy +module Lexing = Lexing +module List = List +module ListLabels = ListLabels +module Map = Map +module Marshal = Marshal +module MoreLabels = MoreLabels +module Nativeint = Nativeint +module Obj = Obj +module Oo = Oo +module Parsing = Parsing +module Printexc = Printexc +module Printf = Printf +module Queue = Queue +module Random = Random +module Scanf = Scanf +module Set = Set +module Sort = Sort +module Spacetime = Spacetime +module Stack = Stack +module StdLabels = StdLabels +module Stream = Stream +module String = String +module StringLabels = StringLabels +module Sys = Sys +module Uchar = Uchar +module Weak = Weak diff --git a/stdlib/pervasives.mli b/stdlib/stdlib.mli index 6b88883cec..6b7b5c7a9f 100644 --- a/stdlib/pervasives.mli +++ b/stdlib/stdlib.mli @@ -13,15 +13,21 @@ (* *) (**************************************************************************) -(** The initially opened module. +(** The OCaml Standard library. - This module provides the basic operations over the built-in types - (numbers, booleans, byte sequences, strings, exceptions, references, - lists, arrays, input-output channels, ...). + This module is automatically opened at the beginning of each + compilation. All components of this module can therefore be + referred by their short name, without prefixing them by [Stdlib]. +*) + +module Pervasives : sig +(** Pervasives operations. + + This module provides the basic operations over the built-in types + (numbers, booleans, byte sequences, strings, exceptions, references, + lists, arrays, input-output channels, ...). - This module is automatically opened at the beginning of each compilation. - All components of this module can therefore be referred by their short - name, without prefixing them by [Pervasives]. + This module is included in the toplevel {!Stdlib} module. *) @@ -1219,3 +1225,53 @@ val valid_float_lexem : string -> string val unsafe_really_input : in_channel -> bytes -> int -> int -> unit val do_at_exit : unit -> unit +end + +include module type of struct include Pervasives end + +(*MODULE_ALIASES*) +module Arg = Arg +module Array = Array +module ArrayLabels = ArrayLabels +module Buffer = Buffer +module Bytes = Bytes +module BytesLabels = BytesLabels +module Callback = Callback +module Char = Char +module Complex = Complex +module Digest = Digest +module Ephemeron = Ephemeron +module Filename = Filename +module Format = Format +module Gc = Gc +module Genlex = Genlex +module Hashtbl = Hashtbl +module Int32 = Int32 +module Int64 = Int64 +module Lazy = Lazy +module Lexing = Lexing +module List = List +module ListLabels = ListLabels +module Map = Map +module Marshal = Marshal +module MoreLabels = MoreLabels +module Nativeint = Nativeint +module Obj = Obj +module Oo = Oo +module Parsing = Parsing +module Printexc = Printexc +module Printf = Printf +module Queue = Queue +module Random = Random +module Scanf = Scanf +module Set = Set +module Sort = Sort +module Spacetime = Spacetime +module Stack = Stack +module StdLabels = StdLabels +module Stream = Stream +module String = String +module StringLabels = StringLabels +module Sys = Sys +module Uchar = Uchar +module Weak = Weak diff --git a/testsuite/tests/backtrace/pr6920_why_at.byte.reference b/testsuite/tests/backtrace/pr6920_why_at.byte.reference index dcc2fcc1e8..02acac165e 100644 --- a/testsuite/tests/backtrace/pr6920_why_at.byte.reference +++ b/testsuite/tests/backtrace/pr6920_why_at.byte.reference @@ -1,4 +1,4 @@ -Fatal error: exception Pervasives.Exit +Fatal error: exception Stdlib.Pervasives.Exit Raised at file "pr6920_why_at.ml", line 1, characters 41-45 Called from file "pr6920_why_at.ml", line 3, characters 2-11 Called from file "pr6920_why_at.ml", line 9, characters 2-6 diff --git a/testsuite/tests/backtrace/pr6920_why_at.native.reference b/testsuite/tests/backtrace/pr6920_why_at.native.reference index 057c3895ab..00ac4b40ae 100644 --- a/testsuite/tests/backtrace/pr6920_why_at.native.reference +++ b/testsuite/tests/backtrace/pr6920_why_at.native.reference @@ -1,4 +1,4 @@ -Fatal error: exception Pervasives.Exit +Fatal error: exception Stdlib.Pervasives.Exit Raised at file "pr6920_why_at.ml", line 1, characters 35-45 Called from file "pr6920_why_at.ml", line 3, characters 2-11 Called from file "pr6920_why_at.ml", line 9, characters 2-6 diff --git a/testsuite/tests/backtrace/pr6920_why_swallow.byte.reference b/testsuite/tests/backtrace/pr6920_why_swallow.byte.reference index f7e3ca349e..b50fc7f6c9 100644 --- a/testsuite/tests/backtrace/pr6920_why_swallow.byte.reference +++ b/testsuite/tests/backtrace/pr6920_why_swallow.byte.reference @@ -1,4 +1,4 @@ -Fatal error: exception Pervasives.Exit +Fatal error: exception Stdlib.Pervasives.Exit Raised at file "pr6920_why_swallow.ml", line 1, characters 41-45 Called from file "pr6920_why_swallow.ml", line 4, characters 4-13 Called from file "pr6920_why_swallow.ml", line 11, characters 2-6 diff --git a/testsuite/tests/backtrace/pr6920_why_swallow.native.reference b/testsuite/tests/backtrace/pr6920_why_swallow.native.reference index 1e28144bc1..c845d0fdb9 100644 --- a/testsuite/tests/backtrace/pr6920_why_swallow.native.reference +++ b/testsuite/tests/backtrace/pr6920_why_swallow.native.reference @@ -1,4 +1,4 @@ -Fatal error: exception Pervasives.Exit +Fatal error: exception Stdlib.Pervasives.Exit Raised at file "pr6920_why_swallow.ml", line 1, characters 35-45 Called from file "pr6920_why_swallow.ml", line 4, characters 4-13 Called from file "pr6920_why_swallow.ml", line 11, characters 2-6 diff --git a/testsuite/tests/lib-stdlabels/test_stdlabels.ml b/testsuite/tests/lib-stdlabels/test_stdlabels.ml index f697520536..2ddfa289b9 100644 --- a/testsuite/tests/lib-stdlabels/test_stdlabels.ml +++ b/testsuite/tests/lib-stdlabels/test_stdlabels.ml @@ -7,8 +7,8 @@ module B : module type of Bytes = BytesLabels module L : module type of List = ListLabels module S : module type of String = StringLabels -module M : module type of Map = MoreLabels.Map -module Se : module type of Set = MoreLabels.Set +module M : module type of struct include Map end = MoreLabels.Map +module Se : module type of struct include Set end = MoreLabels.Set (* For *) @@ -35,7 +35,7 @@ module Indirection = struct end module type HS = sig type statistics = Indirection.t - include module type of Hashtbl + include module type of struct include Hashtbl end with type statistics := Indirection.t end module H : HS = MoreLabels.Hashtbl diff --git a/testsuite/tests/messages/precise_locations.ml b/testsuite/tests/messages/precise_locations.ml index d3f673b960..c204d46148 100644 --- a/testsuite/tests/messages/precise_locations.ml +++ b/testsuite/tests/messages/precise_locations.ml @@ -86,7 +86,7 @@ end);; Line _, characters 0-9: open List ^^^^^^^^^ -Error (warning 33): unused open List. +Error (warning 33): unused open Stdlib.List. |}];; type unknown += Foo;; diff --git a/testsuite/tests/no-alias-deps/aliases.cmo.reference b/testsuite/tests/no-alias-deps/aliases.cmo.reference index b236b1dcd3..f606378617 100644 --- a/testsuite/tests/no-alias-deps/aliases.cmo.reference +++ b/testsuite/tests/no-alias-deps/aliases.cmo.reference @@ -1,7 +1,7 @@ File aliases.cmo Unit name: Aliases Interfaces imported: - aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Pervasives + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Stdlib aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa D aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa CamlinternalFormatBasics -------------------------------- C @@ -10,6 +10,6 @@ Interfaces imported: -------------------------------- A Required globals: D - Pervasives + Stdlib Uses unsafe features: no Force link: no diff --git a/testsuite/tests/tool-ocamldoc-html/Module_whitespace.reference b/testsuite/tests/tool-ocamldoc-html/Module_whitespace.reference index fc98a0bb9d..ade8cee781 100644 --- a/testsuite/tests/tool-ocamldoc-html/Module_whitespace.reference +++ b/testsuite/tests/tool-ocamldoc-html/Module_whitespace.reference @@ -21,4 +21,4 @@ <pre><span id="VALcompare"><span class="keyword">val</span> compare</span> : <code class="type">'a -> 'a -> int</code></pre></div> -<pre><code class="code"><span class="keyword">end</span></code><code class="code">)</code></pre></body></html>
\ No newline at end of file +<pre><code class="code"><span class="keyword">end</span></code><code class="code">)</code></pre></body></html> diff --git a/testsuite/tests/translprim/comparison_table.ml.reference b/testsuite/tests/translprim/comparison_table.ml.reference index 635b05a2f6..acc22beecf 100644 --- a/testsuite/tests/translprim/comparison_table.ml.reference +++ b/testsuite/tests/translprim/comparison_table.ml.reference @@ -243,8 +243,8 @@ (apply f (field 0 param) (field 1 param))) map = (function f l - (apply (field 16 (global List!)) (apply uncurry f) - l))) + (apply (field 16 (global Stdlib__list!)) + (apply uncurry f) l))) (makeblock 0 (makeblock 0 (apply map gen_cmp vec) (apply map cmp vec)) @@ -291,7 +291,7 @@ (apply f (field 0 param) (field 1 param))) map = (function f l - (apply (field 16 (global List!)) + (apply (field 16 (global Stdlib__list!)) (apply uncurry f) l))) (makeblock 0 (makeblock 0 (apply map eta_gen_cmp vec) diff --git a/testsuite/tests/typing-implicit_unpack/implicit_unpack.ocaml.reference b/testsuite/tests/typing-implicit_unpack/implicit_unpack.ocaml.reference index 7d22d177fe..f433636668 100644 --- a/testsuite/tests/typing-implicit_unpack/implicit_unpack.ocaml.reference +++ b/testsuite/tests/typing-implicit_unpack/implicit_unpack.ocaml.reference @@ -1,5 +1,7 @@ -val sort : (module Set.S with type elt = 'a) -> 'a list -> 'a list = <fun> -val make_set : ('a -> 'a -> int) -> (module Set.S with type elt = 'a) = <fun> +val sort : (module Stdlib.Set.S with type elt = 'a) -> 'a list -> 'a list = + <fun> +val make_set : ('a -> 'a -> int) -> (module Stdlib.Set.S with type elt = 'a) = + <fun> val sort_cmp : ('a -> 'a -> int) -> 'a list -> 'a list = <fun> module type S = sig type t val x : t end val f : (module S with type t = int) -> int = <fun> diff --git a/testsuite/tests/typing-poly/poly.ml b/testsuite/tests/typing-poly/poly.ml index 56aed197ec..18b528b286 100644 --- a/testsuite/tests/typing-poly/poly.ml +++ b/testsuite/tests/typing-poly/poly.ml @@ -1363,7 +1363,7 @@ let {foo} = (raise Exit : t);; type s = A of int let (A x) = (raise Exit : s);; [%%expect {| -Exception: Pervasives.Exit. +Exception: Stdlib.Pervasives.Exit. |}];; (* PR#5224 *) diff --git a/testsuite/tests/typing-warnings/application.compilers.reference b/testsuite/tests/typing-warnings/application.compilers.reference index efa38a6bf6..f5ec668bd2 100644 --- a/testsuite/tests/typing-warnings/application.compilers.reference +++ b/testsuite/tests/typing-warnings/application.compilers.reference @@ -9,5 +9,5 @@ Characters 19-20: let _ = raise Exit 3;; ^ Warning 20: this argument will not be used by the function. -Exception: Pervasives.Exit. +Exception: Stdlib.Pervasives.Exit. diff --git a/testsuite/tests/typing-warnings/pr6587.compilers.reference b/testsuite/tests/typing-warnings/pr6587.compilers.reference index a7493e08c5..5b46ca55c4 100644 --- a/testsuite/tests/typing-warnings/pr6587.compilers.reference +++ b/testsuite/tests/typing-warnings/pr6587.compilers.reference @@ -6,11 +6,11 @@ Characters 49-85: end Error: Signature mismatch: Modules do not match: - sig val f : fpclass -> Pervasives.fpclass end + sig val f : fpclass -> Stdlib.fpclass end is not included in sig val f : fpclass -> fpclass end Values do not match: - val f : fpclass -> Pervasives.fpclass + val f : fpclass -> Stdlib.fpclass is not included in val f : fpclass -> fpclass diff --git a/testsuite/tests/typing-warnings/pr7297.compilers.reference b/testsuite/tests/typing-warnings/pr7297.compilers.reference index 6e5e1b3af6..b892611095 100644 --- a/testsuite/tests/typing-warnings/pr7297.compilers.reference +++ b/testsuite/tests/typing-warnings/pr7297.compilers.reference @@ -3,5 +3,5 @@ Characters 10-20: let () = raise Exit; () ;; (* warn *) ^^^^^^^^^^ Warning 21: this statement never returns (or has an unsound type.) -Exception: Pervasives.Exit. +Exception: Stdlib.Pervasives.Exit. diff --git a/typing/printtyp.ml b/typing/printtyp.ml index ebf3ee8cd3..00ed00cbbc 100644 --- a/typing/printtyp.ml +++ b/typing/printtyp.ml @@ -48,19 +48,35 @@ let ident ppf id = pp_print_string ppf (ident_name id) (* Print a path *) -let ident_pervasives = Ident.create_persistent "Pervasives" +let ident_stdlib = Ident.create_persistent "Stdlib" let printing_env = ref Env.empty let non_shadowed_pervasive = function - | Pdot(Pident id, s, _pos) as path -> - Ident.same id ident_pervasives && + | Pdot(Pident id, s, _) as path -> + Ident.same id ident_stdlib && (try Path.same path (Env.lookup_type (Lident s) !printing_env) with Not_found -> true) + | Pdot(Pdot (Pident id, "Pervasives", _), s, _) as path -> + Ident.same id ident_stdlib && + (* Make sure Stdlib.<s> is the same as Stdlib.Pervasives.<s> *) + (try + let td = + Env.find_type (Env.lookup_type (Lident s) !printing_env) + !printing_env + in + match td.type_private, td.type_manifest with + | Private, _ | _, None -> false + | Public, Some te -> + match (Btype.repr te).desc with + | Tconstr (path', _, _) -> Path.same path path' + | _ -> false + with Not_found -> true) | _ -> false let rec tree_of_path = function | Pident id -> Oide_ident (ident_name id) - | Pdot(_, s, _pos) as path when non_shadowed_pervasive path -> + | Pdot(_, s, _pos) as path + when non_shadowed_pervasive path -> Oide_ident s | Pdot(p, s, _pos) -> Oide_dot (tree_of_path p, s) @@ -70,7 +86,8 @@ let rec tree_of_path = function let rec path ppf = function | Pident id -> ident ppf id - | Pdot(_, s, _pos) as path when non_shadowed_pervasive path -> + | Pdot(_, s, _pos) as path + when non_shadowed_pervasive path -> pp_print_string ppf s | Pdot(p, s, _pos) -> path ppf p; @@ -288,17 +305,25 @@ let rec normalize_type_path ?(cache=false) env p = Not_found -> (Env.normalize_path None env p, Id) +let find_double_underscore s = + let len = String.length s in + let rec loop i = + if i + 1 >= len then + None + else if s.[i] = '_' && s.[i + 1] = '_' then + Some i + else + loop (i + 1) + in + loop 0 + let penalty s = if s <> "" && s.[0] = '_' then 10 else - try - for i = 0 to String.length s - 2 do - if s.[i] = '_' && s.[i + 1] = '_' then - raise Exit - done; - 1 - with Exit -> 10 + match find_double_underscore s with + | None -> 1 + | Some _ -> 10 let rec path_size = function Pident id -> @@ -315,9 +340,11 @@ let same_printing_env env = let set_printing_env env = printing_env := env; - if !Clflags.real_paths - || !printing_env == Env.empty || same_printing_env env then () else - begin + if !Clflags.real_paths || + !printing_env == Env.empty || + same_printing_env env then + () + else begin (* printf "Reset printing_map@."; *) printing_old := env; printing_pers := Env.used_persistent (); @@ -379,9 +406,46 @@ let rec get_best_path r = l; get_best_path r +let rec module_path_is_an_alias_of env path ~alias_of = + match Env.find_module path env with + | { md_type = Mty_alias (_, path'); _ } -> + Path.same path' alias_of || + module_path_is_an_alias_of env path' ~alias_of + | _ -> false + | exception Not_found -> false + +(* Simple heuristic to print Foo__bar.* as Foo.Bar.* when Foo.Bar is an alias + for Foo__bar. This pattern is used by the stdlib. *) +let rec rewrite_double_underscore_paths env p = + match p with + | Pdot (p, s, n) -> Pdot (rewrite_double_underscore_paths env p, s, n) + | Papply (a, b) -> + Papply (rewrite_double_underscore_paths env a, + rewrite_double_underscore_paths env b) + | Pident id -> + let name = Ident.name id in + match find_double_underscore name with + | None -> p + | Some i -> + let better_lid = + Ldot + (Lident (String.sub name 0 i), + String.capitalize_ascii + (String.sub name (i + 2) (String.length name - i - 2))) + in + match Env.lookup_module ~load:true better_lid env with + | exception Not_found -> p + | p' -> + if module_path_is_an_alias_of env p' ~alias_of:p then + p' + else + p + let best_type_path p = - if !Clflags.real_paths || !printing_env == Env.empty + if !printing_env == Env.empty then (p, Id) + else if !Clflags.real_paths + then (rewrite_double_underscore_paths !printing_env p, Id) else let (p', s) = normalize_type_path !printing_env p in let get_path () = get_best_path (PathMap.find p' !printing_map) in @@ -393,7 +457,7 @@ let best_type_path p = done; let p'' = try get_path () with Not_found -> p' in (* Format.eprintf "%a = %a -> %a@." path p path p' path p''; *) - (p'', s) + (rewrite_double_underscore_paths !printing_env p'', s) (* Print a type expression *) @@ -758,6 +822,15 @@ and type_sch ppf ty = typexp true ppf ty and type_scheme ppf ty = reset_and_mark_loops ty; typexp true ppf ty +let type_expansion ppf ty1 ty2 = + let tree1 = tree_of_typexp false ty1 in + let tree2 = tree_of_typexp false ty2 in + let pp = !Oprint.out_type in + if tree1 = tree2 then + pp ppf tree1 + else + fprintf ppf "@[<2>%a@ =@ %a@]" pp tree1 pp tree2 + (* Maxence *) let type_scheme_max ?(b_reset_names=true) ppf ty = if b_reset_names then reset_names () ; @@ -1352,7 +1425,7 @@ let type_expansion t ppf t' = then begin add_delayed (proxy t); type_expr ppf t end else let t' = if proxy t == proxy t' then unalias t' else t' in - fprintf ppf "@[<2>%a@ =@ %a@]" type_expr t type_expr t' + type_expansion ppf t t' let type_path_expansion tp ppf tp' = if Path.same tp tp' then path ppf tp else @@ -1655,3 +1728,6 @@ let report_ambiguous_type_error ppf env (tp0, tp0') tpl txt1 txt2 txt3 = @]" txt2 type_path_list tpl txt3 (type_path_expansion tp0) tp0') + +let tree_of_path p = tree_of_path (rewrite_double_underscore_paths !printing_env p) +let path ppf p = path ppf (rewrite_double_underscore_paths !printing_env p) diff --git a/typing/printtyp.mli b/typing/printtyp.mli index 9bbffc56b7..bec2e723b0 100644 --- a/typing/printtyp.mli +++ b/typing/printtyp.mli @@ -90,3 +90,8 @@ val report_ambiguous_type_error: (* for toploop *) val print_items: (Env.t -> signature_item -> 'a option) -> Env.t -> signature_item list -> (out_sig_item * 'a option) list + +(* Simple heuristic to rewrite Foo__bar.* as Foo.Bar.* when Foo.Bar is an alias for + Foo__bar. This pattern is used by the stdlib. *) +val rewrite_double_underscore_paths: Env.t -> Path.t -> Path.t + diff --git a/typing/typemod.ml b/typing/typemod.ml index ec37ebbfdd..b32100d512 100644 --- a/typing/typemod.ml +++ b/typing/typemod.ml @@ -94,9 +94,9 @@ let type_open_ ?used_slot ?toplevel ovf env loc lid = ignore (extract_sig_open env lid.loc md.md_type); assert false -let type_initially_opened_module env = +let type_initially_opened_module env module_name = let loc = Location.in_file "compiler internals" in - let lid = { Asttypes.loc; txt = Longident.Lident "Pervasives" } in + let lid = { Asttypes.loc; txt = Longident.Lident module_name } in let path = Typetexp.lookup_module ~load:true env lid.loc lid.txt in match Env.open_signature_of_initially_opened_module path env with | Some env -> path, env @@ -105,7 +105,8 @@ let type_initially_opened_module env = ignore (extract_sig_open env lid.loc md.md_type); assert false -let initial_env ~loc ~safe_string ~open_pervasives ~open_implicit_modules = +let initial_env ~loc ~safe_string ~initially_opened_module + ~open_implicit_modules = let env = if safe_string then Env.initial_safe_string @@ -113,10 +114,10 @@ let initial_env ~loc ~safe_string ~open_pervasives ~open_implicit_modules = Env.initial_unsafe_string in let env = - if open_pervasives then - snd (type_initially_opened_module env) - else - env + match initially_opened_module with + | None -> env + | Some name -> + snd (type_initially_opened_module env name) in let open_implicit_module env m = let open Asttypes in diff --git a/typing/typemod.mli b/typing/typemod.mli index f8b81c21d8..68d2103e66 100644 --- a/typing/typemod.mli +++ b/typing/typemod.mli @@ -55,7 +55,8 @@ val package_units: (* Should be in Envaux, but it breaks the build of the debugger *) val initial_env: - loc:Location.t -> safe_string:bool -> open_pervasives:bool -> + loc:Location.t -> safe_string:bool -> + initially_opened_module:string option -> open_implicit_modules:string list -> Env.t type error = |