diff --git a/packages/b/bsdiff/port/Compat.h b/packages/b/bsdiff/port/Compat.h new file mode 100644 index 000000000..58ce7b2f7 --- /dev/null +++ b/packages/b/bsdiff/port/Compat.h @@ -0,0 +1,95 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef __LIB_UTILS_COMPAT_H +#define __LIB_UTILS_COMPAT_H + +#include + +#if !defined(__MINGW32__) +#include +#endif + +#if defined(__APPLE__) + +/* Mac OS has always had a 64-bit off_t, so it doesn't have off64_t. */ +static_assert(sizeof(off_t) >= 8, "This code requires that Mac OS have at least a 64-bit off_t."); +typedef off_t off64_t; + +static inline void* mmap64(void* addr, size_t length, int prot, int flags, int fd, off64_t offset) { + return mmap(addr, length, prot, flags, fd, offset); +} + +static inline off64_t lseek64(int fd, off64_t offset, int whence) { + return lseek(fd, offset, whence); +} + +static inline ssize_t pread64(int fd, void* buf, size_t nbytes, off64_t offset) { + return pread(fd, buf, nbytes, offset); +} + +static inline ssize_t pwrite64(int fd, const void* buf, size_t nbytes, off64_t offset) { + return pwrite(fd, buf, nbytes, offset); +} + +static inline int ftruncate64(int fd, off64_t length) { + return ftruncate(fd, length); +} + +#endif /* __APPLE__ */ + +#if defined(_WIN32) +#define O_CLOEXEC O_NOINHERIT +#define O_NOFOLLOW 0 +#define DEFFILEMODE 0666 +#endif /* _WIN32 */ + +#define ZD "%zd" +#define ZD_TYPE ssize_t + +/* + * Needed for cases where something should be constexpr if possible, but not + * being constexpr is fine if in pre-C++11 code (such as a const static float + * member variable). + */ +#if __cplusplus >= 201103L +#define CONSTEXPR constexpr +#else +#define CONSTEXPR +#endif + +/* + * TEMP_FAILURE_RETRY is defined by some, but not all, versions of + * . (Alas, it is not as standard as we'd hoped!) So, if it's + * not already defined, then define it here. + */ +#ifndef TEMP_FAILURE_RETRY +/* Used to retry syscalls that can return EINTR. */ +#define TEMP_FAILURE_RETRY(exp) ({ \ + decltype (exp) _rc; \ + do { \ + _rc = (exp); \ + } while (_rc == -1 && errno == EINTR); \ + _rc; }) +#endif + +#if defined(_WIN32) +#define OS_PATH_SEPARATOR '\\' +#else +#define OS_PATH_SEPARATOR '/' +#endif + +#endif /* __LIB_UTILS_COMPAT_H */ diff --git a/packages/b/bsdiff/port/xmake.lua b/packages/b/bsdiff/port/xmake.lua new file mode 100644 index 000000000..df5307640 --- /dev/null +++ b/packages/b/bsdiff/port/xmake.lua @@ -0,0 +1,54 @@ +add_requires("zlib") +add_requires("brotli") +add_requires("bzip2") +add_requires("libdivsufsort") +add_requires("libdivsufsort", { + configs = { + use_64 = true + }, + alias = "libdivsufsort64" +}) + +target("libbspatch") + set_kind("$(kind)") + set_languages("c99", "c++17") + add_files("brotli_decompressor.cc", "bspatch.cc", "bz2_decompressor.cc", "buffer_file.cc", "decompressor_interface.cc", + "extents.cc", "extents_file.cc", "file.cc", "logging.cc", "memory_file.cc", "patch_reader.cc", "sink_file.cc", + "utils.cc") + add_defines("_FILE_OFFSET_BITS=64") + add_includedirs("include", { + public = true + }) + add_headerfiles("include/(bsdiff/*.h)") + add_includedirs("..") + add_packages("libdivsufsort", "libdivsufsort64", "brotli", "zlib", "bzip2") + +target("libbsdiff") + set_kind("$(kind)") + set_languages("c99", "c++17") + add_files("brotli_compressor.cc", "bsdiff.cc", "bz2_compressor.cc", "compressor_buffer.cc", "diff_encoder.cc", + "endsley_patch_writer.cc", "logging.cc", "patch_writer.cc", "patch_writer_factory.cc", "split_patch_writer.cc", + "suffix_array_index.cc") + add_defines("_FILE_OFFSET_BITS=64") + add_includedirs("include", { + public = true + }) + add_headerfiles("include/(bsdiff/*.h)") + + add_includedirs("..") + add_packages("libdivsufsort", "libdivsufsort64", "brotli", "zlib", "bzip2") + +target("bsdiff") + set_kind("binary") + set_languages("c99", "c++17") + add_includedirs("..") + add_files("bsdiff_arguments.cc", "bsdiff_main.cc") + add_packages("brotli") + add_deps("libbsdiff") + +target("bspatch") + set_kind("binary") + set_languages("c99", "c++17") + add_includedirs("..") + add_files("bspatch_main.cc") + add_deps("libbspatch") diff --git a/packages/b/bsdiff/xmake.lua b/packages/b/bsdiff/xmake.lua new file mode 100644 index 000000000..4fb2b254a --- /dev/null +++ b/packages/b/bsdiff/xmake.lua @@ -0,0 +1,34 @@ +package("bsdiff") + +set_homepage("https://android.googlesource.com/platform/external/bsdiff/") +set_description("BSDIFF is a binary diffing/patching library") + +add_urls("https://android.googlesource.com/platform/external/bsdiff.git") + +add_versions("2021.11.16", "78b6bd03de79240c228e4b0754c43c44204c7c6a") + +add_deps("bzip2", "brotli", "libdivsufsort") +add_deps("libdivsufsort", {configs = {use_64 = true}}) + +on_install("linux", "macosx", function(package) + os.cp(path.join(package:scriptdir(), "port", "xmake.lua"), "xmake.lua") + os.mkdir("include/utils") + os.cp(path.join(package:scriptdir(), "port", "Compat.h"), "include/utils/Compat.h") + + local configs = {} + if package:config("shared") then + configs.kind = "shared" + end + import("package.tools.xmake").install(package, configs) +end) + +on_test(function(package) + assert(package:check_cxxsnippets({ + test = [[ + #include + void test() { + bsdiff::bsdiff(nullptr, 0, nullptr, 0, "", nullptr); + } + ]] + })) +end)