File ocaml-zarith.patch of Package ocaml-zarith

Overview Repositories Revisions Requests Users Attributes Meta

File ocaml-zarith.patch of Package ocaml-zarith (Revision 81b330d7d76f1fc54422de7829871b6a)

Currently displaying revision 81b330d7d76f1fc54422de7829871b6a , Show latest

--- /dev/null
+++ b/config/discover.ml
@@ -0,0 +1,124 @@
+module C = Configurator.V1
+module OV = Ocaml_version
+open Printf
+
+(* Returns arch, ccdef, opt (cc/as)  *)
+let x86_64_def =
+  "x86_64", ["-DZ_ELF";"-DZ_DOT_LABEL_PREFIX"], []
+
+let i686_def =
+  "i686", ["-DZ_ELF";"-DZ_DOT_LABEL_PREFIX"], []
+
+let cygwin_def word_size =
+  match word_size with
+  | "64" -> "x86_64_mingw64", ["-DZ_COFF"], []
+  | _ -> "i686", ["-DZ_UNDERSCORE_PREFIX";"-DZ_COFF"], []
+
+let darwin_def word_size =
+  match word_size with
+  | "64" -> "x86_64", ["-DZ_UNDERSCORE_PREFIX";"-DZ_MACOS"], []
+  | _ -> failwith "Darwin only supports 64-bit compilation"
+
+let arm_def = "arm", [], []
+
+let no_def = "none", [], []
+
+let extract_from_target word_size str =
+  let reg_all = "\\(.*\\)"
+  and reg_or = "\\|"
+  in
+  let x86_64 = Str.regexp ("x86_64"^reg_all^"-linux-gnu"^reg_or^"x86_64-kfreebsd-gnu")
+  and i686 = Str.regexp ("i486-"^reg_all^"linux-gnu"^reg_or^"i686-"^reg_all^"linux-gnu"^reg_or^"i486-kfreebsd-gnu")
+  and cygwin = Str.regexp ("i686-"^reg_all^"cygwin")
+  and darwin = Str.regexp ("i386-"^reg_all^"darwin"^reg_all^reg_or^"x86_64-"^reg_all^"darwin"^reg_all)
+  and arm = Str.regexp ("armv7"^reg_all^"-gnueabi")
+  in
+  if Str.string_match x86_64 str 0
+  then x86_64_def
+  else if Str.string_match i686 str 0
+  then i686_def
+  else if Str.string_match cygwin str 0
+  then cygwin_def word_size
+  else if Str.string_match darwin str 0
+  then darwin_def word_size
+  else if Str.string_match arm str 0
+  then arm_def
+  else
+       no_def
+
+
+let inc_gmp = {|
+  #include <gmp.h>
+  int main() {return 0;}
+|}
+
+let inc_mpir = {|
+  #include <mpir.h>
+  int main() {return 0;}
+|}
+
+
+let check_code c code lib = C.c_test c code ~link_flags:["-l"^lib]
+
+let check_gmp c = match check_code c inc_gmp "gmp" with
+  | true -> Some ("-DHAS_GMP", "-lgmp")
+  | false -> None
+
+let check_mpir c = match check_code c inc_mpir "mpir" with
+  | true -> Some ("-DHAS_MPIR", "-lmpir")
+  | false -> None
+
+let check_gmp_or_mpir_raw c =
+  if not(C.c_test c inc_gmp || C.c_test c inc_mpir)
+  then failwith "Couldn't find GMP or MPIR"
+
+
+let check_gmp_or_mpir c =
+  match check_gmp c with
+  | None -> check_mpir c
+  | a -> a
+
+let param_cflags = ref []
+let param_ldflags = ref []
+
+let set_cflags str = param_cflags := String.split_on_char ' ' str
+let set_ldflags str = param_ldflags := String.split_on_char ' ' str
+
+let arg_cflags = ("-cflags", Arg.String set_cflags, "custom C flags")
+let arg_ldflags = ("-ldflags", Arg.String set_ldflags, "custom ld flags")
+
+let args = [arg_cflags; arg_ldflags]
+
+let () =
+  C.main ~args ~name:"zarith" (fun c ->
+    let word_size = C.ocaml_config_var_exn c "word_size" in
+    let machine, arch_defines, opt = C.ocaml_config_var_exn c "target" |> extract_from_target word_size in
+    let ov = C.ocaml_config_var_exn c "version" |> OV.of_string_exn in
+    let stdlib_include = sprintf "-I%s" (C.ocaml_config_var_exn c "standard_library") in
+    let cflags = stdlib_include :: ["-O3";"-Wall";"-Wextra"] in
+    let defines = ["-DZ_OCAML_COMPARE_EXT"; "-DZ_OCAML_HASH"] in
+    let defines, ldflags =match !param_cflags, !param_ldflags with
+    | [], [] -> begin
+                  match check_gmp_or_mpir c with
+                  | Some (cflag,ldflag) -> cflag :: defines, [ldflag]
+                  | None -> failwith "Cannot find GMP nor MPIR"
+                end
+    | c_flags, ld_flags ->  begin
+                  match check_gmp_or_mpir c with
+                  | Some (cflag,_) -> cflag :: defines @ c_flags, ld_flags
+                  | None -> failwith "Cannot find GMP nor MPIR"
+                end
+    in
+    let c_api_defines =
+      match Ocaml_version.(compare ov Releases.v4_08) with
+      |(-1) -> ["-DZ_OCAML_LEGACY_CUSTOM_OPERATIONS"]
+      |_ -> [] in
+    let defines = defines @ c_api_defines @ arch_defines in
+    let cflags = cflags @ opt @ defines in
+    let asflags = defines @ opt in
+    C.Flags.write_sexp "cflags.sxp" cflags;
+    C.Flags.write_lines "asflags" asflags;
+    C.Flags.write_lines "cflags" cflags;
+    C.Flags.write_sexp "ldflags.sxp" ldflags;
+    C.Flags.write_lines "ldflags" ldflags;
+    C.Flags.write_lines "arch" [machine])
--- /dev/null
+++ b/config/dune
@@ -0,0 +1,10 @@
+(executable
+ (name discover)
+ (libraries str dune.configurator))
+
+(rule
+ (targets ldflags.sxp cflags.sxp cflags asflags arch ldflags)
+ (deps discover.exe)
+ (action (run ./discover.exe)))
+
+
--- /dev/null
+++ b/config/ocaml_version.ml
@@ -0,0 +1,253 @@
+(* Copyright (c) 2017 Anil Madhavapeddy <anil@recoil.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+*)
+
+type t = { major: int; minor: int; patch: int option; extra: string option }
+let v ?patch ?extra major minor = { major; minor; patch; extra }
+
+let major { major; _ } = major
+let minor { minor; _ } = minor
+let patch { patch; _ } = patch
+let extra { extra; _ } = extra
+
+let to_string ?(sep='+') =
+  function
+  | {major;minor;patch=None;extra=None} -> Printf.sprintf "%d.%02d" major minor
+  | {major;minor;patch=Some patch;extra=None} -> Printf.sprintf "%d.%02d.%d" major minor patch
+  | {major;minor;patch=Some patch;extra=Some extra} -> Printf.sprintf "%d.%02d.%d%c%s" major minor patch sep extra
+  | {major;minor;patch=None;extra=Some extra} -> Printf.sprintf "%d.%02d%c%s" major minor sep extra
+
+let parse s =
+  try Scanf.sscanf s "%d.%d.%d+%s" (fun major minor patch extra -> v ~patch ~extra major minor)
+  with End_of_file | Scanf.Scan_failure _ -> begin
+      try Scanf.sscanf s "%d.%d+%s" (fun major minor extra -> v ~extra major minor)
+      with End_of_file | Scanf.Scan_failure _ -> begin
+          try Scanf.sscanf s "%d.%d.%d" (fun major minor patch -> v ~patch major minor)
+          with End_of_file | Scanf.Scan_failure _ -> begin
+              Scanf.sscanf s "%d.%d" (fun major minor -> v major minor)
+            end
+        end
+    end
+
+let of_string s =
+  try Ok (parse s) with
+  | _ -> Error (`Msg (Printf.sprintf "Unable to parse OCaml version '%s'" s))
+
+let of_string_exn s =
+  try parse s with
+  | _ -> raise (Invalid_argument (Printf.sprintf "Unable to parse OCaml version '%s'" s))
+
+let pp ppf v = Format.pp_print_string ppf (to_string v)
+
+let ( ++ ) x fn =
+  match x with
+  | 0 -> fn ()
+  | r -> r
+
+let compare {major; minor; patch; extra} a =
+  compare major a.major ++ fun () ->
+    compare minor a.minor ++ fun () ->
+      compare patch a.patch ++ fun () ->
+        compare extra a.extra
+
+let sys_version = of_string_exn Sys.ocaml_version
+
+let with_variant t extra = { t with extra }
+let without_variant t = { t with extra=None }
+let with_patch t patch = { t with patch }
+let without_patch t = { t with patch=None }
+let with_just_major_and_minor t = { t with patch=None; extra=None }
+
+module Releases = struct
+  let v4_00_0 = of_string_exn "4.00.0"
+  let v4_00_1 = of_string_exn "4.00.1"
+  let v4_00 = v4_00_1
+
+  let v4_01_0 = of_string_exn "4.01.0"
+  let v4_01 = v4_01_0
+
+  let v4_02_0 = of_string_exn "4.02.0"
+  let v4_02_1 = of_string_exn "4.02.1"
+  let v4_02_2 = of_string_exn "4.02.2"
+  let v4_02_3 = of_string_exn "4.02.3"
+  let v4_02 = v4_02_3
+
+  let v4_03_0 = of_string_exn "4.03.0"
+  let v4_03 = v4_03_0
+
+  let v4_04_0 = of_string_exn "4.04.0"
+  let v4_04_1 = of_string_exn "4.04.1"
+  let v4_04_2 = of_string_exn "4.04.2"
+  let v4_04 = v4_04_2
+
+  let v4_05_0 = of_string_exn "4.05.0"
+  let v4_05 = v4_05_0
+
+  let v4_06_0 = of_string_exn "4.06.0"
+  let v4_06_1 = of_string_exn "4.06.1"
+  let v4_06 = v4_06_1
+
+  let v4_07_0 = of_string_exn "4.07.0"
+  let v4_07_1 = of_string_exn "4.07.1"
+  let v4_07 = v4_07_1
+
+  let v4_08_0 = of_string_exn "4.08.0"
+  let v4_08 = v4_08_0
+
+  let v4_09_0 = of_string_exn "4.09.0"
+  let v4_09 = v4_09_0
+
+  let all_patches = [
+    v4_00_1; v4_01_0; v4_02_0; v4_02_1; v4_02_2;
+    v4_02_3; v4_03_0; v4_04_0; v4_04_1; v4_04_2;
+    v4_05_0; v4_06_0; v4_06_1; v4_07_0; v4_07_1;
+    v4_08_0; v4_09_0 ]
+
+  let all = [ v4_00; v4_01; v4_02; v4_03; v4_04;
+              v4_05; v4_06; v4_07; v4_08; v4_09 ]
+
+  let recent = [ v4_02; v4_03; v4_04; v4_05; v4_06; v4_07 ]
+
+  let latest = v4_07
+
+  let dev = [ v4_08; v4_09 ]
+
+  let is_dev t =
+    let t = with_just_major_and_minor t in
+    let dev = List.map with_just_major_and_minor dev in
+    List.mem t dev
+
+  let recent_with_dev = List.concat [recent; dev]
+
+end
+
+type arch = [`X86_64 | `Aarch64 | `Ppc64le | `Aarch32 ]
+let arches = [ `X86_64; `Aarch64; `Ppc64le; `Aarch32 ]
+
+let string_of_arch = function
+  | `Aarch64 -> "arm64"
+  | `Aarch32 -> "arm32v7"
+  | `X86_64 -> "amd64"
+  | `Ppc64le -> "ppc64le"
+
+let arch_of_string = function
+  | "arm64" | "aarch64" -> Ok `Aarch64
+  | "amd64" | "x86_64" -> Ok `X86_64
+  | "arm32" | "arm32v7" | "aarch32" -> Ok `Aarch32
+  | "ppc64le" -> Ok `Ppc64le
+  | arch -> Error (`Msg ("Unknown architecture " ^ arch))
+
+let arch_of_string_exn a =
+  match arch_of_string a with
+  | Ok a -> a
+  | Error (`Msg m) -> raise (Invalid_argument m)
+
+module Since = struct
+  let bytes = Releases.v4_03_0
+
+  let arch (a:arch) =
+    match a with
+    | `Aarch32 -> Releases.v4_06_0
+    | `Aarch64 -> Releases.v4_05_0
+    | `Ppc64le -> Releases.v4_06_0
+    | `X86_64 -> Releases.v4_00_0 (* TODO obviously earlier *)
+end
+
+module Has = struct
+
+  let bytes v =
+    match compare Since.bytes v with
+    |(-1) | 0 -> true
+    |_ -> false
+
+  let arch (a:arch) v =
+    match compare (Since.arch a) v with
+    |(-1) | 0 -> true
+    |_ -> false
+end
+
+module Configure_options = struct
+  type o = [ `Afl | `Flambda | `Default_unsafe_string | `Force_safe_string | `Frame_pointer ]
+
+  let to_description t = 
+    match t with
+    | `Afl -> "AFL (fuzzing) support"
+    | `Flambda -> "flambda inlining"
+    | `Default_unsafe_string -> "default to unsafe strings"
+    | `Force_safe_string -> "force safe string mode"
+    | `Frame_pointer -> "frame pointer"
+
+  let to_string t =
+    match t with
+    | `Afl -> "afl"
+    | `Flambda -> "flambda"
+    | `Default_unsafe_string -> "default-unsafe-string"
+    | `Force_safe_string -> "force-safe-string"
+    | `Frame_pointer -> "fp"
+
+  let to_configure_flag t =
+    match t with
+    | `Afl -> "-afl-instrument"
+    | `Flambda -> "-flambda"
+    | `Default_unsafe_string -> "-default-unsafe-string"
+    | `Force_safe_string -> "-force-safe-string"
+    | `Frame_pointer -> "-with-frame-pointer"
+
+end
+
+let compiler_variants arch {major; minor; _} =
+    match major,minor,arch with
+    | 4,9,`X86_64 -> [[]]
+    | 4,9,_ -> [[]]
+    | 4,8,`X86_64 -> [[]; [`Afl]; [`Flambda]; [`Frame_pointer]; [`Frame_pointer;`Flambda]; [`Default_unsafe_string]]
+    | 4,8,_ -> [[]; [`Afl]; [`Flambda];[`Default_unsafe_string]]
+    | 4,7,_ -> [[]; [`Afl]; [`Flambda]; [`Default_unsafe_string]; [`Force_safe_string]]
+    | 4,6,_ -> [[]; [`Afl]; [`Flambda]; [`Default_unsafe_string]; [`Force_safe_string]]
+    | 4,5,_ -> [[]; [`Afl]; [`Flambda]]
+    | 4,4,_ -> [[]; [`Flambda]]
+    | 4,3,_ -> [[]; [`Flambda]]
+    | _ -> [[]]
+
+module Sources = struct
+  let trunk = Releases.v4_08
+
+  let git_tag ({major; minor; patch; _ } as ov) =
+    match major, minor, patch with
+    | major, minor, _ when major = trunk.major && minor = trunk.minor -> "trunk"
+    | _ -> to_string (with_variant ov None)
+end
+
+module Opam = struct
+
+  module V2 = struct
+    let name t =
+      match t.extra with
+      | Some extra when Releases.is_dev t -> Printf.sprintf "ocaml-variants.%s+trunk+%s" (to_string (without_variant t)) extra
+      | Some _ -> "ocaml-variants." ^ (to_string t)
+      | None when Releases.is_dev t -> Printf.sprintf "ocaml-variants.%s+trunk" (to_string t)
+      | None -> "ocaml-base-compiler." ^ (to_string t)
+
+    let variant_switch t vs =
+      match vs with
+      | [] -> with_variant t None
+      | vs ->
+        let v = String.concat "+" (List.map Configure_options.to_string vs) in
+        with_variant t (Some v)
+
+    let switches arch t =
+      compiler_variants arch t |>
+      List.map (fun vs -> variant_switch t vs)
+  end
+end
--- /dev/null
+++ b/config/ocaml_version.mli
@@ -0,0 +1,345 @@
+(* Copyright (c) 2017-2018 Anil Madhavapeddy <anil@recoil.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+*)
+
+(** Manipulate, parse and generate OCaml version strings.
+
+    These are of the form [major.minor.patch+extra], where the
+    [patch] and [extra] fields are optional.  *)
+
+type t
+(** Type of an OCaml version string *)
+
+val v : ?patch:int -> ?extra:string -> int -> int -> t
+(** [v ?patch ?extra major minor] will construct an OCaml
+    version string with the appropriate parameters.  The
+    [patch] and [extra] indicators are optional, but it is
+    conventional to include a [patch] value of 0 for most
+    recent OCaml releases. *)
+
+(** {2 Parsers and serializers} *)
+
+val to_string : ?sep:char -> t -> string
+(** [to_string ?sep t] will convert the version [t] into
+    a human-readable representation.  The [sep] will default
+    to [+] which is the normal representation of extra
+    version strings, but can be changed to another character
+    by supplying [sep].  One such usecase is to generate
+    Docker container tags from OCaml version strings, where
+    only dashes and alphanumeric characters are allowed. *)
+
+val of_string : string -> (t, [> `Msg of string ]) result
+(** [of_string t] will parse the version string in [t].
+    The return value is compatible with the {!Result}
+    combinators defined in the [rresult] library. *)
+
+val of_string_exn : string -> t
+(** [of_string_exn t] behaves as {!of_string} but raises
+    [Invalid_argument] if the string cannot be parsed. *)
+
+val compare : t -> t -> int
+(** [compare a b] is the comparison function for two OCaml
+    version strings. Returns [-1] if [a<b], [0] if they are
+    equal and [1] if [a>b]. Comparison is done using integer
+    comparison for the major, minor and patch versions, and
+    lexical comparison for any extra version strings present. *)
+
+val pp : Format.formatter -> t -> unit
+(** [pp fmt t] will output a human-readable version string of
+    [t] to the [fmt] formatter. *)
+
+(** {2 Architecture Support }
+    These definitions cover the CPU architectures that OCaml
+    runs and is supported on. *)
+
+type arch = [ `X86_64 | `Aarch64 | `Aarch32 | `Ppc64le ]
+(** Type of CPU architectures.
+    TODO: This is currently an incomplete list, and lists just
+    those used by the opam test systems. Contributions welcome
+    to complete it. *)
+
+val arches : arch list
+(** [arches] is an enumeration of all of the possible {!arch} values. *)
+
+val string_of_arch : arch -> string
+(** [string_of_arch arch] will convert [arch] into a human-readable
+    CPU architecture string.  The result will follow the
+    {{:https://golang.org/doc/install/source#environment}GOARCH}
+    convention used by Golang. *)
+
+val arch_of_string : string -> (arch, [> `Msg of string ]) result
+(** [arch_of_string t] will parse the architecture string in [t].
+    The return value is compatible with the {!Result}
+    combinators defined in the [rresult] library. This function
+    is liberal and will attempt to understand variants of the
+    same architecture.  For example, both [aarch64] and [arm64]
+    are parsed into {!`Aarch64}. *)
+
+val arch_of_string_exn: string -> arch
+(** [arch_of_string_exn t] is the same as {!arch_of_string},
+    except that it raises [Invalid_argument] in case of error. *)
+
+(** {2 Accessors} *)
+
+val major : t -> int
+(** [major t] will return the major version number of an OCaml
+    release.  For example, [of_string "4.03.0" |> major] will
+    return [4]. *)
+
+val minor : t -> int
+(** [minor t] will return the minor version number of an OCaml
+    release.  For example, [of_string "4.03.0" |> minor] will
+    return [3]. *)
+
+val patch : t -> int option
+(** [patch t] will return the patch version number of an OCaml
+    release.  For example, [of_string "4.03.0" |> minor] will
+    return [Some 0]. *)
+
+val extra : t -> string option
+(** [extra t] will return the additional information string of
+    an OCaml release.
+    For example, [of_string "4.03.0+flambda" |> extra] will
+    return [Some "flambda"]. *)
+
+val with_variant : t -> string option -> t
+(** [with_variant t extra] will return a fresh value with
+    the extra version information in [t] to
+    [extra], and remove it if [None] is supplied. *)
+
+val without_variant : t -> t
+(** [without_variant t] is {!with_variant} [t None]. It removes
+    any extra version information from the version string [t]. *)
+
+val with_patch : t -> int option -> t
+(** [with_patch t patch] will return a fresh value with
+    the patch number in [t] to [patch], and remove it if [None]
+    is supplied. *)
+
+val without_patch : t -> t
+(** [without_patch t] is as {!with_patch} [t None]. It removes
+    the least significant number from the version string.
+    This is useful for the Docker OCaml containers, which are
+    all named without a patch number and compiled using the
+    latest patch release (e.g. [4.06] instead of [4.06.1]). *)
+
+val with_just_major_and_minor : t -> t
+(** [with_just_major_and_minor t] strips out any patch and
+    extra version information to return the X.Y form of the
+    OCaml release. For example, [4.08.0+trunk+flambda] will
+    return the version representing [4.08]. *)
+
+(** {2 Constants } *)
+
+val sys_version : t
+(** [sys_version] is the version of OCaml that this library is
+    currently compiled with, which will be the same as
+    {!Sys.ocaml_version}. *)
+
+(** Values representing official releases of OCaml. *)
+module Releases : sig
+
+  val v4_00_1 : t
+  (** Version 4.00.1 *)
+
+  val v4_00 : t
+  (** Latest release in the 4.00.x series *)
+
+  val v4_01_0 : t
+  (** Version 4.01.0 *)
+
+  val v4_01 : t
+  (** Latest release in the 4.01.x series *)
+
+  val v4_02_0 : t
+  (** Version 4.02.0 *)
+
+  val v4_02_1 : t
+  (** Version 4.02.1 *)
+
+  val v4_02_2 : t
+  (** Version 4.02.2 *)
+
+  val v4_02_3 : t
+  (** Version 4.02.3 *)
+
+  val v4_02 : t
+  (** Latest release in the 4.02.x series *)
+
+  val v4_03_0 : t
+  (** Version 4.03.0 *)
+
+  val v4_03 : t
+  (** Latest release in the 4.03.x series *)
+
+  val v4_04_0 : t
+  (** Version 4.04.0 *)
+
+  val v4_04_1 : t
+  (** Version 4.04.1 *)
+
+  val v4_04_2 : t
+  (** Version 4.04.2 *)
+
+  val v4_04 : t
+  (** Latest release in the 4.04.x series *)
+
+  val v4_05_0 : t
+  (** Version 4.05.0 *)
+
+  val v4_05 : t
+  (** Latest release in the 4.05.x series *)
+
+  val v4_06_0 : t
+  (** Version 4.06.0 *)
+
+  val v4_06_1 : t
+  (** Version 4.06.1 *)
+
+  val v4_06 : t
+  (** Latest release in the 4.06.x series *)
+
+  val v4_07_0 : t
+  (** Version 4.07.0 *)
+
+  val v4_07_1 : t
+  (** Version 4.07.1 *)
+
+  val v4_07 : t
+  (** Latest release in the 4.07.x series *)
+
+  val v4_08_0 : t
+  (** Versior 4.08.0 *)
+
+  val v4_08 : t
+  (** Latest release in the 4.08.x series *)
+
+  val v4_09_0 : t
+  (** Version 4.09.0 *)
+
+  val v4_09 : t
+  (** Latest release in the 4.09.x series *)
+
+  val all_patches : t list
+  (** [all_patches] is an enumeration of all OCaml releases, including every patch release.
+      To get the major and minor releases with the latest patch version, use {!all} instead. *)
+
+  val all : t list
+  (** [all] is an enumeration of all the OCaml releases, with the latest patch versions in
+      each major and minor release. *)
+
+  val dev : t list
+  (** Enumeration of the latest development OCaml releases.
+      This is usually just one, but may include two active dev
+      versions if a release branch has just been cut. *)
+
+  val latest: t
+  (** [latest] is the most recent stable release of OCaml. *)
+
+  val recent : t list
+  (** [recent] is the last five releases of OCaml, with each at the latest patch level.
+      This is the set that is most reliably tested in the opam package repository. *)
+
+  val recent_with_dev : t list
+  (** [recent_with_dev] are the last four stable releases of OCaml and the latest
+      development branches. *)
+
+  val is_dev : t -> bool
+  (** [is_dev t] will return true if the release [t] represents a development
+      release instead of a stable archive. *)
+end
+
+(** Values relating to the source code and version control of OCaml *)
+module Sources : sig
+
+  val trunk : t
+  (** [trunk] is the version of the development head of the OCaml git repository. *)
+
+  val git_tag : t -> string
+  (* [git_tag v] returns the Git tag or branch that corresponds to the release
+     [v] of OCaml.  If [v] does not have a patch releases, then it will be a branch
+     that points to the relevant release branch. *)
+end
+
+(** {2 Feature Selection} *)
+
+(** Determine which release a feature or architecture first appeared in. *)
+module Since : sig
+
+  val bytes: t
+  (** [bytes] is the release that the {!Bytes} module first appeared in. *)
+
+  val arch : arch -> t 
+  (** [arch a] will return the first release of OCaml that the architecture
+      was reasonably stably supported on. *)
+end
+
+(** Test whether a release has a given feature. *)
+module Has : sig
+
+  val bytes : t -> bool
+  (** [bytes t] will return {!true} if that release has a {!bytes} type.
+      Note that opam provides a [bytes] compatibility package for older releases. *)
+
+  val arch : arch -> t -> bool
+  (** [arch a t] will return {!true} if architecture [a] is supported on release [t]. *)
+end
+
+(** Configuration parameters that affect the behaviour of OCaml at compiler-build-time. *)
+module Configure_options : sig
+
+  type o =
+    [ `Afl
+    | `Default_unsafe_string
+    | `Flambda
+    | `Force_safe_string
+    | `Frame_pointer ]
+  (** Configuration options available at compiler build time. *)
+
+  val to_string : o -> string
+  (** [to_string o] returns a compact representation of {!o} suitable for use in opam version strings. *)
+
+  val to_description : o -> string
+  (** [to_description o] returns a human-readable representation of {!o}. *)
+
+  val to_configure_flag : o -> string
+  (** [to_configure_flag o] returns a string that can be passed to OCaml's [configure] script to activate that feature. *)
+end
+
+val compiler_variants : arch -> t -> Configure_options.o list list
+(** [compiler_variants v] returns a list of configuration options that are available and useful
+    for version [v] of the compiler. *)
+
+(** Opam compiler switches.
+    These are available from the public {{:https://github.com/ocaml/opam-repository}opam-repository}. *)
+module Opam : sig
+
+  (** Opam 2.0 functions *)
+  module V2 : sig
+    val name : t -> string
+    (** [package t] returns the opam2 package for that compiler version. *)
+
+    val variant_switch : t -> Configure_options.o list -> t
+    (** [variant_switch t cs] returns an OCaml version [t] whose
+        variant version field reflects the configuration options in [cs] *)
+
+    val switches : arch -> t -> t list
+    (** [switches arch t] returns the list of opam switches that
+        are available for that compiler and architecture combination.
+        For example, an x86_64 one would yield a list that includes
+        flambda and the flambda-with-frame-pointer combinations. *)
+
+  end
+end
--- /dev/null
+++ b/dune
@@ -0,0 +1,41 @@
+(library
+  (name zarith)
+  (public_name zarith)
+  (modules z q big_int_Z)
+  (c_library_flags (:include config/ldflags.sxp))
+  (self_build_stubs_archive (zarith_c))
+  (wrapped false))
+
+(rule
+ (targets libzarith_c_stubs%{ext_lib} dllzarith_c_stubs%{ext_dll})
+ (deps   caml_z_arch.o caml_z.o)
+ (action (run ocamlmklib -o zarith_c_stubs %{deps} %{read-lines:config/ldflags})))
+
+(executable
+ (name z_pp)
+ (modules z_pp)
+ (libraries str))
+
+(rule
+  (targets z.ml z.mli z_features.h)
+  (deps (:script z_pp.exe) z_pp.ml z.mlp z.mlip META caml_z_arch.S)
+  (action (run %{script} -ov %{ocaml_version} %{read-lines:config/arch})))
+
+(rule
+  (targets caml_z_arch.S)
+  (deps caml_z_arm.S caml_z_i686.S caml_z_x86_64.S caml_z_x86_64_mingw64.S)
+  (action (copy caml_z_%{read-lines:config/arch}.S caml_z_arch.S)))
+
+(rule
+  (targets caml_z_none.S)
+  (action (run touch caml_z_none.S)))
+
+(rule
+  (targets caml_z_arch.o)
+  (deps (:s caml_z_arch.S) zarith.h)
+  (action (run %{cc} %{read-lines:config/asflags} -c %{s} -o %{targets})))
+
+(rule
+  (targets caml_z.o)
+  (deps (:c caml_z.c) zarith.h z_features.h)
+  (action (run %{cc} %{read-lines:config/cflags} -c %{c} -o %{targets})))
--- /dev/null
+++ b/dune-project
@@ -0,0 +1,2 @@
+(lang dune 1.3)
+(name zarith)
--- /dev/null
+++ b/tests/dune
@@ -0,0 +1,17 @@
+(test
+ ( name zq)
+  (modules zq)
+  (libraries zarith))
+;; TODO compare against output64 result or define expect test
+
+(executable
+  (name pi)
+  (modules pi)
+  (libraries zarith))
+ 
+(alias
+ (name runtest)
+ (deps pi.exe)
+ (action (run ./pi.exe 500)))
+
+(rule (copy pi.output pi.expected))

Places

File ocaml-zarith.patch of Package ocaml-zarith (Revision 81b330d7d76f1fc54422de7829871b6a)

Places