CristalCaveGem » LustreC

# OASIS_START

SETUP = ocaml setup.ml

test: setup.data build

	$(SETUP) -test $(TESTFLAGS)

	$(SETUP) -all $(ALLFLAGS)

install: setup.data

reinstall: setup.data

	$(SETUP) -reinstall $(REINSTALLFLAGS)

	$(SETUP) -clean $(CLEANFLAGS)

	$(SETUP) -distclean $(DISTCLEANFLAGS)

setup.data:

	$(SETUP) -configure $(CONFIGUREFLAGS)

.PHONY: build doc test all install uninstall reinstall clean distclean configure

# OASIS_STOP

"src/backends/C": include

"src/backends/Horn": include

# OASIS_START

# useless stuff for the build process

<**/.svn>: -traverse

<**/.svn>: not_hygienic

#!/bin/sh

# OASIS_START

set -e

FST=true

  if $FST; then

    set --

    FST=false

(* OASIS_START *)

module OASISGettext = struct

  let ns_ str =

    str

  let s_ str =

    str

    str

  let fn_ fmt1 fmt2 n =

    if n = 1 then

      fmt1^^""

    else

      fmt2^^""

  let init =

    []

end

module OASISExpr = struct

  open OASISGettext

  type t =

    | EBool of bool

    | EOr of t * t

    | EFlag of flag

    | ETest of test * string

  let eval var_get t =

    let rec eval' =

    in

      eval' t

  let choose ?printer ?name var_get lst =

    let rec choose_aux =

      function

    in

      choose_aux (List.rev lst)

end

module BaseEnvLight = struct

  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

             filename)

      end

  let var_get name env =

  let var_choose lst env =

    OASISExpr.choose

end

module MyOCamlbuildFindlib = struct

    * http://brion.inria.fr/gallium/index.php/Using_ocamlfind_with_ocamlbuild

    * by N. Pouillard and others

    *

    * Updated on 2009/02/28

    *

    *)

  open Ocamlbuild_plugin

  (* these functions are not really officially exported *)

    Ocamlbuild_pack.My_unix.run_and_read

    Ocamlbuild_pack.Lexers.blank_sep_strings

  let split s ch =

    in

  let split_nl s = split s '\n'

  let before_space s =

    try

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

    with Not_found -> s

  let find_packages () =

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

  let find_syntaxes () = ["camlp4o"; "camlp4r"]

  let dispatch =

    function

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

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

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

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

      | After_rules ->

          flag ["ocaml"; "link"; "program"] & A"-linkpkg";

          (* For each ocamlfind package one inject the -package option when

           * compiling, computing dependencies, generating documentation and

           * linking. *)

            begin fun pkg ->

            (find_packages ());

          (* Like -package but for extensions syntax. Morover -syntax is useless

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

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

          ()

end

module MyOCamlbuildBase = struct

  (** Base functions for writing myocamlbuild.ml

      @author Sylvain Le Gall

  open Ocamlbuild_plugin

  module OC = Ocamlbuild_pack.Ocaml_compiler

  type t =

      {

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

        (* Replace the 'dir: include' from _tags by a precise interdepends in

         * directory.

         *)

  let env_filename =

      BaseEnvLight.default_filename

  let dispatch_combine lst =

    fun e ->

        (fun dispatch -> dispatch e)

  let tag_libstubs nm =

    "use_lib"^nm^"_stubs"

  let nm_libstubs nm =

    nm^"_stubs"

        ~allow_empty:true

        ()

    in

        | Before_options ->

            let no_trailing_dot s =

              if String.length s >= 1 && s.[0] = '.' then

            in

              List.iter

                (fun (opt, var) ->

                     opt := no_trailing_dot (BaseEnvLight.var_get var env)

                   with Not_found ->

                [

                  Options.ext_obj, "ext_obj";

                  Options.ext_lib, "ext_lib";

                  Options.ext_dll, "ext_dll";

                ]

            (* Declare OCaml libraries *)

              (function

                     ocaml_lib ~dir:dir (dir^"/"^nm);

                          List.iter

                            (fun str ->

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

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

              t.lib_ocaml;

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

              (fun (dir, include_dirs) ->

                 Pathname.define_context dir include_dirs)

              t.includes;

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

                   (* TODO: be more specific about what depends on headers *)

                   (* Depends on .h files *)

                     headers;

                   (* Setup search path for lib *)

                     (S[A"-I"; P(dir)]);

              )

              t.lib_c;

              (* Add flags *)

              List.iter

              (fun (tags, cond_specs) ->

                 in

              t.flags

            ()

  let dispatch_default t =

      [

        dispatch t;

        MyOCamlbuildFindlib.dispatch;

      ]

end

open Ocamlbuild_plugin;;

let package_default =

  {MyOCamlbuildBase.lib_ocaml = []; lib_c = []; flags = []; includes = []}

let dispatch_default = MyOCamlbuildBase.dispatch_default package_default;;

(* OASIS_STOP *)

Ocamlbuild_plugin.dispatch dispatch_default;;

(* setup.ml generated for the first time by OASIS v0.2.0 *)

(* OASIS_START *)

(*

   Visit http://oasis.forge.ocamlcore.org for more information and

   documentation about functions used in this file.

*)

module OASISGettext = struct

  let ns_ str =

    str

  let s_ str =

    str

    str

  let fn_ fmt1 fmt2 n =

    if n = 1 then

      fmt1^^""

    else

      fmt2^^""

  let init =

    []

end

module OASISContext = struct

  open OASISGettext

  type level =

    [ `Debug

    | `Info

    | `Warning

    | `Error]

  type t =

    {

      quiet:                 bool;

      info:                  bool;

      debug:                 bool;

      printf:                level -> string -> unit;

    }

  let printf lvl str =

    let beg =

      match lvl with

    in

      prerr_endline (beg^str)

  let default =

    ref

      {

        printf                = printf;

      }

  let quiet =

    {!default with quiet = true}

    ["-quiet",

     Arg.Unit (fun () -> default := {!default with quiet = true}),

     "-info",

     Arg.Unit (fun () -> default := {!default with info = true}),

     "-debug",

     Arg.Unit (fun () -> default := {!default with debug = true}),

end

module OASISString = struct

      Mostly inspired by extlib and batteries ExtString and BatString libraries.

      @author Sylvain Le Gall

    *)

  let nsplitf str f =

    if str = "" then

      []

        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

            !what_idx < String.length what do

        if str.[!str_idx] = what.[!what_idx] then

          incr what_idx

      done;

      if !what_idx <> String.length what then

        raise Not_found

        !str_idx - !what_idx

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

            !what_idx < String.length what do

        if str.[!str_idx] = what.[!what_idx] then

          incr what_idx

      done;

      if !what_idx = String.length what then

        true

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

            0 <= !what_idx do

        if str.[!str_idx] = what.[!what_idx] then

          decr what_idx

      done;

      if !what_idx = -1 then

        true

        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

      done;

      buf

end

module OASISUtils = struct

  open OASISGettext

  let compare_csl s1 s2 =

    String.compare (String.lowercase s1) (String.lowercase s2)

  module HashStringCsl =

    Hashtbl.Make

      (struct

           Hashtbl.hash (String.lowercase s)

       end)

  let varname_of_string ?(hyphen='_') s =

    if String.length s = 0 then

      begin

          String.lowercase buf

      end

  let varname_concat ?(hyphen='_') p s =

    let what = String.make 1 hyphen in

    let p =

  let is_varname str =

    str = varname_of_string str

  let failwithf fmt = Printf.ksprintf failwith fmt

end

module PropList = struct

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

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

             Some

               (Printf.sprintf (f_ "No default printer for value %s") nm)

         | Unknown_field (nm, schm) ->

         | _ ->

             None)

  module Data =

  struct

    type t =

        (name, unit -> unit) Hashtbl.t

    let clear t =

      Hashtbl.clear t

  end

  module Schema =

  struct

    type ('ctxt, 'extra) value =

        {

          get:   Data.t -> string;

      t.name

  end

  module Field =

  struct

    type ('ctxt, 'value, 'extra) t =

        {

          set:    Data.t -> ?context:'ctxt -> 'value -> unit;

    let fgets data t =

      t.gets data

  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

  open OASISGettext

  open OASISContext

  let generic_message ~ctxt lvl fmt =

    let cond =

      if ctxt.quiet then

             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

  open OASISGettext

  type s = string

  type comparator =

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

              while !p < String.length v && is_digit v.[!p] do

                incr p

              done;

                String.sub v !p ((String.length v) - !p)

                  | "" -> 0

                  | s -> int_of_string s

              in

  let version_of_string str = str

  let string_of_version t = t

  let chop t =

    try

      let pos =

    with Not_found ->

      t

  let rec comparator_apply v op =

    match op with

      | VGreater cv ->

      | VAnd (op1, op2) ->

          (comparator_apply v op1) && (comparator_apply v op2)

  let rec string_of_comparator =

    function

      | VGreater v  -> "> "^(string_of_version v)

      | VAnd (c1, c2) ->

          (string_of_comparator c1)^" && "^(string_of_comparator c2)

  let rec varname_of_comparator =

    let concat p v =

      OASISUtils.varname_concat

        | VAnd (c1, c2) ->

            (varname_of_comparator c1)^"_and_"^(varname_of_comparator c2)

end

module OASISLicense = struct

  (** License for _oasis fields

      @author Sylvain Le Gall

  type license_version =

    | Version of OASISVersion.t

    | VersionOrLater of OASISVersion.t

    | NoVersion

  type license_dep_5_unit =

    {

      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

  open OASISGettext

  type t =

    | EBool of bool

    | EOr of t * t

    | EFlag of flag

    | ETest of test * string

  let eval var_get t =

    let rec eval' =

    in

      eval' t

  let choose ?printer ?name var_get lst =

    let rec choose_aux =

      function

    in

      choose_aux (List.rev lst)

end

module OASISTypes = struct

  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

    | Arch

    | Monotone

    | OtherVCS of url

  type plugin_kind =

      [  `Configure

       | `Extra

      ]