From 113e5ccf5346d88155878fb4157e0cfdd39c180e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mos=C3=A8=20Giordano?= Date: Wed, 17 Jun 2020 01:24:07 +0000 Subject: [PATCH] Darknet_jll build 2020.6.5+2 --- Artifacts.toml | 228 ++++++++++++++++++ LICENSE | 8 + Project.toml | 11 + README.md | 49 ++++ src/Darknet_jll.jl | 53 ++++ .../aarch64-linux-gnu-cxx11-march+armv8.jl | 59 +++++ .../aarch64-linux-gnu-cxx11-march+carmel.jl | 59 +++++ ...aarch64-linux-gnu-cxx11-march+thunderx2.jl | 59 +++++ .../aarch64-linux-musl-cxx11-march+armv8.jl | 59 +++++ .../aarch64-linux-musl-cxx11-march+carmel.jl | 59 +++++ ...arch64-linux-musl-cxx11-march+thunderx2.jl | 59 +++++ ...mv7l-linux-gnueabihf-cxx11-march+armv7l.jl | 59 +++++ ...armv7l-linux-gnueabihf-cxx11-march+neon.jl | 59 +++++ ...armv7l-linux-gnueabihf-cxx11-march+vfp4.jl | 59 +++++ ...v7l-linux-musleabihf-cxx11-march+armv7l.jl | 59 +++++ ...rmv7l-linux-musleabihf-cxx11-march+neon.jl | 59 +++++ ...rmv7l-linux-musleabihf-cxx11-march+vfp4.jl | 59 +++++ src/wrappers/i686-linux-gnu-cxx11.jl | 59 +++++ src/wrappers/i686-linux-musl-cxx11.jl | 59 +++++ src/wrappers/powerpc64le-linux-gnu-cxx11.jl | 59 +++++ .../x86_64-linux-gnu-cxx11-march+avx2.jl | 59 +++++ .../x86_64-linux-gnu-cxx11-march+avx512.jl | 59 +++++ .../x86_64-linux-gnu-cxx11-march+x86_64.jl | 59 +++++ .../x86_64-linux-musl-cxx11-march+avx2.jl | 59 +++++ .../x86_64-linux-musl-cxx11-march+avx512.jl | 59 +++++ .../x86_64-linux-musl-cxx11-march+x86_64.jl | 59 +++++ 26 files changed, 1588 insertions(+) create mode 100644 Artifacts.toml create mode 100644 Project.toml create mode 100644 README.md create mode 100644 src/Darknet_jll.jl create mode 100644 src/wrappers/aarch64-linux-gnu-cxx11-march+armv8.jl create mode 100644 src/wrappers/aarch64-linux-gnu-cxx11-march+carmel.jl create mode 100644 src/wrappers/aarch64-linux-gnu-cxx11-march+thunderx2.jl create mode 100644 src/wrappers/aarch64-linux-musl-cxx11-march+armv8.jl create mode 100644 src/wrappers/aarch64-linux-musl-cxx11-march+carmel.jl create mode 100644 src/wrappers/aarch64-linux-musl-cxx11-march+thunderx2.jl create mode 100644 src/wrappers/armv7l-linux-gnueabihf-cxx11-march+armv7l.jl create mode 100644 src/wrappers/armv7l-linux-gnueabihf-cxx11-march+neon.jl create mode 100644 src/wrappers/armv7l-linux-gnueabihf-cxx11-march+vfp4.jl create mode 100644 src/wrappers/armv7l-linux-musleabihf-cxx11-march+armv7l.jl create mode 100644 src/wrappers/armv7l-linux-musleabihf-cxx11-march+neon.jl create mode 100644 src/wrappers/armv7l-linux-musleabihf-cxx11-march+vfp4.jl create mode 100644 src/wrappers/i686-linux-gnu-cxx11.jl create mode 100644 src/wrappers/i686-linux-musl-cxx11.jl create mode 100644 src/wrappers/powerpc64le-linux-gnu-cxx11.jl create mode 100644 src/wrappers/x86_64-linux-gnu-cxx11-march+avx2.jl create mode 100644 src/wrappers/x86_64-linux-gnu-cxx11-march+avx512.jl create mode 100644 src/wrappers/x86_64-linux-gnu-cxx11-march+x86_64.jl create mode 100644 src/wrappers/x86_64-linux-musl-cxx11-march+avx2.jl create mode 100644 src/wrappers/x86_64-linux-musl-cxx11-march+avx512.jl create mode 100644 src/wrappers/x86_64-linux-musl-cxx11-march+x86_64.jl diff --git a/Artifacts.toml b/Artifacts.toml new file mode 100644 index 0000000..e048520 --- /dev/null +++ b/Artifacts.toml @@ -0,0 +1,228 @@ +[[Darknet]] +arch = "aarch64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "50ee59141706a1fcc15aa0e531e32cd2de60b34c" +libc = "glibc" +march = "armv8" +os = "linux" + + [[Darknet.download]] + sha256 = "f0311afee37984ede8389381f6c1d762d25794296f522ec75ee71f3b1c9e2239" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.aarch64-linux-gnu-cxx11-march+armv8.tar.gz" +[[Darknet]] +arch = "aarch64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "c4e763b96de3769f8ea92a242d8c3a0be373a282" +libc = "glibc" +march = "carmel" +os = "linux" + + [[Darknet.download]] + sha256 = "a1da6fff1ef1e0796ddb8cb957c36e03d644c409cf85508b92d3204c5403e264" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.aarch64-linux-gnu-cxx11-march+carmel.tar.gz" +[[Darknet]] +arch = "aarch64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "5e850ee5ace63b403d230e9bd8e78af4cb1630b9" +libc = "glibc" +march = "thunderx2" +os = "linux" + + [[Darknet.download]] + sha256 = "5515d78ba0da6968dc52368532bb71c5cbd7a4041863f429ed31d3eba8371e1a" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.aarch64-linux-gnu-cxx11-march+thunderx2.tar.gz" +[[Darknet]] +arch = "aarch64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "ed93578e642a5d30fea85d9bfcea7ac03b045101" +libc = "musl" +march = "armv8" +os = "linux" + + [[Darknet.download]] + sha256 = "e6b0d9c016b8ef37baded72ed04c1b0827e69893a3485285e1371da825f4a484" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.aarch64-linux-musl-cxx11-march+armv8.tar.gz" +[[Darknet]] +arch = "aarch64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "0620f0460e3db41d4c6a9eb698b3a76f717c753f" +libc = "musl" +march = "carmel" +os = "linux" + + [[Darknet.download]] + sha256 = "b2b4964fb84fd00b39cc67966b98ad57ed80b81383044432b7c75a325e6d5cf4" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.aarch64-linux-musl-cxx11-march+carmel.tar.gz" +[[Darknet]] +arch = "aarch64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "f0a3f66a0a0250f1c166f169f9c71101f2b6fd89" +libc = "musl" +march = "thunderx2" +os = "linux" + + [[Darknet.download]] + sha256 = "e6baed1052ef916294bd327677a28630f422df8e8e4d0f83bf3abd28b6dd5050" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.aarch64-linux-musl-cxx11-march+thunderx2.tar.gz" +[[Darknet]] +arch = "armv7l" +cxxstring_abi = "cxx11" +git-tree-sha1 = "3a2579b007f0165e5d0c0a81ecac9273ae2c722b" +libc = "glibc" +march = "armv7l" +os = "linux" + + [[Darknet.download]] + sha256 = "4434bbc7e6b6252e9214d2db0c72d31976f0c01388cc952cc2a05c1bd75feb9e" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.armv7l-linux-gnueabihf-cxx11-march+armv7l.tar.gz" +[[Darknet]] +arch = "armv7l" +cxxstring_abi = "cxx11" +git-tree-sha1 = "5051e7d1f7d012e68d090b43d27fe3a0282a1f99" +libc = "glibc" +march = "neon" +os = "linux" + + [[Darknet.download]] + sha256 = "9540a5e32009c650fafaab9a82d145bd5b47df579c7d21f955895f33b325ae7a" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.armv7l-linux-gnueabihf-cxx11-march+neon.tar.gz" +[[Darknet]] +arch = "armv7l" +cxxstring_abi = "cxx11" +git-tree-sha1 = "60d19984201a28e0aa3b5aafca049dd0222f989d" +libc = "glibc" +march = "vfp4" +os = "linux" + + [[Darknet.download]] + sha256 = "d15cc986be98ab7c8beea08ac9a121f4ec253aaa8b1d4e4752a2ad0773a4454d" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.armv7l-linux-gnueabihf-cxx11-march+vfp4.tar.gz" +[[Darknet]] +arch = "armv7l" +cxxstring_abi = "cxx11" +git-tree-sha1 = "194d49401f65240315d650d21e3e726acc391ee6" +libc = "musl" +march = "armv7l" +os = "linux" + + [[Darknet.download]] + sha256 = "d869d72023cc63bb91f6a7f7b2e2c19353bb248b7744f50b0b1534aca405fe8d" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.armv7l-linux-musleabihf-cxx11-march+armv7l.tar.gz" +[[Darknet]] +arch = "armv7l" +cxxstring_abi = "cxx11" +git-tree-sha1 = "98dc1e3fcff08963aa70ca25e5cc9c7af830ad7f" +libc = "musl" +march = "neon" +os = "linux" + + [[Darknet.download]] + sha256 = "d6901a397f39978031f0c4ff196444f8c2117ae7e096119e1fc09abd74e349f5" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.armv7l-linux-musleabihf-cxx11-march+neon.tar.gz" +[[Darknet]] +arch = "armv7l" +cxxstring_abi = "cxx11" +git-tree-sha1 = "839f0d654af3e725b9de9243aaeacca4e33cea32" +libc = "musl" +march = "vfp4" +os = "linux" + + [[Darknet.download]] + sha256 = "50a02b73cb028ac98a3a57e425d0dcded8888bf22b9411dd674593f5218ea974" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.armv7l-linux-musleabihf-cxx11-march+vfp4.tar.gz" +[[Darknet]] +arch = "i686" +cxxstring_abi = "cxx11" +git-tree-sha1 = "3c87b3ce6925a04c8c126203bb8374750cc47a43" +libc = "glibc" +os = "linux" + + [[Darknet.download]] + sha256 = "980a551d0209db8d256df962d1e05c3344faca9e859f3f857e5c57393d36c099" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.i686-linux-gnu-cxx11.tar.gz" +[[Darknet]] +arch = "i686" +cxxstring_abi = "cxx11" +git-tree-sha1 = "5e41e334a41b7641d5e58618883b758505bf4bcf" +libc = "musl" +os = "linux" + + [[Darknet.download]] + sha256 = "5b0170c38384ea558ebc92f1cc91d865d3ab2f1363d2de770c64e2d12be47f89" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.i686-linux-musl-cxx11.tar.gz" +[[Darknet]] +arch = "powerpc64le" +cxxstring_abi = "cxx11" +git-tree-sha1 = "4d2953ff2a376575423b0c78ade238ff090f67f5" +libc = "glibc" +os = "linux" + + [[Darknet.download]] + sha256 = "778a4a5490b77b611933a83d4be4db32650356df304a29c0510639d2c2f150ab" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.powerpc64le-linux-gnu-cxx11.tar.gz" +[[Darknet]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "2b5e33da1eb47353017992861ccc7b812e3812a8" +libc = "glibc" +march = "avx2" +os = "linux" + + [[Darknet.download]] + sha256 = "314f52e0285ec27a665411a82982ada722ce92d1aedab96eba226175432da4ff" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.x86_64-linux-gnu-cxx11-march+avx2.tar.gz" +[[Darknet]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "3fbe36a917991a8e0b430039e39e8e52e651b3e0" +libc = "glibc" +march = "avx512" +os = "linux" + + [[Darknet.download]] + sha256 = "d4e28c5a8a5f878f0f9efdbd4319c48288557bb722f1d0212633590de289cab7" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.x86_64-linux-gnu-cxx11-march+avx512.tar.gz" +[[Darknet]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "d7874409d85e5eea8f08668901d9526d7180c380" +libc = "glibc" +march = "x86_64" +os = "linux" + + [[Darknet.download]] + sha256 = "9d9d02d0ca43174936e1e8418811683d489af176d38cdbbf17163b64c0fe754a" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.x86_64-linux-gnu-cxx11-march+x86_64.tar.gz" +[[Darknet]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "9d18d5567f3ae648af76568f1347b7b5d5960dc7" +libc = "musl" +march = "avx2" +os = "linux" + + [[Darknet.download]] + sha256 = "8a3fab776b393e2409b04bffbff4d94ed112686aa56227914e3920c498e22f5a" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.x86_64-linux-musl-cxx11-march+avx2.tar.gz" +[[Darknet]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "188d6e89a46c28731b212876f5a3425574d11575" +libc = "musl" +march = "avx512" +os = "linux" + + [[Darknet.download]] + sha256 = "fa0285e3e812983cc5d22b810e5066f3ff16d436abc089c38208d50ed4047dd0" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.x86_64-linux-musl-cxx11-march+avx512.tar.gz" +[[Darknet]] +arch = "x86_64" +cxxstring_abi = "cxx11" +git-tree-sha1 = "c7e1c7eb0c035091186f9a32fe5b071d1fd0569a" +libc = "musl" +march = "x86_64" +os = "linux" + + [[Darknet.download]] + sha256 = "6ac6a34459aab9e6335bff528eeba1cdbdfdceb04a589dc245ca77236fad5005" + url = "https://github.com/giordano/Darknet_jll.jl/releases/download/Darknet-v2020.6.5+2/Darknet.v2020.6.5.x86_64-linux-musl-cxx11-march+x86_64.tar.gz" diff --git a/LICENSE b/LICENSE index 0ae29ce..21ad41d 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/Darknet` directory within its prefix. + MIT License Copyright (c) 2020 Mosè Giordano diff --git a/Project.toml b/Project.toml new file mode 100644 index 0000000..e557002 --- /dev/null +++ b/Project.toml @@ -0,0 +1,11 @@ +name = "Darknet_jll" +uuid = "761d2b37-0f2d-5ad8-be19-54610544a161" +version = "2020.6.5+2" + +[deps] +Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +CompilerSupportLibraries_jll = "e66e0078-7015-5450-92f7-15fbd957f2ae" +Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[compat] +julia = "1.0" diff --git a/README.md b/README.md new file mode 100644 index 0000000..1d5c896 --- /dev/null +++ b/README.md @@ -0,0 +1,49 @@ +# `Darknet_jll.jl` (v2020.6.5+2) + +This is an autogenerated package constructed using [`BinaryBuilder.jl`](https://github.com/JuliaPackaging/BinaryBuilder.jl). + +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 `Darknet_jll.jl` have been built from these sources: + +* compressed archive: https://github.com/AlexeyAB/darknet/archive/3708b2e47d355ba0a206fd7a06bbc5a6e38af4ff.zip (SHA256 checksum: `e18a6374822fe3c9b95f2b6a4086decbdfbd1c589f2481ce5704a4384044ea6f`) + +## Platforms + +`Darknet_jll.jl` is available for the following platforms: + +* `ExtendedPlatform(Linux(:aarch64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="armv8")` (`aarch64-linux-gnu-cxx11-march+armv8`) +* `ExtendedPlatform(Linux(:aarch64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="carmel")` (`aarch64-linux-gnu-cxx11-march+carmel`) +* `ExtendedPlatform(Linux(:aarch64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="thunderx2")` (`aarch64-linux-gnu-cxx11-march+thunderx2`) +* `ExtendedPlatform(Linux(:aarch64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="armv8")` (`aarch64-linux-musl-cxx11-march+armv8`) +* `ExtendedPlatform(Linux(:aarch64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="carmel")` (`aarch64-linux-musl-cxx11-march+carmel`) +* `ExtendedPlatform(Linux(:aarch64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="thunderx2")` (`aarch64-linux-musl-cxx11-march+thunderx2`) +* `ExtendedPlatform(Linux(:armv7l, libc=:glibc, call_abi=:eabihf, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="armv7l")` (`armv7l-linux-gnueabihf-cxx11-march+armv7l`) +* `ExtendedPlatform(Linux(:armv7l, libc=:glibc, call_abi=:eabihf, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="neon")` (`armv7l-linux-gnueabihf-cxx11-march+neon`) +* `ExtendedPlatform(Linux(:armv7l, libc=:glibc, call_abi=:eabihf, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="vfp4")` (`armv7l-linux-gnueabihf-cxx11-march+vfp4`) +* `ExtendedPlatform(Linux(:armv7l, libc=:musl, call_abi=:eabihf, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="armv7l")` (`armv7l-linux-musleabihf-cxx11-march+armv7l`) +* `ExtendedPlatform(Linux(:armv7l, libc=:musl, call_abi=:eabihf, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="neon")` (`armv7l-linux-musleabihf-cxx11-march+neon`) +* `ExtendedPlatform(Linux(:armv7l, libc=:musl, call_abi=:eabihf, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="vfp4")` (`armv7l-linux-musleabihf-cxx11-march+vfp4`) +* `Linux(:i686, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`i686-linux-gnu-cxx11`) +* `Linux(:i686, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`i686-linux-musl-cxx11`) +* `Linux(:powerpc64le, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11))` (`powerpc64le-linux-gnu-cxx11`) +* `ExtendedPlatform(Linux(:x86_64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="avx2")` (`x86_64-linux-gnu-cxx11-march+avx2`) +* `ExtendedPlatform(Linux(:x86_64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="avx512")` (`x86_64-linux-gnu-cxx11-march+avx512`) +* `ExtendedPlatform(Linux(:x86_64, libc=:glibc, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="x86_64")` (`x86_64-linux-gnu-cxx11-march+x86_64`) +* `ExtendedPlatform(Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="avx2")` (`x86_64-linux-musl-cxx11-march+avx2`) +* `ExtendedPlatform(Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="avx512")` (`x86_64-linux-musl-cxx11-march+avx512`) +* `ExtendedPlatform(Linux(:x86_64, libc=:musl, compiler_abi=CompilerABI(cxxstring_abi=:cxx11)); march="x86_64")` (`x86_64-linux-musl-cxx11-march+x86_64`) + +## Dependencies + +The following JLL packages are required by `Darknet_jll.jl`: + +* `CompilerSupportLibraries_jll)` + +## Products + +The code bindings within this package are autogenerated from the following `Products`: + +* `LibraryProduct`: `libdarknet` diff --git a/src/Darknet_jll.jl b/src/Darknet_jll.jl new file mode 100644 index 0000000..0b49f8c --- /dev/null +++ b/src/Darknet_jll.jl @@ -0,0 +1,53 @@ +module Darknet_jll + +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 Darknet_jll on Julia versions older than 1.3!") +end + +using Pkg, Pkg.BinaryPlatforms, Pkg.Artifacts, Libdl +import Base: UUID + +# 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[] + +# Load Artifacts.toml file +artifacts_toml = joinpath(@__DIR__, "..", "Artifacts.toml") + +# Extract all platforms +artifacts = Pkg.Artifacts.load_artifacts_toml(artifacts_toml; pkg_uuid=UUID("761d2b37-0f2d-5ad8-be19-54610544a161")) +platforms = [Pkg.Artifacts.unpack_platform(e, "Darknet", artifacts_toml) for e in artifacts["Darknet"]] + +# 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 Darknet; 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 Darknet_jll diff --git a/src/wrappers/aarch64-linux-gnu-cxx11-march+armv8.jl b/src/wrappers/aarch64-linux-gnu-cxx11-march+armv8.jl new file mode 100644 index 0000000..25416e7 --- /dev/null +++ b/src/wrappers/aarch64-linux-gnu-cxx11-march+armv8.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for aarch64-linux-gnu-cxx11-march+armv8 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/aarch64-linux-gnu-cxx11-march+carmel.jl b/src/wrappers/aarch64-linux-gnu-cxx11-march+carmel.jl new file mode 100644 index 0000000..21ed82a --- /dev/null +++ b/src/wrappers/aarch64-linux-gnu-cxx11-march+carmel.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for aarch64-linux-gnu-cxx11-march+carmel +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/aarch64-linux-gnu-cxx11-march+thunderx2.jl b/src/wrappers/aarch64-linux-gnu-cxx11-march+thunderx2.jl new file mode 100644 index 0000000..2efb930 --- /dev/null +++ b/src/wrappers/aarch64-linux-gnu-cxx11-march+thunderx2.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for aarch64-linux-gnu-cxx11-march+thunderx2 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/aarch64-linux-musl-cxx11-march+armv8.jl b/src/wrappers/aarch64-linux-musl-cxx11-march+armv8.jl new file mode 100644 index 0000000..6acc53d --- /dev/null +++ b/src/wrappers/aarch64-linux-musl-cxx11-march+armv8.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for aarch64-linux-musl-cxx11-march+armv8 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/aarch64-linux-musl-cxx11-march+carmel.jl b/src/wrappers/aarch64-linux-musl-cxx11-march+carmel.jl new file mode 100644 index 0000000..4da551b --- /dev/null +++ b/src/wrappers/aarch64-linux-musl-cxx11-march+carmel.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for aarch64-linux-musl-cxx11-march+carmel +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/aarch64-linux-musl-cxx11-march+thunderx2.jl b/src/wrappers/aarch64-linux-musl-cxx11-march+thunderx2.jl new file mode 100644 index 0000000..07804f3 --- /dev/null +++ b/src/wrappers/aarch64-linux-musl-cxx11-march+thunderx2.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for aarch64-linux-musl-cxx11-march+thunderx2 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/armv7l-linux-gnueabihf-cxx11-march+armv7l.jl b/src/wrappers/armv7l-linux-gnueabihf-cxx11-march+armv7l.jl new file mode 100644 index 0000000..95a1776 --- /dev/null +++ b/src/wrappers/armv7l-linux-gnueabihf-cxx11-march+armv7l.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for armv7l-linux-gnueabihf-cxx11-march+armv7l +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/armv7l-linux-gnueabihf-cxx11-march+neon.jl b/src/wrappers/armv7l-linux-gnueabihf-cxx11-march+neon.jl new file mode 100644 index 0000000..076edab --- /dev/null +++ b/src/wrappers/armv7l-linux-gnueabihf-cxx11-march+neon.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for armv7l-linux-gnueabihf-cxx11-march+neon +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/armv7l-linux-gnueabihf-cxx11-march+vfp4.jl b/src/wrappers/armv7l-linux-gnueabihf-cxx11-march+vfp4.jl new file mode 100644 index 0000000..556529c --- /dev/null +++ b/src/wrappers/armv7l-linux-gnueabihf-cxx11-march+vfp4.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for armv7l-linux-gnueabihf-cxx11-march+vfp4 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/armv7l-linux-musleabihf-cxx11-march+armv7l.jl b/src/wrappers/armv7l-linux-musleabihf-cxx11-march+armv7l.jl new file mode 100644 index 0000000..1a131de --- /dev/null +++ b/src/wrappers/armv7l-linux-musleabihf-cxx11-march+armv7l.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for armv7l-linux-musleabihf-cxx11-march+armv7l +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/armv7l-linux-musleabihf-cxx11-march+neon.jl b/src/wrappers/armv7l-linux-musleabihf-cxx11-march+neon.jl new file mode 100644 index 0000000..a207cd2 --- /dev/null +++ b/src/wrappers/armv7l-linux-musleabihf-cxx11-march+neon.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for armv7l-linux-musleabihf-cxx11-march+neon +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/armv7l-linux-musleabihf-cxx11-march+vfp4.jl b/src/wrappers/armv7l-linux-musleabihf-cxx11-march+vfp4.jl new file mode 100644 index 0000000..3d17353 --- /dev/null +++ b/src/wrappers/armv7l-linux-musleabihf-cxx11-march+vfp4.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for armv7l-linux-musleabihf-cxx11-march+vfp4 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +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..280c758 --- /dev/null +++ b/src/wrappers/i686-linux-gnu-cxx11.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for i686-linux-gnu-cxx11 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/i686-linux-musl-cxx11.jl b/src/wrappers/i686-linux-musl-cxx11.jl new file mode 100644 index 0000000..385c76f --- /dev/null +++ b/src/wrappers/i686-linux-musl-cxx11.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for i686-linux-musl-cxx11 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +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..e3b6702 --- /dev/null +++ b/src/wrappers/powerpc64le-linux-gnu-cxx11.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for powerpc64le-linux-gnu-cxx11 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/x86_64-linux-gnu-cxx11-march+avx2.jl b/src/wrappers/x86_64-linux-gnu-cxx11-march+avx2.jl new file mode 100644 index 0000000..1ed5455 --- /dev/null +++ b/src/wrappers/x86_64-linux-gnu-cxx11-march+avx2.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for x86_64-linux-gnu-cxx11-march+avx2 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/x86_64-linux-gnu-cxx11-march+avx512.jl b/src/wrappers/x86_64-linux-gnu-cxx11-march+avx512.jl new file mode 100644 index 0000000..b66c23a --- /dev/null +++ b/src/wrappers/x86_64-linux-gnu-cxx11-march+avx512.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for x86_64-linux-gnu-cxx11-march+avx512 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/x86_64-linux-gnu-cxx11-march+x86_64.jl b/src/wrappers/x86_64-linux-gnu-cxx11-march+x86_64.jl new file mode 100644 index 0000000..c8f1a8a --- /dev/null +++ b/src/wrappers/x86_64-linux-gnu-cxx11-march+x86_64.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for x86_64-linux-gnu-cxx11-march+x86_64 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/x86_64-linux-musl-cxx11-march+avx2.jl b/src/wrappers/x86_64-linux-musl-cxx11-march+avx2.jl new file mode 100644 index 0000000..7057f92 --- /dev/null +++ b/src/wrappers/x86_64-linux-musl-cxx11-march+avx2.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for x86_64-linux-musl-cxx11-march+avx2 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/x86_64-linux-musl-cxx11-march+avx512.jl b/src/wrappers/x86_64-linux-musl-cxx11-march+avx512.jl new file mode 100644 index 0000000..1b7c986 --- /dev/null +++ b/src/wrappers/x86_64-linux-musl-cxx11-march+avx512.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for x86_64-linux-musl-cxx11-march+avx512 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() + diff --git a/src/wrappers/x86_64-linux-musl-cxx11-march+x86_64.jl b/src/wrappers/x86_64-linux-musl-cxx11-march+x86_64.jl new file mode 100644 index 0000000..7298671 --- /dev/null +++ b/src/wrappers/x86_64-linux-musl-cxx11-march+x86_64.jl @@ -0,0 +1,59 @@ +# Autogenerated wrapper script for Darknet_jll for x86_64-linux-musl-cxx11-march+x86_64 +export libdarknet + +using CompilerSupportLibraries_jll +## Global variables +PATH = "" +LIBPATH = "" +LIBPATH_env = "LD_LIBRARY_PATH" +LIBPATH_default = "" + +# Relative path to `libdarknet` +const libdarknet_splitpath = ["lib", "libdarknet.so"] + +# This will be filled out by __init__() for all products, as it must be done at runtime +libdarknet_path = "" + +# libdarknet-specific global declaration +# This will be filled out by __init__() +libdarknet_handle = C_NULL + +# This must be `const` so that we can use it with `ccall()` +const libdarknet = "libdarknet.so" + + +""" +Open all libraries +""" +function __init__() + global artifact_dir = abspath(artifact"Darknet") + + # Initialize PATH and LIBPATH environment variable listings + global PATH_list, LIBPATH_list + # We first need to add to LIBPATH_list the libraries provided by Julia + append!(LIBPATH_list, [joinpath(Sys.BINDIR, Base.LIBDIR, "julia"), joinpath(Sys.BINDIR, Base.LIBDIR)]) + # 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), (CompilerSupportLibraries_jll.PATH_list,)) + foreach(p -> append!(LIBPATH_list, p), (CompilerSupportLibraries_jll.LIBPATH_list,)) + + global libdarknet_path = normpath(joinpath(artifact_dir, libdarknet_splitpath...)) + + # Manually `dlopen()` this right now so that future invocations + # of `ccall` with its `SONAME` will find this path immediately. + global libdarknet_handle = dlopen(libdarknet_path) + push!(LIBPATH_list, dirname(libdarknet_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(LIBPATH_list, ':') + + # Add each element of LIBPATH to our DL_LOAD_PATH (necessary on platforms + # that don't honor our "already opened" trick) + #for lp in LIBPATH_list + # push!(DL_LOAD_PATH, lp) + #end +end # __init__() +