Chris_T avatar Chris_T committed b4f5539

Use oasis "dynamic update" by default.

Comments (0)

Files changed (4)

 
 # OASIS_STOP
 
+setup.ml: _oasis
+	oasis setup -setup-update dynamic
+
 WEB = lacaml.forge.ocamlcore.org:/home/groups/lacaml/htdocs/
 
 upload-doc: doc
 # OASIS_START
-# DO NOT EDIT (digest: 9688db43fe670f62810e3b1256fec814)
-# 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
-<**/.svn>: -traverse
-<**/.svn>: not_hygienic
-".bzr": -traverse
-".bzr": not_hygienic
-".hg": -traverse
-".hg": not_hygienic
-".git": -traverse
-".git": not_hygienic
-"_darcs": -traverse
-"_darcs": not_hygienic
-# Library lacaml
-"lib/lacaml.cmxs": use_lacaml
-<lib/*.ml{,i}>: oasis_library_lacaml_ccopt
-"lib/impl_c.c": oasis_library_lacaml_ccopt
-"lib/utils_c.c": oasis_library_lacaml_ccopt
-"lib/vec2_S_c.c": oasis_library_lacaml_ccopt
-"lib/vec2_D_c.c": oasis_library_lacaml_ccopt
-"lib/vec2_C_c.c": oasis_library_lacaml_ccopt
-"lib/vec2_Z_c.c": oasis_library_lacaml_ccopt
-"lib/mat4_S_c.c": oasis_library_lacaml_ccopt
-"lib/mat4_D_c.c": oasis_library_lacaml_ccopt
-"lib/mat4_C_c.c": oasis_library_lacaml_ccopt
-"lib/mat4_Z_c.c": oasis_library_lacaml_ccopt
-"lib/impl4_S_c.c": oasis_library_lacaml_ccopt
-"lib/impl4_D_c.c": oasis_library_lacaml_ccopt
-"lib/impl4_C_c.c": oasis_library_lacaml_ccopt
-"lib/impl4_Z_c.c": oasis_library_lacaml_ccopt
-"lib/impl2_S_c.c": oasis_library_lacaml_ccopt
-"lib/impl2_D_c.c": oasis_library_lacaml_ccopt
-"lib/impl2_C_c.c": oasis_library_lacaml_ccopt
-"lib/impl2_Z_c.c": oasis_library_lacaml_ccopt
-"lib/exp10.c": oasis_library_lacaml_ccopt
-<lib/lacaml.{cma,cmxa}>: oasis_library_lacaml_cclib
-"lib/liblacaml_stubs.lib": oasis_library_lacaml_cclib
-"lib/dlllacaml_stubs.dll": oasis_library_lacaml_cclib
-"lib/liblacaml_stubs.a": oasis_library_lacaml_cclib
-"lib/dlllacaml_stubs.so": oasis_library_lacaml_cclib
-<lib/lacaml.{cma,cmxa}>: use_liblacaml_stubs
-<lib/*.ml{,i}>: pkg_bigarray
-"lib/impl_c.c": pkg_bigarray
-"lib/utils_c.c": pkg_bigarray
-"lib/vec2_S_c.c": pkg_bigarray
-"lib/vec2_D_c.c": pkg_bigarray
-"lib/vec2_C_c.c": pkg_bigarray
-"lib/vec2_Z_c.c": pkg_bigarray
-"lib/mat4_S_c.c": pkg_bigarray
-"lib/mat4_D_c.c": pkg_bigarray
-"lib/mat4_C_c.c": pkg_bigarray
-"lib/mat4_Z_c.c": pkg_bigarray
-"lib/impl4_S_c.c": pkg_bigarray
-"lib/impl4_D_c.c": pkg_bigarray
-"lib/impl4_C_c.c": pkg_bigarray
-"lib/impl4_Z_c.c": pkg_bigarray
-"lib/impl2_S_c.c": pkg_bigarray
-"lib/impl2_D_c.c": pkg_bigarray
-"lib/impl2_C_c.c": pkg_bigarray
-"lib/impl2_Z_c.c": pkg_bigarray
-"lib/exp10.c": pkg_bigarray
-# Library lacaml_top
-"lib/lacaml_top.cmxs": use_lacaml_top
-# Executable blas
-<examples/blas/blas.{native,byte}>: use_lacaml
-<examples/blas/blas.{native,byte}>: pkg_bigarray
-<examples/blas/*.ml{,i}>: use_lacaml
-<examples/blas/*.ml{,i}>: pkg_bigarray
-# Executable eig
-<examples/eig/eig.{native,byte}>: use_lacaml
-<examples/eig/eig.{native,byte}>: pkg_bigarray
-# Executable sbev
-<examples/eig/sbev.{native,byte}>: use_lacaml
-<examples/eig/sbev.{native,byte}>: pkg_bigarray
-# Executable sbgv
-<examples/eig/sbgv.{native,byte}>: use_lacaml
-<examples/eig/sbgv.{native,byte}>: pkg_bigarray
-<examples/eig/*.ml{,i}>: use_lacaml
-<examples/eig/*.ml{,i}>: pkg_bigarray
-# Executable lin_eq
-<examples/lin_eq/lin_eq.{native,byte}>: use_lacaml
-<examples/lin_eq/lin_eq.{native,byte}>: pkg_bigarray
-# Executable gbsv
-<examples/lin_eq/gbsv.{native,byte}>: use_lacaml
-<examples/lin_eq/gbsv.{native,byte}>: pkg_bigarray
-<examples/lin_eq/*.ml{,i}>: use_lacaml
-<examples/lin_eq/*.ml{,i}>: pkg_bigarray
-# Executable lin_eq_comp
-<examples/lin_eq_comp/lin_eq_comp.{native,byte}>: use_lacaml
-<examples/lin_eq_comp/lin_eq_comp.{native,byte}>: pkg_bigarray
-<examples/lin_eq_comp/*.ml{,i}>: use_lacaml
-<examples/lin_eq_comp/*.ml{,i}>: pkg_bigarray
-# Executable lin_reg
-<examples/lin_reg/lin_reg.{native,byte}>: use_lacaml
-<examples/lin_reg/lin_reg.{native,byte}>: pkg_bigarray
-<examples/lin_reg/*.ml{,i}>: use_lacaml
-<examples/lin_reg/*.ml{,i}>: pkg_bigarray
-# Executable qr
-<examples/qr/qr.{native,byte}>: use_lacaml
-<examples/qr/qr.{native,byte}>: pkg_bigarray
-<examples/qr/*.ml{,i}>: use_lacaml
-<examples/qr/*.ml{,i}>: pkg_bigarray
-# Executable svd
-<examples/svd/svd.{native,byte}>: use_lacaml
-<examples/svd/svd.{native,byte}>: pkg_bigarray
-<examples/svd/*.ml{,i}>: use_lacaml
-<examples/svd/*.ml{,i}>: pkg_bigarray
 # OASIS_STOP
 
 <**/*.ml{,i}>: warn_A, warn_e, warn_r, annot
 (* OASIS_START *)
-(* DO NOT EDIT (digest: a0e7db74bcbca6550f3bbeae63fe5c3c) *)
-module OASISGettext = struct
-(* # 21 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/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/.opam/4.00.1/build/oasis.0.3.0/src/oasis/OASISExpr.ml" *)
-
-
-
-  open OASISGettext
-
-  type test = string 
-
-  type flag = string 
-
-  type t =
-    | EBool of bool
-    | ENot of t
-    | EAnd of t * t
-    | EOr of t * 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
-            in
-              (v = vl)
-    in
-      eval' t
-
-  let choose ?printer ?name var_get lst =
-    let rec choose_aux =
-      function
-        | (cond, vl) :: tl ->
-            if eval var_get cond then
-              vl
-            else
-              choose_aux tl
-        | [] ->
-            let str_lst =
-              if lst = [] then
-                s_ "<empty>"
-              else
-                String.concat
-                  (s_ ", ")
-                  (List.map
-                     (fun (cond, vl) ->
-                        match printer with
-                          | Some p -> p vl
-                          | None -> s_ "<no printer>")
-                     lst)
-            in
-              match name with
-                | Some nm ->
-                    failwith
-                      (Printf.sprintf
-                         (f_ "No result for the choice list '%s': %s")
-                         nm str_lst)
-                | None ->
-                    failwith
-                      (Printf.sprintf
-                         (f_ "No result for a choice list: %s")
-                         str_lst)
-    in
-      choose_aux (List.rev lst)
-
-end
-
-
-# 117 "myocamlbuild.ml"
-module BaseEnvLight = struct
-(* # 21 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/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
-        let chn =
-          open_in_bin filename
-        in
-        let st =
-          Stream.of_channel chn
-        in
-        let line =
-          ref 1
-        in
-        let st_line =
-          Stream.from
-            (fun _ ->
-               try
-                 match Stream.next st with
-                   | '\n' -> incr line; Some '\n'
-                   | c -> Some c
-               with Stream.Failure -> None)
-        in
-        let lexer =
-          Genlex.make_lexer ["="] st_line
-        in
-        let rec read_file mp =
-          match Stream.npeek 3 lexer with
-            | [Genlex.Ident nm; Genlex.Kwd "="; Genlex.String value] ->
-                Stream.junk lexer;
-                Stream.junk lexer;
-                Stream.junk lexer;
-                read_file (MapString.add nm value mp)
-            | [] ->
-                mp
-            | _ ->
-                failwith
-                  (Printf.sprintf
-                     "Malformed data file '%s' line %d"
-                     filename !line)
-        in
-        let mp =
-          read_file MapString.empty
-        in
-          close_in chn;
-          mp
-      end
-    else if allow_empty then
-      begin
-        MapString.empty
-      end
-    else
-      begin
-        failwith
-          (Printf.sprintf
-             "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.create ((String.length str) * 2)
-      in
-        Buffer.add_substitute
-          buff
-          (fun var ->
-             try
-               var_expand (MapString.find var env)
-             with Not_found ->
-               failwith
-                 (Printf.sprintf
-                    "No variable %s defined when trying to expand %S."
-                    var
-                    str))
-          str;
-        Buffer.contents buff
-    in
-      var_expand (MapString.find name env)
-
-  let var_choose lst env =
-    OASISExpr.choose
-      (fun nm -> var_get nm env)
-      lst
-end
-
-
-# 215 "myocamlbuild.ml"
-module MyOCamlbuildFindlib = struct
-(* # 21 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/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
-    *
-    * Updated on 2009/02/28
-    *
-    * 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 [] 
-    in
-    let rec go s =
-      let pos = 
-        String.index s ch 
-      in
-        x := (String.before s pos)::!x;
-        go (String.after s (pos + 1))
-    in
-      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 ->
-          (* by using Before_options one let command line options have an higher priority *)
-          (* on the contrary using After_options will guarantee to have the higher priority *)
-          (* override default commands by ocamlfind ones *)
-          Options.ocamlc     := ocamlfind & A"ocamlc";
-          Options.ocamlopt   := ocamlfind & A"ocamlopt";
-          Options.ocamldep   := ocamlfind & A"ocamldep";
-          Options.ocamldoc   := ocamlfind & A"ocamldoc";
-          Options.ocamlmktop := ocamlfind & A"ocamlmktop"
-                                  
-      | After_rules ->
-          
-          (* When one link an OCaml library/binary/package, one should use -linkpkg *)
-          flag ["ocaml"; "link"; "program"] & A"-linkpkg";
-          
-          (* For each ocamlfind package one inject the -package option when
-           * compiling, computing dependencies, generating documentation and
-           * linking. *)
-          List.iter 
-            begin fun pkg ->
-              flag ["ocaml"; "compile";  "pkg_"^pkg] & S[A"-package"; A pkg];
-              flag ["ocaml"; "ocamldep"; "pkg_"^pkg] & S[A"-package"; A pkg];
-              flag ["ocaml"; "doc";      "pkg_"^pkg] & S[A"-package"; A pkg];
-              flag ["ocaml"; "link";     "pkg_"^pkg] & S[A"-package"; A pkg];
-              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"; "compile";  "syntax_"^syntax] & S[A"-syntax"; A syntax];
-          flag ["ocaml"; "ocamldep"; "syntax_"^syntax] & S[A"-syntax"; A 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
-           * ocamlfind, this module will then be added twice on the command line.
-           *                        
-           * To solve this, one approach is to add the "-thread" option when using
-           * the "threads" package using the previous plugin.
-           *)
-          flag ["ocaml"; "pkg_threads"; "compile"] (S[A "-thread"]);
-          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/.opam/4.00.1/build/oasis.0.3.0/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 
-
-(* # 56 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/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 
-        ~filename:env_filename 
-        ~allow_empty:true
-        ()
-    in
-      match e with 
-        | Before_options ->
-            let no_trailing_dot s =
-              if String.length s >= 1 && s.[0] = '.' then
-                String.sub s 1 ((String.length s) - 1)
-              else
-                s
-            in
-              List.iter
-                (fun (opt, var) ->
-                   try 
-                     opt := no_trailing_dot (BaseEnvLight.var_get var env)
-                   with Not_found ->
-                     Printf.eprintf "W: Cannot get variable %s" var)
-                [
-                  Options.ext_obj, "ext_obj";
-                  Options.ext_lib, "ext_lib";
-                  Options.ext_dll, "ext_dll";
-                ]
-
-        | After_rules -> 
-            (* Declare OCaml libraries *)
-            List.iter 
-              (function
-                 | nm, [] ->
-                     ocaml_lib nm
-                 | nm, dir :: tl ->
-                     ocaml_lib ~dir:dir (dir^"/"^nm);
-                     List.iter 
-                       (fun 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"; 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"; 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"; 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) ->
-                 let spec = 
-                   BaseEnvLight.var_choose cond_specs env
-                 in
-                   flag tags & spec)
-              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 =
-       [("lacaml", ["lib"]); ("lacaml_top", ["lib"])];
-     lib_c =
-       [
-          ("lacaml",
-            "lib",
-            ["lib/f2c.h"; "lib/lacaml_macros.h"; "lib/utils_c.h"])
-       ];
-     flags =
-       [
-          (["oasis_library_lacaml_ccopt"; "compile"],
-            [
-               (OASISExpr.EBool true,
-                 S
-                   [
-                      A "-ccopt";
-                      A "-g";
-                      A "-ccopt";
-                      A "-std=c99";
-                      A "-ccopt";
-                      A "-O2";
-                      A "-ccopt";
-                      A "-fPIC";
-                      A "-ccopt";
-                      A "-DPIC"
-                   ]);
-               (OASISExpr.ETest ("system", "mingw"),
-                 S
-                   [
-                      A "-ccopt";
-                      A "-g";
-                      A "-ccopt";
-                      A "-std=c99";
-                      A "-ccopt";
-                      A "-O2";
-                      A "-ccopt";
-                      A "-fPIC";
-                      A "-ccopt";
-                      A "-DPIC";
-                      A "-ccopt";
-                      A "-DEXTERNAL_EXP10"
-                   ]);
-               (OASISExpr.ETest ("system", "macosx"),
-                 S
-                   [
-                      A "-ccopt";
-                      A "-g";
-                      A "-ccopt";
-                      A "-std=c99";
-                      A "-ccopt";
-                      A "-O2";
-                      A "-ccopt";
-                      A "-fPIC";
-                      A "-ccopt";
-                      A "-DPIC";
-                      A "-ccopt";
-                      A "-DEXTERNAL_EXP10"
-                   ]);
-               (OASISExpr.EAnd
-                  (OASISExpr.ETest ("system", "macosx"),
-                    OASISExpr.ETest ("system", "mingw")),
-                 S
-                   [
-                      A "-ccopt";
-                      A "-g";
-                      A "-ccopt";
-                      A "-std=c99";
-                      A "-ccopt";
-                      A "-O2";
-                      A "-ccopt";
-                      A "-fPIC";
-                      A "-ccopt";
-                      A "-DPIC";
-                      A "-ccopt";
-                      A "-DEXTERNAL_EXP10";
-                      A "-ccopt";
-                      A "-DEXTERNAL_EXP10"
-                   ]);
-               (OASISExpr.EAnd
-                  (OASISExpr.EFlag "strict",
-                    OASISExpr.ETest ("ccomp_type", "cc")),
-                 S
-                   [
-                      A "-ccopt";
-                      A "-g";
-                      A "-ccopt";
-                      A "-std=c99";
-                      A "-ccopt";
-                      A "-O2";
-                      A "-ccopt";
-                      A "-fPIC";
-                      A "-ccopt";
-                      A "-DPIC";
-                      A "-ccopt";
-                      A "-Wall";
-                      A "-ccopt";
-                      A "-pedantic";
-                      A "-ccopt";
-                      A "-Wextra";
-                      A "-ccopt";
-                      A "-Wunused";
-                      A "-ccopt";
-                      A "-Wno-long-long"
-                   ]);
-               (OASISExpr.EAnd
-                  (OASISExpr.EAnd
-                     (OASISExpr.EFlag "strict",
-                       OASISExpr.ETest ("ccomp_type", "cc")),
-                    OASISExpr.ETest ("system", "mingw")),
-                 S
-                   [
-                      A "-ccopt";
-                      A "-g";
-                      A "-ccopt";
-                      A "-std=c99";
-                      A "-ccopt";
-                      A "-O2";
-                      A "-ccopt";
-                      A "-fPIC";
-                      A "-ccopt";
-                      A "-DPIC";
-                      A "-ccopt";
-                      A "-Wall";
-                      A "-ccopt";
-                      A "-pedantic";
-                      A "-ccopt";
-                      A "-Wextra";
-                      A "-ccopt";
-                      A "-Wunused";
-                      A "-ccopt";
-                      A "-Wno-long-long";
-                      A "-ccopt";
-                      A "-DEXTERNAL_EXP10"
-                   ]);
-               (OASISExpr.EAnd
-                  (OASISExpr.EAnd
-                     (OASISExpr.EFlag "strict",
-                       OASISExpr.ETest ("ccomp_type", "cc")),
-                    OASISExpr.ETest ("system", "macosx")),
-                 S
-                   [
-                      A "-ccopt";
-                      A "-g";
-                      A "-ccopt";
-                      A "-std=c99";
-                      A "-ccopt";
-                      A "-O2";
-                      A "-ccopt";
-                      A "-fPIC";
-                      A "-ccopt";
-                      A "-DPIC";
-                      A "-ccopt";
-                      A "-Wall";
-                      A "-ccopt";
-                      A "-pedantic";
-                      A "-ccopt";
-                      A "-Wextra";
-                      A "-ccopt";
-                      A "-Wunused";
-                      A "-ccopt";
-                      A "-Wno-long-long";
-                      A "-ccopt";
-                      A "-DEXTERNAL_EXP10"
-                   ]);
-               (OASISExpr.EAnd
-                  (OASISExpr.EAnd
-                     (OASISExpr.EAnd
-                        (OASISExpr.EFlag "strict",
-                          OASISExpr.ETest ("ccomp_type", "cc")),
-                       OASISExpr.ETest ("system", "macosx")),
-                    OASISExpr.ETest ("system", "mingw")),
-                 S
-                   [
-                      A "-ccopt";
-                      A "-g";
-                      A "-ccopt";
-                      A "-std=c99";
-                      A "-ccopt";
-                      A "-O2";
-                      A "-ccopt";
-                      A "-fPIC";
-                      A "-ccopt";
-                      A "-DPIC";
-                      A "-ccopt";
-                      A "-Wall";
-                      A "-ccopt";
-                      A "-pedantic";
-                      A "-ccopt";
-                      A "-Wextra";
-                      A "-ccopt";
-                      A "-Wunused";
-                      A "-ccopt";
-                      A "-Wno-long-long";
-                      A "-ccopt";
-                      A "-DEXTERNAL_EXP10";
-                      A "-ccopt";
-                      A "-DEXTERNAL_EXP10"
-                   ])
-            ]);
-          (["oasis_library_lacaml_cclib"; "link"],
-            [
-               (OASISExpr.EBool true,
-                 S [A "-cclib"; A "-lblas"; A "-cclib"; A "-llapack"]);
-               (OASISExpr.ETest ("system", "macosx"),
-                 S [A "-cclib"; A "-framework"; A "-cclib"; A "vecLib"])
-            ]);
-          (["oasis_library_lacaml_cclib"; "ocamlmklib"; "c"],
-            [
-               (OASISExpr.EBool true, S [A "-lblas"; A "-llapack"]);
-               (OASISExpr.ETest ("system", "macosx"),
-                 S [A "-framework"; A "vecLib"])
-            ])
-       ];
-     includes =
-       [
-          ("examples/svd", ["lib"]);
-          ("examples/qr", ["lib"]);
-          ("examples/lin_reg", ["lib"]);
-          ("examples/lin_eq_comp", ["lib"]);
-          ("examples/lin_eq", ["lib"]);
-          ("examples/eig", ["lib"]);
-          ("examples/blas", ["lib"])
-       ];
-     }
-  ;;
-
-let dispatch_default = MyOCamlbuildBase.dispatch_default package_default;;
-
-# 709 "myocamlbuild.ml"
 (* OASIS_STOP *)
-# 502 "myocamlbuild.ml"
 
 let rec split_on is_delim s i0 i i1 =
   if i >= i1 then [String.sub s i0 (i1 - i0)]
 (* setup.ml generated for the first time by OASIS v0.2.0 *)
 
 (* OASIS_START *)
-(* DO NOT EDIT (digest: 919bab8571237c17a89710e32996907c) *)
-(*
-   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/.opam/4.00.1/build/oasis.0.3.0/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/.opam/4.00.1/build/oasis.0.3.0/src/oasis/OASISContext.ml" *)
-
-  open OASISGettext
-
-  type level =
-    [ `Debug
-    | `Info
-    | `Warning
-    | `Error]
-
-  type t =
-    {
-      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
-        | `Error -> s_ "E: "
-        | `Warning -> s_ "W: "
-        | `Info  -> s_ "I: "
-        | `Debug -> s_ "D: "
-    in
-      prerr_endline (beg^str)
-
-  let default =
-    ref
-      {
-        quiet                 = false;
-        info                  = false;
-        debug                 = false;
-        ignore_plugins        = false;
-        ignore_unknown_fields = false;
-        printf                = printf;
-      }
-
-  let quiet =
-    {!default with quiet = true}
-
-
-  let args () =
-    ["-quiet",
-     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 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/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/.opam/4.00.1/build/oasis.0.3.0/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 varname_of_string ?(hyphen='_') s =
-    if String.length s = 0 then
-      begin
-        invalid_arg "varname_of_string"
-      end
-    else
-      begin
-        let buf =
-          OASISString.replace_chars
-            (fun c ->
-               if ('a' <= c && c <= 'z')
-                 ||
-                  ('A' <= c && c <= 'Z')
-                 ||
-                  ('0' <= c && c <= '9') then
-                 c
-               else
-                 hyphen)
-            s;
-        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 =
-      try
-        OASISString.strip_ends_with ~what p
-      with Not_found ->
-        p
-    in
-    let s =
-      try
-        OASISString.strip_starts_with ~what s
-      with Not_found ->
-        s
-    in
-      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/.opam/4.00.1/build/oasis.0.3.0/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
-         | 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
-
-(* # 71 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/src/oasis/PropList.ml" *)
-  end
-
-  module Schema =
-  struct
-
-    type ('ctxt, 'extra) value =
-        {
-          get:   Data.t -> string;
-          set:   Data.t -> ?context:'ctxt -> string -> unit;
-          help:  (unit -> string) option;
-          extra: 'extra;
-        }
-
-    type ('ctxt, 'extra) t =
-        {
-          name:      name;
-          fields:    (name, ('ctxt, 'extra) value) Hashtbl.t;
-          order:     name Queue.t;
-          name_norm: string -> string;
-        }
-
-    let create ?(case_insensitive=false) nm =
-      {
-        name      = nm;
-        fields    = Hashtbl.create 13;
-        order     = Queue.create ();
-        name_norm =
-          (if case_insensitive then
-             String.lowercase
-           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
-               (f_ "Field '%s' is already defined in schema '%s'")
-               nm t.name);
-        Hashtbl.add
-          t.fields
-          key
-          {
-            set   = set;
-            get   = get;
-            help  = help;
-            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 ->
-           let v =
-             find t k
-           in
-             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;
-          get:    Data.t -> 'value;
-          sets:   Data.t -> ?context:'ctxt -> string -> unit;
-          gets:   Data.t -> string;
-          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 *)
-        try
-          (Hashtbl.find data nm) ();
-          match !v with
-            | Some x -> x
-            | None -> default ()
-        with Not_found ->
-          default ()
-      in
-
-      (* Set data *)
-      let set data ?context x =
-        let x =
-          match update with
-            | Some f ->
-                begin
-                  try
-                    f ?context (get data) x
-                  with Not_set _ ->
-                    x
-                end
-            | None ->
-                x
-        in
-          Hashtbl.replace
-            data
-            nm
-            (fun () -> v := Some x)
-      in
-
-      (* Parse string value, if possible *)
-      let parse =
-        match parse with
-          | Some f ->
-              f
-          | None ->
-              fun ?context s ->
-                failwith
-                  (Printf.sprintf
-                     (f_ "Cannot parse field '%s' when setting value %S")
-                     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
-          | Some f ->
-              f
-          | 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 ->
-                Schema.add t nm sets gets extra help
-            | None ->
-                ()
-        end;
-
-        {
-          set   = set;
-          get   = get;
-          sets  = sets;
-          gets  = gets;
-          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/.opam/4.00.1/build/oasis.0.3.0/src/oasis/OASISMessage.ml" *)
-
-
-  open OASISGettext
-  open OASISContext
-
-  let generic_message ~ctxt lvl fmt =
-    let cond =
-      if ctxt.quiet then
-        false
-      else
-        match lvl with
-          | `Debug -> ctxt.debug
-          | `Info  -> ctxt.info
-          | _ -> true
-    in
-      Printf.ksprintf
-        (fun str ->
-           if cond then
-             begin
-               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/.opam/4.00.1/build/oasis.0.3.0/src/oasis/OASISVersion.ml" *)
-
-  open OASISGettext
-
-
-
-  type s = string
-
-  type t = string 
-
-  type comparator =
-    | VGreater of t
-    | VGreaterEqual of t
-    | VEqual of t
-    | VLesser of t
-    | VLesserEqual 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
-        (* Compare ascii string, using special meaning for version
-         * related char
-         *)
-        let val_ascii c =
-          if c = '~' then -1
-          else if is_digit c then 0
-          else if c = '\000' then 0
-          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
-          while !cmp = 0 &&
-                !p < len1 && !p < len2 &&
-                not (is_digit v1.[!p] && is_digit v2.[!p]) do
-            cmp := (val_ascii v1.[!p]) - (val_ascii v2.[!p]);
-            incr p
-          done;
-          if !cmp = 0 && !p < len1 && !p = len2 then
-            val_ascii v1.[!p]
-          else if !cmp = 0 && !p = len1 && !p < len2 then
-            - (val_ascii v2.[!p])
-          else
-            !cmp
-        in
-
-        (** Compare digit part *)
-        let compare_digit () =
-          let extract_int v p =
-            let start_p = !p in
-              while !p < String.length v && is_digit v.[!p] do
-                incr p
-              done;
-              let substr = 
-                String.sub v !p ((String.length v) - !p)
-              in 
-              let res = 
-                match String.sub v start_p (!p - start_p) with 
-                  | "" -> 0
-                  | s -> int_of_string s
-              in
-                res, substr
-          in
-          let i1, tl1 = extract_int v1 (ref !p) in
-          let i2, tl2 = extract_int v2 (ref !p) in
-            i1 - i2, tl1, tl2
-        in
-
-          match compare_vascii () with
-            | 0 ->
-                begin
-                  match compare_digit () with
-                    | 0, tl1, tl2 ->
-                        if tl1 <> "" && is_digit tl1.[0] then
-                          1
-                        else if tl2 <> "" && is_digit tl2.[0] then
-                          -1
-                        else
-                          version_compare tl1 tl2
-                    | n, _, _ ->
-                        n
-                end
-            | n ->
-                n
-      end
-    else
-      begin
-        0
-      end
-
-
-  let version_of_string str = str
-
-  let string_of_version t = t
-
-  let chop t =
-    try
-      let pos =
-        String.rindex t '.'
-      in
-        String.sub t 0 pos
-    with Not_found ->
-      t
-
-  let rec comparator_apply v op =
-    match op with
-      | VGreater cv ->
-          (version_compare v cv) > 0
-      | VGreaterEqual cv ->
-          (version_compare v cv) >= 0
-      | VLesser cv ->
-          (version_compare v cv) < 0
-      | VLesserEqual cv ->
-          (version_compare v cv) <= 0
-      | VEqual cv ->
-          (version_compare v cv) = 0
-      | VOr (op1, op2) ->
-          (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)
-      | VEqual v    -> "= "^(string_of_version v)
-      | VLesser v   -> "< "^(string_of_version v)
-      | VGreaterEqual v -> ">= "^(string_of_version v)
-      | VLesserEqual v  -> "<= "^(string_of_version v)
-      | VOr (c1, c2)  ->
-          (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
-        p
-        (OASISUtils.varname_of_string
-           (string_of_version v))
-    in
-      function
-        | VGreater v -> concat "gt" v
-        | VLesser v  -> concat "lt" v
-        | VEqual v   -> concat "eq" v
-        | VGreaterEqual v -> concat "ge" v
-        | VLesserEqual v  -> concat "le" v
-        | VOr (c1, c2) ->
-            (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/.opam/4.00.1/build/oasis.0.3.0/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 =
-    | 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/.opam/4.00.1/build/oasis.0.3.0/src/oasis/OASISExpr.ml" *)
-
-
-
-  open OASISGettext
-
-  type test = string 
-
-  type flag = string 
-
-  type t =
-    | EBool of bool
-    | ENot of t
-    | EAnd of t * t
-    | EOr of t * 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
-            in
-              (v = vl)
-    in
-      eval' t
-
-  let choose ?printer ?name var_get lst =
-    let rec choose_aux =
-      function
-        | (cond, vl) :: tl ->
-            if eval var_get cond then
-              vl
-            else
-              choose_aux tl
-        | [] ->
-            let str_lst =
-              if lst = [] then
-                s_ "<empty>"
-              else
-                String.concat
-                  (s_ ", ")
-                  (List.map
-                     (fun (cond, vl) ->
-                        match printer with
-                          | Some p -> p vl
-                          | None -> s_ "<no printer>")
-                     lst)
-            in
-              match name with
-                | Some nm ->
-                    failwith
-                      (Printf.sprintf
-                         (f_ "No result for the choice list '%s': %s")
-                         nm str_lst)
-                | None ->
-                    failwith
-                      (Printf.sprintf
-                         (f_ "No result for a choice list: %s")
-                         str_lst)
-    in
-      choose_aux (List.rev lst)
-
-end
-
-module OASISTypes = struct
-(* # 21 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/src/oasis/OASISTypes.ml" *)
-
-
-
-
-  type name          = string 
-  type package_name  = string 
-  type url           = string 
-  type unix_dirname  = string 
-  type unix_filename = string 
-  type host_dirname  = string 
-  type host_filename = string 
-  type prog          = 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
-    | Svn
-    | Cvs
-    | Hg
-    | Bzr
-    | Arch
-    | Monotone
-    | OtherVCS of url
-    
-
-  type plugin_kind =
-      [  `Configure
-       | `Build
-       | `Doc
-       | `Test
-       | `Install
-       | `Extra
-      ]
-
-  type plugin_data_purpose =
-      [  `Configure
-       | `Build
-       | `Install
-       | `Clean
-       | `Distclean
-       | `Install
-       | `Uninstall
-       | `Test
-       | `Doc
-       | `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/.opam/4.00.1/build/oasis.0.3.0/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_data: PropList.Data.t;
-        cs_plugin_data: plugin_data;
-      }
-      
-
-  type build_section =
-      {
-        bs_build:           bool conditional;
-        bs_install:         bool conditional;
-        bs_path:            unix_dirname;
-        bs_compiled_object: compiled_object;
-        bs_build_depends:   dependency list;
-        bs_build_tools:     tool list;
-        bs_c_sources:       unix_filename list;
-        bs_data_files:      (unix_filename * unix_filename option) list;
-        bs_ccopt:           args conditional;
-        bs_cclib:           args conditional;
-        bs_dlllib:          args conditional;
-        bs_dllpath:         args conditional;
-        bs_byteopt:         args 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_location:    url;
-        src_repo_browser:     url option;
-        src_repo_module:      string option;
-        src_repo_branch:      string option;
-        src_repo_tag:         string option;
-        src_repo_subdir:      unix_filename option;
-      } 
-
-  type test =
-      {
-        test_type:               [`Test] plugin;
-        test_command:            command_line conditional;
-        test_custom:             custom;
-        test_working_directory:  unix_filename option;
-        test_run:                bool conditional;
-        test_tools:              tool list;
-      } 
-
-  type doc_format =
-    | HTML of unix_filename
-    | DocText
-    | PDF
-    | PostScript
-    | Info of unix_filename
-    | DVI
-    | OtherDoc
-    
-
-  type doc =
-      {
-        doc_type:        [`Doc] plugin;
-        doc_custom:      custom;
-        doc_build:       bool conditional;
-        doc_install:     bool conditional;
-        doc_install_dir: unix_filename;
-        doc_title:       string;
-        doc_authors:     string list;
-        doc_abstract:    string option;
-        doc_format:      doc_format;
-        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
-    | Flag       of common_section * flag
-    | SrcRepo    of common_section * source_repository
-    | 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;
-        ocaml_version:    OASISVersion.comparator option;
-        findlib_version:  OASISVersion.comparator option;
-        name:             package_name;
-        version:          OASISVersion.t;
-        license:          OASISLicense.t;
-        license_file:     unix_filename option;
-        copyrights:       string list;
-        maintainers:      string list;
-        authors:          string list;
-        homepage:         url option;
-        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/.opam/4.00.1/build/oasis.0.3.0/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 is_current_dir f1 then
-      f2
-    else
-      let f1' =
-        try OASISString.strip_ends_with ~what:"/" f1 with Not_found -> f1
-      in
-        f1'^"/"^f2
-
-  let make =
-    function
-      | hd :: tl ->
-          List.fold_left
-            (fun f p -> concat f p)
-            hd
-            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.rindex f '/') + 1
-      in
-        String.sub f pos_start ((String.length f) - pos_start)
-    with Not_found ->
-      f
-
-  let chop_extension f =
-    try
-      let last_dot =
-        String.rindex f '.'
-      in
-      let sub =
-        String.sub f 0 last_dot
-      in
-        try
-          let last_slash =
-            String.rindex f '/'
-          in
-            if last_slash < last_dot then
-              sub
-            else
-              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 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/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/.opam/4.00.1/build/oasis.0.3.0/src/oasis/OASISSection.ml" *)
-
-  open OASISTypes
-
-  let section_kind_common = 
-    function
-      | Library (cs, _, _) -> 
-          `Library, cs
-      | Executable (cs, _, _) ->
-          `Executable, cs
-      | Flag (cs, _) ->
-          `Flag, cs
-      | SrcRepo (cs, _) ->
-          `SrcRepo, cs
-      | Test (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)
-      | Executable (_, bs, exec) -> Executable (cs, bs, exec)
-      | Flag (_, flg)            -> Flag (cs, flg)
-      | 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 = 
-    let k, cs = 
-      section_kind_common sct
-    in
-      k, cs.cs_name
-
-  let string_of_section sct =
-    let k, nm =
-      section_id sct
-    in
-      (match k with
-         | `Library    -> "library" 
-         | `Executable -> "executable"
-         | `Flag       -> "flag"
-         | `SrcRepo    -> "src repository"
-         | `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/.opam/4.00.1/build/oasis.0.3.0/src/oasis/OASISBuildSection.ml" *)
-
-end
-
-module OASISExecutable = struct
-(* # 21 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/src/oasis/OASISExecutable.ml" *)
-
-  open OASISTypes
-
-  let unix_exec_is (cs, bs, exec) is_native ext_dll suffix_program = 
-    let dir = 
-      OASISUnixPath.concat
-        bs.bs_path
-        (OASISUnixPath.dirname exec.exec_main_is)
-    in
-    let is_native_exec = 
-      match bs.bs_compiled_object with
-        | Native -> true
-        | 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^"_stubs"^(ext_dll ()))
-      else
-        None
-
-end
-
-module OASISLibrary = struct
-(* # 21 "/Users/mmottl/.opam/4.00.1/build/oasis.0.3.0/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 =
-      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
-    in
-
-    (* The headers that should be compiled along *)
-    let headers =
-      if lib.lib_pack then
-        []
-      else
-        find_modules
-          lib.lib_modules
-          "cmi"
-    in
-
-    (* The .cmx that be compiled along *)
-    let cmxs =
-      let should_be_built =
-        (not lib.lib_pack) && (* Do not install .cmx packed submodules *)
-        match bs.bs_compiled_object with
-          | Native -> true
-          | Best -> is_native
-          | Byte -> false
-      in
-        if should_be_built then
-          find_modules
-            (lib.lib_modules @ lib.lib_internal_modules)
-            "cmx"
-        else
-          []
-    in
-
-    let acc_nopath =
-      []
-    in
-
-    (* Compute what libraries should be built *)
-    let acc_nopath =
-      (* Add the packed header file if required *)
-      let add_pack_header acc =
-        if lib.lib_pack then
-          [cs.cs_name^".cmi"] :: acc
-        else
-          acc
-      in
-      let byte acc =
-        add_pack_header ([cs.cs_name^".cma"] :: acc)
-      in
-      let native acc =
-        let acc = 
-          add_pack_header
-            (if has_native_dynlink then
-               [cs.cs_name^".cmxs"] :: acc
-             else acc)
-        in
-          [cs.cs_name^".cmxa"] :: [cs.cs_name^ext_lib] :: acc
-      in
-        match bs.bs_compiled_object with
-          | Native ->
-              byte (native acc_nopath)
-          | Best when is_native ->
-              byte (native acc_nopath)
-          | Byte | Best ->
-              byte acc_nopath
-    in
-
-    (* Add C library to be built *)
-    let acc_nopath =
-      if bs.bs_c_sources <> [] then
-        begin
-          ["lib"^cs.cs_name^"_stubs"^ext_lib]
-          ::
-          ["dll"^cs.cs_name^"_stubs"^ext_dll]
-          ::
-          acc_nopath
-        end
-      else
-        acc_nopath
-    in
-
-      (* All the files generated *)
-      List.rev_append
-        (List.rev_map
-           (List.rev_map
-              (OASISUnixPath.concat bs.bs_path))
-           acc_nopath)
-        (headers @ cmxs)
-
-  type data = common_section * build_section * library
-  type tree =
-    | Node of (data option) * (tree MapString.t)