myocamlbuild.ml

   1 (* OASIS_START *)
   2 (* DO NOT EDIT (digest: a9256c48d09d8920f4249d0b08175f1b) *)
   3 module OASISGettext = struct
   4 (* # 22 "src/oasis/OASISGettext.ml" *)
   5
   6
   7   let ns_ str = str
   8   let s_ str = str
   9   let f_ (str: ('a, 'b, 'c, 'd) format4) = str
  10
  11
  12   let fn_ fmt1 fmt2 n =
  13     if n = 1 then
  14       fmt1^^""
  15     else
  16       fmt2^^""
  17
  18
  19   let init = []
  20 end
  21
  22 module OASISString = struct
  23 (* # 22 "src/oasis/OASISString.ml" *)
  24
  25
  26   (** Various string utilities.
  27
  28       Mostly inspired by extlib and batteries ExtString and BatString libraries.
  29
  30       @author Sylvain Le Gall
  31   *)
  32
  33
  34   let nsplitf str f =
  35     if str = "" then
  36       []
  37     else
  38       let buf = Buffer.create 13 in
  39       let lst = ref [] in
  40       let push () =
  41         lst := Buffer.contents buf :: !lst;
  42         Buffer.clear buf
  43       in
  44       let str_len = String.length str in
  45       for i = 0 to str_len - 1 do
  46         if f str.[i] then
  47           push ()
  48         else
  49           Buffer.add_char buf str.[i]
  50       done;
  51       push ();
  52       List.rev !lst
  53
  54
  55   (** [nsplit c s] Split the string [s] at char [c]. It doesn't include the
  56       separator.
  57   *)
  58   let nsplit str c =
  59     nsplitf str ((=) c)
  60
  61
  62   let find ~what ?(offset=0) str =
  63     let what_idx = ref 0 in
  64     let str_idx = ref offset in
  65     while !str_idx < String.length str &&
  66           !what_idx < String.length what do
  67       if str.[!str_idx] = what.[!what_idx] then
  68         incr what_idx
  69       else
  70         what_idx := 0;
  71       incr str_idx
  72     done;
  73     if !what_idx <> String.length what then
  74       raise Not_found
  75     else
  76       !str_idx - !what_idx
  77
  78
  79   let sub_start str len =
  80     let str_len = String.length str in
  81     if len >= str_len then
  82       ""
  83     else
  84       String.sub str len (str_len - len)
  85
  86
  87   let sub_end ?(offset=0) str len =
  88     let str_len = String.length str in
  89     if len >= str_len then
  90       ""
  91     else
  92       String.sub str 0 (str_len - len)
  93
  94
  95   let starts_with ~what ?(offset=0) str =
  96     let what_idx = ref 0 in
  97     let str_idx = ref offset in
  98     let ok = ref true in
  99     while !ok &&
 100           !str_idx < String.length str &&
 101           !what_idx < String.length what do
 102       if str.[!str_idx] = what.[!what_idx] then
 103         incr what_idx
 104       else
 105         ok := false;
 106       incr str_idx
 107     done;
 108     !what_idx = String.length what
 109
 110
 111   let strip_starts_with ~what str =
 112     if starts_with ~what str then
 113       sub_start str (String.length what)
 114     else
 115       raise Not_found
 116
 117
 118   let ends_with ~what ?(offset=0) str =
 119     let what_idx = ref ((String.length what) - 1) in
 120     let str_idx = ref ((String.length str) - 1) in
 121     let ok = ref true in
 122     while !ok &&
 123           offset <= !str_idx &&
 124           0 <= !what_idx do
 125       if str.[!str_idx] = what.[!what_idx] then
 126         decr what_idx
 127       else
 128         ok := false;
 129       decr str_idx
 130     done;
 131     !what_idx = -1
 132
 133
 134   let strip_ends_with ~what str =
 135     if ends_with ~what str then
 136       sub_end str (String.length what)
 137     else
 138       raise Not_found
 139
 140
 141   let replace_chars f s =
 142     let buf = Buffer.create (String.length s) in
 143     String.iter (fun c -> Buffer.add_char buf (f c)) s;
 144     Buffer.contents buf
 145
 146   let lowercase_ascii =
 147     replace_chars
 148       (fun c ->
 149          if (c >= 'A' && c <= 'Z') then
 150            Char.chr (Char.code c + 32)
 151          else
 152            c)
 153
 154   let uncapitalize_ascii s =
 155     if s <> "" then
 156       (lowercase_ascii (String.sub s 0 1)) ^ (String.sub s 1 ((String.length s) - 1))
 157     else
 158       s
 159
 160   let uppercase_ascii =
 161     replace_chars
 162       (fun c ->
 163          if (c >= 'a' && c <= 'z') then
 164            Char.chr (Char.code c - 32)
 165          else
 166            c)
 167
 168   let capitalize_ascii s =
 169     if s <> "" then
 170       (uppercase_ascii (String.sub s 0 1)) ^ (String.sub s 1 ((String.length s) - 1))
 171     else
 172       s
 173
 174 end
 175
 176 module OASISUtils = struct
 177 (* # 22 "src/oasis/OASISUtils.ml" *)
 178
 179
 180   open OASISGettext
 181
 182
 183   module MapExt =
 184   struct
 185     module type S =
 186     sig
 187       include Map.S
 188       val add_list: 'a t -> (key * 'a) list -> 'a t
 189       val of_list: (key * 'a) list -> 'a t
 190       val to_list: 'a t -> (key * 'a) list
 191     end
 192
 193     module Make (Ord: Map.OrderedType) =
 194     struct
 195       include Map.Make(Ord)
 196
 197       let rec add_list t =
 198         function
 199           | (k, v) :: tl -> add_list (add k v t) tl
 200           | [] -> t
 201
 202       let of_list lst = add_list empty lst
 203
 204       let to_list t = fold (fun k v acc -> (k, v) :: acc) t []
 205     end
 206   end
 207
 208
 209   module MapString = MapExt.Make(String)
 210
 211
 212   module SetExt  =
 213   struct
 214     module type S =
 215     sig
 216       include Set.S
 217       val add_list: t -> elt list -> t
 218       val of_list: elt list -> t
 219       val to_list: t -> elt list
 220     end
 221
 222     module Make (Ord: Set.OrderedType) =
 223     struct
 224       include Set.Make(Ord)
 225
 226       let rec add_list t =
 227         function
 228           | e :: tl -> add_list (add e t) tl
 229           | [] -> t
 230
 231       let of_list lst = add_list empty lst
 232
 233       let to_list = elements
 234     end
 235   end
 236
 237
 238   module SetString = SetExt.Make(String)
 239
 240
 241   let compare_csl s1 s2 =
 242     String.compare (OASISString.lowercase_ascii s1) (OASISString.lowercase_ascii s2)
 243
 244
 245   module HashStringCsl =
 246     Hashtbl.Make
 247       (struct
 248          type t = string
 249          let equal s1 s2 = (compare_csl s1 s2) = 0
 250          let hash s = Hashtbl.hash (OASISString.lowercase_ascii s)
 251        end)
 252
 253   module SetStringCsl =
 254     SetExt.Make
 255       (struct
 256          type t = string
 257          let compare = compare_csl
 258        end)
 259
 260
 261   let varname_of_string ?(hyphen='_') s =
 262     if String.length s = 0 then
 263       begin
 264         invalid_arg "varname_of_string"
 265       end
 266     else
 267       begin
 268         let buf =
 269           OASISString.replace_chars
 270             (fun c ->
 271                if ('a' <= c && c <= 'z')
 272                  ||
 273                   ('A' <= c && c <= 'Z')
 274                  ||
 275                   ('0' <= c && c <= '9') then
 276                  c
 277                else
 278                  hyphen)
 279             s;
 280         in
 281         let buf =
 282           (* Start with a _ if digit *)
 283           if '0' <= s.[0] && s.[0] <= '9' then
 284             "_"^buf
 285           else
 286             buf
 287         in
 288           OASISString.lowercase_ascii buf
 289       end
 290
 291
 292   let varname_concat ?(hyphen='_') p s =
 293     let what = String.make 1 hyphen in
 294     let p =
 295       try
 296         OASISString.strip_ends_with ~what p
 297       with Not_found ->
 298         p
 299     in
 300     let s =
 301       try
 302         OASISString.strip_starts_with ~what s
 303       with Not_found ->
 304         s
 305     in
 306       p^what^s
 307
 308
 309   let is_varname str =
 310     str = varname_of_string str
 311
 312
 313   let failwithf fmt = Printf.ksprintf failwith fmt
 314
 315
 316   let rec file_location ?pos1 ?pos2 ?lexbuf () =
 317       match pos1, pos2, lexbuf with
 318       | Some p, None, _ | None, Some p, _ ->
 319         file_location ~pos1:p ~pos2:p ?lexbuf ()
 320       | Some p1, Some p2, _ ->
 321         let open Lexing in
 322         let fn, lineno = p1.pos_fname, p1.pos_lnum in
 323         let c1 = p1.pos_cnum - p1.pos_bol in
 324         let c2 = c1 + (p2.pos_cnum - p1.pos_cnum) in
 325         Printf.sprintf (f_ "file %S, line %d, characters %d-%d")  fn lineno c1 c2
 326       | _, _, Some lexbuf ->
 327         file_location
 328           ~pos1:(Lexing.lexeme_start_p lexbuf)
 329           ~pos2:(Lexing.lexeme_end_p lexbuf)
 330           ()
 331       | None, None, None ->
 332         s_ "<position undefined>"
 333
 334
 335   let failwithpf ?pos1 ?pos2 ?lexbuf fmt =
 336     let loc = file_location ?pos1 ?pos2 ?lexbuf () in
 337     Printf.ksprintf (fun s -> failwith (Printf.sprintf "%s: %s" loc s)) fmt
 338
 339
 340 end
 341
 342 module OASISExpr = struct
 343 (* # 22 "src/oasis/OASISExpr.ml" *)
 344
 345
 346   open OASISGettext
 347   open OASISUtils
 348
 349
 350   type test = string
 351   type flag = string
 352
 353
 354   type t =
 355     | EBool of bool
 356     | ENot of t
 357     | EAnd of t * t
 358     | EOr of t * t
 359     | EFlag of flag
 360     | ETest of test * string
 361
 362
 363   type 'a choices = (t * 'a) list
 364
 365
 366   let eval var_get t =
 367     let rec eval' =
 368       function
 369         | EBool b ->
 370             b
 371
 372         | ENot e ->
 373             not (eval' e)
 374
 375         | EAnd (e1, e2) ->
 376             (eval' e1) && (eval' e2)
 377
 378         | EOr (e1, e2) ->
 379             (eval' e1) || (eval' e2)
 380
 381         | EFlag nm ->
 382             let v =
 383               var_get nm
 384             in
 385               assert(v = "true" || v = "false");
 386               (v = "true")
 387
 388         | ETest (nm, vl) ->
 389             let v =
 390               var_get nm
 391             in
 392               (v = vl)
 393     in
 394       eval' t
 395
 396
 397   let choose ?printer ?name var_get lst =
 398     let rec choose_aux =
 399       function
 400         | (cond, vl) :: tl ->
 401             if eval var_get cond then
 402               vl
 403             else
 404               choose_aux tl
 405         | [] ->
 406             let str_lst =
 407               if lst = [] then
 408                 s_ "<empty>"
 409               else
 410                 String.concat
 411                   (s_ ", ")
 412                   (List.map
 413                      (fun (cond, vl) ->
 414                         match printer with
 415                           | Some p -> p vl
 416                           | None -> s_ "<no printer>")
 417                      lst)
 418             in
 419               match name with
 420                 | Some nm ->
 421                     failwith
 422                       (Printf.sprintf
 423                          (f_ "No result for the choice list '%s': %s")
 424                          nm str_lst)
 425                 | None ->
 426                     failwith
 427                       (Printf.sprintf
 428                          (f_ "No result for a choice list: %s")
 429                          str_lst)
 430     in
 431       choose_aux (List.rev lst)
 432
 433
 434 end
 435
 436
 437 # 437 "myocamlbuild.ml"
 438 module BaseEnvLight = struct
 439 (* # 22 "src/base/BaseEnvLight.ml" *)
 440
 441
 442   module MapString = Map.Make(String)
 443
 444
 445   type t = string MapString.t
 446
 447
 448   let default_filename = Filename.concat (Sys.getcwd ()) "setup.data"
 449
 450
 451   let load ?(allow_empty=false) ?(filename=default_filename) ?stream () =
 452     let line = ref 1 in
 453     let lexer st =
 454       let st_line =
 455         Stream.from
 456           (fun _ ->
 457              try
 458                match Stream.next st with
 459                | '\n' -> incr line; Some '\n'
 460                | c -> Some c
 461              with Stream.Failure -> None)
 462       in
 463       Genlex.make_lexer ["="] st_line
 464     in
 465     let rec read_file lxr mp =
 466       match Stream.npeek 3 lxr with
 467       | [Genlex.Ident nm; Genlex.Kwd "="; Genlex.String value] ->
 468         Stream.junk lxr; Stream.junk lxr; Stream.junk lxr;
 469         read_file lxr (MapString.add nm value mp)
 470       | [] -> mp
 471       | _ ->
 472         failwith
 473           (Printf.sprintf "Malformed data file '%s' line %d" filename !line)
 474     in
 475     match stream with
 476     | Some st -> read_file (lexer st) MapString.empty
 477     | None ->
 478       if Sys.file_exists filename then begin
 479         let chn = open_in_bin filename in
 480         let st = Stream.of_channel chn in
 481         try
 482           let mp = read_file (lexer st) MapString.empty in
 483           close_in chn; mp
 484         with e ->
 485           close_in chn; raise e
 486       end else if allow_empty then begin
 487         MapString.empty
 488       end else begin
 489         failwith
 490           (Printf.sprintf
 491              "Unable to load environment, the file '%s' doesn't exist."
 492              filename)
 493       end
 494
 495   let rec var_expand str env =
 496     let buff = Buffer.create ((String.length str) * 2) in
 497     Buffer.add_substitute
 498       buff
 499       (fun var ->
 500          try
 501            var_expand (MapString.find var env) env
 502          with Not_found ->
 503            failwith
 504              (Printf.sprintf
 505                 "No variable %s defined when trying to expand %S."
 506                 var
 507                 str))
 508       str;
 509     Buffer.contents buff
 510
 511
 512   let var_get name env = var_expand (MapString.find name env) env
 513   let var_choose lst env = OASISExpr.choose (fun nm -> var_get nm env) lst
 514 end
 515
 516
 517 # 517 "myocamlbuild.ml"
 518 module MyOCamlbuildFindlib = struct
 519 (* # 22 "src/plugins/ocamlbuild/MyOCamlbuildFindlib.ml" *)
 520
 521
 522   (** OCamlbuild extension, copied from
 523     * https://ocaml.org/learn/tutorials/ocamlbuild/Using_ocamlfind_with_ocamlbuild.html
 524     * by N. Pouillard and others
 525     *
 526     * Updated on 2016-06-02
 527     *
 528     * Modified by Sylvain Le Gall
 529   *)
 530   open Ocamlbuild_plugin
 531
 532
 533   type conf = {no_automatic_syntax: bool}
 534
 535
 536   let run_and_read = Ocamlbuild_pack.My_unix.run_and_read
 537
 538
 539   let blank_sep_strings = Ocamlbuild_pack.Lexers.blank_sep_strings
 540
 541
 542   let exec_from_conf exec =
 543     let exec =
 544       let env = BaseEnvLight.load ~allow_empty:true () in
 545       try
 546         BaseEnvLight.var_get exec env
 547       with Not_found ->
 548         Printf.eprintf "W: Cannot get variable %s\n" exec;
 549         exec
 550     in
 551     let fix_win32 str =
 552       if Sys.os_type = "Win32" then begin
 553         let buff = Buffer.create (String.length str) in
 554         (* Adapt for windowsi, ocamlbuild + win32 has a hard time to handle '\\'.
 555         *)
 556         String.iter
 557           (fun c -> Buffer.add_char buff (if c = '\\' then '/' else c))
 558           str;
 559         Buffer.contents buff
 560       end else begin
 561         str
 562       end
 563     in
 564     fix_win32 exec
 565
 566
 567   let split s ch =
 568     let buf = Buffer.create 13 in
 569     let x = ref [] in
 570     let flush () =
 571       x := (Buffer.contents buf) :: !x;
 572       Buffer.clear buf
 573     in
 574     String.iter
 575       (fun c ->
 576          if c = ch then
 577            flush ()
 578          else
 579            Buffer.add_char buf c)
 580       s;
 581     flush ();
 582     List.rev !x
 583
 584
 585   let split_nl s = split s '\n'
 586
 587
 588   let before_space s =
 589     try
 590       String.before s (String.index s ' ')
 591     with Not_found -> s
 592
 593   (* ocamlfind command *)
 594   let ocamlfind x = S[Sh (exec_from_conf "ocamlfind"); x]
 595
 596   (* This lists all supported packages. *)
 597   let find_packages () =
 598     List.map before_space (split_nl & run_and_read (exec_from_conf "ocamlfind" ^ " list"))
 599
 600
 601   (* Mock to list available syntaxes. *)
 602   let find_syntaxes () = ["camlp4o"; "camlp4r"]
 603
 604
 605   let well_known_syntax = [
 606     "camlp4.quotations.o";
 607     "camlp4.quotations.r";
 608     "camlp4.exceptiontracer";
 609     "camlp4.extend";
 610     "camlp4.foldgenerator";
 611     "camlp4.listcomprehension";
 612     "camlp4.locationstripper";
 613     "camlp4.macro";
 614     "camlp4.mapgenerator";
 615     "camlp4.metagenerator";
 616     "camlp4.profiler";
 617     "camlp4.tracer"
 618   ]
 619
 620
 621   let dispatch conf =
 622     function
 623       | After_options ->
 624         (* By using Before_options one let command line options have an higher
 625          * priority on the contrary using After_options will guarantee to have
 626          * the higher priority override default commands by ocamlfind ones *)
 627         Options.ocamlc     := ocamlfind & A"ocamlc";
 628         Options.ocamlopt   := ocamlfind & A"ocamlopt";
 629         Options.ocamldep   := ocamlfind & A"ocamldep";
 630         Options.ocamldoc   := ocamlfind & A"ocamldoc";
 631         Options.ocamlmktop := ocamlfind & A"ocamlmktop";
 632         Options.ocamlmklib := ocamlfind & A"ocamlmklib"
 633
 634       | After_rules ->
 635
 636         (* Avoid warnings for unused tag *)
 637         flag ["tests"] N;
 638
 639         (* When one link an OCaml library/binary/package, one should use
 640          * -linkpkg *)
 641         flag ["ocaml"; "link"; "program"] & A"-linkpkg";
 642
 643         (* For each ocamlfind package one inject the -package option when
 644          * compiling, computing dependencies, generating documentation and
 645          * linking. *)
 646         List.iter
 647           begin fun pkg ->
 648             let base_args = [A"-package"; A pkg] in
 649             (* TODO: consider how to really choose camlp4o or camlp4r. *)
 650             let syn_args = [A"-syntax"; A "camlp4o"] in
 651             let (args, pargs) =
 652               (* Heuristic to identify syntax extensions: whether they end in
 653                  ".syntax"; some might not.
 654               *)
 655               if not (conf.no_automatic_syntax) &&
 656                  (Filename.check_suffix pkg "syntax" ||
 657                   List.mem pkg well_known_syntax) then
 658                 (syn_args @ base_args, syn_args)
 659               else
 660                 (base_args, [])
 661             in
 662             flag ["ocaml"; "compile";  "pkg_"^pkg] & S args;
 663             flag ["ocaml"; "ocamldep"; "pkg_"^pkg] & S args;
 664             flag ["ocaml"; "doc";      "pkg_"^pkg] & S args;
 665             flag ["ocaml"; "link";     "pkg_"^pkg] & S base_args;
 666             flag ["ocaml"; "infer_interface"; "pkg_"^pkg] & S args;
 667
 668             (* TODO: Check if this is allowed for OCaml < 3.12.1 *)
 669             flag ["ocaml"; "compile";  "package("^pkg^")"] & S pargs;
 670             flag ["ocaml"; "ocamldep"; "package("^pkg^")"] & S pargs;
 671             flag ["ocaml"; "doc";      "package("^pkg^")"] & S pargs;
 672             flag ["ocaml"; "infer_interface"; "package("^pkg^")"] & S pargs;
 673           end
 674           (find_packages ());
 675
 676         (* Like -package but for extensions syntax. Morover -syntax is useless
 677          * when linking. *)
 678         List.iter begin fun syntax ->
 679           flag ["ocaml"; "compile";  "syntax_"^syntax] & S[A"-syntax"; A syntax];
 680           flag ["ocaml"; "ocamldep"; "syntax_"^syntax] & S[A"-syntax"; A syntax];
 681           flag ["ocaml"; "doc";      "syntax_"^syntax] & S[A"-syntax"; A syntax];
 682           flag ["ocaml"; "infer_interface"; "syntax_"^syntax] &
 683           S[A"-syntax"; A syntax];
 684         end (find_syntaxes ());
 685
 686         (* The default "thread" tag is not compatible with ocamlfind.
 687          * Indeed, the default rules add the "threads.cma" or "threads.cmxa"
 688          * options when using this tag. When using the "-linkpkg" option with
 689          * ocamlfind, this module will then be added twice on the command line.
 690          *
 691          * To solve this, one approach is to add the "-thread" option when using
 692          * the "threads" package using the previous plugin.
 693         *)
 694         flag ["ocaml"; "pkg_threads"; "compile"] (S[A "-thread"]);
 695         flag ["ocaml"; "pkg_threads"; "doc"] (S[A "-I"; A "+threads"]);
 696         flag ["ocaml"; "pkg_threads"; "link"] (S[A "-thread"]);
 697         flag ["ocaml"; "pkg_threads"; "infer_interface"] (S[A "-thread"]);
 698         flag ["c"; "pkg_threads"; "compile"] (S[A "-thread"]);
 699         flag ["ocaml"; "package(threads)"; "compile"] (S[A "-thread"]);
 700         flag ["ocaml"; "package(threads)"; "doc"] (S[A "-I"; A "+threads"]);
 701         flag ["ocaml"; "package(threads)"; "link"] (S[A "-thread"]);
 702         flag ["ocaml"; "package(threads)"; "infer_interface"] (S[A "-thread"]);
 703         flag ["c"; "package(threads)"; "compile"] (S[A "-thread"]);
 704
 705       | _ ->
 706         ()
 707 end
 708
 709 module MyOCamlbuildBase = struct
 710 (* # 22 "src/plugins/ocamlbuild/MyOCamlbuildBase.ml" *)
 711
 712
 713   (** Base functions for writing myocamlbuild.ml
 714       @author Sylvain Le Gall
 715     *)
 716
 717
 718   open Ocamlbuild_plugin
 719   module OC = Ocamlbuild_pack.Ocaml_compiler
 720
 721
 722   type dir = string
 723   type file = string
 724   type name = string
 725   type tag = string
 726
 727
 728   type t =
 729       {
 730         lib_ocaml: (name * dir list * string list) list;
 731         lib_c:     (name * dir * file list) list;
 732         flags:     (tag list * (spec OASISExpr.choices)) list;
 733         (* Replace the 'dir: include' from _tags by a precise interdepends in
 734          * directory.
 735          *)
 736         includes:  (dir * dir list) list;
 737       }
 738
 739
 740 (* # 110 "src/plugins/ocamlbuild/MyOCamlbuildBase.ml" *)
 741
 742
 743   let env_filename = Pathname.basename BaseEnvLight.default_filename
 744
 745
 746   let dispatch_combine lst =
 747     fun e ->
 748       List.iter
 749         (fun dispatch -> dispatch e)
 750         lst
 751
 752
 753   let tag_libstubs nm =
 754     "use_lib"^nm^"_stubs"
 755
 756
 757   let nm_libstubs nm =
 758     nm^"_stubs"
 759
 760
 761   let dispatch t e =
 762     let env = BaseEnvLight.load ~allow_empty:true () in
 763       match e with
 764         | Before_options ->
 765             let no_trailing_dot s =
 766               if String.length s >= 1 && s.[0] = '.' then
 767                 String.sub s 1 ((String.length s) - 1)
 768               else
 769                 s
 770             in
 771               List.iter
 772                 (fun (opt, var) ->
 773                    try
 774                      opt := no_trailing_dot (BaseEnvLight.var_get var env)
 775                    with Not_found ->
 776                      Printf.eprintf "W: Cannot get variable %s\n" var)
 777                 [
 778                   Options.ext_obj, "ext_obj";
 779                   Options.ext_lib, "ext_lib";
 780                   Options.ext_dll, "ext_dll";
 781                 ]
 782
 783         | After_rules ->
 784             (* Declare OCaml libraries *)
 785             List.iter
 786               (function
 787                  | nm, [], intf_modules ->
 788                      ocaml_lib nm;
 789                      let cmis =
 790                        List.map (fun m -> (OASISString.uncapitalize_ascii m) ^ ".cmi")
 791                                 intf_modules in
 792                      dep ["ocaml"; "link"; "library"; "file:"^nm^".cma"] cmis
 793                  | nm, dir :: tl, intf_modules ->
 794                      ocaml_lib ~dir:dir (dir^"/"^nm);
 795                      List.iter
 796                        (fun dir ->
 797                           List.iter
 798                             (fun str ->
 799                                flag ["ocaml"; "use_"^nm; str] (S[A"-I"; P dir]))
 800                             ["compile"; "infer_interface"; "doc"])
 801                        tl;
 802                      let cmis =
 803                        List.map (fun m -> dir^"/"^(OASISString.uncapitalize_ascii m)^".cmi")
 804                                 intf_modules in
 805                      dep ["ocaml"; "link"; "library"; "file:"^dir^"/"^nm^".cma"]
 806                          cmis)
 807               t.lib_ocaml;
 808
 809             (* Declare directories dependencies, replace "include" in _tags. *)
 810             List.iter
 811               (fun (dir, include_dirs) ->
 812                  Pathname.define_context dir include_dirs)
 813               t.includes;
 814
 815             (* Declare C libraries *)
 816             List.iter
 817               (fun (lib, dir, headers) ->
 818                    (* Handle C part of library *)
 819                    flag ["link"; "library"; "ocaml"; "byte"; tag_libstubs lib]
 820                      (S[A"-dllib"; A("-l"^(nm_libstubs lib)); A"-cclib";
 821                         A("-l"^(nm_libstubs lib))]);
 822
 823                    flag ["link"; "library"; "ocaml"; "native"; tag_libstubs lib]
 824                      (S[A"-cclib"; A("-l"^(nm_libstubs lib))]);
 825
 826                    if bool_of_string (BaseEnvLight.var_get "native_dynlink" env) then
 827                      flag ["link"; "program"; "ocaml"; "byte"; tag_libstubs lib]
 828                          (S[A"-dllib"; A("dll"^(nm_libstubs lib))]);
 829
 830                    (* When ocaml link something that use the C library, then one
 831                       need that file to be up to date.
 832                       This holds both for programs and for libraries.
 833                     *)
 834                    dep ["link"; "ocaml"; tag_libstubs lib]
 835                      [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];
 836
 837                    dep  ["compile"; "ocaml"; tag_libstubs lib]
 838                      [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)];
 839
 840                    (* TODO: be more specific about what depends on headers *)
 841                    (* Depends on .h files *)
 842                    dep ["compile"; "c"]
 843                      headers;
 844
 845                    (* Setup search path for lib *)
 846                    flag ["link"; "ocaml"; "use_"^lib]
 847                      (S[A"-I"; P(dir)]);
 848               )
 849               t.lib_c;
 850
 851               (* Add flags *)
 852               List.iter
 853               (fun (tags, cond_specs) ->
 854                  let spec = BaseEnvLight.var_choose cond_specs env in
 855                  let rec eval_specs =
 856                    function
 857                      | S lst -> S (List.map eval_specs lst)
 858                      | A str -> A (BaseEnvLight.var_expand str env)
 859                      | spec -> spec
 860                  in
 861                    flag tags & (eval_specs spec))
 862               t.flags
 863         | _ ->
 864             ()
 865
 866
 867   let dispatch_default conf t =
 868     dispatch_combine
 869       [
 870         dispatch t;
 871         MyOCamlbuildFindlib.dispatch conf;
 872       ]
 873
 874
 875 end
 876
 877
 878 # 878 "myocamlbuild.ml"
 879 open Ocamlbuild_plugin;;
 880 let package_default =
 881   {
 882      MyOCamlbuildBase.lib_ocaml =
 883        [
 884           ("sqlgg", ["lib"], []);
 885           ("sqlgg_traits", ["impl/ocaml"], []);
 886           ("sqlgg_mariadb", ["impl/ocaml/mariadb"], []);
 887           ("sqlgg_mysql", ["impl/ocaml/mysql"], []);
 888           ("sqlgg_sqlite3", ["impl/ocaml/sqlite3"], [])
 889        ];
 890      lib_c = [];
 891      flags = [];
 892      includes =
 893        [
 894           ("src", ["lib"]);
 895           ("impl/ocaml/sqlite3", ["impl/ocaml"]);
 896           ("impl/ocaml/mysql", ["impl/ocaml"]);
 897           ("impl/ocaml/mariadb", ["impl/ocaml"])
 898        ]
 899   }
 900   ;;
 901
 902 let conf = {MyOCamlbuildFindlib.no_automatic_syntax = false}
 903
 904 let dispatch_default = MyOCamlbuildBase.dispatch_default conf package_default;;
 905
 906 # 907 "myocamlbuild.ml"
 907 (* OASIS_STOP *)
 908 Ocamlbuild_plugin.dispatch dispatch_default;;