Add support for OCaml (#1382)

Co-authored-by: Tim Besard <[email protected]>

Author: topolarity

Project.toml

@@ -36,7 +36,7 @@ ghr_jll = "07c12ed4-43bc-5495-8a2a-d5838ef8d533"
 [compat]
 ArgParse = "1.1"
 Binutils_jll = "2"
-BinaryBuilderBase = "1.35.2"
+BinaryBuilderBase = "1.38"
 Downloads = "1"
 GitHub = "5.1"
 HTTP = "0.8, 0.9, 1"

README.md

@@ -32,4 +32,4 @@ Building binary packages is a pain.  `BinaryBuilder` follows a philosophy that i
 
 All packages are cross compiled. If a package does not support cross compilation, we patch the package or, in extreme cases, rebundle prebuilt executables.
 
-The cross-compilation environment that we use is a homegrown Linux environment with many different compilers built for it, including various versions of `gcc`, `clang`, `gfortran`, `rustc` and `go`.  You can read more about this in [the `RootFS.md` file](https://github.com/JuliaPackaging/Yggdrasil/blob/master/RootFS.md) within the Yggdrasil repository.
+The cross-compilation environment that we use is a homegrown Linux environment with many different compilers built for it, including various versions of `gcc`, `clang`, `gfortran`, `rustc`, `go`, and `ocaml`.  You can read more about this in [the `RootFS.md` file](https://github.com/JuliaPackaging/Yggdrasil/blob/master/RootFS.md) within the Yggdrasil repository.

docs/src/build_tips.md

@@ -127,6 +127,12 @@ Example of packages using Rust:
 
 	The Rust toolchain currently used does not work with the `i686-w64-mingw32` (32-bit Windows) platform.
 
+## OCaml builds
+
+The OCaml toolchain provided by BinaryBuilder can be requested by adding `:ocaml` to the `compilers` keyword argument to [`build_tarballs`](@ref): `compilers=[:c, :ocaml]`, and a specific version of the toolchain can be selected by adding the `preferred_ocaml_version` keyword argument to [`build_tarballs`](@ref).
+
+The OCaml toolchain provided by BinaryBuilder automatically selects the appropriate target.
+
  ## C builds
 
  If your library has no build system like Make, CMake, Meson, or Autoconf, you may need to use the C compiler directly.  The C compiler is stored in the `CC` environment variable, and you can direct output to `libdir` (shared libraries) and `bindir` (executables).
@@ -135,7 +141,7 @@ As a high-level example:
  ```sh
 # this assumes you are operating out of a Git source named `hello`
 # adjust your `cd` appropriately
-cd $WORKSPACE/srcdir/hello 
+cd $WORKSPACE/srcdir/hello
 mkdir -p ${libdir}                                         # make sure the libdir is instantiated
 ${CC} -shared -o ${libdir}/libhello.${dlext} -fPIC hello.c # compile the library, save to `libdir`
 ```

docs/src/index.md

@@ -1,6 +1,6 @@
 # BinaryBuilder.jl
 
-The purpose of the [`BinaryBuilder.jl`](https://github.com/JuliaPackaging/BinaryBuilder.jl) Julia package is to provide a system for compiling 3rd-party binary dependencies that should work anywhere the [official Julia distribution](https://julialang.org/downloads) does.  In particular, using this package you will be able to compile your large pre-existing codebases of C, C++, Fortran, Rust, Go, etc... software into binaries that can be downloaded and loaded/run on a very wide range of machines.  As it is difficult (and often expensive) to natively compile software packages across the growing number of platforms that this package will need to support, we focus on providing a set of Linux-hosted cross-compilers.  This package will therefore set up an environment to perform cross-compilation for all of the major platforms, and will do its best to make the compilation process as painless as possible.
+The purpose of the [`BinaryBuilder.jl`](https://github.com/JuliaPackaging/BinaryBuilder.jl) Julia package is to provide a system for compiling 3rd-party binary dependencies that should work anywhere the [official Julia distribution](https://julialang.org/downloads) does.  In particular, using this package you will be able to compile your large pre-existing codebases of C, C++, Fortran, Rust, Go, OCaml, etc... software into binaries that can be downloaded and loaded/run on a very wide range of machines.  As it is difficult (and often expensive) to natively compile software packages across the growing number of platforms that this package will need to support, we focus on providing a set of Linux-hosted cross-compilers.  This package will therefore set up an environment to perform cross-compilation for all of the major platforms, and will do its best to make the compilation process as painless as possible.
 
 Note that at this time, BinaryBuilder itself runs on Linux `x86_64` and macOS `x86_64` systems only, with Windows support under active development.  On macOS and Windows, you must have `docker` installed as the backing virtualization engine.  Note that Docker Desktop is the recommended version; if you have Docker Machine installed it may not work correctly or may need additional configuration.
 

generate_precompile.jl

@@ -9,6 +9,7 @@ using SnoopCompile
         ExecutableProduct("hello_world_fortran", :hello_world_fortran),
         ExecutableProduct("hello_world_go", :hello_world_go),
         ExecutableProduct("hello_world_rust", :hello_world_rust),
+        ExecutableProduct("hello_world_ocaml", :hello_world_ocaml),
     ]
 
     # First, do the build, but only output the meta json, since we definitely want that to be fast
@@ -55,7 +56,7 @@ using SnoopCompile
         Dependency[
             Dependency("Zlib_jll"),
         ];
-        compilers=[:c, :rust, :go],
+        compilers=[:c, :rust, :go, :ocaml],
     )
 
     rm("build"; recursive=true, force=true)

src/AutoBuild.jl

@@ -488,6 +488,13 @@ function get_compilers_versions(; compilers = [:c])
             go version
             """
     end
+    if :ocaml in compilers
+        output *=
+            """
+            ocamlc -v
+            ocamlopt -v
+            """
+    end
     if :rust in compilers
         output *=
             """
@@ -824,7 +831,15 @@ function autobuild(dir::AbstractString,
         build_path = joinpath(dir, "build", triplet(platform))
         mkpath(build_path)
 
-        shards = choose_shards(platform; extract_kwargs(kwargs, (:preferred_gcc_version,:preferred_llvm_version,:preferred_rust_version,:preferred_go_version,:bootstrap_list,:compilers))...)
+        shards = choose_shards(platform; extract_kwargs(kwargs, (
+            :preferred_gcc_version,
+            :preferred_llvm_version,
+            :preferred_rust_version,
+            :preferred_go_version,
+            :preferred_ocaml_version,
+            :bootstrap_list,
+            :compilers,
+        ))...)
         concrete_platform = get_concrete_platform(platform, shards)
 
         prefix = setup_workspace(

src/wizard/obtain_source.jl

@@ -334,11 +334,11 @@ function get_name_and_version(state::WizardState)
     end
 end
 
-@enum Compilers C=1 Go Rust
+@enum Compilers C=1 Go Rust OCaml
 function get_compilers(state::WizardState)
     while state.compilers === nothing
-        compiler_descriptions = Dict(C => "C/C++/Fortran", Go => "Go", Rust => "Rust")
-        compiler_symbols = Dict(Int(C) => :c, Int(Go) => :go, Int(Rust) => :rust)
+        compiler_descriptions = Dict(C => "C/C++/Fortran", Go => "Go", Rust => "Rust", OCaml => "OCaml")
+        compiler_symbols = Dict(Int(C) => :c, Int(Go) => :go, Int(Rust) => :rust, Int(OCaml) => :ocaml)
         terminal = TTYTerminal("xterm", state.ins, state.outs, state.outs)
         result = nothing
         while true

test/building.jl

@@ -156,6 +156,12 @@ shards_to_test = expand_cxxstring_abis(expand_gfortran_versions(shards_to_test))
                 push!(compilers, :rust)
             end
 
+            # OCaml is not available on 32-bit platforms, and our shards aren't for FreeBSD
+            if !(nbits(shard) == 32 || Sys.isfreebsd(shard))
+                push!(products, ExecutableProduct("hello_world_ocaml", :hello_world_ocaml))
+                push!(compilers, :ocaml)
+            end
+
             build_output_meta = autobuild(
                 build_path,
                 "testsuite",

test/wizard.jl

@@ -180,7 +180,7 @@ end
     # Check that the state is modified appropriately
     @test state.source_urls == ["http://127.0.0.1:$(port)/a/source.tar.gz"]
     @test getfield.(state.source_files, :hash) == [libfoo_tarball_hash]
-    @test Set(state.compilers) == Set([:c, :rust, :go])
+    @test Set(state.compilers) == Set([:c, :rust, :go, :ocaml])
     @test state.preferred_gcc_version == getversion(available_gcc_builds[1])
     # The default LLVM shard is the latest one, and above we pressed three times
     # arrow down in the reverse order list.