ffi-libarchive-binary 0.5.0-arm64-mingw-ucrt

data/lib/ffi-libarchive-binary/libarchive_recipe.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "open3"
+
+require_relative "configuration"
+require_relative "base_recipe"
+require_relative "zlib_recipe"
+require_relative "libexpat_recipe"
+require_relative "openssl_recipe"
+require_relative "xz_recipe"
+
+module LibarchiveBinary
+  class LibarchiveRecipe < MiniPortileCMake
+    ROOT = Pathname.new(File.expand_path("../..", __dir__))
+    NAME = "libarchive"
+    def initialize
+      libarchive = LibarchiveBinary.library_for(NAME)
+      super(NAME, libarchive["version"])
+      @printed = {}
+
+      @files << {
+        url: libarchive["url"],
+        sha256: libarchive["sha256"],
+      }
+
+      @target = ROOT.join(@target).to_s
+
+      create_dependencies
+    end
+
+    def create_dependencies
+      @zlib_recipe = ZLibRecipe.new
+      @expat_recipe = LibexpatRecipe.new
+      @openssl_recipe = OpensslRecipe.new
+      @xz_recipe = XZRecipe.new
+    end
+
+    def generator_flags
+      MiniPortile::mingw? ? ["-G", "MSYS Makefiles"] : []
+    end
+
+    def default_flags
+      [
+        "-DENABLE_OPENSSL:BOOL=ON",   "-DENABLE_LIBB2:BOOL=OFF",      "-DENABLE_LZ4:BOOL=OFF",
+        "-DENABLE_LZO::BOOL=OFF",     "-DENABLE_LZMA:BOOL=ON",        "-DENABLE_ZSTD:BOOL=OFF",
+        "-DENABLE_ZLIB::BOOL=ON",     "-DENABLE_BZip2:BOOL=OFF",      "-DENABLE_LIBXML2:BOOL=OFF",
+        "-DENABLE_EXPAT::BOOL=ON",    "-DENABLE_TAR:BOOL=OFF",        "-DENABLE_CPIO::BOOL=OFF",
+        "-DENABLE_CAT:BOOL=OFF",      "-DENABLE_ACL:BOOL=OFF",        "-DENABLE_TEST:BOOL=OFF",
+        "-DENABLE_UNZIP:BOOL=OFF",    "-DOPENSSL_USE_STATIC_LIBS=ON", "-DENABLE_XAR:BOOL=ON",
+
+        # Provide root directories - let CMake find libraries in lib or lib64
+        "-DOPENSSL_ROOT_DIR:PATH=#{@openssl_recipe.path}",
+
+        # Add include paths to C flags so CMake's header detection can find them
+        "-DCMAKE_C_FLAGS=-I#{@expat_recipe.path}/include -I#{@openssl_recipe.path}/include -I#{@xz_recipe.path}/include -I#{@zlib_recipe.path}/include",
+
+        # Provide search paths for CMake to find libraries
+        "-DCMAKE_INCLUDE_PATH:STRING=#{include_path}",
+        "-DCMAKE_LIBRARY_PATH:STRING=#{library_path}"
+      ]
+    end
+
+    def configure_defaults
+      df = generator_flags + default_flags
+
+      ar = ARCHS[host]
+      df += ["-DCMAKE_OSX_ARCHITECTURES=#{ar}"] if ar
+
+      df
+    end
+
+    def include_path
+      paths = [@zlib_recipe.path, @expat_recipe.path, @openssl_recipe.path, @xz_recipe.path]
+      paths.map { |k| "#{k}/include" }.join(";")
+    end
+
+    def library_path
+      paths = [@zlib_recipe.path, @expat_recipe.path, @openssl_recipe.path, @xz_recipe.path]
+      paths.map { |k| "#{k}/lib;#{k}/lib64" }.join(";")
+    end
+
+    def activate
+      @zlib_recipe.activate
+      @expat_recipe.activate
+      @openssl_recipe.activate
+      @xz_recipe.activate
+
+      super
+    end
+
+    def cook_if_not
+      cook unless File.exist?(checkpoint)
+    end
+
+    def cook
+      @zlib_recipe.host = @host if @host
+      @zlib_recipe.cook_if_not
+
+      @expat_recipe.host = @host if @host
+      @expat_recipe.cook_if_not
+
+      @openssl_recipe.host = @host if @host
+      @openssl_recipe.cook_if_not
+
+      @xz_recipe.host = @host if @host
+      @xz_recipe.cook_if_not
+
+      # Set explicit LZMA environment variables for libarchive configure
+      ENV['LIBLZMA_CFLAGS'] = "-I#{@xz_recipe.path}/include"
+      ENV['LIBLZMA_LIBS'] = "-L#{@xz_recipe.path}/lib -llzma"
+
+      super
+
+      FileUtils.touch(checkpoint)
+    end
+
+    def checkpoint
+      File.join(@target, "#{name}-#{version}-#{host}.installed")
+    end
+
+    def install
+      super
+
+      libs = Dir.glob(File.join(port_path, "{lib,bin}", "*"))
+        .grep(/\/(?:lib)?[a-zA-Z0-9\-]+\.(?:so|dylib|dll)$/)
+      FileUtils.cp_r(libs, lib_workpath, verbose: true)
+      if lib_fullpath.nil?
+        message("Cannot guess libarchive library name, skipping format verification")
+      else
+        verify_lib
+      end
+    end
+
+    def lib_workpath
+      @lib_workpath ||= ROOT.join("lib", "ffi-libarchive-binary")
+    end
+
+    def lib_fullpath
+      lib_filename = LIBNAMES[@host]
+      @lib_fullpath ||= lib_filename.nil? ? nil : File.join(lib_workpath, lib_filename)
+    end
+
+    def libraries
+      configuration_file = File.join(File.dirname(__FILE__), "..", "..", "ext", "configuration.yml")
+      @libraries ||= ::YAML.load_file(configuration_file)["libraries"] || {}
+    rescue Psych::SyntaxError => e
+      puts "Warning: The configuration file '#{configuration_file}' contains invalid YAML syntax."
+      puts e.message
+      exit 1
+    rescue StandardError => e
+      puts "An unexpected error occurred while loading the configuration file '#{configuration_file}'."
+      puts e.message
+      exit 1
+    end
+
+    def library_for(libname)
+      libraries[libname][MiniPortile::windows? ? "windows" : "all"]
+    rescue StandardError => e
+      puts "Failed to load library configuration for '#{libname}'."
+      puts e.message
+      exit 1
+    end
+
+    def verify_lib
+      begin
+        out, = Open3.capture2("file #{lib_fullpath}")
+      rescue StandardError
+        message("failed to call file, library verification skipped.\n")
+        return
+      end
+      unless out.include?(target_format)
+        raise "Invalid file format '#{out.strip}', '#{target_format}' expected"
+      end
+
+      message("#{lib_fullpath} format has been verified (#{target_format})\n")
+    end
+
+    def target_format
+      @target_format ||= FORMATS[@host].nil? ? "skip" : FORMATS[@host]
+    end
+
+    def message(text)
+      return super unless text.start_with?("\rDownloading")
+
+      match = text.match(/(\rDownloading .*)\((\s*)(\d+)%\)/)
+      pattern = match ? match[1] : text
+      return if @printed[pattern] && match[3].to_i != 100
+
+      @printed[pattern] = true
+      super
+    end
+  end
+end

data/lib/ffi-libarchive-binary/libexpat_recipe.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "base_recipe"
+
+module LibarchiveBinary
+  class LibexpatRecipe < BaseRecipe
+    def initialize
+      super("libexpat")
+
+      @target = ROOT.join(@target).to_s
+    end
+
+    def configure_defaults
+      [
+        "--host=#{@host}",        "--disable-shared", "--enable-static",
+        "--without-tests",        "--without-examples"
+      ]
+    end
+
+    def configure
+      # Set cross-compiler environment variables for aarch64
+      env_vars = cross_compiler_env(host)
+      cmd = ["env"] + env_vars.map { |k, v| "#{k}=#{v}" } +
+            [cflags(host), ldflags(host), "./configure"] + computed_options
+      execute("configure", cmd)
+    end
+
+    def checkpoint
+      File.join(@target, "#{name}-#{version}-#{host}.installed")
+    end
+
+    def cook_if_not
+      cook unless File.exist?(checkpoint)
+    end
+
+    def cook
+      super
+
+      FileUtils.touch(checkpoint)
+    end
+  end
+end

data/lib/ffi-libarchive-binary/libxml2_recipe.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "base_recipe"
+
+module LibarchiveBinary
+  class Libxml2Recipe < BaseRecipe
+    def initialize
+      super("libxml2")
+
+      @target = ROOT.join(@target).to_s
+    end
+
+    def configure_defaults
+      [
+        "--host=#{@host}",
+        "--disable-dependency-tracking",
+        "--without-python",
+        "--without-lzma",
+        "--without-zlib",
+        "--without-iconv",
+        "--without-icu",
+        "--without-debug",
+        "--without-threads",
+        "--without-modules",
+        "--without-catalog",
+        "--without-docbook",
+        "--without-legacy",
+        "--without-http",
+        "--without-ftp",
+        "--enable-static",
+        "--disable-shared"
+      ]
+    end
+
+    def configure
+      cmd = ["env", cflags(host), ldflags(host),
+             "./configure"] + computed_options
+      execute("configure", cmd)
+    end
+
+    def checkpoint
+      File.join(@target, "#{name}-#{version}-#{host}.installed")
+    end
+
+    def cook_if_not
+      cook unless File.exist?(checkpoint)
+    end
+
+    def cook
+      super
+
+      FileUtils.touch(checkpoint)
+    end
+  end
+end

data/lib/ffi-libarchive-binary/openssl_recipe.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "base_recipe"
+
+module LibarchiveBinary
+  OS_COMPILERS = {
+    "arm64-apple-darwin" => "darwin64-arm64-cc",
+    "x86_64-apple-darwin" => "darwin64-x86_64-cc",
+    "aarch64-linux-gnu" => "linux-aarch64",
+    "aarch64-linux-musl" => "linux-aarch64",
+    "x86_64-linux-gnu" => nil,
+    "x86_64-linux-musl" => nil,
+    "x86_64-w64-mingw32" => "mingw64",
+    # Use mingw64 target for Windows ARM64 with clang and explicit CFLAGS
+    # This prevents OpenSSL from adding -m64 flag which would create x86_64 objects
+    "aarch64-w64-mingw32" => "mingw64",
+  }.freeze
+
+  ENV_CMD = ["env", "CFLAGS=-fPIC", "LDFLAGS=-fPIC"].freeze
+
+  class OpensslRecipe < BaseRecipe
+    def initialize
+      super("openssl")
+    end
+
+    def configure
+      os_compiler = OS_COMPILERS[@host]
+      common_opts = ["--openssldir=#{ROOT}/ports/SSL", "--libdir=lib", "no-tests", "no-shared", "no-docs"] +
+        computed_options.grep(/--prefix/)
+
+      # For Windows ARM64, set CFLAGS=-fPIC first to prevent OpenSSL from adding -m64
+      # The mingw64 target unconditionally adds -m64 which breaks ARM64 cross-compilation
+      common_opts.unshift("CFLAGS=-fPIC") if @host == "aarch64-w64-mingw32"
+
+      # Disable assembly for ARM64 as x86_64-specific instructions (AVX512, etc.) won't work
+      common_opts << "no-asm" if @host == "aarch64-w64-mingw32"
+
+      # Disable module loading for Windows ARM64 to avoid resource file compilation
+      # The resource compiler (llvm-rc) can't find Windows SDK headers like winver.h
+      common_opts << "no-module" if @host == "aarch64-w64-mingw32"
+
+      # Disable command-line apps for Windows ARM64 to avoid resource file compilation
+      # The apps/openssl.rc also requires Windows SDK headers which llvm-rc can't find
+      common_opts << "no-apps" if @host == "aarch64-w64-mingw32"
+
+      # Set cross-compiler environment variables for aarch64
+      env_vars = cross_compiler_env(@host)
+      env_prefix = env_vars.empty? ? ENV_CMD : ENV_CMD + env_vars.map { |k, v| "#{k}=#{v}" }
+
+      cmd = if os_compiler.nil?
+              message("OpensslRecipe: guessing with 'config' for '#{@host}'\n")
+              env_prefix + ["./config"] + common_opts
+            else
+              env_prefix + ["./Configure"] + common_opts + [os_compiler]
+            end
+      execute("configure", cmd)
+
+      # For Windows ARM64, fix the Makefile to use pe-arm64 instead of pe-x86-64 for windres
+      # OpenSSL's mingw64 target hardcodes --target=pe-x86-64 which creates x86_64 resource files
+      if @host == "aarch64-w64-mingw32"
+        makefile = File.join(work_path, "Makefile")
+        content = File.read(makefile)
+        content.gsub!("pe-x86-64", "pe-arm64")
+        File.write(makefile, content)
+        message("OpensslRecipe: fixed Makefile to use pe-arm64 for windres\n")
+      end
+    end
+
+    def checkpoint
+      File.join(@target, "#{name}-#{version}-#{host}.installed")
+    end
+
+    def cook_if_not
+      cook unless File.exist?(checkpoint)
+    end
+
+    def cook
+      super
+
+      FileUtils.touch(checkpoint)
+    end
+  end
+end

data/lib/ffi-libarchive-binary/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LibarchiveBinary
+  VERSION = "0.5.0"
+end

data/lib/ffi-libarchive-binary/xz_recipe.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "base_recipe"
+
+module LibarchiveBinary
+  class XZRecipe < BaseRecipe
+    def initialize
+      super("xz")
+    end
+
+    def configure_defaults
+      [
+        "--host=#{@host}",
+        "--disable-doc",      "--disable-xz",       "--with-pic",
+        "--disable-xzdec",    "--disable-lzmadec",  "--disable-lzmainfo",
+        "--disable-scripts",  "--disable-shared",   "--enable-static"
+      ]
+    end
+
+    def configure
+      # Set cross-compiler environment variables for aarch64
+      env_vars = cross_compiler_env(host)
+      cmd = ["env"] + env_vars.map { |k, v| "#{k}=#{v}" } +
+            [cflags(host), ldflags(host), "./configure"] + computed_options
+      execute("configure", cmd)
+    end
+
+    def checkpoint
+      File.join(@target, "#{name}-#{version}-#{host}.installed")
+    end
+
+    def cook_if_not
+      cook unless File.exist?(checkpoint)
+    end
+
+    def cook
+      super
+
+      FileUtils.touch(checkpoint)
+    end
+  end
+end

data/lib/ffi-libarchive-binary/zlib_recipe.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "base_recipe"
+
+module LibarchiveBinary
+  class ZLibRecipe < BaseRecipe
+    def initialize
+      super("zlib")
+    end
+
+    def configure_defaults
+      [
+        "--static",
+      ]
+    end
+
+    def configure_windows
+      mk = File.read("win32/Makefile.gcc")
+      File.open("win32/Makefile.gcc", "wb") do |f|
+        f.puts "BINARY_PATH = #{path}/bin"
+        f.puts "LIBRARY_PATH = #{path}/lib"
+        f.puts "INCLUDE_PATH = #{path}/include"
+        f.puts "SHARED_MODE = 0"
+        f.puts "LOC = -fPIC"
+        f.puts mk
+      end
+    end
+
+    def configure
+      if MiniPortile::windows?
+        Dir.chdir(work_path) do
+          configure_windows
+        end
+      else
+        # Set cross-compiler environment variables for aarch64
+        env_vars = cross_compiler_env(host)
+        cmd = ["env"] + env_vars.map { |k, v| "#{k}=#{v}" } +
+              [cflags(host), ldflags(host), "./configure"] + computed_options
+        execute("configure", cmd)
+      end
+    end
+
+    def configured?
+      if MiniPortile::windows?
+        Dir.chdir(work_path) do
+          !!(File.read("win32/Makefile.gcc") =~ /^BINARY_PATH/)
+        end
+      else
+        super
+      end
+    end
+
+    def compile
+      if MiniPortile::windows?
+        execute("compile", "make -f win32/Makefile.gcc libz.a")
+      else
+        super
+      end
+    end
+
+    def install
+      if MiniPortile::windows?
+        execute("install", "make -f win32/Makefile.gcc install")
+      else
+        super
+      end
+    end
+
+    def checkpoint
+      File.join(@target, "#{name}-#{version}-#{host}.installed")
+    end
+
+    def cook_if_not
+      cook unless File.exist?(checkpoint)
+    end
+
+    def cook
+      super
+
+      FileUtils.touch(checkpoint)
+    end
+  end
+end

data/lib/ffi-libarchive-binary.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "ffi-libarchive-binary/version"
+require "pathname"
+
+module LibarchiveBinary
+  class Error < StandardError; end
+
+  LIBRARY_PATH = Pathname.new(File.join(__dir__, "ffi-libarchive-binary"))
+
+  def self.lib_path
+    LIBRARY_PATH.join(lib_filename).to_s
+  end
+
+  def self.lib_filename
+    if FFI::Platform.windows?
+      "libarchive.dll"
+    elsif FFI::Platform.mac?
+      "libarchive.dylib"
+    else
+      "libarchive.so"
+    end
+  end
+end
+
+module Archive
+  module C
+    def self.ffi_lib(*args)
+      prefixed = args.map do |names|
+        paths = names.is_a?(Array) ? names : [names]
+        if paths.any? { |f| f.include?("libarchive") }
+          [LibarchiveBinary.lib_path] + paths
+        else
+          names
+        end
+      end
+
+      super(*prefixed)
+    end
+  end
+end
+
+require "ffi-libarchive"

data/toolchain/aarch64-linux-gnu.cmake

@@ -0,0 +1,12 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+
+# Specify the cross compiler
+set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
+
+# Where to look for the target environment
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)