Commits

Anonymous committed d52eed5

new oasis -> new {setup,myocamlbuild,_tags}.ml

  • Participants
  • Parent commits 9fdf90f

Comments (0)

Files changed (4)

 # OASIS_START
-# DO NOT EDIT (digest: 44fd8523ebb5be5f5ce5d4ee0525938a)
+# DO NOT EDIT (digest: e9f8754f50e41bdcd60e345f12919319)
 # 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 amall
-"src": include
-<src/amall.{cma,cmxa}>: oasis_library_amall_byte
-<src/*.ml{,i}>: oasis_library_amall_byte
-<src/amall.{cma,cmxa}>: oasis_library_amall_native
-<src/*.ml{,i}>: oasis_library_amall_native
+"src/amall.cmxs": use_amall
+<src/*.ml{,i}>: pkg_iteratees
+<src/*.ml{,i}>: pkg_monad_io.lwt
+<src/*.ml{,i}>: pkg_cadastr
+<src/*.ml{,i}>: pkg_cryptokit
 <src/*.ml{,i}>: pkg_unix
-<src/*.ml{,i}>: pkg_monad_io.lwt
 <src/*.ml{,i}>: pkg_monad_io
-<src/*.ml{,i}>: pkg_iteratees
-<src/*.ml{,i}>: pkg_cryptokit
-<src/*.ml{,i}>: pkg_cadastr
 # Library amall_dbi
-"src/dbi": include
-<src/dbi/amall_dbi.{cma,cmxa}>: oasis_library_amall_dbi_byte
-<src/dbi/*.ml{,i}>: oasis_library_amall_dbi_byte
-<src/dbi/amall_dbi.{cma,cmxa}>: oasis_library_amall_dbi_native
-<src/dbi/*.ml{,i}>: oasis_library_amall_dbi_native
+"src/dbi/amall_dbi.cmxs": use_amall_dbi
 <src/dbi/*.ml{,i}>: use_amall
+<src/dbi/*.ml{,i}>: pkg_iteratees
+<src/dbi/*.ml{,i}>: pkg_monad_io.lwt
+<src/dbi/*.ml{,i}>: pkg_cadastr
+<src/dbi/*.ml{,i}>: pkg_cryptokit
 <src/dbi/*.ml{,i}>: pkg_unix
+<src/dbi/*.ml{,i}>: pkg_postgresql
 <src/dbi/*.ml{,i}>: pkg_threads
-<src/dbi/*.ml{,i}>: pkg_postgresql
-<src/dbi/*.ml{,i}>: pkg_monad_io.lwt
 <src/dbi/*.ml{,i}>: pkg_monad_io
-<src/dbi/*.ml{,i}>: pkg_iteratees
-<src/dbi/*.ml{,i}>: pkg_cryptokit
-<src/dbi/*.ml{,i}>: pkg_cadastr
 # Executable test_uri
-<tests/test_uri.{native,byte}>: oasis_executable_test_uri_byte
-<tests/*.ml{,i}>: oasis_executable_test_uri_byte
-<tests/test_uri.{native,byte}>: oasis_executable_test_uri_native
-<tests/*.ml{,i}>: oasis_executable_test_uri_native
 <tests/test_uri.{native,byte}>: pkg_cadastr
+# Executable test_http_service
+<tests/test_http_service.{native,byte}>: pkg_iteratees
+<tests/test_http_service.{native,byte}>: pkg_monad_io.lwt
+<tests/test_http_service.{native,byte}>: pkg_cadastr
+<tests/test_http_service.{native,byte}>: pkg_cryptokit
 # Executable test_websocket_service
-<tests/test_websocket_service.{native,byte}>: oasis_executable_test_websocket_service_byte
-<tests/*.ml{,i}>: oasis_executable_test_websocket_service_byte
-<tests/test_websocket_service.{native,byte}>: oasis_executable_test_websocket_service_native
-<tests/*.ml{,i}>: oasis_executable_test_websocket_service_native
+<tests/test_websocket_service.{native,byte}>: pkg_iteratees
 <tests/test_websocket_service.{native,byte}>: pkg_monad_io.lwt
-<tests/test_websocket_service.{native,byte}>: pkg_iteratees
+<tests/test_websocket_service.{native,byte}>: pkg_cadastr
 <tests/test_websocket_service.{native,byte}>: pkg_cryptokit
 <tests/test_websocket_service.{native,byte}>: pkg_cadastr.json
-<tests/test_websocket_service.{native,byte}>: pkg_cadastr
+<tests/*.ml{,i}>: pkg_iteratees
+<tests/*.ml{,i}>: pkg_monad_io.lwt
+<tests/*.ml{,i}>: pkg_cadastr
+<tests/*.ml{,i}>: pkg_cryptokit
 <tests/*.ml{,i}>: pkg_cadastr.json
-# Executable test_http_service
-<tests/test_http_service.{native,byte}>: oasis_executable_test_http_service_byte
-<tests/*.ml{,i}>: oasis_executable_test_http_service_byte
-<tests/test_http_service.{native,byte}>: oasis_executable_test_http_service_native
-<tests/*.ml{,i}>: oasis_executable_test_http_service_native
-<tests/test_http_service.{native,byte}>: pkg_monad_io.lwt
-<tests/test_http_service.{native,byte}>: pkg_iteratees
-<tests/test_http_service.{native,byte}>: pkg_cryptokit
-<tests/test_http_service.{native,byte}>: pkg_cadastr
-<tests/*.ml{,i}>: pkg_monad_io.lwt
-<tests/*.ml{,i}>: pkg_iteratees
-<tests/*.ml{,i}>: pkg_cryptokit
-<tests/*.ml{,i}>: pkg_cadastr
 # OASIS_STOP
 
 <src/*.ml{,i}> : camlp4r
 (* OASIS_START *)
-(* DO NOT EDIT (digest: 83f6e5402313a619ce46e4b6b8e6c47d) *)
+(* DO NOT EDIT (digest: fc932406aa9869fa792b1797b9622242) *)
 module OASISGettext = struct
-# 21 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISGettext.ml"
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISExpr.ml"
-  
-  
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/base/BaseEnvLight.ml"
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/plugins/ocamlbuild/MyOCamlbuildFindlib.ml"
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
-  
+
+(* # 56 "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"; "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 =
-       [("src/amall", ["src"]); ("src/dbi/amall_dbi", ["src/dbi"])];
+       [("amall", ["src"]); ("amall_dbi", ["src/dbi"])];
      lib_c = [];
-     flags =
-       [
-          (["oasis_library_amall_byte"; "ocaml"; "link"; "byte"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_native"; "ocaml"; "link"; "native"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_byte"; "ocaml"; "ocamldep"; "byte"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_native"; "ocaml"; "ocamldep"; "native"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_byte"; "ocaml"; "compile"; "byte"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_native"; "ocaml"; "compile"; "native"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_dbi_byte"; "ocaml"; "link"; "byte"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_dbi_native"; "ocaml"; "link"; "native"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_dbi_byte"; "ocaml"; "ocamldep"; "byte"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_dbi_native"; "ocaml"; "ocamldep"; "native"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_dbi_byte"; "ocaml"; "compile"; "byte"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_library_amall_dbi_native"; "ocaml"; "compile"; "native"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_executable_test_uri_byte"; "ocaml"; "link"; "byte"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_executable_test_uri_native"; "ocaml"; "link"; "native"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_executable_test_uri_byte"; "ocaml"; "ocamldep"; "byte"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_executable_test_uri_native"; "ocaml"; "ocamldep"; "native"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_executable_test_uri_byte"; "ocaml"; "compile"; "byte"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          (["oasis_executable_test_uri_native"; "ocaml"; "compile"; "native"],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_websocket_service_byte";
-              "ocaml";
-              "link";
-              "byte"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_websocket_service_native";
-              "ocaml";
-              "link";
-              "native"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_websocket_service_byte";
-              "ocaml";
-              "ocamldep";
-              "byte"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_websocket_service_native";
-              "ocaml";
-              "ocamldep";
-              "native"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_websocket_service_byte";
-              "ocaml";
-              "compile";
-              "byte"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_websocket_service_native";
-              "ocaml";
-              "compile";
-              "native"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_http_service_byte";
-              "ocaml";
-              "link";
-              "byte"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_http_service_native";
-              "ocaml";
-              "link";
-              "native"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_http_service_byte";
-              "ocaml";
-              "ocamldep";
-              "byte"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_http_service_native";
-              "ocaml";
-              "ocamldep";
-              "native"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_http_service_byte";
-              "ocaml";
-              "compile";
-              "byte"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])]);
-          ([
-              "oasis_executable_test_http_service_native";
-              "ocaml";
-              "compile";
-              "native"
-           ],
-            [(OASISExpr.EBool true, S [A "-w"; A "A"])])
-       ];
-     }
+     flags = [];
+     includes = [("src/dbi", ["src"])]
+  }
   ;;
 
 let dispatch_default = MyOCamlbuildBase.dispatch_default package_default;;
 
+# 491 "myocamlbuild.ml"
 (* OASIS_STOP *)
 Ocamlbuild_plugin.dispatch dispatch_default;;
 (* setup.ml generated for the first time by OASIS v0.2.1~alpha1 *)
 
 (* OASIS_START *)
-(* DO NOT EDIT (digest: 2e0f67ef16980077a6fccb082d6d1755) *)
+(* DO NOT EDIT (digest: cd037f6a769249f0a79fd0d9154fe3f8) *)
 (*
-   Regenerated by OASIS v0.2.1~alpha1
+   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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISGettext.ml"
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISContext.ml"
-  
+(* # 21 "src/oasis/OASISContext.ml" *)
+
   open OASISGettext
-  
+
   type level =
     [ `Debug
     | `Info
     | `Warning
     | `Error]
-  
+
   type t =
     {
-      verbose:        bool;
-      debug:          bool;
-      ignore_plugins: bool;
-      printf:         level -> string -> unit;
+      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;
-        debug          = false;
-        ignore_plugins = false;
-        printf         = printf;
+        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 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISUtils.ml"
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/PropList.ml"
-  
+(* # 21 "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 string_of_exception =
-    function
-      | Not_set (nm, Some rsn) ->
-          Printf.sprintf (f_ "Field '%s' is not set: %s") nm rsn
-      | Not_set (nm, None) ->
-          Printf.sprintf (f_ "Field '%s' is not set") nm
-      | No_printer nm ->
-          Printf.sprintf (f_ "No default printer for value %s") nm
-      | Unknown_field (nm, schm) ->
-          Printf.sprintf (f_ "Field %s is not defined in schema %s") nm schm
-      | e ->
-          raise e
-  
+
+  let () =
+    Printexc.register_printer
+      (function
+         | Not_set (nm, Some rsn) ->
+             Some 
+               (Printf.sprintf (f_ "Field '%s' is not set: %s") nm rsn)
+         | Not_set (nm, None) ->
+             Some 
+               (Printf.sprintf (f_ "Field '%s' is not set") nm)
+         | No_printer nm ->
+             Some
+               (Printf.sprintf (f_ "No default printer for value %s") nm)
+         | Unknown_field (nm, schm) ->
+             Some 
+               (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
-  
-# 66 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/PropList.ml"
+
+(* # 71 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISMessage.ml"
-  
-  
+(* # 21 "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
-  
-  
-  let string_of_exception e =
-    try
-      PropList.string_of_exception e
-    with
-      | Failure s ->
-          s
-      | e ->
-          Printexc.to_string e
-  
-  (* TODO
-  let register_exn_printer f =
-   *)
-  
+
 end
 
 module OASISVersion = struct
-# 21 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISVersion.ml"
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISLicense.ml"
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISExpr.ml"
-  
-  
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISTypes.ml"
-  
-  
-  
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISTypes.ml"
-  
+
+(* # 102 "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_pack:               bool;
         lib_internal_modules:   string list;
         lib_findlib_parent:     findlib_name option;
         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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISUnixPath.ml"
-  
+(* # 21 "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 "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
-# 1 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISSection.ml"
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISBuildSection.ml"
-  
+(* # 21 "src/oasis/OASISBuildSection.ml" *)
+
 end
 
 module OASISExecutable = struct
-# 21 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISExecutable.ml"
-  
+(* # 21 "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 "/home/gds/dev/ovm/work312/src/oasis/work/src/oasis/OASISLibrary.ml"
-  
+(* # 21 "src/oasis/OASISLibrary.ml" *)
+
   open OASISTypes
   open OASISUtils
   open OASISGettext
-  
+  open OASISSection
+
   type library_name = name
-  
-  let generated_unix_files ~ctxt (cs, bs, lib)
-        source_file_exists is_native ext_lib ext_dll =
+  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 =
+      List.map
+        (OASISUnixPath.concat bs.bs_path)
+        [modul;
+         OASISUnixPath.uncapitalize_file modul;
+         OASISUnixPath.capitalize_file modul]
+    in
+      (* TODO: we should be able to be able to determine the source for every
+       * files. Hence we should introduce a Module(source: fn) for the fields
+       * Modules and InternalModules
+       *)
+      List.fold_left
+        (fun acc base_fn ->
+           match acc with
+             | `No_sources _ ->
+                 begin
+                   let file_found =
+                     List.fold_left
+                       (fun acc ext ->
+                          if source_file_exists (base_fn^ext) then
+                            (base_fn^ext) :: acc
+                          else
+                            acc)
+                       []
+                       [".ml"; ".mli"; ".mll"; ".mly"]
+                   in
+                     match file_found with
+                       | [] ->
+                           acc
+                       | lst ->
+                           `Sources (base_fn, lst)
+                 end
+             | `Sources _ ->
+                 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 ->
+         match find_module source_file_exists (cs, bs, lib) modul with
+           | `Sources (base_fn, lst) ->
+               (base_fn, lst) :: acc
+           | `No_sources _ ->
+               OASISMessage.warning
+                 ~ctxt
+                 (f_ "Cannot find source file matching \
+                      module '%s' in library %s")
+                 modul cs.cs_name;
+               acc)
+      []
+      (lib.lib_modules @ lib.lib_internal_modules)
+
+  let generated_unix_files
+        ~ctxt
+        ~is_native
+        ~has_native_dynlink
+        ~ext_lib
+        ~ext_dll
+        ~source_file_exists
+        (cs, bs, lib) =
+
+    let find_modules lst ext = 
+      let find_module modul =
+        match find_module source_file_exists (cs, bs, lib) modul with
+          | `Sources (base_fn, _) ->
+              [base_fn]
+          | `No_sources lst ->
+              OASISMessage.warning
+                ~ctxt
+                (f_ "Cannot find source file matching \
+                     module '%s' in library %s")
+                modul cs.cs_name;
+              lst
+      in
+      List.map 
+        (fun nm -> 
+           List.map 
+             (fun base_fn -> base_fn ^"."^ext)
+             (find_module nm))
+        lst