]> git.pld-linux.org Git - packages/camlp5.git/commitdiff
- replaced ocaml-4.02.2 patch by real ocaml 4.02.2 support from camlp5 git
authorJakub Bogusz <qboosh@pld-linux.org>
Mon, 20 Jul 2015 19:05:22 +0000 (21:05 +0200)
committerJakub Bogusz <qboosh@pld-linux.org>
Mon, 20 Jul 2015 19:05:22 +0000 (21:05 +0200)
- updated descriptions (camlp5 not camlp4)
- release 2 (ocaml rebuild)

camlp5.spec
ocaml-4.02.2.patch

index af58a41568c4d7dba66572a54de7ee87d59ea061..7692f1660ecbc57d1aa71a1eb7981ed8d6ee4bad 100644 (file)
@@ -2,7 +2,7 @@ Summary:        Objective Caml Preprocessor
 Summary(pl.UTF-8):     Preprocesor OCamla
 Name:          camlp5
 Version:       6.12
 Summary(pl.UTF-8):     Preprocesor OCamla
 Name:          camlp5
 Version:       6.12
-Release:       1
+Release:       2
 License:       distributable
 Group:         Development/Languages
 Source0:       http://pauillac.inria.fr/~ddr/camlp5/distrib/src/%{name}-%{version}.tgz
 License:       distributable
 Group:         Development/Languages
 Source0:       http://pauillac.inria.fr/~ddr/camlp5/distrib/src/%{name}-%{version}.tgz
@@ -19,31 +19,31 @@ Requires:   %{name} = %{epoch}:%{version}-%{release}
 BuildRoot:     %{tmpdir}/%{name}-%{version}-root-%(id -u -n)
 
 %description
 BuildRoot:     %{tmpdir}/%{name}-%{version}-root-%(id -u -n)
 
 %description
-Camlp4 is a Pre-Processor-Pretty-Printer for Objective Caml. It offers
+Camlp5 is a Pre-Processor-Pretty-Printer for Objective Caml. It offers
 tools for syntax (grammars) and the ability to modify the concrete
 syntax of the language (quotations, syntax extensions).
 
 tools for syntax (grammars) and the ability to modify the concrete
 syntax of the language (quotations, syntax extensions).
 
-Camlp4 can parse normal Ocaml concrete syntax or any other
+Camlp5 can parse normal Ocaml concrete syntax or any other
 user-definable syntax. As an example, an alternative syntax is
 provided, named revised, because it tries to fix some small problems
 of the normal syntax.
 
 user-definable syntax. As an example, an alternative syntax is
 provided, named revised, because it tries to fix some small problems
 of the normal syntax.
 
-Camlp4 can pretty print the normal Ocaml concrete syntax or the
+Camlp5 can pretty print the normal Ocaml concrete syntax or the
 revised one. It is therefore always possible to have a version of your
 sources compilable by the Objective Caml compiler without
 preprocessing.
 
 %description -l pl.UTF-8
 revised one. It is therefore always possible to have a version of your
 sources compilable by the Objective Caml compiler without
 preprocessing.
 
 %description -l pl.UTF-8
-Camlp4 jest preprocesorem OCamla. Oferuje narzędzia do manipulowania
+Camlp5 jest preprocesorem OCamla. Oferuje narzędzia do manipulowania
 składnią (gramatyki) oraz możliwość modyfikowania oryginalnej składni
 języka (cytowania, rozszerzenia).
 
 składnią (gramatyki) oraz możliwość modyfikowania oryginalnej składni
 języka (cytowania, rozszerzenia).
 
-Camlp4 może sparsować oryginalną składnię Ocamla lub dowolną inną
+Camlp5 może sparsować oryginalną składnię Ocamla lub dowolną inną
 definiowalną przez użytkownika. Jako przykład podana jest alternatywna
 składnia (revised syntax), która próbuje poprawić drobne problemy
 występujące w składni oryginalnej.
 
 definiowalną przez użytkownika. Jako przykład podana jest alternatywna
 składnia (revised syntax), która próbuje poprawić drobne problemy
 występujące w składni oryginalnej.
 
-Camlp4 umie ładnie formatować źródła zarówno w oryginalnej jak i
+Camlp5 umie ładnie formatować źródła zarówno w oryginalnej jak i
 poprawionej składni OCamla. Potrafi także tłumaczyć programy z jednej
 składni na drugą.
 
 poprawionej składni OCamla. Potrafi także tłumaczyć programy z jednej
 składni na drugą.
 
@@ -60,11 +60,12 @@ Preprocesor OCamla - dokumentacja HTML.
 
 %prep
 %setup -q
 
 %prep
 %setup -q
+%patch0 -p1
+
 cp %{SOURCE1} doc/camlp4.pdf
 
 cp %{SOURCE1} doc/camlp4.pdf
 
-cp ocaml_src/lib/versdep/4.02.{1,2}.ml
-cp -a ocaml_stuff/4.02.{1,2}
-%patch0 -p1
+#cp ocaml_src/lib/versdep/4.02.{1,2}.ml
+#cp -a ocaml_stuff/4.02.{1,2}
 
 %build 
 ./configure \
 
 %build 
 ./configure \
@@ -97,9 +98,13 @@ rm -rf $RPM_BUILD_ROOT
 %files
 %defattr(644,root,root,755)
 %doc CHANGES DEVEL ICHANGES MODE README UPGRADING doc/camlp4.pdf
 %files
 %defattr(644,root,root,755)
 %doc CHANGES DEVEL ICHANGES MODE README UPGRADING doc/camlp4.pdf
-%attr(755,root,root) %{_bindir}/*
+%attr(755,root,root) %{_bindir}/camlp5*
+%attr(755,root,root) %{_bindir}/mkcamlp5*
+%attr(755,root,root) %{_bindir}/ocpp5
 %{_libdir}/ocaml/%{name}
 %{_libdir}/ocaml/%{name}
-%{_mandir}/man1/*
+%{_mandir}/man1/camlp5*.1*
+%{_mandir}/man1/mkcamlp5*.1*
+%{_mandir}/man1/ocpp5.1*
 
 %files doc-html
 %defattr(644,root,root,755)
 
 %files doc-html
 %defattr(644,root,root,755)
index 6fd012f80029aa9e2e61d143a24c33622b680273..6caff78673b52c1a4f00b65fca95cc03d98a54a0 100644 (file)
---- camlp5-6.12/ocaml_stuff/4.02.2/utils/pconfig.ml~   2014-09-19 08:53:41.000000000 +0200
-+++ camlp5-6.12/ocaml_stuff/4.02.2/utils/pconfig.ml    2015-07-09 20:23:00.812336784 +0200
-@@ -1,4 +1,4 @@
--let ocaml_version = "4.02.1"
+From 7fafc03c599d9286ef7e1470dae94838c8e8806d Mon Sep 17 00:00:00 2001
+From: Daniel de-Rauglaudre <deraugla@sysadm-OptiPlex-9020-AIO.(none)>
+Date: Tue, 12 May 2015 18:37:59 +0200
+Subject: [PATCH] updated for ocaml version 4.02.2
+
+---
+ CHANGES                                  |   2 +
+ ocaml_src/lib/versdep/4.02.2.ml          | 661 ++++++++++++++++++++++++
+ ocaml_stuff/4.02.2/parsing/.depend       |   4 +
+ ocaml_stuff/4.02.2/parsing/.gitignore    |   1 +
+ ocaml_stuff/4.02.2/parsing/Makefile      |  19 +
+ ocaml_stuff/4.02.2/parsing/asttypes.mli  |  49 ++
+ ocaml_stuff/4.02.2/parsing/location.mli  | 135 +++++
+ ocaml_stuff/4.02.2/parsing/longident.mli |  22 +
+ ocaml_stuff/4.02.2/parsing/parsetree.mli | 829 +++++++++++++++++++++++++++++++
+ ocaml_stuff/4.02.2/utils/.depend         |   2 +
+ ocaml_stuff/4.02.2/utils/.gitignore      |   1 +
+ ocaml_stuff/4.02.2/utils/Makefile        |  27 +
+ ocaml_stuff/4.02.2/utils/pconfig.ml      |   4 +
+ ocaml_stuff/4.02.2/utils/pconfig.mli     |   4 +
+ ocaml_stuff/4.02.2/utils/warnings.mli    |  86 ++++
+ 15 files changed, 1846 insertions(+)
+ create mode 100644 ocaml_src/lib/versdep/4.02.2.ml
+ create mode 100644 ocaml_stuff/4.02.2/parsing/.depend
+ create mode 100644 ocaml_stuff/4.02.2/parsing/.gitignore
+ create mode 100644 ocaml_stuff/4.02.2/parsing/Makefile
+ create mode 100644 ocaml_stuff/4.02.2/parsing/asttypes.mli
+ create mode 100644 ocaml_stuff/4.02.2/parsing/location.mli
+ create mode 100644 ocaml_stuff/4.02.2/parsing/longident.mli
+ create mode 100644 ocaml_stuff/4.02.2/parsing/parsetree.mli
+ create mode 100644 ocaml_stuff/4.02.2/utils/.depend
+ create mode 100644 ocaml_stuff/4.02.2/utils/.gitignore
+ create mode 100644 ocaml_stuff/4.02.2/utils/Makefile
+ create mode 100644 ocaml_stuff/4.02.2/utils/pconfig.ml
+ create mode 100644 ocaml_stuff/4.02.2/utils/pconfig.mli
+ create mode 100644 ocaml_stuff/4.02.2/utils/warnings.mli
+
+#diff --git a/CHANGES b/CHANGES
+#index ba9243e..db34fd3 100644
+#--- a/CHANGES
+#+++ b/CHANGES
+#@@ -1,6 +1,8 @@
+# Camlp5 Version 6.13:
+# --------------------
+# 
+#+* [12 May 15] Upgraded for ocaml version 4.02.2
+#+
+# Camlp5 Version 6.12:
+# --------------------
+# 
+diff --git a/ocaml_src/lib/versdep/4.02.2.ml b/ocaml_src/lib/versdep/4.02.2.ml
+new file mode 100644
+index 0000000..cbe5f5b
+--- /dev/null
++++ b/ocaml_src/lib/versdep/4.02.2.ml
+@@ -0,0 +1,661 @@
++(* camlp5r pa_macro.cmo *)
++(* versdep.ml,v *)
++(* Copyright (c) INRIA 2007-2014 *)
++
++open Parsetree;;
++open Longident;;
++open Asttypes;;
++
++type ('a, 'b) choice =
++    Left of 'a
++  | Right of 'b
++;;
++
++let sys_ocaml_version = Sys.ocaml_version;;
++
++let ocaml_location (fname, lnum, bolp, lnuml, bolpl, bp, ep) =
++  let loc_at n lnum bolp =
++    {Lexing.pos_fname = if lnum = -1 then "" else fname;
++     Lexing.pos_lnum = lnum; Lexing.pos_bol = bolp; Lexing.pos_cnum = n}
++  in
++  {Location.loc_start = loc_at bp lnum bolp;
++   Location.loc_end = loc_at ep lnuml bolpl;
++   Location.loc_ghost = bp = 0 && ep = 0}
++;;
++
++let loc_none =
++  let loc =
++    {Lexing.pos_fname = "_none_"; Lexing.pos_lnum = 1; Lexing.pos_bol = 0;
++     Lexing.pos_cnum = -1}
++  in
++  {Location.loc_start = loc; Location.loc_end = loc;
++   Location.loc_ghost = true}
++;;
++
++let mkloc loc txt = {Location.txt = txt; Location.loc = loc};;
++let mknoloc txt = mkloc loc_none txt;;
++
++let ocaml_id_or_li_of_string_list loc sl =
++  let mkli s =
++    let rec loop f =
++      function
++        i :: il -> loop (fun s -> Ldot (f i, s)) il
++      | [] -> f s
++    in
++    loop (fun s -> Lident s)
++  in
++  match List.rev sl with
++    [] -> None
++  | s :: sl -> Some (mkli s (List.rev sl))
++;;
++
++let list_map_check f l =
++  let rec loop rev_l =
++    function
++      x :: l ->
++        begin match f x with
++          Some s -> loop (s :: rev_l) l
++        | None -> None
++        end
++    | [] -> Some (List.rev rev_l)
++  in
++  loop [] l
++;;
++
++let ocaml_value_description vn t p =
++  {pval_type = t; pval_prim = p; pval_loc = t.ptyp_loc;
++   pval_name = mkloc t.ptyp_loc vn; pval_attributes = []}
++;;
++
++let ocaml_class_type_field loc ctfd =
++  {pctf_desc = ctfd; pctf_loc = loc; pctf_attributes = []}
++;;
++
++let ocaml_class_field loc cfd =
++  {pcf_desc = cfd; pcf_loc = loc; pcf_attributes = []}
++;;
++
++let ocaml_mktyp loc x =
++  {ptyp_desc = x; ptyp_loc = loc; ptyp_attributes = []}
++;;
++let ocaml_mkpat loc x =
++  {ppat_desc = x; ppat_loc = loc; ppat_attributes = []}
++;;
++let ocaml_mkexp loc x =
++  {pexp_desc = x; pexp_loc = loc; pexp_attributes = []}
++;;
++let ocaml_mkmty loc x =
++  {pmty_desc = x; pmty_loc = loc; pmty_attributes = []}
++;;
++let ocaml_mkmod loc x =
++  {pmod_desc = x; pmod_loc = loc; pmod_attributes = []}
++;;
++let ocaml_mkfield loc (lab, x) fl = (lab, x) :: fl;;
++let ocaml_mkfield_var loc = [];;
++
++let variance_of_bool_bool =
++  function
++    false, true -> Contravariant
++  | true, false -> Covariant
++  | _ -> Invariant
++;;
++
++let ocaml_type_declaration tn params cl tk pf tm loc variance =
++  match list_map_check (fun s_opt -> s_opt) params with
++    Some params ->
++      let _ =
++        if List.length params <> List.length variance then
++          failwith "internal error: ocaml_type_declaration"
++      in
++      let params =
++        List.map2
++          (fun os va ->
++             ocaml_mktyp loc (Ptyp_var os), variance_of_bool_bool va)
++          params variance
++      in
++      Right
++        {ptype_params = params; ptype_cstrs = cl; ptype_kind = tk;
++         ptype_private = pf; ptype_manifest = tm; ptype_loc = loc;
++         ptype_name = mkloc loc tn; ptype_attributes = []}
++  | None -> Left "no '_' type param in this ocaml version"
++;;
++
++let ocaml_class_type =
++  Some (fun d loc -> {pcty_desc = d; pcty_loc = loc; pcty_attributes = []})
++;;
++
++let ocaml_class_expr =
++  Some (fun d loc -> {pcl_desc = d; pcl_loc = loc; pcl_attributes = []})
++;;
++
++let ocaml_class_structure p cil = {pcstr_self = p; pcstr_fields = cil};;
++
++let ocaml_pmty_ident loc li = Pmty_ident (mkloc loc li);;
++
++let ocaml_pmty_functor sloc s mt1 mt2 =
++  Pmty_functor (mkloc sloc s, Some mt1, mt2)
++;;
++
++let ocaml_pmty_typeof = Some (fun me -> Pmty_typeof me);;
++
++let ocaml_pmty_with mt lcl =
++  let lcl = List.map snd lcl in Pmty_with (mt, lcl)
++;;
++
++let ocaml_ptype_abstract = Ptype_abstract;;
++
++let ocaml_ptype_record ltl priv =
++  Ptype_record
++    (List.map
++       (fun (s, mf, ct, loc) ->
++          {pld_name = mkloc loc s; pld_mutable = mf; pld_type = ct;
++           pld_loc = loc; pld_attributes = []})
++       ltl)
++;;
++
++let ocaml_ptype_variant ctl priv =
++  try
++    let ctl =
++      List.map
++        (fun (c, tl, rto, loc) ->
++           if rto <> None then raise Exit
++           else
++             {pcd_name = mkloc loc c; pcd_args = tl; pcd_res = None;
++              pcd_loc = loc; pcd_attributes = []})
++        ctl
++    in
++    Some (Ptype_variant ctl)
++  with Exit -> None
++;;
++
++let ocaml_ptyp_arrow lab t1 t2 = Ptyp_arrow (lab, t1, t2);;
++
++let ocaml_ptyp_class li tl ll = Ptyp_class (mknoloc li, tl);;
++
++let ocaml_ptyp_constr loc li tl = Ptyp_constr (mkloc loc li, tl);;
++
++let ocaml_ptyp_object ml =
++  let ml = List.map (fun (s, t) -> s, [], t) ml in Ptyp_object (ml, Closed)
++;;
++
++let ocaml_ptyp_package = Some (fun pt -> Ptyp_package pt);;
++
++let ocaml_ptyp_poly =
++  Some
++    (fun cl t ->
++       match cl with
++         [] -> t.ptyp_desc
++       | _ -> Ptyp_poly (cl, t))
++;;
++
++let ocaml_ptyp_variant catl clos sl_opt =
++  let catl =
++    List.map
++      (function
++         Left (c, a, tl) -> Rtag (c, [], a, tl)
++       | Right t -> Rinherit t)
++      catl
++  in
++  let clos = if clos then Closed else Open in
++  Some (Ptyp_variant (catl, clos, sl_opt))
++;;
++
++let ocaml_package_type li ltl =
++  mknoloc li, List.map (fun (li, t) -> mkloc t.ptyp_loc li, t) ltl
++;;
++
++let ocaml_const_string s = Const_string (s, None);;
++
++let ocaml_const_int32 = Some (fun s -> Const_int32 (Int32.of_string s));;
++
++let ocaml_const_int64 = Some (fun s -> Const_int64 (Int64.of_string s));;
++
++let ocaml_const_nativeint =
++  Some (fun s -> Const_nativeint (Nativeint.of_string s))
++;;
++
++let ocaml_pexp_apply f lel = Pexp_apply (f, lel);;
++
++let ocaml_pexp_assertfalse fname loc =
++  Pexp_assert
++    (ocaml_mkexp loc (Pexp_construct (mkloc loc (Lident "false"), None)))
++;;
++
++let ocaml_pexp_assert fname loc e = Pexp_assert e;;
++
++let ocaml_pexp_constraint e ot1 ot2 =
++  match ot2 with
++    Some t2 -> Pexp_coerce (e, ot1, t2)
++  | None ->
++      match ot1 with
++        Some t1 -> Pexp_constraint (e, t1)
++      | None -> failwith "internal error: ocaml_pexp_constraint"
++;;
++
++let ocaml_pexp_construct loc li po chk_arity =
++  Pexp_construct (mkloc loc li, po)
++;;
++
++let ocaml_pexp_construct_args =
++  function
++    Pexp_construct (li, po) -> Some (li.txt, li.loc, po, 0)
++  | _ -> None
++;;
++
++let mkexp_ocaml_pexp_construct_arity loc li_loc li al =
++  let a = ocaml_mkexp loc (Pexp_tuple al) in
++  {pexp_desc = ocaml_pexp_construct li_loc li (Some a) true; pexp_loc = loc;
++   pexp_attributes = [mkloc loc "ocaml.explicit_arity", PStr []]}
++;;
++
++let ocaml_pexp_field loc e li = Pexp_field (e, mkloc loc li);;
++
++let ocaml_pexp_for i e1 e2 df e =
++  Pexp_for (ocaml_mkpat loc_none (Ppat_var (mknoloc i)), e1, e2, df, e)
++;;
++
++let ocaml_case (p, wo, loc, e) = {pc_lhs = p; pc_guard = wo; pc_rhs = e};;
++
++let ocaml_pexp_function lab eo pel =
++  match pel with
++    [{pc_lhs = p; pc_guard = None; pc_rhs = e}] -> Pexp_fun (lab, eo, p, e)
++  | pel ->
++      if lab = "" && eo = None then Pexp_function pel
++      else failwith "internal error: bad ast in ocaml_pexp_function"
++;;
++
++let ocaml_pexp_lazy = Some (fun e -> Pexp_lazy e);;
++
++let ocaml_pexp_ident li = Pexp_ident (mknoloc li);;
++
++let ocaml_pexp_letmodule =
++  Some (fun i me e -> Pexp_letmodule (mknoloc i, me, e))
++;;
++
++let ocaml_pexp_new loc li = Pexp_new (mkloc loc li);;
++
++let ocaml_pexp_newtype = Some (fun s e -> Pexp_newtype (s, e));;
++
++let ocaml_pexp_object = Some (fun cs -> Pexp_object cs);;
++
++let ocaml_pexp_open = Some (fun li e -> Pexp_open (Fresh, mknoloc li, e));;
++
++let ocaml_pexp_override sel =
++  let sel = List.map (fun (s, e) -> mknoloc s, e) sel in Pexp_override sel
++;;
++
++let ocaml_pexp_pack : ('a -> 'b -> 'c, 'd) choice option =
++  Some (Right ((fun me -> Pexp_pack me), (fun pt -> Ptyp_package pt)))
++;;
++
++let ocaml_pexp_poly = Some (fun e t -> Pexp_poly (e, t));;
++
++let ocaml_pexp_record lel eo =
++  let lel = List.map (fun (li, loc, e) -> mkloc loc li, e) lel in
++  Pexp_record (lel, eo)
++;;
++
++let ocaml_pexp_setinstvar s e = Pexp_setinstvar (mknoloc s, e);;
++
++let ocaml_pexp_variant =
++  let pexp_variant_pat =
++    function
++      Pexp_variant (lab, eo) -> Some (lab, eo)
++    | _ -> None
++  in
++  let pexp_variant (lab, eo) = Pexp_variant (lab, eo) in
++  Some (pexp_variant_pat, pexp_variant)
++;;
++
++let ocaml_value_binding loc p e =
++  {pvb_pat = p; pvb_expr = e; pvb_loc = loc; pvb_attributes = []}
++;;
++
++let ocaml_ppat_alias p i iloc = Ppat_alias (p, mkloc iloc i);;
++
++let ocaml_ppat_array = Some (fun pl -> Ppat_array pl);;
++
++let ocaml_ppat_construct loc li po chk_arity =
++  Ppat_construct (mkloc loc li, po)
++;;
++
++let ocaml_ppat_construct_args =
++  function
++    Ppat_construct (li, po) -> Some (li.txt, li.loc, po, 0)
++  | _ -> None
++;;
++
++let mkpat_ocaml_ppat_construct_arity loc li_loc li al =
++  let a = ocaml_mkpat loc (Ppat_tuple al) in
++  {ppat_desc = ocaml_ppat_construct li_loc li (Some a) true; ppat_loc = loc;
++   ppat_attributes = [mkloc loc "ocaml.explicit_arity", PStr []]}
++;;
++
++let ocaml_ppat_lazy = Some (fun p -> Ppat_lazy p);;
++
++let ocaml_ppat_record lpl is_closed =
++  let lpl = List.map (fun (li, loc, p) -> mkloc loc li, p) lpl in
++  Ppat_record (lpl, (if is_closed then Closed else Open))
++;;
++
++let ocaml_ppat_type = Some (fun loc li -> Ppat_type (mkloc loc li));;
++
++let ocaml_ppat_unpack =
++  Some ((fun loc s -> Ppat_unpack (mkloc loc s)), (fun pt -> Ptyp_package pt))
++;;
++
++let ocaml_ppat_var loc s = Ppat_var (mkloc loc s);;
++
++let ocaml_ppat_variant =
++  let ppat_variant_pat =
++    function
++      Ppat_variant (lab, po) -> Some (lab, po)
++    | _ -> None
++  in
++  let ppat_variant (lab, po) = Ppat_variant (lab, po) in
++  Some (ppat_variant_pat, ppat_variant)
++;;
++
++let ocaml_psig_class_type = Some (fun ctl -> Psig_class_type ctl);;
++
++let ocaml_psig_exception loc s ed =
++  Psig_exception
++    {pext_name = mkloc loc s; pext_kind = Pext_decl (ed, None);
++     pext_loc = loc; pext_attributes = []}
++;;
++
++let ocaml_psig_include loc mt =
++  Psig_include {pincl_mod = mt; pincl_loc = loc; pincl_attributes = []}
++;;
++
++let ocaml_psig_module loc s mt =
++  Psig_module
++    {pmd_name = mkloc loc s; pmd_type = mt; pmd_attributes = [];
++     pmd_loc = loc}
++;;
++
++let ocaml_psig_modtype loc s mto =
++  let pmtd =
++    {pmtd_name = mkloc loc s; pmtd_type = mto; pmtd_attributes = [];
++     pmtd_loc = loc}
++  in
++  Psig_modtype pmtd
++;;
++
++let ocaml_psig_open loc li =
++  Psig_open
++    {popen_lid = mknoloc li; popen_override = Fresh; popen_loc = loc;
++     popen_attributes = []}
++;;
++
++let ocaml_psig_recmodule =
++  let f ntl =
++    let ntl =
++      List.map
++        (fun (s, mt) ->
++           {pmd_name = mknoloc s; pmd_type = mt; pmd_attributes = [];
++            pmd_loc = loc_none})
++        ntl
++    in
++    Psig_recmodule ntl
++  in
++  Some f
++;;
++
++let ocaml_psig_type stl =
++  let stl = List.map (fun (s, t) -> t) stl in Psig_type stl
++;;
++
++let ocaml_psig_value s vd = Psig_value vd;;
++
++let ocaml_pstr_class_type = Some (fun ctl -> Pstr_class_type ctl);;
++
++let ocaml_pstr_eval e = Pstr_eval (e, []);;
++
++let ocaml_pstr_exception loc s ed =
++  Pstr_exception
++    {pext_name = mkloc loc s; pext_kind = Pext_decl (ed, None);
++     pext_loc = loc; pext_attributes = []}
++;;
++
++let ocaml_pstr_exn_rebind =
++  Some
++    (fun loc s li ->
++       Pstr_exception
++         {pext_name = mkloc loc s; pext_kind = Pext_rebind (mkloc loc li);
++          pext_loc = loc; pext_attributes = []})
++;;
++
++let ocaml_pstr_include =
++  Some
++    (fun loc me ->
++       Pstr_include {pincl_mod = me; pincl_loc = loc; pincl_attributes = []})
++;;
++
++let ocaml_pstr_modtype loc s mt =
++  let pmtd =
++    {pmtd_name = mkloc loc s; pmtd_type = Some mt; pmtd_attributes = [];
++     pmtd_loc = loc}
++  in
++  Pstr_modtype pmtd
++;;
++
++let ocaml_pstr_module loc s me =
++  let mb =
++    {pmb_name = mkloc loc s; pmb_expr = me; pmb_attributes = [];
++     pmb_loc = loc}
++  in
++  Pstr_module mb
++;;
++
++let ocaml_pstr_open loc li =
++  Pstr_open
++    {popen_lid = mknoloc li; popen_override = Fresh; popen_loc = loc;
++     popen_attributes = []}
++;;
++
++let ocaml_pstr_primitive s vd = Pstr_primitive vd;;
++
++let ocaml_pstr_recmodule =
++  let f nel =
++    Pstr_recmodule
++      (List.map
++         (fun (s, mt, me) ->
++            {pmb_name = mknoloc s; pmb_expr = me; pmb_attributes = [];
++             pmb_loc = loc_none})
++         nel)
++  in
++  Some f
++;;
++
++let ocaml_pstr_type stl =
++  let stl = List.map (fun (s, t) -> t) stl in Pstr_type stl
++;;
++
++let ocaml_class_infos =
++  Some
++    (fun virt (sl, sloc) name expr loc variance ->
++       let _ =
++         if List.length sl <> List.length variance then
++           failwith "internal error: ocaml_class_infos"
++       in
++       let params =
++         List.map2
++           (fun os va ->
++              ocaml_mktyp loc (Ptyp_var os), variance_of_bool_bool va)
++           sl variance
++       in
++       {pci_virt = virt; pci_params = params; pci_name = mkloc loc name;
++        pci_expr = expr; pci_loc = loc; pci_attributes = []})
++;;
++
++let ocaml_pmod_ident li = Pmod_ident (mknoloc li);;
++
++let ocaml_pmod_functor s mt me = Pmod_functor (mknoloc s, Some mt, me);;
++
++let ocaml_pmod_unpack : ('a -> 'b -> 'c, 'd) choice option =
++  Some (Right ((fun e -> Pmod_unpack e), (fun pt -> Ptyp_package pt)))
++;;
++
++let ocaml_pcf_cstr = Some (fun (t1, t2, loc) -> Pcf_constraint (t1, t2));;
++
++let ocaml_pcf_inher ce pb = Pcf_inherit (Fresh, ce, pb);;
++
++let ocaml_pcf_init = Some (fun e -> Pcf_initializer e);;
++
++let ocaml_pcf_meth (s, pf, ovf, e, loc) =
++  let pf = if pf then Private else Public in
++  let ovf = if ovf then Override else Fresh in
++  Pcf_method (mkloc loc s, pf, Cfk_concrete (ovf, e))
++;;
++
++let ocaml_pcf_val (s, mf, ovf, e, loc) =
++  let mf = if mf then Mutable else Immutable in
++  let ovf = if ovf then Override else Fresh in
++  Pcf_val (mkloc loc s, mf, Cfk_concrete (ovf, e))
++;;
++
++let ocaml_pcf_valvirt =
++  let ocaml_pcf (s, mf, t, loc) =
++    let mf = if mf then Mutable else Immutable in
++    Pcf_val (mkloc loc s, mf, Cfk_virtual t)
++  in
++  Some ocaml_pcf
++;;
++
++let ocaml_pcf_virt (s, pf, t, loc) =
++  Pcf_val (mkloc loc s, Immutable, Cfk_virtual t)
++;;
++
++let ocaml_pcl_apply = Some (fun ce lel -> Pcl_apply (ce, lel));;
++
++let ocaml_pcl_constr = Some (fun li ctl -> Pcl_constr (mknoloc li, ctl));;
++
++let ocaml_pcl_constraint = Some (fun ce ct -> Pcl_constraint (ce, ct));;
++
++let ocaml_pcl_fun = Some (fun lab ceo p ce -> Pcl_fun (lab, ceo, p, ce));;
++
++let ocaml_pcl_let = Some (fun rf pel ce -> Pcl_let (rf, pel, ce));;
++
++let ocaml_pcl_structure = Some (fun cs -> Pcl_structure cs);;
++
++let ocaml_pctf_cstr = Some (fun (t1, t2, loc) -> Pctf_constraint (t1, t2));;
++
++let ocaml_pctf_inher ct = Pctf_inherit ct;;
++
++let ocaml_pctf_meth (s, pf, t, loc) = Pctf_method (s, pf, Concrete, t);;
++
++let ocaml_pctf_val (s, mf, t, loc) = Pctf_val (s, mf, Concrete, t);;
++
++let ocaml_pctf_virt (s, pf, t, loc) = Pctf_val (s, Immutable, Virtual, t);;
++
++let ocaml_pcty_constr = Some (fun li ltl -> Pcty_constr (mknoloc li, ltl));;
++
++let ocaml_pcty_fun = Some (fun lab t ct -> Pcty_arrow (lab, t, ct));;
++
++let ocaml_pcty_signature =
++  let f (t, ctfl) =
++    let cs = {pcsig_self = t; pcsig_fields = ctfl} in Pcty_signature cs
++  in
++  Some f
++;;
++
++let ocaml_pdir_bool = Some (fun b -> Pdir_bool b);;
++
++let ocaml_pwith_modsubst =
++  Some (fun loc me -> Pwith_modsubst (mkloc loc "", mkloc loc me))
++;;
++
++let ocaml_pwith_type loc (i, td) = Pwith_type (mkloc loc i, td);;
++
++let ocaml_pwith_module loc me =
++  Pwith_module (mkloc loc (Lident ""), mkloc loc me)
++;;
++
++let ocaml_pwith_typesubst = Some (fun td -> Pwith_typesubst td);;
++
++let module_prefix_can_be_in_first_record_label_only = true;;
++
++let split_or_patterns_with_bindings = false;;
++
++let has_records_with_with = true;;
++
++(* *)
++
++let jocaml_pstr_def : (_ -> _) option = None;;
++
++let jocaml_pexp_def : (_ -> _ -> _) option = None;;
++
++let jocaml_pexp_par : (_ -> _ -> _) option = None;;
++
++let jocaml_pexp_reply : (_ -> _ -> _ -> _) option = None;;
++
++let jocaml_pexp_spawn : (_ -> _) option = None;;
++
++let arg_rest =
++  function
++    Arg.Rest r -> Some r
++  | _ -> None
++;;
++
++let arg_set_string =
++  function
++    Arg.Set_string r -> Some r
++  | _ -> None
++;;
++
++let arg_set_int =
++  function
++    Arg.Set_int r -> Some r
++  | _ -> None
++;;
++
++let arg_set_float =
++  function
++    Arg.Set_float r -> Some r
++  | _ -> None
++;;
++
++let arg_symbol =
++  function
++    Arg.Symbol (s, f) -> Some (s, f)
++  | _ -> None
++;;
++
++let arg_tuple =
++  function
++    Arg.Tuple t -> Some t
++  | _ -> None
++;;
++
++let arg_bool =
++  function
++    Arg.Bool f -> Some f
++  | _ -> None
++;;
++
++let char_escaped = Char.escaped;;
++
++let hashtbl_mem = Hashtbl.mem;;
++
++let list_rev_append = List.rev_append;;
++
++let list_rev_map = List.rev_map;;
++
++let list_sort = List.sort;;
++
++let pervasives_set_binary_mode_out = Pervasives.set_binary_mode_out;;
++
++let printf_ksprintf = Printf.ksprintf;;
++
++let string_contains = String.contains;;
++
++let string_copy = Bytes.copy;;
++
++let string_create = Bytes.create;;
++
++let string_unsafe_set = Bytes.unsafe_set;;
++
++let string_set = Bytes.set;;
++
++let array_create = Array.make;;
+diff --git a/ocaml_stuff/4.02.2/parsing/.depend b/ocaml_stuff/4.02.2/parsing/.depend
+new file mode 100644
+index 0000000..c589fb6
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/parsing/.depend
+@@ -0,0 +1,4 @@
++asttypes.cmi : location.cmi
++location.cmi : ../utils/warnings.cmi
++longident.cmi :
++parsetree.cmi : longident.cmi location.cmi asttypes.cmi
+diff --git a/ocaml_stuff/4.02.2/parsing/.gitignore b/ocaml_stuff/4.02.2/parsing/.gitignore
+new file mode 100644
+index 0000000..8e6c39c
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/parsing/.gitignore
+@@ -0,0 +1 @@
++*.cm[oi]
+diff --git a/ocaml_stuff/4.02.2/parsing/Makefile b/ocaml_stuff/4.02.2/parsing/Makefile
+new file mode 100644
+index 0000000..6d08a19
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/parsing/Makefile
+@@ -0,0 +1,19 @@
++# Makefile,v
++
++FILES=asttypes.cmi location.cmi longident.cmi parsetree.cmi
++INCL=-I ../utils
++
++all: $(FILES)
++
++clean:
++      rm -f *.cmi
++
++depend:
++      ocamldep $(INCL) *.ml* | sed -e 's/  *$$//' > .depend
++
++.SUFFIXES: .mli .cmi
++
++.mli.cmi:
++      $(OCAMLN)c $(INCL) -c $<
++
++include .depend
+diff --git a/ocaml_stuff/4.02.2/parsing/asttypes.mli b/ocaml_stuff/4.02.2/parsing/asttypes.mli
+new file mode 100644
+index 0000000..b212a2b
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/parsing/asttypes.mli
+@@ -0,0 +1,49 @@
++(***********************************************************************)
++(*                                                                     *)
++(*                                OCaml                                *)
++(*                                                                     *)
++(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
++(*                                                                     *)
++(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
++(*  en Automatique.  All rights reserved.  This file is distributed    *)
++(*  under the terms of the Q Public License version 1.0.               *)
++(*                                                                     *)
++(***********************************************************************)
++
++(* Auxiliary a.s.t. types used by parsetree and typedtree. *)
++
++type constant =
++    Const_int of int
++  | Const_char of char
++  | Const_string of string * string option
++  | Const_float of string
++  | Const_int32 of int32
++  | Const_int64 of int64
++  | Const_nativeint of nativeint
++
++type rec_flag = Nonrecursive | Recursive
++
++type direction_flag = Upto | Downto
++
++type private_flag = Private | Public
++
++type mutable_flag = Immutable | Mutable
++
++type virtual_flag = Virtual | Concrete
++
++type override_flag = Override | Fresh
++
++type closed_flag = Closed | Open
++
++type label = string
++
++type 'a loc = 'a Location.loc = {
++  txt : 'a;
++  loc : Location.t;
++}
++
++
++type variance =
++  | Covariant
++  | Contravariant
++  | Invariant
+diff --git a/ocaml_stuff/4.02.2/parsing/location.mli b/ocaml_stuff/4.02.2/parsing/location.mli
+new file mode 100644
+index 0000000..77b754f
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/parsing/location.mli
+@@ -0,0 +1,135 @@
++(***********************************************************************)
++(*                                                                     *)
++(*                                OCaml                                *)
++(*                                                                     *)
++(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
++(*                                                                     *)
++(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
++(*  en Automatique.  All rights reserved.  This file is distributed    *)
++(*  under the terms of the Q Public License version 1.0.               *)
++(*                                                                     *)
++(***********************************************************************)
++
++(* Source code locations (ranges of positions), used in parsetree. *)
++
++open Format
++
++type t = {
++  loc_start: Lexing.position;
++  loc_end: Lexing.position;
++  loc_ghost: bool;
++}
++
++(* Note on the use of Lexing.position in this module.
++   If [pos_fname = ""], then use [!input_name] instead.
++   If [pos_lnum = -1], then [pos_bol = 0]. Use [pos_cnum] and
++     re-parse the file to get the line and character numbers.
++   Else all fields are correct.
++*)
++
++val none : t
++(** An arbitrary value of type [t]; describes an empty ghost range. *)
++
++val in_file : string -> t
++(** Return an empty ghost range located in a given file. *)
++
++val init : Lexing.lexbuf -> string -> unit
++(** Set the file name and line number of the [lexbuf] to be the start
++    of the named file. *)
++
++val curr : Lexing.lexbuf -> t
++(** Get the location of the current token from the [lexbuf]. *)
++
++val symbol_rloc: unit -> t
++val symbol_gloc: unit -> t
++
++(** [rhs_loc n] returns the location of the symbol at position [n], starting
++  at 1, in the current parser rule. *)
++val rhs_loc: int -> t
++
++val input_name: string ref
++val input_lexbuf: Lexing.lexbuf option ref
++
++val get_pos_info: Lexing.position -> string * int * int (* file, line, char *)
++val print_loc: formatter -> t -> unit
++val print_error: formatter -> t -> unit
++val print_error_cur_file: formatter -> unit
++val print_warning: t -> formatter -> Warnings.t -> unit
++val formatter_for_warnings : formatter ref
++val prerr_warning: t -> Warnings.t -> unit
++val echo_eof: unit -> unit
++val reset: unit -> unit
++
++val warning_printer : (t -> formatter -> Warnings.t -> unit) ref
++(** Hook for intercepting warnings. *)
++
++val default_warning_printer : t -> formatter -> Warnings.t -> unit
++(** Original warning printer for use in hooks. *)
++
++val highlight_locations: formatter -> t list -> bool
++
++type 'a loc = {
++  txt : 'a;
++  loc : t;
++}
++
++val mknoloc : 'a -> 'a loc
++val mkloc : 'a -> t -> 'a loc
++
++val print: formatter -> t -> unit
++val print_filename: formatter -> string -> unit
++
++val absolute_path: string -> string
++
++val show_filename: string -> string
++    (** In -absname mode, return the absolute path for this filename.
++        Otherwise, returns the filename unchanged. *)
++
++
++val absname: bool ref
++
++
++(* Support for located errors *)
++
++type error =
++  {
++    loc: t;
++    msg: string;
++    sub: error list;
++    if_highlight: string; (* alternative message if locations are highlighted *)
++  }
++
++exception Error of error
++
++val error: ?loc:t -> ?sub:error list -> ?if_highlight:string -> string -> error
++
++val errorf: ?loc:t -> ?sub:error list -> ?if_highlight:string
++            -> ('a, unit, string, error) format4 -> 'a
++
++val raise_errorf: ?loc:t -> ?sub:error list -> ?if_highlight:string
++            -> ('a, unit, string, 'b) format4 -> 'a
++
++val error_of_printer: t -> (formatter -> 'a -> unit) -> 'a -> error
++
++val error_of_printer_file: (formatter -> 'a -> unit) -> 'a -> error
++
++val error_of_exn: exn -> error option
++
++val register_error_of_exn: (exn -> error option) -> unit
++  (* Each compiler module which defines a custom type of exception
++     which can surface as a user-visible error should register
++     a "printer" for this exception using [register_error_of_exn].
++     The result of the printer is an [error] value containing
++     a location, a message, and optionally sub-messages (each of them
++     being located as well). *)
++
++val report_error: formatter -> error -> unit
++
++val error_reporter : (formatter -> error -> unit) ref
++(** Hook for intercepting error reports. *)
++
++val default_error_reporter : formatter -> error -> unit
++(** Original error reporter for use in hooks. *)
++
++val report_exception: formatter -> exn -> unit
++  (* Reraise the exception if it is unknown. *)
+diff --git a/ocaml_stuff/4.02.2/parsing/longident.mli b/ocaml_stuff/4.02.2/parsing/longident.mli
+new file mode 100644
+index 0000000..9e79585
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/parsing/longident.mli
+@@ -0,0 +1,22 @@
++(***********************************************************************)
++(*                                                                     *)
++(*                                OCaml                                *)
++(*                                                                     *)
++(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
++(*                                                                     *)
++(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
++(*  en Automatique.  All rights reserved.  This file is distributed    *)
++(*  under the terms of the Q Public License version 1.0.               *)
++(*                                                                     *)
++(***********************************************************************)
++
++(* Long identifiers, used in parsetree. *)
++
++type t =
++    Lident of string
++  | Ldot of t * string
++  | Lapply of t * t
++
++val flatten: t -> string list
++val last: t -> string
++val parse: string -> t
+diff --git a/ocaml_stuff/4.02.2/parsing/parsetree.mli b/ocaml_stuff/4.02.2/parsing/parsetree.mli
+new file mode 100644
+index 0000000..295e3ea
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/parsing/parsetree.mli
+@@ -0,0 +1,829 @@
++(***********************************************************************)
++(*                                                                     *)
++(*                                OCaml                                *)
++(*                                                                     *)
++(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
++(*                                                                     *)
++(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
++(*  en Automatique.  All rights reserved.  This file is distributed    *)
++(*  under the terms of the Q Public License version 1.0.               *)
++(*                                                                     *)
++(***********************************************************************)
++
++(** Abstract syntax tree produced by parsing *)
++
++open Asttypes
++
++(** {2 Extension points} *)
++
++type attribute = string loc * payload
++       (* [@id ARG]
++          [@@id ARG]
++
++          Metadata containers passed around within the AST.
++          The compiler ignores unknown attributes.
++       *)
++
++and extension = string loc * payload
++      (* [%id ARG]
++         [%%id ARG]
++
++         Sub-language placeholder -- rejected by the typechecker.
++      *)
++
++and attributes = attribute list
++
++and payload =
++  | PStr of structure
++  | PTyp of core_type  (* : T *)
++  | PPat of pattern * expression option  (* ? P  or  ? P when E *)
++
++(** {2 Core language} *)
++
++(* Type expressions *)
++
++and core_type =
++    {
++     ptyp_desc: core_type_desc;
++     ptyp_loc: Location.t;
++     ptyp_attributes: attributes; (* ... [@id1] [@id2] *)
++    }
++
++and core_type_desc =
++  | Ptyp_any
++        (*  _ *)
++  | Ptyp_var of string
++        (* 'a *)
++  | Ptyp_arrow of label * core_type * core_type
++        (* T1 -> T2       (label = "")
++           ~l:T1 -> T2    (label = "l")
++           ?l:T1 -> T2    (label = "?l")
++         *)
++  | Ptyp_tuple of core_type list
++        (* T1 * ... * Tn
++
++           Invariant: n >= 2
++        *)
++  | Ptyp_constr of Longident.t loc * core_type list
++        (* tconstr
++           T tconstr
++           (T1, ..., Tn) tconstr
++         *)
++  | Ptyp_object of (string * attributes * core_type) list * closed_flag
++        (* < l1:T1; ...; ln:Tn >     (flag = Closed)
++           < l1:T1; ...; ln:Tn; .. > (flag = Open)
++         *)
++  | Ptyp_class of Longident.t loc * core_type list
++        (* #tconstr
++           T #tconstr
++           (T1, ..., Tn) #tconstr
++         *)
++  | Ptyp_alias of core_type * string
++        (* T as 'a *)
++  | Ptyp_variant of row_field list * closed_flag * label list option
++        (* [ `A|`B ]         (flag = Closed; labels = None)
++           [> `A|`B ]        (flag = Open;   labels = None)
++           [< `A|`B ]        (flag = Closed; labels = Some [])
++           [< `A|`B > `X `Y ](flag = Closed; labels = Some ["X";"Y"])
++         *)
++  | Ptyp_poly of string list * core_type
++        (* 'a1 ... 'an. T
++
++           Can only appear in the following context:
++
++           - As the core_type of a Ppat_constraint node corresponding
++             to a constraint on a let-binding: let x : 'a1 ... 'an. T
++             = e ...
++
++           - Under Cfk_virtual for methods (not values).
++
++           - As the core_type of a Pctf_method node.
++
++           - As the core_type of a Pexp_poly node.
++
++           - As the pld_type field of a label_declaration.
++
++           - As a core_type of a Ptyp_object node.
++         *)
++
++  | Ptyp_package of package_type
++        (* (module S) *)
++  | Ptyp_extension of extension
++        (* [%id] *)
++
++and package_type = Longident.t loc * (Longident.t loc * core_type) list
++      (*
++        (module S)
++        (module S with type t1 = T1 and ... and tn = Tn)
++       *)
++
++and row_field =
++  | Rtag of label * attributes * bool * core_type list
++        (* [`A]                   ( true,  [] )
++           [`A of T]              ( false, [T] )
++           [`A of T1 & .. & Tn]   ( false, [T1;...Tn] )
++           [`A of & T1 & .. & Tn] ( true,  [T1;...Tn] )
++
++          - The 2nd field is true if the tag contains a
++            constant (empty) constructor.
++          - '&' occurs when several types are used for the same constructor
++            (see 4.2 in the manual)
++
++          - TODO: switch to a record representation, and keep location
++        *)
++  | Rinherit of core_type
++        (* [ T ] *)
++
++(* Patterns *)
++
++and pattern =
++    {
++     ppat_desc: pattern_desc;
++     ppat_loc: Location.t;
++     ppat_attributes: attributes; (* ... [@id1] [@id2] *)
++    }
++
++and pattern_desc =
++  | Ppat_any
++        (* _ *)
++  | Ppat_var of string loc
++        (* x *)
++  | Ppat_alias of pattern * string loc
++        (* P as 'a *)
++  | Ppat_constant of constant
++        (* 1, 'a', "true", 1.0, 1l, 1L, 1n *)
++  | Ppat_interval of constant * constant
++        (* 'a'..'z'
++
++           Other forms of interval are recognized by the parser
++           but rejected by the type-checker. *)
++  | Ppat_tuple of pattern list
++        (* (P1, ..., Pn)
++
++           Invariant: n >= 2
++        *)
++  | Ppat_construct of Longident.t loc * pattern option
++        (* C                None
++           C P              Some P
++           C (P1, ..., Pn)  Some (Ppat_tuple [P1; ...; Pn])
++         *)
++  | Ppat_variant of label * pattern option
++        (* `A             (None)
++           `A P           (Some P)
++         *)
++  | Ppat_record of (Longident.t loc * pattern) list * closed_flag
++        (* { l1=P1; ...; ln=Pn }     (flag = Closed)
++           { l1=P1; ...; ln=Pn; _}   (flag = Open)
++
++           Invariant: n > 0
++         *)
++  | Ppat_array of pattern list
++        (* [| P1; ...; Pn |] *)
++  | Ppat_or of pattern * pattern
++        (* P1 | P2 *)
++  | Ppat_constraint of pattern * core_type
++        (* (P : T) *)
++  | Ppat_type of Longident.t loc
++        (* #tconst *)
++  | Ppat_lazy of pattern
++        (* lazy P *)
++  | Ppat_unpack of string loc
++        (* (module P)
++           Note: (module P : S) is represented as
++           Ppat_constraint(Ppat_unpack, Ptyp_package)
++         *)
++  | Ppat_exception of pattern
++        (* exception P *)
++  | Ppat_extension of extension
++        (* [%id] *)
++
++(* Value expressions *)
++
++and expression =
++    {
++     pexp_desc: expression_desc;
++     pexp_loc: Location.t;
++     pexp_attributes: attributes; (* ... [@id1] [@id2] *)
++    }
++
++and expression_desc =
++  | Pexp_ident of Longident.t loc
++        (* x
++           M.x
++         *)
++  | Pexp_constant of constant
++        (* 1, 'a', "true", 1.0, 1l, 1L, 1n *)
++  | Pexp_let of rec_flag * value_binding list * expression
++        (* let P1 = E1 and ... and Pn = EN in E       (flag = Nonrecursive)
++           let rec P1 = E1 and ... and Pn = EN in E   (flag = Recursive)
++         *)
++  | Pexp_function of case list
++        (* function P1 -> E1 | ... | Pn -> En *)
++  | Pexp_fun of label * expression option * pattern * expression
++        (* fun P -> E1                          (lab = "", None)
++           fun ~l:P -> E1                       (lab = "l", None)
++           fun ?l:P -> E1                       (lab = "?l", None)
++           fun ?l:(P = E0) -> E1                (lab = "?l", Some E0)
++
++           Notes:
++           - If E0 is provided, lab must start with '?'.
++           - "fun P1 P2 .. Pn -> E1" is represented as nested Pexp_fun.
++           - "let f P = E" is represented using Pexp_fun.
++         *)
++  | Pexp_apply of expression * (label * expression) list
++        (* E0 ~l1:E1 ... ~ln:En
++           li can be empty (non labeled argument) or start with '?'
++           (optional argument).
++
++           Invariant: n > 0
++         *)
++  | Pexp_match of expression * case list
++        (* match E0 with P1 -> E1 | ... | Pn -> En *)
++  | Pexp_try of expression * case list
++        (* try E0 with P1 -> E1 | ... | Pn -> En *)
++  | Pexp_tuple of expression list
++        (* (E1, ..., En)
++
++           Invariant: n >= 2
++        *)
++  | Pexp_construct of Longident.t loc * expression option
++        (* C                None
++           C E              Some E
++           C (E1, ..., En)  Some (Pexp_tuple[E1;...;En])
++        *)
++  | Pexp_variant of label * expression option
++        (* `A             (None)
++           `A E           (Some E)
++         *)
++  | Pexp_record of (Longident.t loc * expression) list * expression option
++        (* { l1=P1; ...; ln=Pn }     (None)
++           { E0 with l1=P1; ...; ln=Pn }   (Some E0)
++
++           Invariant: n > 0
++         *)
++  | Pexp_field of expression * Longident.t loc
++        (* E.l *)
++  | Pexp_setfield of expression * Longident.t loc * expression
++        (* E1.l <- E2 *)
++  | Pexp_array of expression list
++        (* [| E1; ...; En |] *)
++  | Pexp_ifthenelse of expression * expression * expression option
++        (* if E1 then E2 else E3 *)
++  | Pexp_sequence of expression * expression
++        (* E1; E2 *)
++  | Pexp_while of expression * expression
++        (* while E1 do E2 done *)
++  | Pexp_for of
++      pattern *  expression * expression * direction_flag * expression
++        (* for i = E1 to E2 do E3 done      (flag = Upto)
++           for i = E1 downto E2 do E3 done  (flag = Downto)
++         *)
++  | Pexp_constraint of expression * core_type
++        (* (E : T) *)
++  | Pexp_coerce of expression * core_type option * core_type
++        (* (E :> T)        (None, T)
++           (E : T0 :> T)   (Some T0, T)
++         *)
++  | Pexp_send of expression * string
++        (*  E # m *)
++  | Pexp_new of Longident.t loc
++        (* new M.c *)
++  | Pexp_setinstvar of string loc * expression
++        (* x <- 2 *)
++  | Pexp_override of (string loc * expression) list
++        (* {< x1 = E1; ...; Xn = En >} *)
++  | Pexp_letmodule of string loc * module_expr * expression
++        (* let module M = ME in E *)
++  | Pexp_assert of expression
++        (* assert E
++           Note: "assert false" is treated in a special way by the
++           type-checker. *)
++  | Pexp_lazy of expression
++        (* lazy E *)
++  | Pexp_poly of expression * core_type option
++        (* Used for method bodies.
++
++           Can only be used as the expression under Cfk_concrete
++           for methods (not values). *)
++  | Pexp_object of class_structure
++        (* object ... end *)
++  | Pexp_newtype of string * expression
++        (* fun (type t) -> E *)
++  | Pexp_pack of module_expr
++        (* (module ME)
++
++           (module ME : S) is represented as
++           Pexp_constraint(Pexp_pack, Ptyp_package S) *)
++  | Pexp_open of override_flag * Longident.t loc * expression
++        (* let open M in E
++           let! open M in E
++        *)
++  | Pexp_extension of extension
++        (* [%id] *)
++
++and case =   (* (P -> E) or (P when E0 -> E) *)
++    {
++     pc_lhs: pattern;
++     pc_guard: expression option;
++     pc_rhs: expression;
++    }
++
++(* Value descriptions *)
++
++and value_description =
++    {
++     pval_name: string loc;
++     pval_type: core_type;
++     pval_prim: string list;
++     pval_attributes: attributes;  (* ... [@@id1] [@@id2] *)
++     pval_loc: Location.t;
++    }
++
++(*
++  val x: T                            (prim = [])
++  external x: T = "s1" ... "sn"       (prim = ["s1";..."sn"])
++
++  Note: when used under Pstr_primitive, prim cannot be empty
++*)
++
++(* Type declarations *)
++
++and type_declaration =
++    {
++     ptype_name: string loc;
++     ptype_params: (core_type * variance) list;
++           (* ('a1,...'an) t; None represents  _*)
++     ptype_cstrs: (core_type * core_type * Location.t) list;
++           (* ... constraint T1=T1'  ... constraint Tn=Tn' *)
++     ptype_kind: type_kind;
++     ptype_private: private_flag;   (* = private ... *)
++     ptype_manifest: core_type option;  (* = T *)
++     ptype_attributes: attributes;   (* ... [@@id1] [@@id2] *)
++     ptype_loc: Location.t;
++    }
++
++(*
++  type t                     (abstract, no manifest)
++  type t = T0                (abstract, manifest=T0)
++  type t = C of T | ...      (variant,  no manifest)
++  type t = T0 = C of T | ... (variant,  manifest=T0)
++  type t = {l: T; ...}       (record,   no manifest)
++  type t = T0 = {l : T; ...} (record,   manifest=T0)
++  type t = ..                (open,     no manifest)
++*)
++
++and type_kind =
++  | Ptype_abstract
++  | Ptype_variant of constructor_declaration list
++        (* Invariant: non-empty list *)
++  | Ptype_record of label_declaration list
++        (* Invariant: non-empty list *)
++  | Ptype_open
++
++and label_declaration =
++    {
++     pld_name: string loc;
++     pld_mutable: mutable_flag;
++     pld_type: core_type;
++     pld_loc: Location.t;
++     pld_attributes: attributes; (* l [@id1] [@id2] : T *)
++    }
++
++(*  { ...; l: T; ... }            (mutable=Immutable)
++    { ...; mutable l: T; ... }    (mutable=Mutable)
++
++    Note: T can be a Ptyp_poly.
++*)
++
++and constructor_declaration =
++    {
++     pcd_name: string loc;
++     pcd_args: core_type list;
++     pcd_res: core_type option;
++     pcd_loc: Location.t;
++     pcd_attributes: attributes; (* C [@id1] [@id2] of ... *)
++    }
++(*
++  | C of T1 * ... * Tn     (res = None)
++  | C: T0                  (args = [], res = Some T0)
++  | C: T1 * ... * Tn -> T0 (res = Some T0)
++*)
++
++and type_extension =
++    {
++     ptyext_path: Longident.t loc;
++     ptyext_params: (core_type * variance) list;
++     ptyext_constructors: extension_constructor list;
++     ptyext_private: private_flag;
++     ptyext_attributes: attributes;   (* ... [@@id1] [@@id2] *)
++    }
++(*
++  type t += ...
++*)
++
++and extension_constructor =
++    {
++     pext_name: string loc;
++     pext_kind : extension_constructor_kind;
++     pext_loc : Location.t;
++     pext_attributes: attributes; (* C [@id1] [@id2] of ... *)
++    }
++
++and extension_constructor_kind =
++    Pext_decl of core_type list * core_type option
++      (*
++         | C of T1 * ... * Tn     ([T1; ...; Tn], None)
++         | C: T0                  ([], Some T0)
++         | C: T1 * ... * Tn -> T0 ([T1; ...; Tn], Some T0)
++       *)
++  | Pext_rebind of Longident.t loc
++      (*
++         | C = D
++       *)
++
++(** {2 Class language} *)
++
++(* Type expressions for the class language *)
++
++and class_type =
++    {
++     pcty_desc: class_type_desc;
++     pcty_loc: Location.t;
++     pcty_attributes: attributes; (* ... [@id1] [@id2] *)
++    }
++
++and class_type_desc =
++  | Pcty_constr of Longident.t loc * core_type list
++        (* c
++           ['a1, ..., 'an] c *)
++  | Pcty_signature of class_signature
++        (* object ... end *)
++  | Pcty_arrow of label * core_type * class_type
++        (* T -> CT       (label = "")
++           ~l:T -> CT    (label = "l")
++           ?l:T -> CT    (label = "?l")
++         *)
++  | Pcty_extension of extension
++        (* [%id] *)
++
++and class_signature =
++    {
++     pcsig_self: core_type;
++     pcsig_fields: class_type_field list;
++    }
++(* object('selfpat) ... end
++   object ... end             (self = Ptyp_any)
++ *)
++
++and class_type_field =
++    {
++     pctf_desc: class_type_field_desc;
++     pctf_loc: Location.t;
++     pctf_attributes: attributes; (* ... [@@id1] [@@id2] *)
++    }
++
++and class_type_field_desc =
++  | Pctf_inherit of class_type
++        (* inherit CT *)
++  | Pctf_val of (string * mutable_flag * virtual_flag * core_type)
++        (* val x: T *)
++  | Pctf_method  of (string * private_flag * virtual_flag * core_type)
++        (* method x: T
++
++           Note: T can be a Ptyp_poly.
++         *)
++  | Pctf_constraint  of (core_type * core_type)
++        (* constraint T1 = T2 *)
++  | Pctf_attribute of attribute
++        (* [@@@id] *)
++  | Pctf_extension of extension
++        (* [%%id] *)
++
++and 'a class_infos =
++    {
++     pci_virt: virtual_flag;
++     pci_params: (core_type * variance) list;
++     pci_name: string loc;
++     pci_expr: 'a;
++     pci_loc: Location.t;
++     pci_attributes: attributes;  (* ... [@@id1] [@@id2] *)
++    }
++(* class c = ...
++   class ['a1,...,'an] c = ...
++   class virtual c = ...
++
++   Also used for "class type" declaration.
++*)
++
++and class_description = class_type class_infos
++
++and class_type_declaration = class_type class_infos
++
++(* Value expressions for the class language *)
++
++and class_expr =
++    {
++     pcl_desc: class_expr_desc;
++     pcl_loc: Location.t;
++     pcl_attributes: attributes; (* ... [@id1] [@id2] *)
++    }
++
++and class_expr_desc =
++  | Pcl_constr of Longident.t loc * core_type list
++        (* c
++           ['a1, ..., 'an] c *)
++  | Pcl_structure of class_structure
++        (* object ... end *)
++  | Pcl_fun of label * expression option * pattern * class_expr
++        (* fun P -> CE                          (lab = "", None)
++           fun ~l:P -> CE                       (lab = "l", None)
++           fun ?l:P -> CE                       (lab = "?l", None)
++           fun ?l:(P = E0) -> CE                (lab = "?l", Some E0)
++         *)
++  | Pcl_apply of class_expr * (label * expression) list
++        (* CE ~l1:E1 ... ~ln:En
++           li can be empty (non labeled argument) or start with '?'
++           (optional argument).
++
++           Invariant: n > 0
++         *)
++  | Pcl_let of rec_flag * value_binding list * class_expr
++        (* let P1 = E1 and ... and Pn = EN in CE      (flag = Nonrecursive)
++           let rec P1 = E1 and ... and Pn = EN in CE  (flag = Recursive)
++         *)
++  | Pcl_constraint of class_expr * class_type
++        (* (CE : CT) *)
++  | Pcl_extension of extension
++        (* [%id] *)
++
++and class_structure =
++    {
++     pcstr_self: pattern;
++     pcstr_fields: class_field list;
++    }
++(* object(selfpat) ... end
++   object ... end           (self = Ppat_any)
++ *)
++
++and class_field =
++    {
++     pcf_desc: class_field_desc;
++     pcf_loc: Location.t;
++     pcf_attributes: attributes; (* ... [@@id1] [@@id2] *)
++    }
++
++and class_field_desc =
++  | Pcf_inherit of override_flag * class_expr * string option
++        (* inherit CE
++           inherit CE as x
++           inherit! CE
++           inherit! CE as x
++         *)
++  | Pcf_val of (string loc * mutable_flag * class_field_kind)
++        (* val x = E
++           val virtual x: T
++         *)
++  | Pcf_method of (string loc * private_flag * class_field_kind)
++        (* method x = E            (E can be a Pexp_poly)
++           method virtual x: T     (T can be a Ptyp_poly)
++         *)
++  | Pcf_constraint of (core_type * core_type)
++        (* constraint T1 = T2 *)
++  | Pcf_initializer of expression
++        (* initializer E *)
++  | Pcf_attribute of attribute
++        (* [@@@id] *)
++  | Pcf_extension of extension
++        (* [%%id] *)
++
++and class_field_kind =
++  | Cfk_virtual of core_type
++  | Cfk_concrete of override_flag * expression
++
++and class_declaration = class_expr class_infos
++
++(** {2 Module language} *)
++
++(* Type expressions for the module language *)
++
++and module_type =
++    {
++     pmty_desc: module_type_desc;
++     pmty_loc: Location.t;
++     pmty_attributes: attributes; (* ... [@id1] [@id2] *)
++    }
++
++and module_type_desc =
++  | Pmty_ident of Longident.t loc
++        (* S *)
++  | Pmty_signature of signature
++        (* sig ... end *)
++  | Pmty_functor of string loc * module_type option * module_type
++        (* functor(X : MT1) -> MT2 *)
++  | Pmty_with of module_type * with_constraint list
++        (* MT with ... *)
++  | Pmty_typeof of module_expr
++        (* module type of ME *)
++  | Pmty_extension of extension
++        (* [%id] *)
++  | Pmty_alias of Longident.t loc
++        (* (module M) *)
++
++and signature = signature_item list
++
++and signature_item =
++    {
++     psig_desc: signature_item_desc;
++     psig_loc: Location.t;
++    }
++
++and signature_item_desc =
++  | Psig_value of value_description
++        (*
++          val x: T
++          external x: T = "s1" ... "sn"
++         *)
++  | Psig_type of type_declaration list
++        (* type t1 = ... and ... and tn = ... *)
++  | Psig_typext of type_extension
++        (* type t1 += ... *)
++  | Psig_exception of extension_constructor
++        (* exception C of T *)
++  | Psig_module of module_declaration
++        (* module X : MT *)
++  | Psig_recmodule of module_declaration list
++        (* module rec X1 : MT1 and ... and Xn : MTn *)
++  | Psig_modtype of module_type_declaration
++        (* module type S = MT
++           module type S *)
++  | Psig_open of open_description
++        (* open X *)
++  | Psig_include of include_description
++        (* include MT *)
++  | Psig_class of class_description list
++        (* class c1 : ... and ... and cn : ... *)
++  | Psig_class_type of class_type_declaration list
++        (* class type ct1 = ... and ... and ctn = ... *)
++  | Psig_attribute of attribute
++        (* [@@@id] *)
++  | Psig_extension of extension * attributes
++        (* [%%id] *)
++
++and module_declaration =
++    {
++     pmd_name: string loc;
++     pmd_type: module_type;
++     pmd_attributes: attributes; (* ... [@@id1] [@@id2] *)
++     pmd_loc: Location.t;
++    }
++(* S : MT *)
++
++and module_type_declaration =
++    {
++     pmtd_name: string loc;
++     pmtd_type: module_type option;
++     pmtd_attributes: attributes; (* ... [@@id1] [@@id2] *)
++     pmtd_loc: Location.t;
++    }
++(* S = MT
++   S       (abstract module type declaration, pmtd_type = None)
++*)
++
++and open_description =
++    {
++     popen_lid: Longident.t loc;
++     popen_override: override_flag;
++     popen_loc: Location.t;
++     popen_attributes: attributes;
++    }
++(* open! X - popen_override = Override (silences the 'used identifier
++                              shadowing' warning)
++   open  X - popen_override = Fresh
++ *)
++
++and 'a include_infos =
++    {
++     pincl_mod: 'a;
++     pincl_loc: Location.t;
++     pincl_attributes: attributes;
++    }
++
++and include_description = module_type include_infos
++(* include MT *)
++
++and include_declaration = module_expr include_infos
++(* include ME *)
++
++and with_constraint =
++  | Pwith_type of Longident.t loc * type_declaration
++        (* with type X.t = ...
++
++           Note: the last component of the longident must match
++           the name of the type_declaration. *)
++  | Pwith_module of Longident.t loc * Longident.t loc
++        (* with module X.Y = Z *)
++  | Pwith_typesubst of type_declaration
++        (* with type t := ... *)
++  | Pwith_modsubst of string loc * Longident.t loc
++        (* with module X := Z *)
++
++(* Value expressions for the module language *)
++
++and module_expr =
++    {
++     pmod_desc: module_expr_desc;
++     pmod_loc: Location.t;
++     pmod_attributes: attributes; (* ... [@id1] [@id2] *)
++    }
++
++and module_expr_desc =
++  | Pmod_ident of Longident.t loc
++        (* X *)
++  | Pmod_structure of structure
++        (* struct ... end *)
++  | Pmod_functor of string loc * module_type option * module_expr
++        (* functor(X : MT1) -> ME *)
++  | Pmod_apply of module_expr * module_expr
++        (* ME1(ME2) *)
++  | Pmod_constraint of module_expr * module_type
++        (* (ME : MT) *)
++  | Pmod_unpack of expression
++        (* (val E) *)
++  | Pmod_extension of extension
++        (* [%id] *)
++
++and structure = structure_item list
++
++and structure_item =
++    {
++     pstr_desc: structure_item_desc;
++     pstr_loc: Location.t;
++    }
++
++and structure_item_desc =
++  | Pstr_eval of expression * attributes
++        (* E *)
++  | Pstr_value of rec_flag * value_binding list
++        (* let P1 = E1 and ... and Pn = EN       (flag = Nonrecursive)
++           let rec P1 = E1 and ... and Pn = EN   (flag = Recursive)
++         *)
++  | Pstr_primitive of value_description
++        (* external x: T = "s1" ... "sn" *)
++  | Pstr_type of type_declaration list
++        (* type t1 = ... and ... and tn = ... *)
++  | Pstr_typext of type_extension
++        (* type t1 += ... *)
++  | Pstr_exception of extension_constructor
++        (* exception C of T
++           exception C = M.X *)
++  | Pstr_module of module_binding
++        (* module X = ME *)
++  | Pstr_recmodule of module_binding list
++        (* module rec X1 = ME1 and ... and Xn = MEn *)
++  | Pstr_modtype of module_type_declaration
++        (* module type S = MT *)
++  | Pstr_open of open_description
++        (* open X *)
++  | Pstr_class of class_declaration list
++        (* class c1 = ... and ... and cn = ... *)
++  | Pstr_class_type of class_type_declaration list
++        (* class type ct1 = ... and ... and ctn = ... *)
++  | Pstr_include of include_declaration
++        (* include ME *)
++  | Pstr_attribute of attribute
++        (* [@@@id] *)
++  | Pstr_extension of extension * attributes
++        (* [%%id] *)
++
++and value_binding =
++  {
++    pvb_pat: pattern;
++    pvb_expr: expression;
++    pvb_attributes: attributes;
++    pvb_loc: Location.t;
++  }
++
++and module_binding =
++    {
++     pmb_name: string loc;
++     pmb_expr: module_expr;
++     pmb_attributes: attributes;
++     pmb_loc: Location.t;
++    }
++(* X = ME *)
++
++(** {2 Toplevel} *)
++
++(* Toplevel phrases *)
++
++type toplevel_phrase =
++  | Ptop_def of structure
++  | Ptop_dir of string * directive_argument
++     (* #use, #load ... *)
++
++and directive_argument =
++  | Pdir_none
++  | Pdir_string of string
++  | Pdir_int of int
++  | Pdir_ident of Longident.t
++  | Pdir_bool of bool
+diff --git a/ocaml_stuff/4.02.2/utils/.depend b/ocaml_stuff/4.02.2/utils/.depend
+new file mode 100644
+index 0000000..b261ffe
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/utils/.depend
+@@ -0,0 +1,2 @@
++pconfig.cmo: pconfig.cmi
++pconfig.cmx: pconfig.cmi
+diff --git a/ocaml_stuff/4.02.2/utils/.gitignore b/ocaml_stuff/4.02.2/utils/.gitignore
+new file mode 100644
+index 0000000..23e90de
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/utils/.gitignore
+@@ -0,0 +1 @@
++*.cm[oix]
+diff --git a/ocaml_stuff/4.02.2/utils/Makefile b/ocaml_stuff/4.02.2/utils/Makefile
+new file mode 100644
+index 0000000..f4ea281
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/utils/Makefile
+@@ -0,0 +1,27 @@
++# Makefile,v
++
++FILES=warnings.cmi pconfig.cmo
++INCL=
++
++all: $(FILES)
++
++opt: pconfig.cmx
++
++clean:
++      rm -f *.cm[oix] *.o
++
++depend:
++      ocamldep $(INCL) *.ml* | sed -e 's/  *$$//' > .depend
++
++.SUFFIXES: .mli .cmi .ml .cmo .cmx
++
++.mli.cmi:
++      $(OCAMLN)c $(INCL) -c $<
++
++.ml.cmo:
++      $(OCAMLN)c $(INCL) -c $<
++
++.ml.cmx:
++      $(OCAMLN)opt $(INCL) -c $<
++
++include .depend
+diff --git a/ocaml_stuff/4.02.2/utils/pconfig.ml b/ocaml_stuff/4.02.2/utils/pconfig.ml
+new file mode 100644
+index 0000000..e35511d
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/utils/pconfig.ml
+@@ -0,0 +1,4 @@
 +let ocaml_version = "4.02.2"
 +let ocaml_version = "4.02.2"
- let ocaml_name = "ocaml"
- let ast_impl_magic_number = "Caml1999M016"
- let ast_intf_magic_number = "Caml1999N015"
++let ocaml_name = "ocaml"
++let ast_impl_magic_number = "Caml1999M016"
++let ast_intf_magic_number = "Caml1999N015"
+diff --git a/ocaml_stuff/4.02.2/utils/pconfig.mli b/ocaml_stuff/4.02.2/utils/pconfig.mli
+new file mode 100644
+index 0000000..f6382d3
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/utils/pconfig.mli
+@@ -0,0 +1,4 @@
++val ocaml_version : string
++val ocaml_name : string
++val ast_impl_magic_number : string
++val ast_intf_magic_number : string
+diff --git a/ocaml_stuff/4.02.2/utils/warnings.mli b/ocaml_stuff/4.02.2/utils/warnings.mli
+new file mode 100644
+index 0000000..ffd943f
+--- /dev/null
++++ b/ocaml_stuff/4.02.2/utils/warnings.mli
+@@ -0,0 +1,86 @@
++(***********************************************************************)
++(*                                                                     *)
++(*                                OCaml                                *)
++(*                                                                     *)
++(*            Pierre Weis && Damien Doligez, INRIA Rocquencourt        *)
++(*                                                                     *)
++(*  Copyright 1998 Institut National de Recherche en Informatique et   *)
++(*  en Automatique.  All rights reserved.  This file is distributed    *)
++(*  under the terms of the Q Public License version 1.0.               *)
++(*                                                                     *)
++(***********************************************************************)
++
++open Format
++
++type t =
++  | Comment_start                           (*  1 *)
++  | Comment_not_end                         (*  2 *)
++  | Deprecated of string                    (*  3 *)
++  | Fragile_match of string                 (*  4 *)
++  | Partial_application                     (*  5 *)
++  | Labels_omitted                          (*  6 *)
++  | Method_override of string list          (*  7 *)
++  | Partial_match of string                 (*  8 *)
++  | Non_closed_record_pattern of string     (*  9 *)
++  | Statement_type                          (* 10 *)
++  | Unused_match                            (* 11 *)
++  | Unused_pat                              (* 12 *)
++  | Instance_variable_override of string list (* 13 *)
++  | Illegal_backslash                       (* 14 *)
++  | Implicit_public_methods of string list  (* 15 *)
++  | Unerasable_optional_argument            (* 16 *)
++  | Undeclared_virtual_method of string     (* 17 *)
++  | Not_principal of string                 (* 18 *)
++  | Without_principality of string          (* 19 *)
++  | Unused_argument                         (* 20 *)
++  | Nonreturning_statement                  (* 21 *)
++  | Preprocessor of string                  (* 22 *)
++  | Useless_record_with                     (* 23 *)
++  | Bad_module_name of string               (* 24 *)
++  | All_clauses_guarded                     (* 25 *)
++  | Unused_var of string                    (* 26 *)
++  | Unused_var_strict of string             (* 27 *)
++  | Wildcard_arg_to_constant_constr         (* 28 *)
++  | Eol_in_string                           (* 29 *)
++  | Duplicate_definitions of string * string * string * string (* 30 *)
++  | Multiple_definition of string * string * string (* 31 *)
++  | Unused_value_declaration of string      (* 32 *)
++  | Unused_open of string                   (* 33 *)
++  | Unused_type_declaration of string       (* 34 *)
++  | Unused_for_index of string              (* 35 *)
++  | Unused_ancestor of string               (* 36 *)
++  | Unused_constructor of string * bool * bool (* 37 *)
++  | Unused_extension of string * bool * bool   (* 38 *)
++  | Unused_rec_flag                         (* 39 *)
++  | Name_out_of_scope of string * string list * bool   (* 40 *)
++  | Ambiguous_name of string list * string list * bool (* 41 *)
++  | Disambiguated_name of string            (* 42 *)
++  | Nonoptional_label of string             (* 43 *)
++  | Open_shadow_identifier of string * string (* 44 *)
++  | Open_shadow_label_constructor of string * string (* 45 *)
++  | Bad_env_variable of string * string     (* 46 *)
++  | Attribute_payload of string * string    (* 47 *)
++  | Eliminated_optional_arguments of string list (* 48 *)
++  | No_cmi_file of string                   (* 49 *)
++  | Bad_docstring of bool                   (* 50 *)
++;;
++
++val parse_options : bool -> string -> unit;;
++
++val is_active : t -> bool;;
++val is_error : t -> bool;;
++
++val defaults_w : string;;
++val defaults_warn_error : string;;
++
++val print : formatter -> t -> unit;;
++
++exception Errors of int;;
++
++val check_fatal : unit -> unit;;
++
++val help_warnings: unit -> unit
++
++type state
++val backup: unit -> state
++val restore: state -> unit
+-- 
+2.4.6
+
This page took 0.133129 seconds and 4 git commands to generate.