CristalCaveGem » LustreC

(* OASIS_START *)

  let ns_ str =

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

    if n = 1 then

      fmt1^^""

    else

      fmt2^^""

module OASISExpr = struct

  type flag = string

    | 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

        | EBool b ->

            b

        | ENot e ->

            (eval' e1) && (eval' e2)

        | EOr (e1, e2) ->

            let v =

              var_get nm

            in

              assert(v = "true" || v = "false");

              (v = "true")

            let v =

              var_get nm

            in

              (v = vl)

    in

      eval' t

        | (cond, vl) :: tl ->

              vl

              choose_aux tl

        | [] ->

                s_ "<empty>"

              else

                  (List.map

                     (fun (cond, vl) ->

                        match printer with

                          | Some p -> p vl

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

                     lst)

            in

                    failwith

                         nm str_lst)

                | None ->

                    failwith

                      (Printf.sprintf

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

                         str_lst)

    in

      choose_aux (List.rev lst)

      "setup.data"

    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

            (fun _ ->

               try

                   | c -> Some c

               with Stream.Failure -> None)

        in

        in

        let rec read_file mp =

                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

          (Printf.sprintf

             filename)

      end

  let rec var_expand str env =

    let buff =

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

        buff

        (fun var ->

           try

             var_expand (MapString.find var env) env

           with Not_found ->

             failwith

               (Printf.sprintf

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

                  var

                  str))

        str;

      Buffer.contents buff

  let var_get name env =

    var_expand (MapString.find name env) env

  let var_choose lst env =

      (fun nm -> var_get nm env)

      lst

end

    * by N. Pouillard and others

    *

    * Updated on 2009/02/28

    *

  open Ocamlbuild_plugin

  let blank_sep_strings =

  let exec_from_conf exec =

    let exec =

      let env_filename = Pathname.basename BaseEnvLight.default_filename in

      let env = BaseEnvLight.load ~filename:env_filename ~allow_empty:true () in

      try

        BaseEnvLight.var_get exec env

      with Not_found ->

        Printf.eprintf "W: Cannot get variable %s\n" exec;

        exec

    in

    let fix_win32 str =

      if Sys.os_type = "Win32" then begin

        let buff = Buffer.create (String.length str) in

        (* Adapt for windowsi, ocamlbuild + win32 has a hard time to handle '\\'.

         *)

        String.iter

          (fun c -> Buffer.add_char buff (if c = '\\' then '/' else c))

          str;

        Buffer.contents buff

      end else begin

        str

      end

  let split s ch =

    let buf = Buffer.create 13 in

    let x = ref [] in

    let flush () =

      x := (Buffer.contents buf) :: !x;

      Buffer.clear buf

        (fun c ->

           if c = ch then

             flush ()

           else

             Buffer.add_char buf c)

        s;

      flush ();

      List.rev !x

    try

      String.before s (String.index s ' ')

    with Not_found -> s

  let ocamlfind x = S[Sh (exec_from_conf "ocamlfind"); x]

  (* This lists all supported packages. *)

    List.map before_space (split_nl & run_and_read "ocamlfind list")

  (* Mock to list available syntaxes. *)

  let well_known_syntax = [

    "camlp4.quotations.o";

    "camlp4.quotations.r";

    "camlp4.exceptiontracer";

    "camlp4.extend";

    "camlp4.foldgenerator";

    "camlp4.listcomprehension";

    "camlp4.locationstripper";

    "camlp4.macro";

    "camlp4.mapgenerator";

    "camlp4.metagenerator";

    "camlp4.profiler";

    "camlp4.tracer"

  ]

    function

          (* 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.ocamlopt   := ocamlfind & A"ocamlopt";

          Options.ocamldep   := ocamlfind & A"ocamldep";

          Options.ocamldoc   := ocamlfind & A"ocamldoc";

          Options.ocamlmklib := ocamlfind & A"ocamlmklib"

          (* When one link an OCaml library/binary/package, one should use

           * -linkpkg *)

           * compiling, computing dependencies, generating documentation and

           * linking. *)

              (* TODO: consider how to really choose camlp4o or camlp4r. *)

              let syn_args = [A"-syntax"; A "camlp4o"] in

              let args =

              (* Heuristic to identify syntax extensions: whether they end in

                 ".syntax"; some might not.

               *)

                if Filename.check_suffix pkg "syntax" ||

                   List.mem pkg well_known_syntax then

                  syn_args @ base_args

                else

                  base_args

              in

              flag ["ocaml"; "compile";  "pkg_"^pkg] & S args;

              flag ["ocaml"; "ocamldep"; "pkg_"^pkg] & S args;

              flag ["ocaml"; "doc";      "pkg_"^pkg] & S args;

              flag ["ocaml"; "link";     "pkg_"^pkg] & S base_args;

              flag ["ocaml"; "infer_interface"; "pkg_"^pkg] & S args;

            end

           * 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];

                S[A"-syntax"; A syntax];

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

           * the "threads" package using the previous plugin.

           *)

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

          flag ["ocaml"; "package(threads)"; "compile"] (S[A "-thread"]);

          flag ["ocaml"; "package(threads)"; "doc"] (S[A "-I"; A "+threads"]);

          flag ["ocaml"; "package(threads)"; "link"] (S[A "-thread"]);

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

end

module MyOCamlbuildBase = struct

      @author Sylvain Le Gall

    *)

  type file = string

  type name = string

  type tag = string

(* # 62 "src/plugins/ocamlbuild/MyOCamlbuildBase.ml" *)

      {

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

         * directory.

         *)

      }

    fun e ->

  let tag_libstubs nm =

    "use_lib"^nm^"_stubs"

    nm^"_stubs"

  let dispatch t e =

    let env =

      BaseEnvLight.load

        ~filename:env_filename

        ()

    in

            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) ->

                   with Not_found ->

                  Options.ext_obj, "ext_obj";

                  Options.ext_lib, "ext_lib";

                  Options.ext_dll, "ext_dll";

                ]

                     ocaml_lib nm;

                     let cmis =

                       List.map (fun m -> (String.uncapitalize m) ^ ".cmi")

                                intf_modules in

                     dep ["ocaml"; "link"; "library"; "file:"^nm^".cma"] cmis

                 | nm, dir :: tl, intf_modules ->

                       (fun dir ->

                            (fun str ->

                               flag ["ocaml"; "use_"^nm; str] (S[A"-I"; P dir]))

                            ["compile"; "infer_interface"; "doc"])

                     let cmis =

                       List.map (fun m -> dir^"/"^(String.uncapitalize m)^".cmi")

                                intf_modules in

                     dep ["ocaml"; "link"; "library"; "file:"^dir^"/"^nm^".cma"]

                         cmis)

            (* Declare directories dependencies, replace "include" in _tags. *)

                 Pathname.define_context dir include_dirs)

              t.includes;

            List.iter

              (fun (lib, dir, headers) ->

                   (* Handle C part of library *)

                     (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))]);

                     (S[A"-dllib"; A("dll"^(nm_libstubs lib))]);

                      need that file to be up to date.

                    *)

                     [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];

                   dep  ["compile"; "ocaml"; "program"; tag_libstubs lib]

                     [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];

                   (* Depends on .h files *)

              )

              t.lib_c;

              List.iter

              (fun (tags, cond_specs) ->

                 let rec eval_specs =

                   function

                     | S lst -> S (List.map eval_specs lst)

                     | A str -> A (BaseEnvLight.var_expand str env)

                     | spec -> spec

        dispatch t;

        MyOCamlbuildFindlib.dispatch;

      ]

let package_default =

let dispatch_default = MyOCamlbuildBase.dispatch_default package_default;;

Ocamlbuild_plugin.dispatch dispatch_default;;