From a170be0a24df9a47a7eb4227ea3ef0962fa634ce Mon Sep 17 00:00:00 2001 From: jlbuild Date: Tue, 15 Sep 2020 10:24:22 +0000 Subject: [PATCH] tectonic_jll build 0.1.15+0 --- .gitignore | 1 + Artifacts.toml | 154 ++++++++++++++++++ LICENSE | 8 + Project.toml | 18 ++ README.md | 51 ++++++ src/tectonic_jll.jl | 101 ++++++++++++ src/wrappers/aarch64-linux-gnu-cxx03.jl | 76 +++++++++ src/wrappers/aarch64-linux-gnu-cxx11.jl | 76 +++++++++ src/wrappers/armv7l-linux-gnueabihf-cxx03.jl | 76 +++++++++ src/wrappers/armv7l-linux-gnueabihf-cxx11.jl | 76 +++++++++ src/wrappers/i686-linux-gnu-cxx03.jl | 76 +++++++++ src/wrappers/i686-linux-gnu-cxx11.jl | 76 +++++++++ src/wrappers/powerpc64le-linux-gnu-cxx03.jl | 76 +++++++++ src/wrappers/powerpc64le-linux-gnu-cxx11.jl | 76 +++++++++ src/wrappers/x86_64-apple-darwin14-cxx03.jl | 76 +++++++++ src/wrappers/x86_64-apple-darwin14-cxx11.jl | 76 +++++++++ src/wrappers/x86_64-linux-gnu-cxx03.jl | 76 +++++++++ src/wrappers/x86_64-linux-gnu-cxx11.jl | 76 +++++++++ .../x86_64-unknown-freebsd11.1-cxx03.jl | 76 +++++++++ .../x86_64-unknown-freebsd11.1-cxx11.jl | 76 +++++++++ src/wrappers/x86_64-w64-mingw32-cxx03.jl | 76 +++++++++ src/wrappers/x86_64-w64-mingw32-cxx11.jl | 76 +++++++++ 22 files changed, 1549 insertions(+) create mode 100644 .gitignore create mode 100644 Artifacts.toml create mode 100644 Project.toml create mode 100644 README.md create mode 100644 src/tectonic_jll.jl create mode 100644 src/wrappers/aarch64-linux-gnu-cxx03.jl create mode 100644 src/wrappers/aarch64-linux-gnu-cxx11.jl create mode 100644 src/wrappers/armv7l-linux-gnueabihf-cxx03.jl create mode 100644 src/wrappers/armv7l-linux-gnueabihf-cxx11.jl create mode 100644 src/wrappers/i686-linux-gnu-cxx03.jl create mode 100644 src/wrappers/i686-linux-gnu-cxx11.jl create mode 100644 src/wrappers/powerpc64le-linux-gnu-cxx03.jl create mode 100644 src/wrappers/powerpc64le-linux-gnu-cxx11.jl create mode 100644 src/wrappers/x86_64-apple-darwin14-cxx03.jl create mode 100644 src/wrappers/x86_64-apple-darwin14-cxx11.jl create mode 100644 src/wrappers/x86_64-linux-gnu-cxx03.jl create mode 100644 src/wrappers/x86_64-linux-gnu-cxx11.jl create mode 100644 src/wrappers/x86_64-unknown-freebsd11.1-cxx03.jl create mode 100644 src/wrappers/x86_64-unknown-freebsd11.1-cxx11.jl create mode 100644 src/wrappers/x86_64-w64-mingw32-cxx03.jl create mode 100644 src/wrappers/x86_64-w64-mingw32-cxx11.jl diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3ae43e4 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +override/ diff --git a/Artifacts.toml b/Artifacts.toml new file mode 100644 index 0000000..9817947 --- /dev/null +++ b/Artifacts.toml @@ -0,0 +1,154 @@ +[[tectonic]] +arch = "aarch64" +cxxstring_abi = "cxx03" +git-tree-sha1 = "778f1ecce02e88ed0d064635d7a0fbe34dd7ab26" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "545113b8bc9c93e8a888a30ce8d59246a5095f6ee004911a3c97be8f4b74ffca" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.aarch64-linux-gnu-cxx03.tar.gz" +[[tectonic]] +arch = "aarch64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "ba106c8fc6c8afb9b38ecad76593392c2bfb477d" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "7e31d2f055098bc59e12022d00449983e0d55ea0c3140d3467f9ed889a743380" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.aarch64-linux-gnu-cxx11.tar.gz" +[[tectonic]] +arch = "armv7l" +cxxstring_abi = "cxx03" +git-tree-sha1 = "4e54e1ab2962d5aef28a154bf9447d9ba5726555" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "88e998908f88d18c6a68f0d3ee00a147eb5a029961357d6d893cb02f7cceea38" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.armv7l-linux-gnueabihf-cxx03.tar.gz" +[[tectonic]] +arch = "armv7l" +cxxstring_abi = "cxx11" +git-tree-sha1 = "67f28e393b182bd89ddc224dddf37f7ff038c398" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "2ae5fad28808f449491c91917ae1670d91065a6db38ab2913598ea0533a0a00e" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.armv7l-linux-gnueabihf-cxx11.tar.gz" +[[tectonic]] +arch = "i686" +cxxstring_abi = "cxx03" +git-tree-sha1 = "4f68ea94ffe806d38060ce1aa6daea399ef4a888" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "173ee3d49526835d3d452977d7b44f1e7dbc678794ed3e8e69ff8382908e9a7c" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.i686-linux-gnu-cxx03.tar.gz" +[[tectonic]] +arch = "i686" +cxxstring_abi = "cxx11" +git-tree-sha1 = "89b907de511caecf08b32197d1652d33e1d1aa81" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "1454193f24ff30a0cb63b7f81de88cd74e4690570066248b2280ed843185dbef" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.i686-linux-gnu-cxx11.tar.gz" +[[tectonic]] +arch = "powerpc64le" +cxxstring_abi = "cxx03" +git-tree-sha1 = "06ad47a469364f0d13ec8d1f335728a27526de0f" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "e62addc9868964e8437b773678b610ae4200822cd7bb827e1b13449e2e45f751" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.powerpc64le-linux-gnu-cxx03.tar.gz" +[[tectonic]] +arch = "powerpc64le" +cxxstring_abi = "cxx11" +git-tree-sha1 = "5eecc15c99fdd8c425229f7254a465fa417d9479" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "aaba4c5ec34f457c48128b006d8aa5da96c00647cf1900e8c7570c5450556cea" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.powerpc64le-linux-gnu-cxx11.tar.gz" +[[tectonic]] +arch = "x86_64" +cxxstring_abi = "cxx03" +git-tree-sha1 = "91828ba484d5553bf69d45c772e4bb9b381d0094" +os = "macos" + + [[tectonic.download]] + sha256 = "10c06394e2a0e68cc01723b5fdddc4472af3a4888e69180d705b231cc4c12d47" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.x86_64-apple-darwin14-cxx03.tar.gz" +[[tectonic]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "b6129c97e9711e908e2385ab6ecf8af6282250ec" +os = "macos" + + [[tectonic.download]] + sha256 = "5a3a2ed311a1431b463d7752540372b15756862d840fbbf8330732dcb0b278e3" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.x86_64-apple-darwin14-cxx11.tar.gz" +[[tectonic]] +arch = "x86_64" +cxxstring_abi = "cxx03" +git-tree-sha1 = "ae5c16da7d8ef93e48554ce257cebe4284ef5941" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "8946ea84b37d9d367bf78b75cd46685e1edf5274ad644e38660a70223955e9c8" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.x86_64-linux-gnu-cxx03.tar.gz" +[[tectonic]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "160bf5e1a2e9b9cecbd55ea57cbe11f0a49326ec" +libc = "glibc" +os = "linux" + + [[tectonic.download]] + sha256 = "778beda21eb2ec4d4aa3b9686d703ee8e3561fc7d6ff6f08bdc41ee8b0808209" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.x86_64-linux-gnu-cxx11.tar.gz" +[[tectonic]] +arch = "x86_64" +cxxstring_abi = "cxx03" +git-tree-sha1 = "2203547e4e2c3ea83655d1e1f3bd4a24bb5bea17" +os = "freebsd" + + [[tectonic.download]] + sha256 = "26fbac5cd6be806cb84a3141637cba35e5d11ab004cd3dfddc9ff7a48d6ab9a1" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.x86_64-unknown-freebsd11.1-cxx03.tar.gz" +[[tectonic]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "d4b8f74b3c27d3bf5c90ba28ac732c1db5e57ddf" +os = "freebsd" + + [[tectonic.download]] + sha256 = "1cb6f9b6e5e59af8ffe87800f33a92e799170f2946c35190fbc6aef738d1b265" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.x86_64-unknown-freebsd11.1-cxx11.tar.gz" +[[tectonic]] +arch = "x86_64" +cxxstring_abi = "cxx03" +git-tree-sha1 = "0dd7f4c31f9a44074e386783f28fbab72da89871" +os = "windows" + + [[tectonic.download]] + sha256 = "da2f7c9caeeec3542f28f5bb27da075e2b9de8545e014e993ea7dafa17dfa971" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.x86_64-w64-mingw32-cxx03.tar.gz" +[[tectonic]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "67802c3fc030aa170e25157cb2cfc9083d5d42b4" +os = "windows" + + [[tectonic.download]] + sha256 = "d52cd841aa33b185a58af818c001322bd2162c1a290569a73394cc3487e770c7" + url = "https://github.com/JuliaBinaryWrappers/tectonic_jll.jl/releases/download/tectonic-v0.1.15+0/tectonic.v0.1.15.x86_64-w64-mingw32-cxx11.tar.gz" diff --git a/LICENSE b/LICENSE index 30feb68..30a2167 100644 --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,11 @@ +The Julia source code within this repository (all files under `src/`) are +released under the terms of the MIT "Expat" License, the text of which is +included below. This license does not apply to the binary package wrapped by +this Julia package and automatically downloaded by the Julia package manager +upon installing this wrapper package. The binary package's license is shipped +alongside the binary itself and can be found within the +`share/licenses/tectonic` directory within its prefix. + MIT License Copyright (c) 2020 JuliaBinaryWrappers diff --git a/Project.toml b/Project.toml new file mode 100644 index 0000000..4c426a6 --- /dev/null +++ b/Project.toml @@ -0,0 +1,18 @@ +name = "tectonic_jll" +uuid = "d7dd28d6-a5e6-559c-9131-7eb760cdacc5" +version = "0.1.15+0" + +[deps] +Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +OpenSSL_jll = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +Zlib_jll = "83775a58-1f1d-513f-b197-d71354ab007a" +FreeType2_jll = "d7e528f0-a631-5988-bf34-fe36492bcfd7" +libpng_jll = "b53b4c65-9356-5827-b1ea-8c7a1a84506f" +Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +HarfBuzz_jll = "2e76f6c2-a576-52d4-95c1-20adfe4de566" +ICU_jll = "a51ab1cf-af8e-5615-a023-bc2c838bba6b" +Fontconfig_jll = "a3f928ae-7b40-5064-980b-68af3947d34b" +Graphite2_jll = "3b182d85-2403-5c21-9c21-1e1f0cc25472" + +[compat] +julia = "1.0" diff --git a/README.md b/README.md new file mode 100644 index 0000000..b9cef84 --- /dev/null +++ b/README.md @@ -0,0 +1,51 @@ +# `tectonic_jll.jl` (v0.1.15+0) + +This is an autogenerated package constructed using [`BinaryBuilder.jl`](https://github.com/JuliaPackaging/BinaryBuilder.jl). The originating [`build_tarballs.jl`](https://github.com/JuliaPackaging/Yggdrasil/blob/31ace39b9e934a02733adc8f1f4c54e4a54e2169/T/tectonic/build_tarballs.jl) script can be found on [`Yggdrasil`](https://github.com/JuliaPackaging/Yggdrasil/), the community build tree. If you have any issue, please report it to the Yggdrasil [bug tracker](https://github.com/JuliaPackaging/Yggdrasil/issues). + +For more details about JLL packages and how to use them, see `BinaryBuilder.jl` [documentation](https://juliapackaging.github.io/BinaryBuilder.jl/dev/jll/). + +## Sources + +The tarballs for `tectonic_jll.jl` have been built from these sources: + +* compressed archive: https://github.com/tectonic-typesetting/tectonic/archive/tectonic@0.1.15.tar.gz (SHA256 checksum: `0e55188eafc1b58f3660a303fcdd6adc071051b9eb728119837fbeed2309914f`) + +## Platforms + +`tectonic_jll.jl` is available for the following platforms: + +* `Linux(:aarch64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))` (`aarch64-linux-gnu-cxx03`) +* `Linux(:aarch64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`aarch64-linux-gnu-cxx11`) +* `Linux(:armv7l, libc=:glibc, call_abi=:eabihf, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))` (`armv7l-linux-gnueabihf-cxx03`) +* `Linux(:armv7l, libc=:glibc, call_abi=:eabihf, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`armv7l-linux-gnueabihf-cxx11`) +* `Linux(:i686, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))` (`i686-linux-gnu-cxx03`) +* `Linux(:i686, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`i686-linux-gnu-cxx11`) +* `Linux(:powerpc64le, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))` (`powerpc64le-linux-gnu-cxx03`) +* `Linux(:powerpc64le, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`powerpc64le-linux-gnu-cxx11`) +* `MacOS(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))` (`x86_64-apple-darwin14-cxx03`) +* `MacOS(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`x86_64-apple-darwin14-cxx11`) +* `Linux(:x86_64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))` (`x86_64-linux-gnu-cxx03`) +* `Linux(:x86_64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`x86_64-linux-gnu-cxx11`) +* `FreeBSD(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))` (`x86_64-unknown-freebsd11.1-cxx03`) +* `FreeBSD(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`x86_64-unknown-freebsd11.1-cxx11`) +* `Windows(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx03))` (`x86_64-w64-mingw32-cxx03`) +* `Windows(:x86_64, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`x86_64-w64-mingw32-cxx11`) + +## Dependencies + +The following JLL packages are required by `tectonic_jll.jl`: + +* [`Fontconfig_jll`](https://github.com/JuliaBinaryWrappers/Fontconfig_jll.jl) +* [`FreeType2_jll`](https://github.com/JuliaBinaryWrappers/FreeType2_jll.jl) +* [`Graphite2_jll`](https://github.com/JuliaBinaryWrappers/Graphite2_jll.jl) +* [`HarfBuzz_jll`](https://github.com/JuliaBinaryWrappers/HarfBuzz_jll.jl) +* [`ICU_jll`](https://github.com/JuliaBinaryWrappers/ICU_jll.jl) +* [`OpenSSL_jll`](https://github.com/JuliaBinaryWrappers/OpenSSL_jll.jl) +* [`Zlib_jll`](https://github.com/JuliaBinaryWrappers/Zlib_jll.jl) +* [`libpng_jll`](https://github.com/JuliaBinaryWrappers/libpng_jll.jl) + +## Products + +The code bindings within this package are autogenerated from the following `Products`: + +* `ExecutableProduct`: `tectonic` diff --git a/src/tectonic_jll.jl b/src/tectonic_jll.jl new file mode 100644 index 0000000..d8aa267 --- /dev/null +++ b/src/tectonic_jll.jl @@ -0,0 +1,101 @@ +module tectonic_jll + +if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@optlevel")) + @eval Base.Experimental.@optlevel 0 +end + +if VERSION < v"1.3.0-rc4" + # We lie a bit in the registry that JLL packages are usable on Julia 1.0-1.2. + # This is to allow packages that might want to support Julia 1.0 to get the + # benefits of a JLL package on 1.3 (requiring them to declare a dependence on + # this JLL package in their Project.toml) but engage in heroic hacks to do + # something other than actually use a JLL package on 1.0-1.2. By allowing + # this package to be installed (but not loaded) on 1.0-1.2, we enable users + # to avoid splitting their package versions into pre-1.3 and post-1.3 branches + # if they are willing to engage in the kinds of hoop-jumping they might need + # to in order to install binaries in a JLL-compatible way on 1.0-1.2. One + # example of this hoop-jumping being to express a dependency on this JLL + # package, then import it within a `VERSION >= v"1.3"` conditional, and use + # the deprecated `build.jl` mechanism to download the binaries through e.g. + # `BinaryProvider.jl`. This should work well for the simplest packages, and + # require greater and greater heroics for more and more complex packages. + error("Unable to import tectonic_jll on Julia versions older than 1.3!") +end + +using Pkg, Pkg.BinaryPlatforms, Pkg.Artifacts, Libdl +import Base: UUID + +wrapper_available = false +""" + is_available() + +Return whether the artifact is available for the current platform. +""" +is_available() = wrapper_available + +# We put these inter-JLL-package API values here so that they are always defined, even if there +# is no underlying wrapper held within this JLL package. +const PATH_list = String[] +const LIBPATH_list = String[] + +# We determine, here, at compile-time, whether our JLL package has been dev'ed and overridden +override_dir = joinpath(dirname(@__DIR__), "override") +if isdir(override_dir) + function find_artifact_dir() + return override_dir + end +else + function find_artifact_dir() + return artifact"tectonic" + end + + """ + dev_jll() + + Check this package out to the dev package directory (usually ~/.julia/dev), + copying the artifact over to a local `override` directory, allowing package + developers to experiment with a locally-built binary. + """ + function dev_jll() + # First, `dev` out the package, but don't effect the current project + mktempdir() do temp_env + Pkg.activate(temp_env) do + Pkg.develop("tectonic_jll") + end + end + # Create the override directory + override_dir = joinpath(Pkg.devdir(), "tectonic_jll", "override") + # Copy the current artifact contents into that directory + if !isdir(override_dir) + cp(artifact"tectonic", override_dir) + end + # Force recompilation of that package, just in case it wasn't dev'ed before + touch(joinpath(Pkg.devdir(), "tectonic_jll", "src", "tectonic_jll.jl")) + @info("tectonic_ll dev'ed out to /depot/dev/tectonic_jll with pre-populated override directory") + end +end +# Load Artifacts.toml file +artifacts_toml = joinpath(@__DIR__, "..", "Artifacts.toml") + +# Extract all platforms +artifacts = Pkg.Artifacts.load_artifacts_toml(artifacts_toml; pkg_uuid=UUID("d7dd28d6-a5e6-559c-9131-7eb760cdacc5")) +platforms = [Pkg.Artifacts.unpack_platform(e, "tectonic", artifacts_toml) for e in artifacts["tectonic"]] + +# Filter platforms based on what wrappers we've generated on-disk +filter!(p -> isfile(joinpath(@__DIR__, "wrappers", replace(triplet(p), "arm-" => "armv7l-") * ".jl")), platforms) + +# From the available options, choose the best platform +best_platform = select_platform(Dict(p => triplet(p) for p in platforms)) + +# Silently fail if there's no binaries for this platform +if best_platform === nothing + @debug("Unable to load tectonic; unsupported platform $(triplet(platform_key_abi()))") +else + # Load the appropriate wrapper. Note that on older Julia versions, we still + # say "arm-linux-gnueabihf" instead of the more correct "armv7l-linux-gnueabihf", + # so we manually correct for that here: + best_platform = replace(best_platform, "arm-" => "armv7l-") + include(joinpath(@__DIR__, "wrappers", "$(best_platform).jl")) +end + +end # module tectonic_jll diff --git a/src/wrappers/aarch64-linux-gnu-cxx03.jl b/src/wrappers/aarch64-linux-gnu-cxx03.jl new file mode 100644 index 0000000..0d6d4f4 --- /dev/null +++ b/src/wrappers/aarch64-linux-gnu-cxx03.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for aarch64-linux-gnu-cxx03 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/aarch64-linux-gnu-cxx11.jl b/src/wrappers/aarch64-linux-gnu-cxx11.jl new file mode 100644 index 0000000..8d14300 --- /dev/null +++ b/src/wrappers/aarch64-linux-gnu-cxx11.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for aarch64-linux-gnu-cxx11 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/armv7l-linux-gnueabihf-cxx03.jl b/src/wrappers/armv7l-linux-gnueabihf-cxx03.jl new file mode 100644 index 0000000..4f72070 --- /dev/null +++ b/src/wrappers/armv7l-linux-gnueabihf-cxx03.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for armv7l-linux-gnueabihf-cxx03 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/armv7l-linux-gnueabihf-cxx11.jl b/src/wrappers/armv7l-linux-gnueabihf-cxx11.jl new file mode 100644 index 0000000..929f062 --- /dev/null +++ b/src/wrappers/armv7l-linux-gnueabihf-cxx11.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for armv7l-linux-gnueabihf-cxx11 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/i686-linux-gnu-cxx03.jl b/src/wrappers/i686-linux-gnu-cxx03.jl new file mode 100644 index 0000000..28a3a15 --- /dev/null +++ b/src/wrappers/i686-linux-gnu-cxx03.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for i686-linux-gnu-cxx03 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/i686-linux-gnu-cxx11.jl b/src/wrappers/i686-linux-gnu-cxx11.jl new file mode 100644 index 0000000..749623b --- /dev/null +++ b/src/wrappers/i686-linux-gnu-cxx11.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for i686-linux-gnu-cxx11 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/powerpc64le-linux-gnu-cxx03.jl b/src/wrappers/powerpc64le-linux-gnu-cxx03.jl new file mode 100644 index 0000000..846c0d2 --- /dev/null +++ b/src/wrappers/powerpc64le-linux-gnu-cxx03.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for powerpc64le-linux-gnu-cxx03 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/powerpc64le-linux-gnu-cxx11.jl b/src/wrappers/powerpc64le-linux-gnu-cxx11.jl new file mode 100644 index 0000000..2c14acb --- /dev/null +++ b/src/wrappers/powerpc64le-linux-gnu-cxx11.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for powerpc64le-linux-gnu-cxx11 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/x86_64-apple-darwin14-cxx03.jl b/src/wrappers/x86_64-apple-darwin14-cxx03.jl new file mode 100644 index 0000000..574681d --- /dev/null +++ b/src/wrappers/x86_64-apple-darwin14-cxx03.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for x86_64-apple-darwin14-cxx03 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "DYLD_FALLBACK_LIBRARY_PATH" +LIBPATH_default = "~/lib:/usr/local/lib:/lib:/usr/lib" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/x86_64-apple-darwin14-cxx11.jl b/src/wrappers/x86_64-apple-darwin14-cxx11.jl new file mode 100644 index 0000000..91f1090 --- /dev/null +++ b/src/wrappers/x86_64-apple-darwin14-cxx11.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for x86_64-apple-darwin14-cxx11 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "DYLD_FALLBACK_LIBRARY_PATH" +LIBPATH_default = "~/lib:/usr/local/lib:/lib:/usr/lib" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/x86_64-linux-gnu-cxx03.jl b/src/wrappers/x86_64-linux-gnu-cxx03.jl new file mode 100644 index 0000000..1b822c2 --- /dev/null +++ b/src/wrappers/x86_64-linux-gnu-cxx03.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for x86_64-linux-gnu-cxx03 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/x86_64-linux-gnu-cxx11.jl b/src/wrappers/x86_64-linux-gnu-cxx11.jl new file mode 100644 index 0000000..2563cbf --- /dev/null +++ b/src/wrappers/x86_64-linux-gnu-cxx11.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for x86_64-linux-gnu-cxx11 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/x86_64-unknown-freebsd11.1-cxx03.jl b/src/wrappers/x86_64-unknown-freebsd11.1-cxx03.jl new file mode 100644 index 0000000..2f31ec3 --- /dev/null +++ b/src/wrappers/x86_64-unknown-freebsd11.1-cxx03.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for x86_64-unknown-freebsd11.1-cxx03 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/x86_64-unknown-freebsd11.1-cxx11.jl b/src/wrappers/x86_64-unknown-freebsd11.1-cxx11.jl new file mode 100644 index 0000000..90d5593 --- /dev/null +++ b/src/wrappers/x86_64-unknown-freebsd11.1-cxx11.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for x86_64-unknown-freebsd11.1-cxx11 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ':', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ':', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ':') + global LIBPATH = join(vcat(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ':') + + +end # __init__() diff --git a/src/wrappers/x86_64-w64-mingw32-cxx03.jl b/src/wrappers/x86_64-w64-mingw32-cxx03.jl new file mode 100644 index 0000000..a91596d --- /dev/null +++ b/src/wrappers/x86_64-w64-mingw32-cxx03.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for x86_64-w64-mingw32-cxx03 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic.exe"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ';', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ';', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ';') + global LIBPATH = join(vcat(LIBPATH_list, [Sys.BINDIR, joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ';') + + +end # __init__() diff --git a/src/wrappers/x86_64-w64-mingw32-cxx11.jl b/src/wrappers/x86_64-w64-mingw32-cxx11.jl new file mode 100644 index 0000000..e4a524d --- /dev/null +++ b/src/wrappers/x86_64-w64-mingw32-cxx11.jl @@ -0,0 +1,76 @@ +# Autogenerated wrapper script for tectonic_jll for x86_64-w64-mingw32-cxx11 +export tectonic + +using Fontconfig_jll +using FreeType2_jll +using Graphite2_jll +using HarfBuzz_jll +using ICU_jll +using OpenSSL_jll +using Zlib_jll +using libpng_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "PATH" +LIBPATH_default = "" + +# Relative path to `tectonic` +const tectonic_splitpath = ["bin", "tectonic.exe"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +tectonic_path = "" + +# tectonic-specific global declaration +function tectonic(f::Function; adjust_PATH::Bool = true, adjust_LIBPATH::Bool = true) + global PATH, LIBPATH + env_mapping = Dict{String,String}() + if adjust_PATH + if !isempty(get(ENV, "PATH", "")) + env_mapping["PATH"] = string(PATH, ';', ENV["PATH"]) + else + env_mapping["PATH"] = PATH + end + end + if adjust_LIBPATH + LIBPATH_base = get(ENV, LIBPATH_env, expanduser(LIBPATH_default)) + if !isempty(LIBPATH_base) + env_mapping[LIBPATH_env] = string(LIBPATH, ';', LIBPATH_base) + else + env_mapping[LIBPATH_env] = LIBPATH + end + end + withenv(env_mapping...) do + f(tectonic_path) + end +end + + +# Inform that the wrapper is available for this platform +wrapper_available = true + +""" +Open all libraries +""" +function __init__() + # This either calls `@artifact_str()`, or returns a constant string if we're overridden. + global artifact_dir = find_artifact_dir() + + global PATH_list, LIBPATH_list + # Initialize PATH and LIBPATH environment variable listings + # From the list of our dependencies, generate a tuple of all the PATH and LIBPATH lists, + # then append them to our own. + foreach(p -> append!(PATH_list, p), (Fontconfig_jll.PATH_list, FreeType2_jll.PATH_list, Graphite2_jll.PATH_list, HarfBuzz_jll.PATH_list, ICU_jll.PATH_list, OpenSSL_jll.PATH_list, Zlib_jll.PATH_list, libpng_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (Fontconfig_jll.LIBPATH_list, FreeType2_jll.LIBPATH_list, Graphite2_jll.LIBPATH_list, HarfBuzz_jll.LIBPATH_list, ICU_jll.LIBPATH_list, OpenSSL_jll.LIBPATH_list, Zlib_jll.LIBPATH_list, libpng_jll.LIBPATH_list,)) + + global tectonic_path = normpath(joinpath(artifact_dir, tectonic_splitpath...)) + + push!(PATH_list, dirname(tectonic_path)) + # Filter out duplicate and empty entries in our PATH and LIBPATH entries + filter!(!isempty, unique!(PATH_list)) + filter!(!isempty, unique!(LIBPATH_list)) + global PATH = join(PATH_list, ';') + global LIBPATH = join(vcat(LIBPATH_list, [Sys.BINDIR, joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]), ';') + + +end # __init__()