Commits

camlspotter committed a5e2738

ocaml 4 fix

  • Participants
  • Parent commits 8b11729

Comments (0)

Files changed (5)

sexplib/sexplib-7.0.5/INSTALL

 (* OASIS_START *)
-(* DO NOT EDIT (digest: b4b9b34e94dfc4c6914f87aae494ed32) *)
+(* DO NOT EDIT (digest: 985800bd1bed371585f8cb11e4b98e42) *)
 This is the INSTALL file for the sexplib distribution.
 
 This package uses OASIS to generate its build system. See section OASIS for
 In order to compile this package, you will need:
 * ocaml (>= 3.12) for all, test conv, test sexp, doc sexplib
 * findlib
+* compiler-libs for library sexplib, library sexplib_top
 * type_conv (>= 3.0.5) for library pa_sexp_conv
 
 Installing

sexplib/sexplib-7.0.5/_tags

 # OASIS_START
-# DO NOT EDIT (digest: a1d81a7e4d410a35183ff1a62ca59486)
+# DO NOT EDIT (digest: 7701c4de41e43064c6f60642318d1b9a)
 # Ignore VCS directories, you can use the same kind of rule outside 
 # OASIS_START/STOP if you want to exclude directories that contains 
 # useless stuff for the build process
 "_darcs": -traverse
 "_darcs": not_hygienic
 # Library sexplib
-"lib": include
+"lib/sexplib.cmxs": use_sexplib
 "lib/type.cmx": for-pack(Sexplib)
 "lib/parser.cmx": for-pack(Sexplib)
 "lib/lexer.cmx": for-pack(Sexplib)
 "lib/conv_error.cmx": for-pack(Sexplib)
 "lib/exn_magic.cmx": for-pack(Sexplib)
 "lib/std.cmx": for-pack(Sexplib)
+<lib/*.ml{,i}>: pkg_compiler-libs
 <lib/*.ml{,i}>: pkg_unix
+<lib/*.ml{,i}>: pkg_bigarray
 <lib/*.ml{,i}>: pkg_num
-<lib/*.ml{,i}>: pkg_bigarray
 # Library pa_sexp_conv
-"syntax": include
-<syntax/*.ml{,i}>: pkg_type_conv
+"syntax/pa_sexp_conv.cmxs": use_pa_sexp_conv
 <syntax/*.ml{,i}>: pkg_camlp4.quotations
 <syntax/*.ml{,i}>: pkg_camlp4.extend
+<syntax/*.ml{,i}>: pkg_type_conv
+# Library sexplib_top
+"top/sexplib_top.cmxs": use_sexplib_top
+<top/*.ml{,i}>: pkg_compiler-libs
+# Executable sexp_test
+"lib_test/sexp_test.byte": use_sexplib
+"lib_test/sexp_test.byte": pkg_compiler-libs
+"lib_test/sexp_test.byte": pkg_unix
+"lib_test/sexp_test.byte": pkg_bigarray
+"lib_test/sexp_test.byte": pkg_num
 # Executable conv_test
+"lib_test/conv_test.byte": use_sexplib
 "lib_test/conv_test.byte": use_pa_sexp_conv
-"lib_test/conv_test.byte": use_sexplib
-"lib_test/conv_test.byte": pkg_unix
-"lib_test/conv_test.byte": pkg_type_conv
-"lib_test/conv_test.byte": pkg_num
+"lib_test/conv_test.byte": pkg_compiler-libs
 "lib_test/conv_test.byte": pkg_camlp4.quotations
 "lib_test/conv_test.byte": pkg_camlp4.extend
+"lib_test/conv_test.byte": pkg_type_conv
+"lib_test/conv_test.byte": pkg_unix
 "lib_test/conv_test.byte": pkg_bigarray
+"lib_test/conv_test.byte": pkg_num
+<lib_test/*.ml{,i}>: use_sexplib
 <lib_test/*.ml{,i}>: use_pa_sexp_conv
-<lib_test/*.ml{,i}>: pkg_type_conv
+<lib_test/*.ml{,i}>: pkg_compiler-libs
 <lib_test/*.ml{,i}>: pkg_camlp4.quotations
 <lib_test/*.ml{,i}>: pkg_camlp4.extend
-# Library sexplib_top
-"top": include
-# Executable sexp_test
-"lib_test/sexp_test.byte": use_sexplib
-"lib_test/sexp_test.byte": pkg_unix
-"lib_test/sexp_test.byte": pkg_num
-"lib_test/sexp_test.byte": pkg_bigarray
-<lib_test/*.ml{,i}>: use_sexplib
+<lib_test/*.ml{,i}>: pkg_type_conv
 <lib_test/*.ml{,i}>: pkg_unix
+<lib_test/*.ml{,i}>: pkg_bigarray
 <lib_test/*.ml{,i}>: pkg_num
-<lib_test/*.ml{,i}>: pkg_bigarray
 # OASIS_STOP
 <syntax/pa_sexp_conv.ml>: syntax_camlp4o
 <lib/pre_sexp.ml>:pp(cpp -traditional -undef)

sexplib/sexplib-7.0.5/lib/META

 # OASIS_START
-# DO NOT EDIT (digest: 753f7af494baaf733d5ff4e8d89ff68b)
+# DO NOT EDIT (digest: 74b789ae0ccffba9a1e6c570c37f8ed7)
 version = "7.0.5"
 description = "automated S-expression conversion"
-requires = "unix bigarray num"
+requires = "unix bigarray num compiler-libs"
 archive(byte) = "sexplib.cma"
+archive(byte, plugin) = "sexplib.cma"
 archive(native) = "sexplib.cmxa"
+archive(native, plugin) = "sexplib.cmxs"
 exists_if = "sexplib.cma"
 package "top" (
  version = "7.0.5"
  description = "Toplevel printers for S-expressions"
  requires = "sexplib"
  archive(byte) = "sexplib_top.cma"
+ archive(byte, plugin) = "sexplib_top.cma"
  archive(native) = "sexplib_top.cmxa"
+ archive(native, plugin) = "sexplib_top.cmxs"
  exists_if = "sexplib_top.cma"
 )
 

sexplib/sexplib-7.0.5/myocamlbuild.ml

 (* OASIS_START *)
-(* DO NOT EDIT (digest: 6a36af2626fc8bc901ff0b729583bf22) *)
+(* DO NOT EDIT (digest: 0efba536b0d78bc2f532c2849df63160) *)
 module OASISGettext = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISGettext.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISGettext.ml"
+
   let ns_ str =
     str
-  
+
   let s_ str =
     str
-  
+
   let f_ (str : ('a, 'b, 'c, 'd) format4) =
     str
-  
+
   let fn_ fmt1 fmt2 n =
     if n = 1 then
       fmt1^^""
     else
       fmt2^^""
-  
+
   let init =
     []
-  
+
 end
 
 module OASISExpr = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISExpr.ml"
-  
-  
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISExpr.ml"
+
+
+
   open OASISGettext
-  
+
   type test = string 
-  
+
   type flag = string 
-  
+
   type t =
     | EBool of bool
     | ENot of t
     | EFlag of flag
     | ETest of test * string
     
-  
+
   type 'a choices = (t * 'a) list 
-  
+
   let eval var_get t =
     let rec eval' =
       function
         | EBool b ->
             b
-  
+
         | ENot e ->
             not (eval' e)
-  
+
         | EAnd (e1, e2) ->
             (eval' e1) && (eval' e2)
-  
+
         | EOr (e1, e2) ->
             (eval' e1) || (eval' e2)
-  
+
         | EFlag nm ->
             let v =
               var_get nm
             in
               assert(v = "true" || v = "false");
               (v = "true")
-  
+
         | ETest (nm, vl) ->
             let v =
               var_get nm
               (v = vl)
     in
       eval' t
-  
+
   let choose ?printer ?name var_get lst =
     let rec choose_aux =
       function
                          str_lst)
     in
       choose_aux (List.rev lst)
-  
+
 end
 
 
+# 117 "myocamlbuild.ml"
 module BaseEnvLight = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/base/BaseEnvLight.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/base/BaseEnvLight.ml"
+
   module MapString = Map.Make(String)
-  
+
   type t = string MapString.t
-  
+
   let default_filename =
     Filename.concat
       (Sys.getcwd ())
       "setup.data"
-  
+
   let load ?(allow_empty=false) ?(filename=default_filename) () =
     if Sys.file_exists filename then
       begin
              "Unable to load environment, the file '%s' doesn't exist."
              filename)
       end
-  
+
   let var_get name env =
     let rec var_expand str =
       let buff =
         Buffer.contents buff
     in
       var_expand (MapString.find name env)
-  
+
   let var_choose lst env =
     OASISExpr.choose
       (fun nm -> var_get nm env)
 end
 
 
+# 215 "myocamlbuild.ml"
 module MyOCamlbuildFindlib = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/plugins/ocamlbuild/MyOCamlbuildFindlib.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/plugins/ocamlbuild/MyOCamlbuildFindlib.ml"
+
   (** OCamlbuild extension, copied from 
     * http://brion.inria.fr/gallium/index.php/Using_ocamlfind_with_ocamlbuild
     * by N. Pouillard and others
     * Modified by Sylvain Le Gall 
     *)
   open Ocamlbuild_plugin
-  
+
   (* these functions are not really officially exported *)
   let run_and_read = 
     Ocamlbuild_pack.My_unix.run_and_read
-  
+
   let blank_sep_strings = 
     Ocamlbuild_pack.Lexers.blank_sep_strings
-  
+
   let split s ch =
     let x = 
       ref [] 
       try
         go s
       with Not_found -> !x
-  
+
   let split_nl s = split s '\n'
-  
+
   let before_space s =
     try
       String.before s (String.index s ' ')
     with Not_found -> s
-  
+
   (* this lists all supported packages *)
   let find_packages () =
     List.map before_space (split_nl & run_and_read "ocamlfind list")
-  
+
   (* this is supposed to list available syntaxes, but I don't know how to do it. *)
   let find_syntaxes () = ["camlp4o"; "camlp4r"]
-  
+
   (* ocamlfind command *)
   let ocamlfind x = S[A"ocamlfind"; x]
-  
+
   let dispatch =
     function
       | Before_options ->
               flag ["ocaml"; "infer_interface"; "pkg_"^pkg] & S[A"-package"; A pkg];
             end 
             (find_packages ());
-  
+
           (* Like -package but for extensions syntax. Morover -syntax is useless
            * when linking. *)
           List.iter begin fun syntax ->
           flag ["ocaml"; "doc";      "syntax_"^syntax] & S[A"-syntax"; A syntax];
           flag ["ocaml"; "infer_interface"; "syntax_"^syntax] & S[A"-syntax"; A syntax];
           end (find_syntaxes ());
-  
+
           (* The default "thread" tag is not compatible with ocamlfind.
            * Indeed, the default rules add the "threads.cma" or "threads.cmxa"
            * options when using this tag. When using the "-linkpkg" option with
           flag ["ocaml"; "pkg_threads"; "doc"] (S[A "-I"; A "+threads"]);
           flag ["ocaml"; "pkg_threads"; "link"] (S[A "-thread"]);
           flag ["ocaml"; "pkg_threads"; "infer_interface"] (S[A "-thread"])
-  
+
       | _ -> 
           ()
-  
+
 end
 
 module MyOCamlbuildBase = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
+
   (** Base functions for writing myocamlbuild.ml
       @author Sylvain Le Gall
     *)
-  
-  
-  
+
+
+
   open Ocamlbuild_plugin
-  
+  module OC = Ocamlbuild_pack.Ocaml_compiler
+
   type dir = string 
   type file = string 
   type name = string 
   type tag = string 
-  
-# 55 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
-  
+
+# 56 "/home/jun/.share/projects/externals/oasis/_build/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
+
   type t =
       {
         lib_ocaml: (name * dir list) list;
         lib_c:     (name * dir * file list) list; 
         flags:     (tag list * (spec OASISExpr.choices)) list;
+        (* Replace the 'dir: include' from _tags by a precise interdepends in
+         * directory.
+         *)
+        includes:  (dir * dir list) list; 
       } 
-  
+
   let env_filename =
     Pathname.basename 
       BaseEnvLight.default_filename
-  
+
   let dispatch_combine lst =
     fun e ->
       List.iter 
         (fun dispatch -> dispatch e)
         lst 
-  
+
+  let tag_libstubs nm =
+    "use_lib"^nm^"_stubs"
+
+  let nm_libstubs nm =
+    nm^"_stubs"
+
   let dispatch t e = 
     let env = 
       BaseEnvLight.load 
                   Options.ext_lib, "ext_lib";
                   Options.ext_dll, "ext_dll";
                 ]
-  
+
         | After_rules -> 
             (* Declare OCaml libraries *)
             List.iter 
               (function
-                 | lib, [] ->
-                     ocaml_lib lib;
-                 | lib, dir :: tl ->
-                     ocaml_lib ~dir:dir lib;
+                 | nm, [] ->
+                     ocaml_lib nm
+                 | nm, dir :: tl ->
+                     ocaml_lib ~dir:dir (dir^"/"^nm);
                      List.iter 
                        (fun dir -> 
-                          flag 
-                            ["ocaml"; "use_"^lib; "compile"] 
-                            (S[A"-I"; P dir]))
+                          List.iter
+                            (fun str ->
+                               flag ["ocaml"; "use_"^nm; str] (S[A"-I"; P dir]))
+                            ["compile"; "infer_interface"; "doc"])
                        tl)
               t.lib_ocaml;
-  
+
+            (* Declare directories dependencies, replace "include" in _tags. *)
+            List.iter 
+              (fun (dir, include_dirs) ->
+                 Pathname.define_context dir include_dirs)
+              t.includes;
+
             (* Declare C libraries *)
             List.iter
               (fun (lib, dir, headers) ->
                    (* Handle C part of library *)
-                   flag ["link"; "library"; "ocaml"; "byte"; "use_lib"^lib]
-                     (S[A"-dllib"; A("-l"^lib); A"-cclib"; A("-l"^lib)]);
-  
-                   flag ["link"; "library"; "ocaml"; "native"; "use_lib"^lib]
-                     (S[A"-cclib"; A("-l"^lib)]);
+                   flag ["link"; "library"; "ocaml"; "byte"; tag_libstubs lib]
+                     (S[A"-dllib"; A("-l"^(nm_libstubs lib)); A"-cclib";
+                        A("-l"^(nm_libstubs lib))]);
+
+                   flag ["link"; "library"; "ocaml"; "native"; tag_libstubs lib]
+                     (S[A"-cclib"; A("-l"^(nm_libstubs lib))]);
                         
-                   flag ["link"; "program"; "ocaml"; "byte"; "use_lib"^lib]
-                     (S[A"-dllib"; A("dll"^lib)]);
-  
+                   flag ["link"; "program"; "ocaml"; "byte"; tag_libstubs lib]
+                     (S[A"-dllib"; A("dll"^(nm_libstubs lib))]);
+
                    (* When ocaml link something that use the C library, then one
                       need that file to be up to date.
                     *)
-                   dep  ["link"; "ocaml"; "program"; "use_lib"^lib]
-                     [dir/"lib"^lib^"."^(!Options.ext_lib)];
-  
-                   dep  ["compile"; "ocaml"; "program"; "use_lib"^lib]
-                     [dir/"lib"^lib^"."^(!Options.ext_lib)];
-  
+                   dep ["link"; "ocaml"; "program"; tag_libstubs lib]
+                     [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];
+
+                   dep  ["compile"; "ocaml"; "program"; tag_libstubs lib]
+                     [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];
+
                    (* TODO: be more specific about what depends on headers *)
                    (* Depends on .h files *)
                    dep ["compile"; "c"] 
                      headers;
-  
+
                    (* Setup search path for lib *)
                    flag ["link"; "ocaml"; "use_"^lib] 
                      (S[A"-I"; P(dir)]);
               )
               t.lib_c;
-  
+
               (* Add flags *)
               List.iter
               (fun (tags, cond_specs) ->
               t.flags
         | _ -> 
             ()
-  
+
   let dispatch_default t =
     dispatch_combine 
       [
         dispatch t;
         MyOCamlbuildFindlib.dispatch;
       ]
-  
+
 end
 
 
+# 476 "myocamlbuild.ml"
 open Ocamlbuild_plugin;;
 let package_default =
   {
      MyOCamlbuildBase.lib_ocaml =
        [
-          ("lib/sexplib", ["lib"]);
-          ("syntax/pa_sexp_conv", ["syntax"]);
-          ("top/sexplib_top", ["top"])
+          ("sexplib", ["lib"]);
+          ("pa_sexp_conv", ["syntax"]);
+          ("sexplib_top", ["top"])
        ];
      lib_c = [];
      flags = [];
+     includes = [("lib_test", ["lib"; "syntax"])];
      }
   ;;
 
 let dispatch_default = MyOCamlbuildBase.dispatch_default package_default;;
 
-# 472 "myocamlbuild.ml"
+# 495 "myocamlbuild.ml"
 (* OASIS_STOP *)
 
 Ocamlbuild_plugin.dispatch 

sexplib/sexplib-7.0.5/setup.ml

 (* setup.ml generated for the first time by OASIS v0.2.0 *)
 
 (* OASIS_START *)
-(* DO NOT EDIT (digest: 45e10b84ce2d3eaf3fd842c91210e92a) *)
+(* DO NOT EDIT (digest: 723311c0599efa0d3e7e74436ec9645f) *)
 (*
-   Regenerated by OASIS v0.3.0~rc2
+   Regenerated by OASIS v0.3.0
    Visit http://oasis.forge.ocamlcore.org for more information and
    documentation about functions used in this file.
 *)
 module OASISGettext = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISGettext.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISGettext.ml"
+
   let ns_ str =
     str
-  
+
   let s_ str =
     str
-  
+
   let f_ (str : ('a, 'b, 'c, 'd) format4) =
     str
-  
+
   let fn_ fmt1 fmt2 n =
     if n = 1 then
       fmt1^^""
     else
       fmt2^^""
-  
+
   let init =
     []
-  
+
 end
 
 module OASISContext = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISContext.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISContext.ml"
+
   open OASISGettext
-  
+
   type level =
     [ `Debug
     | `Info
     | `Warning
     | `Error]
-  
+
   type t =
     {
-      verbose:               bool;
+      quiet:                 bool;
+      info:                  bool;
       debug:                 bool;
       ignore_plugins:        bool;
       ignore_unknown_fields: bool;
       printf:                level -> string -> unit;
     }
-  
+
   let printf lvl str =
     let beg =
       match lvl with
         | `Debug -> s_ "D: "
     in
       prerr_endline (beg^str)
-  
+
   let default =
     ref
       {
-        verbose               = true;
+        quiet                 = false;
+        info                  = false;
         debug                 = false;
         ignore_plugins        = false;
         ignore_unknown_fields = false;
         printf                = printf;
       }
-  
+
   let quiet =
-    {!default with
-         verbose = false;
-         debug   = false;
-    }
-  
-  
+    {!default with quiet = true}
+
+
   let args () =
     ["-quiet",
-     Arg.Unit (fun () -> default := {!default with verbose = false}),
+     Arg.Unit (fun () -> default := {!default with quiet = true}),
      (s_ " Run quietly");
-  
+
+     "-info",
+     Arg.Unit (fun () -> default := {!default with info = true}),
+     (s_ " Display information message");
+
+
      "-debug",
      Arg.Unit (fun () -> default := {!default with debug = true}),
      (s_ " Output debug message")]
 end
 
+module OASISString = struct
+# 1 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISString.ml"
+
+
+
+  (** Various string utilities.
+     
+      Mostly inspired by extlib and batteries ExtString and BatString libraries.
+
+      @author Sylvain Le Gall
+    *)
+
+  let nsplitf str f =
+    if str = "" then
+      []
+    else
+      let buf = Buffer.create 13 in
+      let lst = ref [] in
+      let push () =
+        lst := Buffer.contents buf :: !lst;
+        Buffer.clear buf
+      in
+      let str_len = String.length str in
+        for i = 0 to str_len - 1 do
+          if f str.[i] then
+            push ()
+          else
+            Buffer.add_char buf str.[i]
+        done;
+        push ();
+        List.rev !lst
+
+  (** [nsplit c s] Split the string [s] at char [c]. It doesn't include the
+      separator.
+    *)
+  let nsplit str c =
+    nsplitf str ((=) c)
+
+  let find ~what ?(offset=0) str =
+    let what_idx = ref 0 in
+    let str_idx = ref offset in 
+      while !str_idx < String.length str && 
+            !what_idx < String.length what do
+        if str.[!str_idx] = what.[!what_idx] then
+          incr what_idx
+        else
+          what_idx := 0;
+        incr str_idx
+      done;
+      if !what_idx <> String.length what then
+        raise Not_found
+      else 
+        !str_idx - !what_idx
+
+  let sub_start str len = 
+    let str_len = String.length str in
+    if len >= str_len then
+      ""
+    else
+      String.sub str len (str_len - len)
+
+  let sub_end ?(offset=0) str len =
+    let str_len = String.length str in
+    if len >= str_len then
+      ""
+    else
+      String.sub str 0 (str_len - len)
+
+  let starts_with ~what ?(offset=0) str =
+    let what_idx = ref 0 in
+    let str_idx = ref offset in
+    let ok = ref true in
+      while !ok &&
+            !str_idx < String.length str && 
+            !what_idx < String.length what do
+        if str.[!str_idx] = what.[!what_idx] then
+          incr what_idx
+        else
+          ok := false;
+        incr str_idx
+      done;
+      if !what_idx = String.length what then
+        true
+      else 
+        false
+
+  let strip_starts_with ~what str =
+    if starts_with ~what str then
+      sub_start str (String.length what)
+    else
+      raise Not_found
+
+  let ends_with ~what ?(offset=0) str =
+    let what_idx = ref ((String.length what) - 1) in
+    let str_idx = ref ((String.length str) - 1) in
+    let ok = ref true in
+      while !ok &&
+            offset <= !str_idx && 
+            0 <= !what_idx do
+        if str.[!str_idx] = what.[!what_idx] then
+          decr what_idx
+        else
+          ok := false;
+        decr str_idx
+      done;
+      if !what_idx = -1 then
+        true
+      else 
+        false
+
+  let strip_ends_with ~what str =
+    if ends_with ~what str then
+      sub_end str (String.length what)
+    else
+      raise Not_found
+
+  let replace_chars f s =
+    let buf = String.make (String.length s) 'X' in
+      for i = 0 to String.length s - 1 do
+        buf.[i] <- f s.[i]
+      done;
+      buf
+
+end
+
 module OASISUtils = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISUtils.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISUtils.ml"
+
   open OASISGettext
-  
+
   module MapString = Map.Make(String)
-  
+
   let map_string_of_assoc assoc =
     List.fold_left
       (fun acc (k, v) -> MapString.add k v acc)
       MapString.empty
       assoc
-  
+
   module SetString = Set.Make(String)
-  
+
   let set_string_add_list st lst =
     List.fold_left
       (fun acc e -> SetString.add e acc)
       st
       lst
-  
+
   let set_string_of_list =
     set_string_add_list
       SetString.empty
-  
-  
+
+
   let compare_csl s1 s2 =
     String.compare (String.lowercase s1) (String.lowercase s2)
-  
+
   module HashStringCsl =
     Hashtbl.Make
       (struct
          type t = string
-  
+
          let equal s1 s2 =
              (String.lowercase s1) = (String.lowercase s2)
-  
+
          let hash s =
            Hashtbl.hash (String.lowercase s)
        end)
-  
-  let split sep str =
-    let str_len =
-      String.length str
-    in
-    let rec split_aux acc pos =
-      if pos < str_len then
-        (
-          let pos_sep =
-            try
-              String.index_from str pos sep
-            with Not_found ->
-              str_len
-          in
-          let part =
-            String.sub str pos (pos_sep - pos)
-          in
-          let acc =
-            part :: acc
-          in
-            if pos_sep >= str_len then
-              (
-                (* Nothing more in the string *)
-                List.rev acc
-              )
-            else if pos_sep = (str_len - 1) then
-              (
-                (* String end with a separator *)
-                List.rev ("" :: acc)
-              )
-            else
-              (
-                split_aux acc (pos_sep + 1)
-              )
-        )
-      else
-        (
-          List.rev acc
-        )
-    in
-      split_aux [] 0
-  
-  
+
   let varname_of_string ?(hyphen='_') s =
     if String.length s = 0 then
       begin
       end
     else
       begin
-        let buff =
-          Buffer.create (String.length s)
-        in
-          (* Start with a _ if digit *)
-          if '0' <= s.[0] && s.[0] <= '9' then
-            Buffer.add_char buff hyphen;
-  
-          String.iter
+        let buf =
+          OASISString.replace_chars
             (fun c ->
                if ('a' <= c && c <= 'z')
                  ||
                   ('A' <= c && c <= 'Z')
                  ||
                   ('0' <= c && c <= '9') then
-                 Buffer.add_char buff c
+                 c
                else
-                 Buffer.add_char buff hyphen)
+                 hyphen)
             s;
-  
-          String.lowercase (Buffer.contents buff)
+        in
+        let buf =
+          (* Start with a _ if digit *)
+          if '0' <= s.[0] && s.[0] <= '9' then
+            "_"^buf
+          else
+            buf
+        in
+          String.lowercase buf
       end
-  
+
   let varname_concat ?(hyphen='_') p s =
+    let what = String.make 1 hyphen in
     let p =
-      let p_len =
-        String.length p
-      in
-        if p_len > 0 && p.[p_len - 1] = hyphen then
-          String.sub p 0 (p_len - 1)
-        else
-          p
+      try
+        OASISString.strip_ends_with ~what p
+      with Not_found ->
+        p
     in
     let s =
-      let s_len =
-        String.length s
-      in
-        if s_len > 0 && s.[0] = hyphen then
-          String.sub s 1 (s_len - 1)
-        else
-          s
+      try
+        OASISString.strip_starts_with ~what s
+      with Not_found ->
+        s
     in
-      Printf.sprintf "%s%c%s" p hyphen s
-  
-  
+      p^what^s
+
+
   let is_varname str =
     str = varname_of_string str
-  
+
   let failwithf fmt = Printf.ksprintf failwith fmt
-  
+
 end
 
 module PropList = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/PropList.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/PropList.ml"
+
   open OASISGettext
-  
+
   type name = string
-  
+
   exception Not_set of name * string option
   exception No_printer of name
   exception Unknown_field of name * name
-  
+
   let () =
     Printexc.register_printer
       (function
                (Printf.sprintf (f_ "Field %s is not defined in schema %s") nm schm)
          | _ ->
              None)
-  
+
   module Data =
   struct
-  
+
     type t =
         (name, unit -> unit) Hashtbl.t
-  
+
     let create () =
       Hashtbl.create 13
-  
+
     let clear t =
       Hashtbl.clear t
-  
-# 71 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/PropList.ml"
+
+# 71 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/PropList.ml"
   end
-  
+
   module Schema =
   struct
-  
+
     type ('ctxt, 'extra) value =
         {
           get:   Data.t -> string;
           help:  (unit -> string) option;
           extra: 'extra;
         }
-  
+
     type ('ctxt, 'extra) t =
         {
           name:      name;
           order:     name Queue.t;
           name_norm: string -> string;
         }
-  
+
     let create ?(case_insensitive=false) nm =
       {
         name      = nm;
            else
              fun s -> s);
       }
-  
+
     let add t nm set get extra help =
       let key =
         t.name_norm nm
       in
-  
+
         if Hashtbl.mem t.fields key then
           failwith
             (Printf.sprintf
             extra = extra;
           };
         Queue.add nm t.order
-  
+
     let mem t nm =
       Hashtbl.mem t.fields nm
-  
+
     let find t nm =
       try
         Hashtbl.find t.fields (t.name_norm nm)
       with Not_found ->
         raise (Unknown_field (nm, t.name))
-  
+
     let get t data nm =
       (find t nm).get data
-  
+
     let set t data nm ?context x =
       (find t nm).set
         data
         ?context
         x
-  
+
     let fold f acc t =
       Queue.fold
         (fun acc k ->
              f acc k v.extra v.help)
         acc
         t.order
-  
+
     let iter f t =
       fold
         (fun () -> f)
         ()
         t
-  
+
     let name t =
       t.name
   end
-  
+
   module Field =
   struct
-  
+
     type ('ctxt, 'value, 'extra) t =
         {
           set:    Data.t -> ?context:'ctxt -> 'value -> unit;
           help:   (unit -> string) option;
           extra:  'extra;
         }
-  
+
     let new_id =
       let last_id =
         ref 0
       in
         fun () -> incr last_id; !last_id
-  
+
     let create ?schema ?name ?parse ?print ?default ?update ?help extra =
       (* Default value container *)
       let v =
         ref None
       in
-  
+
       (* If name is not given, create unique one *)
       let nm =
         match name with
           | Some s -> s
           | None -> Printf.sprintf "_anon_%d" (new_id ())
       in
-  
+
       (* Last chance to get a value: the default *)
       let default () =
         match default with
           | Some d -> d
           | None -> raise (Not_set (nm, Some (s_ "no default value")))
       in
-  
+
       (* Get data *)
       let get data =
         (* Get value *)
         with Not_found ->
           default ()
       in
-  
+
       (* Set data *)
       let set data ?context x =
         let x =
             nm
             (fun () -> v := Some x)
       in
-  
+
       (* Parse string value, if possible *)
       let parse =
         match parse with
                      nm
                      s)
       in
-  
+
       (* Set data, from string *)
       let sets data ?context s =
         set ?context data (parse ?context s)
       in
-  
+
       (* Output value as string, if possible *)
       let print =
         match print with
           | None ->
               fun _ -> raise (No_printer nm)
       in
-  
+
       (* Get data, as a string *)
       let gets data =
         print (get data)
       in
-  
+
         begin
           match schema with
             | Some t ->
             | None ->
                 ()
         end;
-  
+
         {
           set   = set;
           get   = get;
           help  = help;
           extra = extra;
         }
-  
+
     let fset data t ?context x =
       t.set data ?context x
-  
+
     let fget data t =
       t.get data
-  
+
     let fsets data t ?context s =
       t.sets data ?context s
-  
+
     let fgets data t =
       t.gets data
-  
+
   end
-  
+
   module FieldRO =
   struct
-  
+
     let create ?schema ?name ?parse ?print ?default ?update ?help extra =
       let fld =
         Field.create ?schema ?name ?parse ?print ?default ?update ?help extra
       in
         fun data -> Field.fget data fld
-  
+
   end
 end
 
 module OASISMessage = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISMessage.ml"
-  
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISMessage.ml"
+
+
   open OASISGettext
   open OASISContext
-  
+
   let generic_message ~ctxt lvl fmt =
     let cond =
-      match lvl with
-        | `Debug -> ctxt.debug
-        | _ -> ctxt.verbose
+      if ctxt.quiet then
+        false
+      else
+        match lvl with
+          | `Debug -> ctxt.debug
+          | `Info  -> ctxt.info
+          | _ -> true
     in
       Printf.ksprintf
         (fun str ->
                ctxt.printf lvl str
              end)
         fmt
-  
+
   let debug ~ctxt fmt =
     generic_message ~ctxt `Debug fmt
-  
+
   let info ~ctxt fmt =
     generic_message ~ctxt `Info fmt
-  
+
   let warning ~ctxt fmt =
     generic_message ~ctxt `Warning fmt
-  
+
   let error ~ctxt fmt =
     generic_message ~ctxt `Error fmt
-  
+
 end
 
 module OASISVersion = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISVersion.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISVersion.ml"
+
   open OASISGettext
-  
-  
-  
+
+
+
   type s = string
-  
+
   type t = string 
-  
+
   type comparator =
     | VGreater of t
     | VGreaterEqual of t
     | VOr of  comparator * comparator
     | VAnd of comparator * comparator
     
-  
+
   (* Range of allowed characters *)
   let is_digit c =
     '0' <= c && c <= '9'
-  
+
   let is_alpha c =
     ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')
-  
+
   let is_special =
     function
       | '.' | '+' | '-' | '~' -> true
       | _ -> false
-  
+
   let rec version_compare v1 v2 =
     if v1 <> "" || v2 <> "" then
       begin
           else if is_alpha c then Char.code c
           else (Char.code c) + 256
         in
-  
+
         let len1 = String.length v1 in
         let len2 = String.length v2 in
-  
+
         let p = ref 0 in
-  
+
         (** Compare ascii part *)
         let compare_vascii () =
           let cmp = ref 0 in
           else
             !cmp
         in
-  
+
         (** Compare digit part *)
         let compare_digit () =
           let extract_int v p =
           let i2, tl2 = extract_int v2 (ref !p) in
             i1 - i2, tl1, tl2
         in
-  
+
           match compare_vascii () with
             | 0 ->
                 begin
       begin
         0
       end
-  
-  
-  let version_of_string str =
-    String.iter
-      (fun c ->
-         if is_alpha c || is_digit c || is_special c then
-           ()
-         else
-           failwith
-             (Printf.sprintf
-                (f_ "Char %C is not allowed in version '%s'")
-                c str))
-      str;
-    str
-  
-  let string_of_version t =
-    t
-  
+
+
+  let version_of_string str = str
+
+  let string_of_version t = t
+
   let chop t =
     try
       let pos =
         String.sub t 0 pos
     with Not_found ->
       t
-  
+
   let rec comparator_apply v op =
     match op with
       | VGreater cv ->
           (comparator_apply v op1) || (comparator_apply v op2)
       | VAnd (op1, op2) ->
           (comparator_apply v op1) && (comparator_apply v op2)
-  
+
   let rec string_of_comparator =
     function
       | VGreater v  -> "> "^(string_of_version v)
           (string_of_comparator c1)^" || "^(string_of_comparator c2)
       | VAnd (c1, c2) ->
           (string_of_comparator c1)^" && "^(string_of_comparator c2)
-  
+
   let rec varname_of_comparator =
     let concat p v =
       OASISUtils.varname_concat
             (varname_of_comparator c1)^"_or_"^(varname_of_comparator c2)
         | VAnd (c1, c2) ->
             (varname_of_comparator c1)^"_and_"^(varname_of_comparator c2)
-  
+
+  let version_0_3_or_after t =
+    comparator_apply t (VGreaterEqual (string_of_version "0.3"))
+
 end
 
 module OASISLicense = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISLicense.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISLicense.ml"
+
   (** License for _oasis fields
       @author Sylvain Le Gall
     *)
-  
-  
-  
+
+
+
   type license = string 
-  
+
   type license_exception = string 
-  
+
   type license_version =
     | Version of OASISVersion.t
     | VersionOrLater of OASISVersion.t
     | NoVersion
     
-  
+
+  type license_dep_5_unit =
+    {
+      license:   license;
+      excption:  license_exception option;
+      version:   license_version;
+    }
+    
+
   type license_dep_5 =
-      {
-        license:    license;
-        exceptions: license_exception list;
-        version:    license_version;
-      } 
-  
+    | DEP5Unit of license_dep_5_unit
+    | DEP5Or of license_dep_5 list
+    | DEP5And of license_dep_5 list
+    
+
   type t =
     | DEP5License of license_dep_5
     | OtherLicense of string (* URL *)
     
-  
+
 end
 
 module OASISExpr = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISExpr.ml"
-  
-  
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISExpr.ml"
+
+
+
   open OASISGettext
-  
+
   type test = string 
-  
+
   type flag = string 
-  
+
   type t =
     | EBool of bool
     | ENot of t
     | EFlag of flag
     | ETest of test * string
     
-  
+
   type 'a choices = (t * 'a) list 
-  
+
   let eval var_get t =
     let rec eval' =
       function
         | EBool b ->
             b
-  
+
         | ENot e ->
             not (eval' e)
-  
+
         | EAnd (e1, e2) ->
             (eval' e1) && (eval' e2)
-  
+
         | EOr (e1, e2) ->
             (eval' e1) || (eval' e2)
-  
+
         | EFlag nm ->
             let v =
               var_get nm
             in
               assert(v = "true" || v = "false");
               (v = "true")
-  
+
         | ETest (nm, vl) ->
             let v =
               var_get nm
               (v = vl)
     in
       eval' t
-  
+
   let choose ?printer ?name var_get lst =
     let rec choose_aux =
       function
                          str_lst)
     in
       choose_aux (List.rev lst)
-  
+
 end
 
 module OASISTypes = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISTypes.ml"
-  
-  
-  
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISTypes.ml"
+
+
+
+
   type name          = string 
   type package_name  = string 
   type url           = string 
   type arg           = string 
   type args          = string list 
   type command_line  = (prog * arg list) 
-  
+
   type findlib_name = string 
   type findlib_full = string 
-  
+
   type compiled_object =
     | Byte
     | Native
     | Best
     
-  
+
   type dependency =
     | FindlibPackage of findlib_full * OASISVersion.comparator option
     | InternalLibrary of name
     
-  
+
   type tool =
     | ExternalTool of name
     | InternalExecutable of name
     
-  
+
   type vcs =
     | Darcs
     | Git
     | Monotone
     | OtherVCS of url
     
-  
+
   type plugin_kind =
       [  `Configure
        | `Build
        | `Install
        | `Extra
       ]
-  
+
   type plugin_data_purpose =
       [  `Configure
        | `Build
        | `Extra
        | `Other of string
       ]
-  
+
   type 'a plugin = 'a * name * OASISVersion.t option 
-  
+
   type all_plugin = plugin_kind plugin
-  
+
   type plugin_data = (all_plugin * plugin_data_purpose * (unit -> unit)) list
-  
-# 102 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISTypes.ml"
-  
+
+# 102 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISTypes.ml"
+
   type 'a conditional = 'a OASISExpr.choices 
-  
+
   type custom =
       {
         pre_command:  (command_line option) conditional;
         post_command: (command_line option) conditional;
       }
       
-  
+
   type common_section =
       {
         cs_name: name;
         cs_plugin_data: plugin_data;
       }
       
-  
+
   type build_section =
       {
         bs_build:           bool conditional;
         bs_nativeopt:       args conditional;
       }
       
-  
+
   type library =
       {
         lib_modules:            string list;
         lib_findlib_name:       findlib_name option;
         lib_findlib_containers: findlib_name list;
       } 
-  
+
   type executable =
       {
         exec_custom:          bool;
         exec_main_is:         unix_filename;
       } 
-  
+
   type flag =
       {
         flag_description:  string option;
         flag_default:      bool conditional;
       } 
-  
+
   type source_repository =
       {
         src_repo_type:        vcs;
         src_repo_tag:         string option;
         src_repo_subdir:      unix_filename option;
       } 
-  
+
   type test =
       {
         test_type:               [`Test] plugin;
         test_run:                bool conditional;
         test_tools:              tool list;
       } 
-  
+
   type doc_format =
     | HTML of unix_filename
     | DocText
     | DVI
     | OtherDoc
     
-  
+
   type doc =
       {
         doc_type:        [`Doc] plugin;
         doc_data_files:  (unix_filename * unix_filename option) list;
         doc_build_tools: tool list;
       } 
-  
+
   type section =
     | Library    of common_section * build_section * library
     | Executable of common_section * build_section * executable
     | Test       of common_section * test
     | Doc        of common_section * doc
     
-  
+
   type section_kind =
       [ `Library | `Executable | `Flag | `SrcRepo | `Test | `Doc ]
-  
+
   type package = 
       {
         oasis_version:    OASISVersion.t;
         synopsis:         string;
         description:      string option;
         categories:       url list;
-  
+
         conf_type:        [`Configure] plugin;
         conf_custom:      custom;
-  
+
         build_type:       [`Build] plugin;
         build_custom:     custom;
-  
+
         install_type:     [`Install] plugin;
         install_custom:   custom;
         uninstall_custom: custom;
-  
+
         clean_custom:     custom;
         distclean_custom: custom;
-  
+
         files_ab:         unix_filename list;
         sections:         section list;
         plugins:          [`Extra] plugin list;
         schema_data:      PropList.Data.t;
         plugin_data:      plugin_data;
       } 
-  
+
 end
 
 module OASISUnixPath = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISUnixPath.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISUnixPath.ml"
+
   type unix_filename = string
   type unix_dirname = string
-  
+
   type host_filename = string
   type host_dirname = string
-  
+
   let current_dir_name = "."
-  
+
   let parent_dir_name = ".."
-  
+
+  let is_current_dir fn =
+    fn = current_dir_name || fn = ""
+
   let concat f1 f2 =
-    if f1 = current_dir_name then
+    if is_current_dir f1 then
       f2
-    else if f2 = current_dir_name then
-      f1
     else
-      f1^"/"^f2
-  
+      let f1' =
+        try OASISString.strip_ends_with ~what:"/" f1 with Not_found -> f1
+      in
+        f1'^"/"^f2
+
   let make =
     function
       | hd :: tl ->
             tl
       | [] ->
           invalid_arg "OASISUnixPath.make"
-  
+
   let dirname f =
     try
       String.sub f 0 (String.rindex f '/')
     with Not_found ->
       current_dir_name
-  
+
   let basename f =
     try
       let pos_start =
         String.sub f pos_start ((String.length f) - pos_start)
     with Not_found ->
       f
-  
+
   let chop_extension f =
     try
       let last_dot =
               f
         with Not_found ->
           sub
-  
+
     with Not_found ->
       f
-  
+
   let capitalize_file f =
     let dir = dirname f in
     let base = basename f in
     concat dir (String.capitalize base)
-  
+
   let uncapitalize_file f =
     let dir = dirname f in
     let base = basename f in
     concat dir (String.uncapitalize base)
+
 end
 
+module OASISHostPath = struct
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISHostPath.ml"
+
+
+  open Filename
+
+  module Unix = OASISUnixPath
+
+  let make =
+    function
+      | [] ->
+          invalid_arg "OASISHostPath.make"
+      | hd :: tl ->
+          List.fold_left Filename.concat hd tl
+
+  let of_unix ufn =
+    if Sys.os_type = "Unix" then
+      ufn
+    else
+      make
+        (List.map
+           (fun p ->
+              if p = Unix.current_dir_name then
+                current_dir_name
+              else if p = Unix.parent_dir_name then
+                parent_dir_name
+              else
+                p)
+           (OASISString.nsplit ufn '/'))
+
+
+end
+
 module OASISSection = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISSection.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISSection.ml"
+
   open OASISTypes
-  
+
   let section_kind_common = 
     function
       | Library (cs, _, _) -> 
           `Test, cs
       | Doc (cs, _) ->
           `Doc, cs
-  
+
   let section_common sct =
     snd (section_kind_common sct)
-  
+
   let section_common_set cs =
     function
       | Library (_, bs, lib)     -> Library (cs, bs, lib)
       | SrcRepo (_, src_repo)    -> SrcRepo (cs, src_repo)
       | Test (_, tst)            -> Test (cs, tst)
       | Doc (_, doc)             -> Doc (cs, doc)
-  
+
   (** Key used to identify section
     *)
   let section_id sct = 
       section_kind_common sct
     in
       k, cs.cs_name
-  
+
   let string_of_section sct =
     let k, nm =
       section_id sct
          | `Test       -> "test"
          | `Doc        -> "doc")
       ^" "^nm
-  
+
+  let section_find id scts =
+    List.find
+      (fun sct -> id = section_id sct)
+      scts
+
+  module CSection =
+  struct
+    type t = section
+
+    let id = section_id
+
+    let compare t1 t2 = 
+      compare (id t1) (id t2)
+      
+    let equal t1 t2 =
+      (id t1) = (id t2)
+
+    let hash t =
+      Hashtbl.hash (id t)
+  end
+
+  module MapSection = Map.Make(CSection)
+  module SetSection = Set.Make(CSection)
+
 end
 
 module OASISBuildSection = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISBuildSection.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISBuildSection.ml"
+
 end
 
 module OASISExecutable = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISExecutable.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISExecutable.ml"
+
   open OASISTypes
-  
+
   let unix_exec_is (cs, bs, exec) is_native ext_dll suffix_program = 
     let dir = 
       OASISUnixPath.concat
         | Best -> is_native ()
         | Byte -> false
     in
-  
+
       OASISUnixPath.concat
         dir
         (cs.cs_name^(suffix_program ())),
-  
+
       if not is_native_exec && 
          not exec.exec_custom && 
          bs.bs_c_sources <> [] then
-        Some (dir^"/dll"^cs.cs_name^(ext_dll ()))
+        Some (dir^"/dll"^cs.cs_name^"_stubs"^(ext_dll ()))
       else
         None
-  
+
 end
 
 module OASISLibrary = struct
-# 21 "/Users/mmottl/Downloads/oasis-0.3.0~rc2/src/oasis/OASISLibrary.ml"
-  
+# 21 "/home/jun/.share/projects/externals/oasis/_build/src/oasis/OASISLibrary.ml"
+
   open OASISTypes
   open OASISUtils
   open OASISGettext
-  
+  open OASISSection
+
   type library_name = name
-  
+  type findlib_part_name = name
+  type 'a map_of_findlib_part_name = 'a OASISUtils.MapString.t
+
+  exception InternalLibraryNotFound of library_name
+  exception FindlibPackageNotFound of findlib_name
+
+  type group_t =
+    | Container of findlib_name * group_t list
+    | Package of (findlib_name *
+                  common_section *
+                  build_section *
+                  library *
+                  group_t list)
+
   (* Look for a module file, considering capitalization or not. *)
   let find_module source_file_exists (cs, bs, lib) modul =
     let possible_base_fn =
                  acc)
         (`No_sources possible_base_fn)
         possible_base_fn
-  
+
   let source_unix_files ~ctxt (cs, bs, lib) source_file_exists =
     List.fold_left
       (fun acc modul ->