myocamlbuild.ml.in

open Ocamlbuild_plugin
open Printf

let ocaml = "@OCAML@"
let ocamlc = "@OCAMLC@"
let ocamlopt = "@OCAMLOPT@"
let ocamlbest = "@OCAMLBEST@"
let ocamldep = "@OCAMLDEP@"
let ocamlmktop = "@OCAMLMKTOP@"
let ocamlmklib = "@OCAMLMKLIB@"
let ocamldoc = "@OCAMLDOC@"
let ocamlfind_destdir = "@OCAMLFIND_DESTDIR@"

let native_available = ocamlc != ocamlbest
let lablgl_available = "@OCAML_PKG_lablgl@" <> "no"
let lablgl_dir = "@LABGL_DIR@"
let lwt_available = "@OCAML_PKG_lwt_extra@" <> "no"
let lwt_dir = "@LWT_DIR@"

let general_cflags = "@CFLAGS@"

(* Set the toolchain from the autoconf variables *)
let set_options () =
  let f x y = x := P y in
  f Options.ocamlc ocamlc;
  f Options.ocamlopt ocamlopt;
  f Options.ocamldep ocamldep;
  f Options.ocamlmktop ocamlmktop;
  f Options.ocamlmklib ocamlmklib;
  f Options.ocamldoc ocamldoc

let elementary_cflags = "@ELEMENTARY_CFLAGS@"
let elementary_libs = "@ELEMENTARY_LIBS@"
let elementary_version = "@ELEMENTARY_VERSION@"
let elm_eo_class_obj = "@ELM_EO_CLASS_OBJ@"

let ( & ) f x  = f x

(* The file variants.h is generated: this function adds the rules of builing *)
let write_variants () =
  let action env builder =
    Cmd (S [P ocaml; P ("src" / "write_variants.ml"); Sh ">";
      P ("src" / "variants.h")]) in
  rule "write_variants2" ~prod:("src" / "variants.h")
    ~dep:("src" / "write_variants.ml") action;
  (*dep ["c"; "compile"; "efl"] ["src" / "variants.h"]*)
  dep ["extension:c"] ["src" / "variants.h"]

(* Add a rule to generate src/intro.txt *)
let write_intro () =
  let intro = "src" / "intro.txt" in
  let lib = "src" / "efl_doc.odocl" in
  let action env builder =
          Cmd (S [P ocaml; P ("src" / "write_intro.ml"); P lib; P intro]) in
  let deps = ["src" / "write_intro.ml"; lib] in
  rule "write_intro" ~prod:intro ~deps action;
  flag_and_dep ["doc"; "extension:html"] (S [A "-intro"; P intro]);
  flag_and_dep ["doc"; "extension:html"] (P ("src" / "start.txt"));
  flag ["doc"; "extension:html"] (Sh "-t \"OCaml EFL Documentation\"");
  flag ["doc"; "extension:html"] (A "-colorize-code")

(* Add rules to generate src/elm_connect{.ml,.mli,_wrap.c}*)
let write_connect () =
  let widgets_filename = "src" / "write_connect" / "widgets.txt" in
  let get_txt_dep () =
    let ch = open_in widgets_filename in
    let r = ref [] in
    (try while true do
      let s = input_line ch in
      r := s :: !r
    done with End_of_file -> ());
    close_in ch;
    let aux s = ["src" / "write_connect" / (sprintf "%s.txt" s)] in
    List.rev_map aux !r in
  let gen_prog = "src" / "write_connect" / "main.cma" in
  let action env builder =
    let deps = get_txt_dep () in
    List.iter (function
    | Outcome.Good _ -> ()
    | Outcome.Bad exn -> raise exn)  (builder deps);
    let arg = P elm_eo_class_obj in
    Cmd (S [P ocaml; P gen_prog; arg]) in
  let prods = [
    "src" / "elm_connect.mli";
    "src" / "elm_connect.ml";
    "src" / "elm_connect_wrap.c"
  ] in
  rule "write_connect" ~deps:[gen_prog; widgets_filename] ~prods action

(* Add rules to generate enum bindings *)
let write_enums () =
  let enums_filename = "src" / "write_enums" / "enums.txt" in
  let gen_prog = "src" / "write_enums" / "main.cma" in
  let action _ _ = Cmd (S [P ocaml; P gen_prog]) in
  let deps = [gen_prog; enums_filename] in
  let prods = [
    "src" / "henums.ml";
    "src" / "enums_wrap.c";
    "src" / "enums_wrap.h";
    "src" / "enums_variants_wrap.h";
    "src" / "write_enums" / "help.mli";
    "src" / "write_enums" / "help.ml";
    "src" / "henums_check.ml"
  ] in
  rule "write_enums" ~deps ~prods action;
  dep ["extension:c"] prods;
  dep ["file:src/enums_wrap.c"] ["src" / "include.h"]

(* Add rules to generate structure bindings *)
let write_struct () =
  let struct_filename = "src" / "write_struct" / "structs.txt" in
  let gen_prog = "src" / "write_struct" / "main.cma" in
  let action _ _ = Cmd (S [P ocaml; P gen_prog]) in
  let deps = [gen_prog; struct_filename] in
  let prods = [
    "src" / "hstructs.ml";
    "src" / "structs_wrap.c";
    "src" / "structs_wrap.h";
    "src" / "write_struct" / "help.mli";
  ] in
  rule "write_struct" ~deps ~prods action;
  dep ["extension:c"] prods;
  dep ["file:src/structs_wrap.c"] ["src" / "include.h"]

(* Add rule to generate other_wrap.{h,c} *)
let write_other () =
  let gen_prog = "src" / "write_other.cma" in
  let action _ _ = Cmd (S [P ocaml; P gen_prog]) in
  let deps = [gen_prog] in
  let prods = [
    "src" / "other_wrap.h";
    "src" / "other_wrap.c";
  ] in
  rule "write_other" ~deps ~prods action;
  dep ["extension:c"] prods;
  dep ["file:src/write_other.c"] ["src" / "include.h"]

(* Add rule to generate autofun* *)
let write_autofun () =
  let gen_prog = "src" / "write_fun" / "main.cma" in
  let action _ _ = Cmd (S [P ocaml; P gen_prog]) in
  let deps = [gen_prog] in
  let prods = [
    "src" / "autofun.ml";
    "src" / "autofun_wrap.c";
    "src" / "autofun_check.ml";
  ] in
  rule "write_autofun" ~deps ~prods action;
  dep ["file:src/autofun_wrap.c"] ["src" / "include.h"]

(* Add rule to generate file efl.mli *)
let write_big_mli () =
  let mlpack_name = "src" / "efl.mlpack" in
  let gen_prog = "src" / "write_big_mli.cma" in
  let action env build =
    let modules = string_list_of_file mlpack_name in
    let check_public = function
      | "Henums" | "Henums_check" | "Hstructs"
        | "Autofun" | "Autofun_check" | "Common" -> false
      | _ -> true in
    let public_modules = List.filter check_public modules in
    let mli_of_module s = "src" / String.uncapitalize s ^ ".mli" in
    let mli_files = List.map mli_of_module public_modules in
    let deps = List.map (fun x -> [x]) mli_files in
    List.iter (function
      | Outcome.Good _ -> ()
      | Outcome.Bad exn -> raise exn) (build deps);
    let args = List.map (fun s -> Sh s) public_modules in
    Cmd (S [P ocaml; P gen_prog; S args]) in
  let deps = [gen_prog; mlpack_name] in
  let prod = "src" / "efl.mli" in
  rule "write_big_mli" ~deps ~prod ~insert:`top action

(* Add rule to generate files from *.multi.* *)
let rule_multi () =
  let f kind suffix =
    let src = sprintf "%%.%s.multi" suffix in
    let prog = "src" / "write_multi.ml" in
    let deps = [prog; src] in
    let prod = sprintf "%%.%s" suffix in
    let action env _ =
      let src = env src and prod = env prod in
      Cmd(S [P ocaml; P prog; Sh kind; Sh elementary_version; P src; P prod]) in
    rule (sprintf "multi_%s" suffix) ~deps ~prod ~insert:`bottom action in
  f "ml" "ml";
  f "ml" "mli";
  f "ml" "txt";
  f "c" "c";
  f "c" "h"

let add_header_depends () =
  let headers = [
    "include.h";
    "eina_wrap.h";
    "evas_wrap.h";
    "evas_event_wrap.h";
    "evas_object_wrap.h";
    "ecore_wrap.h";
    "ethumb_wrap.h";
    "edje_wrap.h";
    "elm_wrap.h";
    "elm_object_wrap.h";
    "elm_gen_wrap.h";
    "elm_calendar_wrap.h";
    "elm_clock_wrap.h";
    "elm_dayselector_wrap.h";
    "elm_entry_wrap.h";
    "elm_icon_wrap.h";
    "elm_list_wrap.h";
    "elm_scroller_wrap.h";
    "elm_web_wrap.h";
  ] in
  List.iter (fun s -> dep ["extension:c"] ["src" / s]) headers

let rule_examples () =
  let dep = "examples" / "list.txt" in
  let prod = "ex" in
  let action env build =
    let list = string_list_of_file dep in
    let list1 = List.filter (function
      | "myglview_example" -> lablgl_available
      | "lwt_example" -> lwt_available
      | x -> true) list in
    let aux x =
      if native_available && x = "test" then [sprintf "examples/%s.native" x]
      else [sprintf "examples/%s.byte" x] in
    let deps = List.map aux list1 in
    List.iter (function
      | Outcome.Good _ -> ()
      | Outcome.Bad exn -> raise exn) (build deps);
    Nop in
  rule "examples" ~dep ~prod action;
  flag ["link"; "pkg_unix"] (Sh "unix.cma");
  flag ["link"; "pkg_thread"] (Sh "-thread unix.cma threads.cma");
  flag ["compile"; "pkg_thread"] (Sh "-thread");
  if lablgl_available then (
    tag_file "examples/myglview_example.cmo" ["pkg_lablgl"];
    tag_file "examples/myglview_example.byte" ["pkg_lablgl"];
    flag ["compile"; "pkg_lablgl"] (Sh (sprintf "-I %s" lablgl_dir));
    flag ["link"; "pkg_lablgl"] (Sh (sprintf "-I %s lablgl.cma" lablgl_dir))
  );
  if lwt_available then (
    tag_file "examples/lwt_example.cmo" ["pkg_lwt"];
    tag_file "examples/lwt_example.byte" ["pkg_lwt"];
    flag ["compile"; "pkg_lwt"] (Sh (sprintf "-I %s" lwt_dir));
    flag ["link"; "pkg_lwt"]  (Sh (sprintf
      "-I %s bigarray.cma lwt.cma lwt-unix.cma lwt-preemptive.cma lwt-extra.cma"
      lwt_dir))
  )
    
let () = dispatch & fun h ->
  match h with
  | After_options ->
    (* We want a clean root directory *)
    Options.make_links := false;
    Options.include_dirs := ["src"];
    set_options ();
  | After_rules ->
    write_variants ();
    write_intro ();
    write_connect ();
    write_enums ();
    write_struct ();
    write_other ();
    write_autofun ();
    write_big_mli ();
    add_header_depends ();
    rule_examples ();
    rule_multi ();

    flag ["file:src/efl.cma"] (Sh "-dllib -lefl_stubs");
    flag ["examples"; "link"; "byte"] (Sh (sprintf "-I src -dllpath _build/src -dllpath %s/stublibs -dllib -lefl_stubs" ocamlfind_destdir));
    flag ["file:src/efl.cmxa"] (Sh "-cclib -lefl_stubs");
    dep ["file:src/efl.cma"] ["src" / "libefl_stubs.a"];
    dep ["examples"] ["src" / "libefl_stubs.a"];

    (* Insert flags and linking information about the EFL *)
    flag ["compile"; "c"] (Sh (sprintf "-ccopt \"%s %s\"" elementary_cflags
      general_cflags));
    flag ["use_libefl_stubs"] (Sh (sprintf "-cclib '%s'" elementary_libs));
    flag ["ocamlmklib"] (Sh elementary_libs);

    (* Used to compile the examples *)
    flag ["use_efl"; "link"] (Sh (sprintf "-cclib '%s'" elementary_libs));

    (* Removed a harmless warning in generating the documentation *)
    flag ["doc"] (Sh "-hide-warnings");
  | _ -> ()