Commits

camlspotter committed 39b1a43

oasis fix (disabling test)

Comments (0)

Files changed (7)

ulib/ulib-0.0.1/INSTALL.txt

 (* OASIS_START *)
-(* DO NOT EDIT (digest: eecf658cbebd124f70ad20af129a44ee) *)
+(* DO NOT EDIT (digest: c22cd31ed011bb63c579defa18f1dfdd) *)
 This is the INSTALL file for the ulib distribution.
 
 This package uses OASIS to generate its build system. See section OASIS for
 ============
 
 In order to compile this package, you will need:
-* ocaml for all, test test, doc ulib
+* ocaml for all, doc ulib
 * findlib
-* oUnit for executable test
 
 Installing
 ==========
 
-1. Uncompress source directory and got to the root of the package
+1. Uncompress the source archive and go to the root of the package
 2. Run 'ocaml setup.ml -configure'
 3. Run 'ocaml setup.ml -build'
 4. Run 'ocaml setup.ml -install'
 OASIS
 =====
 
-OASIS is a software that helps to write setup.ml using a simple '_oasis'
-configuration file. The generated setup only depends on standard OCaml
-installation, no additional library is required.
+OASIS is a program that generates a setup.ml file using a simple '_oasis'
+configuration file. The generated setup only depends on the standard OCaml
+installation: no additional library is required.
 
 (* OASIS_STOP *)

ulib/ulib-0.0.1/_oasis

   Path:       src
   Modules:    Ulib
 
-Executable test
-  Install: false
-  Path: test
-  MainIs: test.ml
-  BuildDepends: oUnit
-
-Test test
-  Command: $test
+# Executable test
+#   Install: false
+#   Path: test
+#   MainIs: test.ml
+#   BuildDepends: oUnit
+# 
+# Test test
+#   Command: $test
   
 Document ulib
   Title: API reference for ulib

ulib/ulib-0.0.1/_tags

 # OASIS_START
-# DO NOT EDIT (digest: c7884d02e98be97b29a8caa0799bb19b)
+# DO NOT EDIT (digest: 0bbb04ec16e575e5e48970e7c2016f74)
+# 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 ulib
-"src": include
-# Executable test
-"test/test.byte": pkg_oUnit
-<test/*.ml{,i}>: pkg_oUnit
+"src/ulib.cmxs": use_ulib
 # OASIS_STOP

ulib/ulib-0.0.1/configure

 #!/bin/sh
 
 # OASIS_START
-# DO NOT EDIT (digest: ed33e59fe00e48bc31edf413bbc8b8d6)
+# DO NOT EDIT (digest: 425187ed8bfdbdd207fd76392dd243a7)
 set -e
 
-ocaml setup.ml -configure $*
+FST=true
+for i in "$@"; do 
+  if $FST; then
+    set --
+    FST=false
+  fi
+
+  case $i in
+    --*=*)
+      ARG=${i%%=*}
+      VAL=${i##*=}
+      set -- "$@" "$ARG" "$VAL"
+      ;;
+    *)
+      set -- "$@" "$i"
+      ;;
+  esac
+done
+
+ocaml setup.ml -configure "$@"
 # OASIS_STOP

ulib/ulib-0.0.1/myocamlbuild.ml

 (* OASIS_START *)
-(* DO NOT EDIT (digest: 58e2d5784ef3a802d1a212cf379e9013) *)
+(* DO NOT EDIT (digest: 251d3679b3fa8a0193a0a25f861e3b26) *)
 module OASISGettext = struct
-# 21 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISGettext.ml"
-  
-  let ns_ str = 
+# 21 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/src/oasis/OASISGettext.ml"
+
+  let ns_ str =
     str
-  
-  let s_ 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 = 
+
+  let init =
     []
-  
+
 end
 
 module OASISExpr = struct
-# 21 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISExpr.ml"
-  
-  
-  
+# 21 "/mnt/home/jun/.opam/system/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
     | EFlag of flag
     | ETest of test * string
     
-  
+
   type 'a choices = (t * 'a) list 
-  
+
   let eval var_get t =
-    let rec eval' = 
+    let rec eval' =
       function
         | EBool b ->
             b
-  
-        | ENot e -> 
+
+        | ENot e ->
             not (eval' e)
-  
+
         | EAnd (e1, e2) ->
             (eval' e1) && (eval' e2)
-  
-        | EOr (e1, 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 = 
+    let rec choose_aux =
       function
         | (cond, vl) :: tl ->
-            if eval var_get cond then 
-              vl 
+            if eval var_get cond then
+              vl
             else
               choose_aux tl
         | [] ->
-            let str_lst = 
+            let str_lst =
               if lst = [] then
                 s_ "<empty>"
               else
-                String.concat 
+                String.concat
                   (s_ ", ")
                   (List.map
                      (fun (cond, vl) ->
                           | None -> s_ "<no printer>")
                      lst)
             in
-              match name with 
+              match name with
                 | Some nm ->
                     failwith
-                      (Printf.sprintf 
+                      (Printf.sprintf
                          (f_ "No result for the choice list '%s': %s")
                          nm str_lst)
                 | None ->
                          str_lst)
     in
       choose_aux (List.rev lst)
-  
+
 end
 
 
+# 117 "myocamlbuild.ml"
 module BaseEnvLight = struct
-# 21 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/base/BaseEnvLight.ml"
-  
+# 21 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/src/base/BaseEnvLight.ml"
+
   module MapString = Map.Make(String)
-  
+
   type t = string MapString.t
-  
+
   let default_filename =
-    Filename.concat 
+    Filename.concat
       (Sys.getcwd ())
       "setup.data"
-  
+
   let load ?(allow_empty=false) ?(filename=default_filename) () =
     if Sys.file_exists filename then
       begin
         let line =
           ref 1
         in
-        let st_line = 
+        let st_line =
           Stream.from
             (fun _ ->
                try
-                 match Stream.next st with 
+                 match Stream.next st with
                    | '\n' -> incr line; Some '\n'
                    | c -> Some c
                with Stream.Failure -> None)
         in
-        let lexer = 
+        let lexer =
           Genlex.make_lexer ["="] st_line
         in
         let rec read_file mp =
-          match Stream.npeek 3 lexer with 
+          match Stream.npeek 3 lexer with
             | [Genlex.Ident nm; Genlex.Kwd "="; Genlex.String value] ->
-                Stream.junk lexer; 
-                Stream.junk lexer; 
+                Stream.junk lexer;
+                Stream.junk lexer;
                 Stream.junk lexer;
                 read_file (MapString.add nm value mp)
             | [] ->
       end
     else
       begin
-        failwith 
-          (Printf.sprintf 
+        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 
+        Buffer.add_substitute
           buff
-          (fun var -> 
-             try 
+          (fun var ->
+             try
                var_expand (MapString.find var env)
              with Not_found ->
-               failwith 
-                 (Printf.sprintf 
+               failwith
+                 (Printf.sprintf
                     "No variable %s defined when trying to expand %S."
-                    var 
+                    var
                     str))
           str;
         Buffer.contents buff
     in
       var_expand (MapString.find name env)
-  
-  let var_choose lst env = 
+
+  let var_choose lst env =
     OASISExpr.choose
       (fun nm -> var_get nm env)
       lst
 end
 
 
+# 215 "myocamlbuild.ml"
 module MyOCamlbuildFindlib = struct
-# 21 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/plugins/ocamlbuild/MyOCamlbuildFindlib.ml"
-  
+# 21 "/mnt/home/jun/.opam/system/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
     * 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
            * 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 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
-  
+# 21 "/mnt/home/jun/.opam/system/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 
-  
-# 55 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/plugins/ocamlbuild/MyOCamlbuildBase.ml"
-  
+
+# 56 "/mnt/home/jun/.opam/system/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 
                   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/ulib", ["src"])];
+     MyOCamlbuildBase.lib_ocaml = [("ulib", ["src"])];
      lib_c = [];
      flags = [];
+     includes = [];
      }
   ;;
 
 let dispatch_default = MyOCamlbuildBase.dispatch_default package_default;;
 
+# 490 "myocamlbuild.ml"
 (* OASIS_STOP *)
 Ocamlbuild_plugin.dispatch dispatch_default;;

ulib/ulib-0.0.1/setup.ml

 (* setup.ml generated for the first time by OASIS v0.2.0 *)
 
 (* OASIS_START *)
-(* DO NOT EDIT (digest: 6da770aa280fe7954ef2a359b9e9bd9f) *)
+(* DO NOT EDIT (digest: d7d416b0bdaf6d2f4ee2365466283345) *)
 (*
-   Regenerated by OASIS v0.2.0
+   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/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISGettext.ml"
-  
-  let ns_ str = 
+# 21 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/src/oasis/OASISGettext.ml"
+
+  let ns_ str =
     str
-  
-  let s_ 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 = 
+
+  let init =
     []
-  
+
 end
 
 module OASISContext = struct
-# 21 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISContext.ml"
-  
-  open OASISGettext 
-  
+# 21 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/src/oasis/OASISContext.ml"
+
+  open OASISGettext
+
   type level =
     [ `Debug
-    | `Info 
+    | `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 
+
+  let printf lvl str =
+    let beg =
+      match lvl with
         | `Error -> s_ "E: "
         | `Warning -> s_ "W: "
         | `Info  -> s_ "I: "
         | `Debug -> s_ "D: "
     in
-      match lvl with 
-        | `Error ->
-            prerr_endline (beg^str)
-        | _ ->
-            print_endline (beg^str)
-  
+      prerr_endline (beg^str)
+
   let default =
-    ref 
+    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;
-    }
-  
-  
+
+  let quiet =
+    {!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 "/mnt/home/jun/.opam/system/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 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISUtils.ml"
-  
+# 21 "/mnt/home/jun/.opam/system/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 
+    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 = 
+
+
+  let compare_csl s1 s2 =
     String.compare (String.lowercase s1) (String.lowercase s2)
-  
-  module HashStringCsl = 
+
+  module HashStringCsl =
     Hashtbl.Make
       (struct
          type t = string
-  
-         let equal s1 s2 = 
+
+         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 = 
+
+  let varname_of_string ?(hyphen='_') s =
     if String.length s = 0 then
       begin
-        invalid_arg "varname_of_string" 
+        invalid_arg "varname_of_string"
       end
     else
       begin
-        let buff = 
-          Buffer.create (String.length s)
+        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
-            Buffer.add_char buff hyphen;
-  
-          String.iter
-            (fun c ->
-               if ('a' <= c && c <= 'z') 
-                 || 
-                  ('A' <= c && c <= 'Z') 
-                 || 
-                  ('0' <= c && c <= '9') then
-                 Buffer.add_char buff c
-               else
-                 Buffer.add_char buff hyphen)
-            s;
-  
-          String.lowercase (Buffer.contents buff)
+            "_"^buf
+          else
+            buf
+        in
+          String.lowercase buf
       end
-  
-  let varname_concat ?(hyphen='_') p s = 
-    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
+
+  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 = 
-      let s_len =
-        String.length s
-      in
-        if s_len > 0 && s.[0] = hyphen then
-          String.sub s 1 (s_len - 1)
-        else
-          s
+    let s =
+      try
+        OASISString.strip_starts_with ~what s
+      with Not_found ->
+        s
     in
-      Printf.sprintf "%s%c%s" p hyphen s
-  
-  
-  let is_varname str = 
+      p^what^s
+
+
+  let is_varname str =
     str = varname_of_string str
-  
-  let failwithf1 fmt a =
-    failwith (Printf.sprintf fmt a)
-  
-  let failwithf2 fmt a b =
-    failwith (Printf.sprintf fmt a b)
-  
-  let failwithf3 fmt a b c =
-    failwith (Printf.sprintf fmt a b c)
-  
-  let failwithf4 fmt a b c d =
-    failwith (Printf.sprintf fmt a b c d)
-  
-  let failwithf5 fmt a b c d e =
-    failwith (Printf.sprintf fmt a b c d e)
-  
+
+  let failwithf fmt = Printf.ksprintf failwith fmt
+
 end
 
 module PropList = struct
-# 21 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/PropList.ml"
-  
+# 21 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/src/oasis/PropList.ml"
+
   open OASISGettext
-  
+
   type name = string
-  
-  exception Not_set of name * string option 
+
+  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 = 
+
+    type t =
         (name, unit -> unit) Hashtbl.t
-  
+
     let create () =
       Hashtbl.create 13
-  
+
     let clear t =
       Hashtbl.clear t
-  
-# 59 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/PropList.ml"
+
+# 71 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/src/oasis/PropList.ml"
   end
-  
-  module Schema = 
+
+  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 = 
+
+    let create ?(case_insensitive=false) nm =
       {
         name      = nm;
         fields    = Hashtbl.create 13;
         order     = Queue.create ();
-        name_norm = 
-          (if case_insensitive then 
+        name_norm =
+          (if case_insensitive then
              String.lowercase
            else
              fun s -> s);
       }
-  
-    let add t nm set get extra help = 
-      let key = 
+
+    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 
+            (Printf.sprintf
                (f_ "Field '%s' is already defined in schema '%s'")
                nm t.name);
-        Hashtbl.add 
-          t.fields 
-          key 
+        Hashtbl.add
+          t.fields
+          key
           {
-            set   = set; 
-            get   = get; 
+            set   = set;
+            get   = get;
             help  = help;
             extra = extra;
           };
-        Queue.add nm t.order 
-  
+        Queue.add nm t.order
+
     let mem t nm =
-      Hashtbl.mem t.fields nm 
-  
-    let find 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 
+      (find t nm).set
+        data
+        ?context
         x
-  
+
     let fold f acc t =
-      Queue.fold 
+      Queue.fold
         (fun acc k ->
            let v =
              find t k
            in
              f acc k v.extra v.help)
-        acc 
+        acc
         t.order
-  
+
     let iter f t =
-      fold 
+      fold
         (fun () -> f)
         ()
         t
-  
-    let name 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 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 
+      let v =
+        ref None
       in
-  
+
       (* If name is not given, create unique one *)
-      let nm = 
-        match name with 
+      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 
+      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 
+        try
           (Hashtbl.find data nm) ();
-          match !v with 
-            | Some x -> x 
+          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 
+      let set data ?context x =
+        let x =
+          match update with
             | Some f ->
                 begin
-                  try 
+                  try
                     f ?context (get data) x
                   with Not_set _ ->
                     x
             | None ->
                 x
         in
-          Hashtbl.replace 
-            data 
-            nm 
-            (fun () -> v := Some x) 
+          Hashtbl.replace
+            data
+            nm
+            (fun () -> v := Some x)
       in
-  
+
       (* Parse string value, if possible *)
       let parse =
-        match parse with 
-          | Some f -> 
+        match parse with
+          | Some f ->
               f
           | None ->
               fun ?context s ->
-                failwith 
-                  (Printf.sprintf 
+                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
           | None ->
               fun _ -> raise (No_printer nm)
       in
-  
+
       (* Get data, as a string *)
       let gets data =
         print (get data)
       in
-  
-        begin 
-          match schema with 
+
+        begin
+          match schema with
             | Some t ->
                 Schema.add t nm sets gets extra help
             | None ->
                 ()
         end;
-  
+
         {
           set   = set;
           get   = get;
           help  = help;
           extra = extra;
         }
-  
-    let fset data t ?context x = 
+
+    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 
-  
+      t.gets data
+
   end
-  
+
   module FieldRO =
   struct
-  
+
     let create ?schema ?name ?parse ?print ?default ?update ?help extra =
-      let fld = 
+      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/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISMessage.ml"
-  
-  
+# 21 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/src/oasis/OASISMessage.ml"
+
+
   open OASISGettext
   open OASISContext
-  
+
   let generic_message ~ctxt lvl fmt =
-    let cond = 
-      match lvl with 
-        | `Debug -> ctxt.debug
-        | _ -> ctxt.verbose
+    let cond =
+      if ctxt.quiet then
+        false
+      else
+        match lvl with
+          | `Debug -> ctxt.debug
+          | `Info  -> ctxt.info
+          | _ -> true
     in
-      Printf.ksprintf 
-        (fun str -> 
+      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 = 
+
+  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/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISVersion.ml"
-  
+# 21 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/src/oasis/OASISVersion.ml"
+
   open OASISGettext
-  
-  
-  
+
+
+
   type s = string
-  
+
   type t = string 
-  
-  type comparator = 
+
+  type comparator =
     | VGreater of t
     | VGreaterEqual of t
     | VEqual 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 
+    function
       | '.' | '+' | '-' | '~' -> true
       | _ -> false
-  
+
   let rec version_compare v1 v2 =
     if v1 <> "" || v2 <> "" then
       begin
-        (* Compare ascii string, using special meaning for version 
+        (* Compare ascii string, using special meaning for version
          * related char
          *)
-        let val_ascii c = 
+        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 compare_vascii () =
           let cmp = ref 0 in
-          while !cmp = 0 && 
-                !p < len1 && !p < len2 && 
-                not (is_digit v1.[!p] && is_digit v2.[!p]) do 
+          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] 
+            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 compare_digit () =
           let extract_int v p =
             let start_p = !p in
-              while !p < String.length v && is_digit v.[!p] do 
+              while !p < String.length v && is_digit v.[!p] do
                 incr p
               done;
-              match String.sub v start_p (!p - start_p) with 
-                | "" -> 0, 
-                        v
-                | s -> int_of_string s, 
-                       String.sub v !p ((String.length v) - !p)
+              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 
+                  match compare_digit () with
                     | 0, tl1, tl2 ->
                         if tl1 <> "" && is_digit tl1.[0] then
                           1
       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 chop t = 
-    try 
-      let pos = 
-        String.rindex t '.' 
+
+
+  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 ->
           (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 
+    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)  -> 
+      | VOr (c1, c2)  ->
           (string_of_comparator c1)^" || "^(string_of_comparator c2)
-      | VAnd (c1, c2) -> 
+      | VAnd (c1, c2) ->
           (string_of_comparator c1)^" && "^(string_of_comparator c2)
-  
+
   let rec varname_of_comparator =
-    let concat p v = 
+    let concat p v =
       OASISUtils.varname_concat
-        p 
-        (OASISUtils.varname_of_string 
+        p
+        (OASISUtils.varname_of_string
            (string_of_version v))
     in
-      function 
+      function
         | VGreater v -> concat "gt" v
         | VLesser v  -> concat "lt" v
         | VEqual v   -> concat "eq" v
             (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/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISLicense.ml"
-  
+# 21 "/mnt/home/jun/.opam/system/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 = 
+
+  type license_version =
     | Version of OASISVersion.t
     | VersionOrLater of OASISVersion.t
     | NoVersion
     
-  
-  type license_dep_5 = 
-      {
-        license:    license;
-        exceptions: license_exception list;
-        version:    license_version;
-      } 
-  
+
+  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 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISExpr.ml"
-  
-  
-  
+# 21 "/mnt/home/jun/.opam/system/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
     | EFlag of flag
     | ETest of test * string
     
-  
+
   type 'a choices = (t * 'a) list 
-  
+
   let eval var_get t =
-    let rec eval' = 
+    let rec eval' =
       function
         | EBool b ->
             b
-  
-        | ENot e -> 
+
+        | ENot e ->
             not (eval' e)
-  
+
         | EAnd (e1, e2) ->
             (eval' e1) && (eval' e2)
-  
-        | EOr (e1, 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 = 
+    let rec choose_aux =
       function
         | (cond, vl) :: tl ->
-            if eval var_get cond then 
-              vl 
+            if eval var_get cond then
+              vl
             else
               choose_aux tl
         | [] ->
-            let str_lst = 
+            let str_lst =
               if lst = [] then
                 s_ "<empty>"
               else
-                String.concat 
+                String.concat
                   (s_ ", ")
                   (List.map
                      (fun (cond, vl) ->
                           | None -> s_ "<no printer>")
                      lst)
             in
-              match name with 
+              match name with
                 | Some nm ->
                     failwith
-                      (Printf.sprintf 
+                      (Printf.sprintf
                          (f_ "No result for the choice list '%s': %s")
                          nm str_lst)
                 | None ->
                          str_lst)
     in
       choose_aux (List.rev lst)
-  
+
 end
 
 module OASISTypes = struct
-# 21 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISTypes.ml"
-  
-  
-  
-  
+# 21 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/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 = 
+
+  type dependency =
     | FindlibPackage of findlib_full * OASISVersion.comparator option
     | InternalLibrary of name
     
-  
+
   type tool =
     | ExternalTool of name
-    | InternalExecutable of name 
+    | InternalExecutable of name
     
-  
-  type vcs = 
-    | Darcs 
-    | Git 
-    | Svn 
-    | Cvs 
-    | Hg 
-    | Bzr 
-    | Arch 
+
+  type vcs =
+    | Darcs
+    | Git
+    | Svn
+    | Cvs
+    | Hg
+    | Bzr
+    | Arch
     | Monotone
     | OtherVCS of url
     
-  
-  type plugin_kind = 
-      [  `Configure 
-       | `Build 
-       | `Doc 
-       | `Test 
-       | `Install 
+
+  type plugin_kind =
+      [  `Configure
+       | `Build
+       | `Doc
+       | `Test
+       | `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 all_plugin = plugin_kind plugin
+
   type plugin_data = (all_plugin * plugin_data_purpose * (unit -> unit)) list
-  
-# 102 "/home/yoriyuki/Action/ocaml/oasis-0.2.0/src/oasis/OASISTypes.ml"
-  
+
+# 102 "/mnt/home/jun/.opam/system/build/oasis.0.3.0/src/oasis/OASISTypes.ml"
+
   type 'a conditional = 'a OASISExpr.choices 
-  
-  type custom = 
+
+  type custom =
       {
         pre_command:  (command_line option) conditional;
-        post_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 = 
+
+  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 = 
+
+  type executable =
       {
         exec_custom:          bool;
         exec_main_is:         unix_filename;
       } 
-  
-  type flag = 
+
+  type flag =
       {
         flag_description:  string option;
         flag_default:      bool conditional;
       } 
-  
-  type source_repository = 
+
+  type source_repository =
       {
         src_repo_type:        vcs;
         src_repo_location:    url;
         src_repo_tag:         string option;
         src_repo_subdir:      unix_filename option;
       } 
-  
-  type test = 
+
+  type test =
       {
         test_type:               [`Test] plugin;
         test_command:            command_line conditional;
         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.Dat