CristalCaveGem » LustreC

(* OASIS_START *)

module OASISGettext = struct

    str

    str

  let f_ (str : ('a, 'b, 'c, 'd) format4) =

    str

  let fn_ fmt1 fmt2 n =

    if n = 1 then

      fmt1^^""

    else

      fmt2^^""

    []

end

module OASISExpr = struct

  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 =

      function

        | EBool b ->

            b

            not (eval' e)

        | EAnd (e1, e2) ->

            (eval' e1) && (eval' 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 =

      function

        | (cond, vl) :: tl ->

            else

              choose_aux tl

        | [] ->

              if lst = [] then

                s_ "<empty>"

              else

                  (s_ ", ")

                  (List.map

                     (fun (cond, vl) ->

                          | None -> s_ "<no printer>")

                     lst)

            in

                | Some nm ->

                    failwith

                         (f_ "No result for the choice list '%s': %s")

                         nm str_lst)

                | None ->

                         str_lst)

    in

      choose_aux (List.rev lst)

end

module BaseEnvLight = struct

  module MapString = Map.Make(String)

  type t = string MapString.t

  let default_filename =

      (Sys.getcwd ())

      "setup.data"

  let load ?(allow_empty=false) ?(filename=default_filename) () =

    if Sys.file_exists filename then

      begin

        let line =

          ref 1

        in

          Stream.from

            (fun _ ->

               try

                   | '\n' -> incr line; Some '\n'

                   | c -> Some c

               with Stream.Failure -> None)

        in

          Genlex.make_lexer ["="] st_line

        in

        let rec read_file mp =

            | [Genlex.Ident nm; Genlex.Kwd "="; Genlex.String value] ->

                Stream.junk lexer;

                read_file (MapString.add nm value mp)

            | [] ->

      end

    else

      begin

             "Unable to load environment, the file '%s' doesn't exist."

             filename)

      end

  let var_get name env =

    let rec var_expand str =

      let buff =

        Buffer.create ((String.length str) * 2)

      in

          buff

               var_expand (MapString.find var env)

             with Not_found ->

                    "No variable %s defined when trying to expand %S."

                    str))

          str;

        Buffer.contents buff

    in

      var_expand (MapString.find name env)

    OASISExpr.choose

      (fun nm -> var_get nm env)

      lst

end

module MyOCamlbuildFindlib = struct

  (** 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"; "link"] (S[A "-thread"]);

          flag ["ocaml"; "pkg_threads"; "infer_interface"] (S[A "-thread"])

      | _ -> 

          ()

end

module MyOCamlbuildBase = struct

  (** Base functions for writing myocamlbuild.ml

      @author Sylvain Le Gall

    *)

  open Ocamlbuild_plugin

  type dir = string 

  type file = string 

  type name = string 

  type tag = string 

  type t =

      {

        lib_ocaml: (name * dir list) list;

        lib_c:     (name * dir * file list) list; 

        flags:     (tag list * (spec OASISExpr.choices)) list;

      } 

  let env_filename =

    Pathname.basename 

      BaseEnvLight.default_filename

  let dispatch_combine lst =

    fun e ->

      List.iter 

        (fun dispatch -> dispatch e)

        lst 

  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

                     List.iter 

                       (fun dir -> 

                       tl)

              t.lib_ocaml;

            (* Declare C libraries *)

            List.iter

              (fun (lib, dir, headers) ->

                   (* Handle C part of library *)

                   (* When ocaml link something that use the C library, then one

                      need that file to be up to date.

                    *)

                   (* 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

open Ocamlbuild_plugin;;

let package_default =

  ;;

let dispatch_default = MyOCamlbuildBase.dispatch_default package_default;;

(* OASIS_STOP *)

Ocamlbuild_plugin.dispatch dispatch_default;;