From e10b8ff144bb9e2623f6c3426dcee4535009d72e Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Mon, 19 May 2025 18:30:28 +0100 Subject: [PATCH] Rebase to libguestfs 1.55.12 resolves: RHEL-81733 Add btrfs-scrub-full API resolves: RHEL-91936 --- 0001-appliance-Remove-zfs-fuse.patch | 38 - ...required-to-make-AM_GNU_GETTEXT-work.patch | 3434 +++++++++++++++++ ...upported-remote-drive-protocols-RHBZ.patch | 4 +- 0002-Update-common-submodule.patch | 706 ---- ...of-libguestfs-winsupport-features-ex.patch | 2 +- 0003-Update-common-submodule.patch | 248 -- ...nit-Run-depmod-a-to-rebuild-kernel-m.patch | 2 +- ....sh.in-Remove-mlgettext-subdirectory.patch | 25 - 0005-Update-common-submodule.patch | 531 --- 0006-docs-Update-release-notes-for-1.56.patch | 57 - libguestfs.spec | 21 +- sources | 4 +- 12 files changed, 3449 insertions(+), 1623 deletions(-) delete mode 100644 0001-appliance-Remove-zfs-fuse.patch create mode 100644 0001-m4-Add-junk-required-to-make-AM_GNU_GETTEXT-work.patch rename 0007-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch => 0002-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch (99%) delete mode 100644 0002-Update-common-submodule.patch rename 0008-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch => 0003-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch (97%) delete mode 100644 0003-Update-common-submodule.patch rename 0009-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch => 0004-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch (90%) delete mode 100644 0004-ocaml-dep.sh.in-Remove-mlgettext-subdirectory.patch delete mode 100644 0005-Update-common-submodule.patch delete mode 100644 0006-docs-Update-release-notes-for-1.56.patch diff --git a/0001-appliance-Remove-zfs-fuse.patch b/0001-appliance-Remove-zfs-fuse.patch deleted file mode 100644 index 2b8b139..0000000 --- a/0001-appliance-Remove-zfs-fuse.patch +++ /dev/null @@ -1,38 +0,0 @@ -From f6b1a7b57f96f002074e626d58b58f4244080ec9 Mon Sep 17 00:00:00 2001 -From: "Richard W.M. Jones" -Date: Fri, 9 May 2025 15:52:30 +0100 -Subject: [PATCH] appliance: Remove zfs-fuse - -zfs-fuse has been unmaintained for a very long time. In fact, the -website has gone. This means that whatever we need for zfs (probably -some kind of license-compatible kernel module) is not going to be -provided by zfs-fuse. - -See: https://bugzilla.redhat.com/show_bug.cgi?id=2214965 ---- - appliance/packagelist.in | 2 -- - 1 file changed, 2 deletions(-) - -diff --git a/appliance/packagelist.in b/appliance/packagelist.in -index d0637631d..f8c80af24 100644 ---- a/appliance/packagelist.in -+++ b/appliance/packagelist.in -@@ -51,7 +51,6 @@ ifelse(REDHAT,1, - systemd dnl for /sbin/reboot and udevd - vim-minimal - xz -- zfs-fuse - zstd - ) - -@@ -95,7 +94,6 @@ dnl isc-dhcp-client has been replaced with dhcpcd-base - ufsutils - vim-tiny - xz-utils -- zfs-fuse - zstd - uuid-runtime - ) --- -2.47.1 - diff --git a/0001-m4-Add-junk-required-to-make-AM_GNU_GETTEXT-work.patch b/0001-m4-Add-junk-required-to-make-AM_GNU_GETTEXT-work.patch new file mode 100644 index 0000000..c4a8002 --- /dev/null +++ b/0001-m4-Add-junk-required-to-make-AM_GNU_GETTEXT-work.patch @@ -0,0 +1,3434 @@ +From b9f75ca5b8d091c91187720cd52210117718c693 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Mon, 19 May 2025 15:53:29 +0100 +Subject: [PATCH] m4: Add junk required to make 'AM_GNU_GETTEXT' work + +Run gettextize, revert most of its changes, but add the m4/* files +that might be required. + +This is a short term fix. A better / longer-term fix is described by +Dan here: + +https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/message/2AZNWQQ6CBRFZCAADVYQHU5UN5J2JT2F/ +--- + build-aux/config.rpath | 93 ++++- + m4/build-to-host.m4 | 274 ++++++++++++++ + m4/gettext.m4 | 393 ++++++++++++++++++++ + m4/host-cpu-c-abi.m4 | 532 +++++++++++++++++++++++++++ + m4/iconv.m4 | 324 ++++++++++++++++ + m4/intlmacosx.m4 | 71 ++++ + m4/lib-ld.m4 | 170 +++++++++ + m4/lib-link.m4 | 815 +++++++++++++++++++++++++++++++++++++++++ + m4/lib-prefix.m4 | 334 +++++++++++++++++ + m4/nls.m4 | 33 ++ + m4/po.m4 | 157 ++++++++ + m4/progtest.m4 | 93 +++++ + 12 files changed, 3276 insertions(+), 13 deletions(-) + create mode 100644 m4/build-to-host.m4 + create mode 100644 m4/gettext.m4 + create mode 100644 m4/host-cpu-c-abi.m4 + create mode 100644 m4/iconv.m4 + create mode 100644 m4/intlmacosx.m4 + create mode 100644 m4/lib-ld.m4 + create mode 100644 m4/lib-link.m4 + create mode 100644 m4/lib-prefix.m4 + create mode 100644 m4/nls.m4 + create mode 100644 m4/po.m4 + create mode 100644 m4/progtest.m4 + +diff --git a/build-aux/config.rpath b/build-aux/config.rpath +index 29aae9764..e42a98cb6 100755 +--- a/build-aux/config.rpath ++++ b/build-aux/config.rpath +@@ -1,23 +1,15 @@ + #!/usr/bin/sh + # Output a system dependent set of variables, describing how to set the +-# run time search path of shared libraries in an executable. ++# run time search path of shared libraries in a binary (executable or ++# shared library). + # +-# Copyright 1996-2019 Free Software Foundation, Inc. ++# Copyright 1996-2025 Free Software Foundation, Inc. + # Taken from GNU libtool, 2001 + # Originally by Gordon Matzigkeit , 1996 + # + # This file is free software; the Free Software Foundation gives + # unlimited permission to copy and/or distribute it, with or without + # modifications, as long as this notice is preserved. +-# +-# The first argument passed to this file is the canonical host specification, +-# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM +-# or +-# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM +-# The environment variables CC, GCC, LDFLAGS, LD, with_gnu_ld +-# should be set by the caller. +-# +-# The set of defined variables is at the end of this script. + + # Known limitations: + # - On IRIX 6.5 with CC="cc", the run time search patch must not be longer +@@ -25,6 +17,81 @@ + # known workaround is to choose shorter directory names for the build + # directory and/or the installation directory. + ++# func_usage ++# outputs to stdout the --help usage message. ++func_usage () ++{ ++ echo "\ ++Usage: config.rpath [OPTION] HOST ++ ++Prints shell variable assignments that describe how to hardcode a directory ++for the lookup of shared libraries into a binary (executable or shared library). ++ ++The first argument passed to this file is the canonical host specification, ++ CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM ++or ++ CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM ++ ++The environment variables CC, GCC, LDFLAGS, LD, with_gnu_ld ++should be set by the caller. ++ ++The set of defined variables is at the end of this script. ++ ++Options: ++ --help print this help and exit ++ --version print version information and exit ++ ++Send patches and bug reports to ." ++} ++ ++# func_version ++# outputs to stdout the --version message. ++func_version () ++{ ++ echo "config.rpath (GNU gnulib, module havelib)" ++ echo "Copyright (C) 2025 Free Software Foundation, Inc. ++License: All-Permissive. ++This is free software: you are free to change and redistribute it. ++There is NO WARRANTY, to the extent permitted by law." ++ echo ++ printf 'Written by %s.\n' "Bruno Haible" ++} ++ ++# func_fatal_error message ++# outputs to stderr a fatal error message, and terminates the program. ++func_fatal_error () ++{ ++ echo "config.rpath: *** $1" 1>&2 ++ echo "config.rpath: *** Stop." 1>&2 ++ exit 1 ++} ++ ++# Command-line option processing. ++while test $# -gt 0; do ++ case "$1" in ++ --help | --hel | --he | --h ) ++ func_usage ++ exit 0 ;; ++ --version | --versio | --versi | --vers | --ver | --ve | --v ) ++ func_version ++ exit 0 ;; ++ -- ) # Stop option processing ++ shift; break ;; ++ -* ) ++ func_fatal_error "unrecognized option: $1" ++ ;; ++ * ) ++ break ;; ++ esac ++done ++ ++if test $# -gt 1; then ++ func_fatal_error "too many arguments" ++fi ++if test $# -lt 1; then ++ func_fatal_error "too few arguments" ++fi ++ + # All known linkers require a '.a' archive for static linking (except MSVC, + # which needs '.lib'). + libext=a +@@ -371,7 +438,7 @@ else + hardcode_direct=yes + hardcode_minus_L=yes + ;; +- freebsd* | dragonfly*) ++ freebsd* | dragonfly* | midnightbsd*) + hardcode_libdir_flag_spec='-R$libdir' + hardcode_direct=yes + ;; +@@ -547,7 +614,7 @@ case "$host_os" in + freebsd[23].*) + library_names_spec='$libname$shrext$versuffix' + ;; +- freebsd* | dragonfly*) ++ freebsd* | dragonfly* | midnightbsd*) + library_names_spec='$libname$shrext' + ;; + gnu*) +diff --git a/m4/build-to-host.m4 b/m4/build-to-host.m4 +new file mode 100644 +index 000000000..01bff8f34 +--- /dev/null ++++ b/m4/build-to-host.m4 +@@ -0,0 +1,274 @@ ++# build-to-host.m4 ++# serial 5 ++dnl Copyright (C) 2023-2025 Free Software Foundation, Inc. ++dnl This file is free software; the Free Software Foundation ++dnl gives unlimited permission to copy and/or distribute it, ++dnl with or without modifications, as long as this notice is preserved. ++dnl This file is offered as-is, without any warranty. ++ ++dnl Written by Bruno Haible. ++ ++dnl When the build environment ($build_os) is different from the target runtime ++dnl environment ($host_os), file names may need to be converted from the build ++dnl environment syntax to the target runtime environment syntax. This is ++dnl because the Makefiles are executed (mostly) by build environment tools and ++dnl therefore expect file names in build environment syntax, whereas the runtime ++dnl expects file names in target runtime environment syntax. ++dnl ++dnl For example, if $build_os = cygwin and $host_os = mingw32, filenames need ++dnl be converted from Cygwin syntax to native Windows syntax: ++dnl /cygdrive/c/foo/bar -> C:\foo\bar ++dnl /usr/local/share -> C:\cygwin64\usr\local\share ++dnl ++dnl gl_BUILD_TO_HOST([somedir]) ++dnl This macro takes as input an AC_SUBSTed variable 'somedir', which must ++dnl already have its final value assigned, and produces two additional ++dnl AC_SUBSTed variables 'somedir_c' and 'somedir_c_make', that designate the ++dnl same file name value, just in different syntax: ++dnl - somedir_c is the file name in target runtime environment syntax, ++dnl as a C string (starting and ending with a double-quote, ++dnl and with escaped backslashes and double-quotes in ++dnl between). ++dnl - somedir_c_make is the same thing, escaped for use in a Makefile. ++ ++AC_DEFUN([gl_BUILD_TO_HOST], ++[ ++ AC_REQUIRE([AC_CANONICAL_BUILD]) ++ AC_REQUIRE([AC_CANONICAL_HOST]) ++ AC_REQUIRE([gl_BUILD_TO_HOST_INIT]) ++ ++ dnl Define somedir_c. ++ gl_final_[$1]="$[$1]" ++ dnl Translate it from build syntax to host syntax. ++ case "$build_os" in ++ cygwin*) ++ case "$host_os" in ++ mingw* | windows*) ++ gl_final_[$1]=`cygpath -w "$gl_final_[$1]"` ;; ++ esac ++ ;; ++ esac ++ dnl Convert it to C string syntax. ++ [$1]_c=`printf '%s\n' "$gl_final_[$1]" | sed -e "$gl_sed_double_backslashes" -e "$gl_sed_escape_doublequotes" | tr -d "$gl_tr_cr"` ++ [$1]_c='"'"$[$1]_c"'"' ++ AC_SUBST([$1_c]) ++ ++ dnl Define somedir_c_make. ++ [$1]_c_make=`printf '%s\n' "$[$1]_c" | sed -e "$gl_sed_escape_for_make_1" -e "$gl_sed_escape_for_make_2" | tr -d "$gl_tr_cr"` ++ dnl Use the substituted somedir variable, when possible, so that the user ++ dnl may adjust somedir a posteriori when there are no special characters. ++ if test "$[$1]_c_make" = '\"'"${gl_final_[$1]}"'\"'; then ++ [$1]_c_make='\"$([$1])\"' ++ fi ++ AC_SUBST([$1_c_make]) ++]) ++ ++dnl Some initializations for gl_BUILD_TO_HOST. ++AC_DEFUN([gl_BUILD_TO_HOST_INIT], ++[ ++ gl_sed_double_backslashes='s/\\/\\\\/g' ++ gl_sed_escape_doublequotes='s/"/\\"/g' ++changequote(,)dnl ++ gl_sed_escape_for_make_1="s,\\([ \"&'();<>\\\\\`|]\\),\\\\\\1,g" ++changequote([,])dnl ++ gl_sed_escape_for_make_2='s,\$,\\$$,g' ++ dnl Find out how to remove carriage returns from output. Solaris /usr/ucb/tr ++ dnl does not understand '\r'. ++ case `echo r | tr -d '\r'` in ++ '') gl_tr_cr='\015' ;; ++ *) gl_tr_cr='\r' ;; ++ esac ++]) ++ ++ ++dnl The following macros are convenience invocations of gl_BUILD_TO_HOST ++dnl for some of the variables that are defined by Autoconf. ++dnl To do so for _all_ the possible variables, use the module 'configmake'. ++ ++dnl Defines bindir_c and bindir_c_make. ++AC_DEFUN_ONCE([gl_BUILD_TO_HOST_BINDIR], ++[ ++ dnl Find the final value of bindir. ++ gl_saved_prefix="${prefix}" ++ gl_saved_exec_prefix="${exec_prefix}" ++ gl_saved_bindir="${bindir}" ++ dnl Unfortunately, prefix and exec_prefix get only finally determined ++ dnl at the end of configure. ++ if test "X$prefix" = "XNONE"; then ++ prefix="$ac_default_prefix" ++ fi ++ if test "X$exec_prefix" = "XNONE"; then ++ exec_prefix='${prefix}' ++ fi ++ eval exec_prefix="$exec_prefix" ++ eval bindir="$bindir" ++ gl_BUILD_TO_HOST([bindir]) ++ bindir="${gl_saved_bindir}" ++ exec_prefix="${gl_saved_exec_prefix}" ++ prefix="${gl_saved_prefix}" ++]) ++ ++dnl Defines datadir_c and datadir_c_make, ++dnl where datadir = $(datarootdir) ++AC_DEFUN_ONCE([gl_BUILD_TO_HOST_DATADIR], ++[ ++ dnl Find the final value of datadir. ++ gl_saved_prefix="${prefix}" ++ gl_saved_datarootdir="${datarootdir}" ++ gl_saved_datadir="${datadir}" ++ dnl Unfortunately, prefix gets only finally determined at the end of ++ dnl configure. ++ if test "X$prefix" = "XNONE"; then ++ prefix="$ac_default_prefix" ++ fi ++ eval datarootdir="$datarootdir" ++ eval datadir="$datadir" ++ gl_BUILD_TO_HOST([datadir]) ++ datadir="${gl_saved_datadir}" ++ datarootdir="${gl_saved_datarootdir}" ++ prefix="${gl_saved_prefix}" ++]) ++ ++dnl Defines libdir_c and libdir_c_make. ++AC_DEFUN_ONCE([gl_BUILD_TO_HOST_LIBDIR], ++[ ++ dnl Find the final value of libdir. ++ gl_saved_prefix="${prefix}" ++ gl_saved_exec_prefix="${exec_prefix}" ++ gl_saved_libdir="${libdir}" ++ dnl Unfortunately, prefix and exec_prefix get only finally determined ++ dnl at the end of configure. ++ if test "X$prefix" = "XNONE"; then ++ prefix="$ac_default_prefix" ++ fi ++ if test "X$exec_prefix" = "XNONE"; then ++ exec_prefix='${prefix}' ++ fi ++ eval exec_prefix="$exec_prefix" ++ eval libdir="$libdir" ++ gl_BUILD_TO_HOST([libdir]) ++ libdir="${gl_saved_libdir}" ++ exec_prefix="${gl_saved_exec_prefix}" ++ prefix="${gl_saved_prefix}" ++]) ++ ++dnl Defines libexecdir_c and libexecdir_c_make. ++AC_DEFUN_ONCE([gl_BUILD_TO_HOST_LIBEXECDIR], ++[ ++ dnl Find the final value of libexecdir. ++ gl_saved_prefix="${prefix}" ++ gl_saved_exec_prefix="${exec_prefix}" ++ gl_saved_libexecdir="${libexecdir}" ++ dnl Unfortunately, prefix and exec_prefix get only finally determined ++ dnl at the end of configure. ++ if test "X$prefix" = "XNONE"; then ++ prefix="$ac_default_prefix" ++ fi ++ if test "X$exec_prefix" = "XNONE"; then ++ exec_prefix='${prefix}' ++ fi ++ eval exec_prefix="$exec_prefix" ++ eval libexecdir="$libexecdir" ++ gl_BUILD_TO_HOST([libexecdir]) ++ libexecdir="${gl_saved_libexecdir}" ++ exec_prefix="${gl_saved_exec_prefix}" ++ prefix="${gl_saved_prefix}" ++]) ++ ++dnl Defines localedir_c and localedir_c_make. ++AC_DEFUN_ONCE([gl_BUILD_TO_HOST_LOCALEDIR], ++[ ++ dnl Find the final value of localedir. ++ gl_saved_prefix="${prefix}" ++ gl_saved_datarootdir="${datarootdir}" ++ gl_saved_localedir="${localedir}" ++ dnl Unfortunately, prefix gets only finally determined at the end of ++ dnl configure. ++ if test "X$prefix" = "XNONE"; then ++ prefix="$ac_default_prefix" ++ fi ++ eval datarootdir="$datarootdir" ++ eval localedir="$localedir" ++ gl_BUILD_TO_HOST([localedir]) ++ localedir="${gl_saved_localedir}" ++ datarootdir="${gl_saved_datarootdir}" ++ prefix="${gl_saved_prefix}" ++]) ++ ++dnl Defines pkgdatadir_c and pkgdatadir_c_make, ++dnl where pkgdatadir = $(datadir)/$(PACKAGE) ++AC_DEFUN_ONCE([gl_BUILD_TO_HOST_PKGDATADIR], ++[ ++ dnl Find the final value of pkgdatadir. ++ gl_saved_prefix="${prefix}" ++ gl_saved_datarootdir="${datarootdir}" ++ gl_saved_datadir="${datadir}" ++ gl_saved_pkgdatadir="${pkgdatadir}" ++ dnl Unfortunately, prefix gets only finally determined at the end of ++ dnl configure. ++ if test "X$prefix" = "XNONE"; then ++ prefix="$ac_default_prefix" ++ fi ++ eval datarootdir="$datarootdir" ++ eval datadir="$datadir" ++ eval pkgdatadir="$pkgdatadir" ++ gl_BUILD_TO_HOST([pkgdatadir]) ++ pkgdatadir="${gl_saved_pkgdatadir}" ++ datadir="${gl_saved_datadir}" ++ datarootdir="${gl_saved_datarootdir}" ++ prefix="${gl_saved_prefix}" ++]) ++ ++dnl Defines pkglibdir_c and pkglibdir_c_make, ++dnl where pkglibdir = $(libdir)/$(PACKAGE) ++AC_DEFUN_ONCE([gl_BUILD_TO_HOST_PKGLIBDIR], ++[ ++ dnl Find the final value of pkglibdir. ++ gl_saved_prefix="${prefix}" ++ gl_saved_exec_prefix="${exec_prefix}" ++ gl_saved_libdir="${libdir}" ++ gl_saved_pkglibdir="${pkglibdir}" ++ dnl Unfortunately, prefix and exec_prefix get only finally determined ++ dnl at the end of configure. ++ if test "X$prefix" = "XNONE"; then ++ prefix="$ac_default_prefix" ++ fi ++ if test "X$exec_prefix" = "XNONE"; then ++ exec_prefix='${prefix}' ++ fi ++ eval exec_prefix="$exec_prefix" ++ eval libdir="$libdir" ++ eval pkglibdir="$pkglibdir" ++ gl_BUILD_TO_HOST([pkglibdir]) ++ pkglibdir="${gl_saved_pkglibdir}" ++ libdir="${gl_saved_libdir}" ++ exec_prefix="${gl_saved_exec_prefix}" ++ prefix="${gl_saved_prefix}" ++]) ++ ++dnl Defines pkglibexecdir_c and pkglibexecdir_c_make, ++dnl where pkglibexecdir = $(libexecdir)/$(PACKAGE) ++AC_DEFUN_ONCE([gl_BUILD_TO_HOST_PKGLIBEXECDIR], ++[ ++ dnl Find the final value of pkglibexecdir. ++ gl_saved_prefix="${prefix}" ++ gl_saved_exec_prefix="${exec_prefix}" ++ gl_saved_libexecdir="${libexecdir}" ++ gl_saved_pkglibexecdir="${pkglibexecdir}" ++ dnl Unfortunately, prefix and exec_prefix get only finally determined ++ dnl at the end of configure. ++ if test "X$prefix" = "XNONE"; then ++ prefix="$ac_default_prefix" ++ fi ++ if test "X$exec_prefix" = "XNONE"; then ++ exec_prefix='${prefix}' ++ fi ++ eval exec_prefix="$exec_prefix" ++ eval libexecdir="$libexecdir" ++ eval pkglibexecdir="$pkglibexecdir" ++ gl_BUILD_TO_HOST([pkglibexecdir]) ++ pkglibexecdir="${gl_saved_pkglibexecdir}" ++ libexecdir="${gl_saved_libexecdir}" ++ exec_prefix="${gl_saved_exec_prefix}" ++ prefix="${gl_saved_prefix}" ++]) +diff --git a/m4/gettext.m4 b/m4/gettext.m4 +new file mode 100644 +index 000000000..7de17f99c +--- /dev/null ++++ b/m4/gettext.m4 +@@ -0,0 +1,393 @@ ++# gettext.m4 ++# serial 81 (gettext-0.24) ++dnl Copyright (C) 1995-2025 Free Software Foundation, Inc. ++dnl This file is free software; the Free Software Foundation ++dnl gives unlimited permission to copy and/or distribute it, ++dnl with or without modifications, as long as this notice is preserved. ++dnl This file is offered as-is, without any warranty. ++dnl ++dnl This file can be used in projects which are not available under ++dnl the GNU General Public License or the GNU Lesser General Public ++dnl License but which still want to provide support for the GNU gettext ++dnl functionality. ++dnl Please note that the actual code of the GNU gettext library is covered ++dnl by the GNU Lesser General Public License, and the rest of the GNU ++dnl gettext package is covered by the GNU General Public License. ++dnl They are *not* in the public domain. ++ ++dnl Authors: ++dnl Ulrich Drepper , 1995-2000. ++dnl Bruno Haible , 2000-2024. ++ ++dnl Macro to add for using GNU gettext. ++ ++dnl Usage: AM_GNU_GETTEXT([INTLSYMBOL], [NEEDSYMBOL], [INTLDIR]). ++dnl INTLSYMBOL must be one of 'external', 'use-libtool', 'here'. ++dnl INTLSYMBOL should be 'external' for packages other than GNU gettext. ++dnl It should be 'use-libtool' for the packages 'gettext-runtime' and ++dnl 'gettext-tools'. ++dnl It should be 'here' for the package 'gettext-runtime/intl'. ++dnl If INTLSYMBOL is 'here', then a libtool library ++dnl $(top_builddir)/libintl.la will be created (shared and/or static, ++dnl depending on --{enable,disable}-{shared,static} and on the presence of ++dnl AM-DISABLE-SHARED). ++dnl If NEEDSYMBOL is specified and is 'need-ngettext', then GNU gettext ++dnl implementations (in libc or libintl) without the ngettext() function ++dnl will be ignored. If NEEDSYMBOL is specified and is ++dnl 'need-formatstring-macros', then GNU gettext implementations that don't ++dnl support the ISO C 99 formatstring macros will be ignored. ++dnl INTLDIR is used to find the intl libraries. If empty, ++dnl the value '$(top_builddir)/intl/' is used. ++dnl ++dnl The result of the configuration is one of three cases: ++dnl 1) GNU gettext, as included in the intl subdirectory, will be compiled ++dnl and used. ++dnl Catalog format: GNU --> install in $(datadir) ++dnl Catalog extension: .mo after installation, .gmo in source tree ++dnl 2) GNU gettext has been found in the system's C library. ++dnl Catalog format: GNU --> install in $(datadir) ++dnl Catalog extension: .mo after installation, .gmo in source tree ++dnl 3) No internationalization, always use English msgid. ++dnl Catalog format: none ++dnl Catalog extension: none ++dnl If INTLSYMBOL is 'external', only cases 2 and 3 can occur. ++dnl The use of .gmo is historical (it was needed to avoid overwriting the ++dnl GNU format catalogs when building on a platform with an X/Open gettext), ++dnl but we keep it in order not to force irrelevant filename changes on the ++dnl maintainers. ++dnl ++AC_DEFUN([AM_GNU_GETTEXT], ++[ ++ dnl Argument checking. ++ m4_if([$1], [], , [m4_if([$1], [external], , [m4_if([$1], [use-libtool], , [m4_if([$1], [here], , ++ [errprint([ERROR: invalid first argument to AM_GNU_GETTEXT ++])])])])]) ++ m4_if(m4_if([$1], [], [old])[]m4_if([$1], [no-libtool], [old]), [old], ++ [errprint([ERROR: Use of AM_GNU_GETTEXT without [external] argument is no longer supported. ++])]) ++ m4_if([$2], [], , [m4_if([$2], [need-ngettext], , [m4_if([$2], [need-formatstring-macros], , ++ [errprint([ERROR: invalid second argument to AM_GNU_GETTEXT ++])])])]) ++ define([gt_building_libintl_in_same_build_tree], ++ m4_if([$1], [use-libtool], [yes], [m4_if([$1], [here], [yes], [no])])) ++ gt_NEEDS_INIT ++ AM_GNU_GETTEXT_NEED([$2]) ++ ++ AC_REQUIRE([AM_PO_SUBDIRS])dnl ++ ++ dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ AC_REQUIRE([AC_LIB_RPATH]) ++ ++ dnl Sometimes libintl requires libiconv, so first search for libiconv. ++ dnl Ideally we would do this search only after the ++ dnl if test "$USE_NLS" = "yes"; then ++ dnl if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then ++ dnl tests. But if configure.ac invokes AM_ICONV after AM_GNU_GETTEXT ++ dnl the configure script would need to contain the same shell code ++ dnl again, outside any 'if'. There are two solutions: ++ dnl - Invoke AM_ICONV_LINKFLAGS_BODY here, outside any 'if'. ++ dnl - Control the expansions in more detail using AC_PROVIDE_IFELSE. ++ dnl Since AC_PROVIDE_IFELSE is not documented, we avoid it. ++ m4_if(gt_building_libintl_in_same_build_tree, yes, , [ ++ AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) ++ ]) ++ ++ dnl Sometimes, on Mac OS X, libintl requires linking with CoreFoundation. ++ gt_INTL_MACOSX ++ ++ dnl Set USE_NLS. ++ AC_REQUIRE([AM_NLS]) ++ ++ m4_if(gt_building_libintl_in_same_build_tree, yes, [ ++ USE_INCLUDED_LIBINTL=no ++ ]) ++ LIBINTL= ++ LTLIBINTL= ++ POSUB= ++ ++ dnl Add a version number to the cache macros. ++ case " $gt_needs " in ++ *" need-formatstring-macros "*) gt_api_version=3 ;; ++ *" need-ngettext "*) gt_api_version=2 ;; ++ *) gt_api_version=1 ;; ++ esac ++ gt_func_gnugettext_libc="gt_cv_func_gnugettext${gt_api_version}_libc" ++ gt_func_gnugettext_libintl="gt_cv_func_gnugettext${gt_api_version}_libintl" ++ ++ dnl If we use NLS figure out what method ++ if test "$USE_NLS" = "yes"; then ++ gt_use_preinstalled_gnugettext=no ++ m4_if(gt_building_libintl_in_same_build_tree, yes, [ ++ AC_MSG_CHECKING([whether included gettext is requested]) ++ AC_ARG_WITH([included-gettext], ++ [ --with-included-gettext use the GNU gettext library included here], ++ nls_cv_force_use_gnu_gettext=$withval, ++ nls_cv_force_use_gnu_gettext=no) ++ AC_MSG_RESULT([$nls_cv_force_use_gnu_gettext]) ++ ++ nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext" ++ if test "$nls_cv_force_use_gnu_gettext" != "yes"; then ++ ]) ++ dnl User does not insist on using GNU NLS library. Figure out what ++ dnl to use. If GNU gettext is available we use this. Else we have ++ dnl to fall back to GNU NLS library. ++ ++ if test $gt_api_version -ge 3; then ++ gt_revision_test_code=' ++#ifndef __GNU_GETTEXT_SUPPORTED_REVISION ++#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) ++#endif ++changequote(,)dnl ++typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; ++changequote([,])dnl ++' ++ else ++ gt_revision_test_code= ++ fi ++ if test $gt_api_version -ge 2; then ++ gt_expression_test_code=' + * ngettext ("", "", 0)' ++ else ++ gt_expression_test_code= ++ fi ++ ++ AC_CACHE_CHECK([for GNU gettext in libc], [$gt_func_gnugettext_libc], ++ [AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#ifndef __GNU_GETTEXT_SUPPORTED_REVISION ++extern int _nl_msg_cat_cntr; ++extern int *_nl_domain_bindings; ++#define __GNU_GETTEXT_SYMBOL_EXPRESSION (_nl_msg_cat_cntr + *_nl_domain_bindings) ++#else ++#define __GNU_GETTEXT_SYMBOL_EXPRESSION 0 ++#endif ++$gt_revision_test_code ++ ]], ++ [[ ++bindtextdomain ("", ""); ++return * gettext ("")$gt_expression_test_code + __GNU_GETTEXT_SYMBOL_EXPRESSION ++ ]])], ++ [eval "$gt_func_gnugettext_libc=yes"], ++ [eval "$gt_func_gnugettext_libc=no"])]) ++ ++ if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then ++ dnl Sometimes libintl requires libiconv, so first search for libiconv. ++ m4_if(gt_building_libintl_in_same_build_tree, yes, , [ ++ AM_ICONV_LINK ++ ]) ++ dnl Search for libintl and define LIBINTL, LTLIBINTL and INCINTL ++ dnl accordingly. Don't use AC_LIB_LINKFLAGS_BODY([intl],[iconv]) ++ dnl because that would add "-liconv" to LIBINTL and LTLIBINTL ++ dnl even if libiconv doesn't exist. ++ AC_LIB_LINKFLAGS_BODY([intl]) ++ AC_CACHE_CHECK([for GNU gettext in libintl], ++ [$gt_func_gnugettext_libintl], ++ [gt_saved_CPPFLAGS="$CPPFLAGS" ++ CPPFLAGS="$CPPFLAGS $INCINTL" ++ gt_saved_LIBS="$LIBS" ++ LIBS="$LIBS $LIBINTL" ++ dnl Now see whether libintl exists and does not depend on libiconv. ++ AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#ifndef __GNU_GETTEXT_SUPPORTED_REVISION ++extern int _nl_msg_cat_cntr; ++extern ++#ifdef __cplusplus ++"C" ++#endif ++const char *_nl_expand_alias (const char *); ++#define __GNU_GETTEXT_SYMBOL_EXPRESSION (_nl_msg_cat_cntr + *_nl_expand_alias ("")) ++#else ++#define __GNU_GETTEXT_SYMBOL_EXPRESSION 0 ++#endif ++$gt_revision_test_code ++ ]], ++ [[ ++bindtextdomain ("", ""); ++return * gettext ("")$gt_expression_test_code + __GNU_GETTEXT_SYMBOL_EXPRESSION ++ ]])], ++ [eval "$gt_func_gnugettext_libintl=yes"], ++ [eval "$gt_func_gnugettext_libintl=no"]) ++ dnl Now see whether libintl exists and depends on libiconv or other ++ dnl OS dependent libraries, specifically on macOS and AIX. ++ gt_LIBINTL_EXTRA="$INTL_MACOSX_LIBS" ++ AC_REQUIRE([AC_CANONICAL_HOST]) ++ case "$host_os" in ++ aix*) gt_LIBINTL_EXTRA="-lpthread" ;; ++ esac ++ if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" != yes; } \ ++ && { test -n "$LIBICONV" || test -n "$gt_LIBINTL_EXTRA"; }; then ++ LIBS="$LIBS $LIBICONV $gt_LIBINTL_EXTRA" ++ AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#ifndef __GNU_GETTEXT_SUPPORTED_REVISION ++extern int _nl_msg_cat_cntr; ++extern ++#ifdef __cplusplus ++"C" ++#endif ++const char *_nl_expand_alias (const char *); ++#define __GNU_GETTEXT_SYMBOL_EXPRESSION (_nl_msg_cat_cntr + *_nl_expand_alias ("")) ++#else ++#define __GNU_GETTEXT_SYMBOL_EXPRESSION 0 ++#endif ++$gt_revision_test_code ++ ]], ++ [[ ++bindtextdomain ("", ""); ++return * gettext ("")$gt_expression_test_code + __GNU_GETTEXT_SYMBOL_EXPRESSION ++ ]])], ++ [LIBINTL="$LIBINTL $LIBICONV $gt_LIBINTL_EXTRA" ++ LTLIBINTL="$LTLIBINTL $LTLIBICONV $gt_LIBINTL_EXTRA" ++ eval "$gt_func_gnugettext_libintl=yes" ++ ]) ++ fi ++ CPPFLAGS="$gt_saved_CPPFLAGS" ++ LIBS="$gt_saved_LIBS"]) ++ fi ++ ++ dnl If an already present or preinstalled GNU gettext() is found, ++ dnl use it. But if this macro is used in GNU gettext, and GNU ++ dnl gettext is already preinstalled in libintl, we update this ++ dnl libintl. (Cf. the install rule in intl/Makefile.in.) ++ if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" = "yes"; } \ ++ || { { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; } \ ++ && test "$PACKAGE" != gettext-runtime \ ++ && test "$PACKAGE" != gettext-tools \ ++ && test "$PACKAGE" != libintl; }; then ++ gt_use_preinstalled_gnugettext=yes ++ else ++ dnl Reset the values set by searching for libintl. ++ LIBINTL= ++ LTLIBINTL= ++ INCINTL= ++ fi ++ ++ m4_if(gt_building_libintl_in_same_build_tree, yes, [ ++ if test "$gt_use_preinstalled_gnugettext" != "yes"; then ++ dnl GNU gettext is not found in the C library. ++ dnl Fall back on included GNU gettext library. ++ nls_cv_use_gnu_gettext=yes ++ fi ++ fi ++ ++ if test "$nls_cv_use_gnu_gettext" = "yes"; then ++ dnl Mark actions used to generate GNU NLS library. ++ USE_INCLUDED_LIBINTL=yes ++ LIBINTL="m4_if([$3],[],\${top_builddir}/intl,[$3])/libintl.la $LIBICONV $LIBTHREAD" ++ LTLIBINTL="m4_if([$3],[],\${top_builddir}/intl,[$3])/libintl.la $LTLIBICONV $LTLIBTHREAD" ++ LIBS=`echo " $LIBS " | sed -e 's/ -lintl / /' -e 's/^ //' -e 's/ $//'` ++ fi ++ ++ CATOBJEXT= ++ if test "$gt_use_preinstalled_gnugettext" = "yes" \ ++ || test "$nls_cv_use_gnu_gettext" = "yes"; then ++ dnl Mark actions to use GNU gettext tools. ++ CATOBJEXT=.gmo ++ fi ++ ]) ++ ++ if test -n "$INTL_MACOSX_LIBS"; then ++ if test "$gt_use_preinstalled_gnugettext" = "yes" \ ++ || test "$nls_cv_use_gnu_gettext" = "yes"; then ++ dnl Some extra flags are needed during linking. ++ LIBINTL="$LIBINTL $INTL_MACOSX_LIBS" ++ LTLIBINTL="$LTLIBINTL $INTL_MACOSX_LIBS" ++ fi ++ fi ++ ++ if test "$gt_use_preinstalled_gnugettext" = "yes" \ ++ || test "$nls_cv_use_gnu_gettext" = "yes"; then ++ AC_DEFINE([ENABLE_NLS], [1], ++ [Define to 1 if translation of program messages to the user's native language ++ is requested.]) ++ else ++ USE_NLS=no ++ fi ++ fi ++ ++ AC_MSG_CHECKING([whether to use NLS]) ++ AC_MSG_RESULT([$USE_NLS]) ++ if test "$USE_NLS" = "yes"; then ++ AC_MSG_CHECKING([where the gettext function comes from]) ++ if test "$gt_use_preinstalled_gnugettext" = "yes"; then ++ if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then ++ gt_source="external libintl" ++ else ++ gt_source="libc" ++ fi ++ else ++ gt_source="included intl directory" ++ fi ++ AC_MSG_RESULT([$gt_source]) ++ fi ++ ++ if test "$USE_NLS" = "yes"; then ++ ++ if test "$gt_use_preinstalled_gnugettext" = "yes"; then ++ if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then ++ AC_MSG_CHECKING([how to link with libintl]) ++ AC_MSG_RESULT([$LIBINTL]) ++ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCINTL]) ++ fi ++ ++ dnl For backward compatibility. Some packages may be using this. ++ AC_DEFINE([HAVE_GETTEXT], [1], ++ [Define if the GNU gettext() function is already present or preinstalled.]) ++ AC_DEFINE([HAVE_DCGETTEXT], [1], ++ [Define if the GNU dcgettext() function is already present or preinstalled.]) ++ fi ++ ++ dnl We need to process the po/ directory. ++ POSUB=po ++ fi ++ ++ m4_if(gt_building_libintl_in_same_build_tree, yes, [ ++ dnl Make all variables we use known to autoconf. ++ AC_SUBST([USE_INCLUDED_LIBINTL]) ++ AC_SUBST([CATOBJEXT]) ++ ]) ++ ++ m4_if(gt_building_libintl_in_same_build_tree, yes, [], [ ++ dnl For backward compatibility. Some Makefiles may be using this. ++ INTLLIBS="$LIBINTL" ++ AC_SUBST([INTLLIBS]) ++ ]) ++ ++ dnl Make all documented variables known to autoconf. ++ AC_SUBST([LIBINTL]) ++ AC_SUBST([LTLIBINTL]) ++ AC_SUBST([POSUB]) ++ ++ dnl Define localedir_c and localedir_c_make. ++ gl_BUILD_TO_HOST_LOCALEDIR ++]) ++ ++ ++dnl gt_NEEDS_INIT ensures that the gt_needs variable is initialized. ++m4_define([gt_NEEDS_INIT], ++[ ++ m4_divert_text([DEFAULTS], [gt_needs=]) ++ m4_define([gt_NEEDS_INIT], []) ++]) ++ ++ ++dnl Usage: AM_GNU_GETTEXT_NEED([NEEDSYMBOL]) ++AC_DEFUN([AM_GNU_GETTEXT_NEED], ++[ ++ m4_divert_text([INIT_PREPARE], [gt_needs="$gt_needs $1"]) ++]) ++ ++ ++dnl Usage: AM_GNU_GETTEXT_VERSION([gettext-version]) ++AC_DEFUN([AM_GNU_GETTEXT_VERSION], []) ++ ++ ++dnl Usage: AM_GNU_GETTEXT_REQUIRE_VERSION([gettext-version]) ++AC_DEFUN([AM_GNU_GETTEXT_REQUIRE_VERSION], []) +diff --git a/m4/host-cpu-c-abi.m4 b/m4/host-cpu-c-abi.m4 +new file mode 100644 +index 000000000..6ca7721a3 +--- /dev/null ++++ b/m4/host-cpu-c-abi.m4 +@@ -0,0 +1,532 @@ ++# host-cpu-c-abi.m4 ++# serial 20 ++dnl Copyright (C) 2002-2025 Free Software Foundation, Inc. ++dnl This file is free software; the Free Software Foundation ++dnl gives unlimited permission to copy and/or distribute it, ++dnl with or without modifications, as long as this notice is preserved. ++dnl This file is offered as-is, without any warranty. ++ ++dnl From Bruno Haible and Sam Steingold. ++ ++dnl Sets the HOST_CPU variable to the canonical name of the CPU. ++dnl Sets the HOST_CPU_C_ABI variable to the canonical name of the CPU with its ++dnl C language ABI (application binary interface). ++dnl Also defines __${HOST_CPU}__ and __${HOST_CPU_C_ABI}__ as C macros in ++dnl config.h. ++dnl ++dnl This canonical name can be used to select a particular assembly language ++dnl source file that will interoperate with C code on the given host. ++dnl ++dnl For example: ++dnl * 'i386' and 'sparc' are different canonical names, because code for i386 ++dnl will not run on SPARC CPUs and vice versa. They have different ++dnl instruction sets. ++dnl * 'sparc' and 'sparc64' are different canonical names, because code for ++dnl 'sparc' and code for 'sparc64' cannot be linked together: 'sparc' code ++dnl contains 32-bit instructions, whereas 'sparc64' code contains 64-bit ++dnl instructions. A process on a SPARC CPU can be in 32-bit mode or in 64-bit ++dnl mode, but not both. ++dnl * 'mips' and 'mipsn32' are different canonical names, because they use ++dnl different argument passing and return conventions for C functions, and ++dnl although the instruction set of 'mips' is a large subset of the ++dnl instruction set of 'mipsn32'. ++dnl * 'mipsn32' and 'mips64' are different canonical names, because they use ++dnl different sizes for the C types like 'int' and 'void *', and although ++dnl the instruction sets of 'mipsn32' and 'mips64' are the same. ++dnl * The same canonical name is used for different endiannesses. You can ++dnl determine the endianness through preprocessor symbols: ++dnl - 'arm': test __ARMEL__. ++dnl - 'mips', 'mipsn32', 'mips64': test _MIPSEB vs. _MIPSEL. ++dnl - 'powerpc64': test __BIG_ENDIAN__ vs. __LITTLE_ENDIAN__. ++dnl * The same name 'i386' is used for CPUs of type i386, i486, i586 ++dnl (Pentium), AMD K7, Pentium II, Pentium IV, etc., because ++dnl - Instructions that do not exist on all of these CPUs (cmpxchg, ++dnl MMX, SSE, SSE2, 3DNow! etc.) are not frequently used. If your ++dnl assembly language source files use such instructions, you will ++dnl need to make the distinction. ++dnl - Speed of execution of the common instruction set is reasonable across ++dnl the entire family of CPUs. If you have assembly language source files ++dnl that are optimized for particular CPU types (like GNU gmp has), you ++dnl will need to make the distinction. ++dnl See . ++AC_DEFUN([gl_HOST_CPU_C_ABI], ++[ ++ AC_REQUIRE([AC_CANONICAL_HOST]) ++ AC_REQUIRE([gl_C_ASM]) ++ AC_CACHE_CHECK([host CPU and C ABI], [gl_cv_host_cpu_c_abi], ++ [case "$host_cpu" in ++ ++changequote(,)dnl ++ i[34567]86 ) ++changequote([,])dnl ++ gl_cv_host_cpu_c_abi=i386 ++ ;; ++ ++ x86_64 ) ++ # On x86_64 systems, the C compiler may be generating code in one of ++ # these ABIs: ++ # - 64-bit instruction set, 64-bit pointers, 64-bit 'long': x86_64. ++ # - 64-bit instruction set, 64-bit pointers, 32-bit 'long': x86_64 ++ # with native Windows (mingw, MSVC). ++ # - 64-bit instruction set, 32-bit pointers, 32-bit 'long': x86_64-x32. ++ # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': i386. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if (defined __x86_64__ || defined __amd64__ \ ++ || defined _M_X64 || defined _M_AMD64) ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined __ILP32__ || defined _ILP32 ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [gl_cv_host_cpu_c_abi=x86_64-x32], ++ [gl_cv_host_cpu_c_abi=x86_64])], ++ [gl_cv_host_cpu_c_abi=i386]) ++ ;; ++ ++changequote(,)dnl ++ alphaev[4-8] | alphaev56 | alphapca5[67] | alphaev6[78] ) ++changequote([,])dnl ++ gl_cv_host_cpu_c_abi=alpha ++ ;; ++ ++ arm* | aarch64 ) ++ # Assume arm with EABI. ++ # On arm64 systems, the C compiler may be generating code in one of ++ # these ABIs: ++ # - aarch64 instruction set, 64-bit pointers, 64-bit 'long': arm64. ++ # - aarch64 instruction set, 32-bit pointers, 32-bit 'long': arm64-ilp32. ++ # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': arm or armhf. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#ifdef __aarch64__ ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined __ILP32__ || defined _ILP32 ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [gl_cv_host_cpu_c_abi=arm64-ilp32], ++ [gl_cv_host_cpu_c_abi=arm64])], ++ [# Don't distinguish little-endian and big-endian arm, since they ++ # don't require different machine code for simple operations and ++ # since the user can distinguish them through the preprocessor ++ # defines __ARMEL__ vs. __ARMEB__. ++ # But distinguish arm which passes floating-point arguments and ++ # return values in integer registers (r0, r1, ...) - this is ++ # gcc -mfloat-abi=soft or gcc -mfloat-abi=softfp - from arm which ++ # passes them in float registers (s0, s1, ...) and double registers ++ # (d0, d1, ...) - this is gcc -mfloat-abi=hard. GCC 4.6 or newer ++ # sets the preprocessor defines __ARM_PCS (for the first case) and ++ # __ARM_PCS_VFP (for the second case), but older GCC does not. ++ echo 'double ddd; void func (double dd) { ddd = dd; }' > conftest.c ++ # Look for a reference to the register d0 in the .s file. ++ AC_TRY_COMMAND(${CC-cc} $CFLAGS $CPPFLAGS $gl_c_asm_opt conftest.c) >/dev/null 2>&1 ++ if LC_ALL=C grep 'd0,' conftest.$gl_asmext >/dev/null; then ++ gl_cv_host_cpu_c_abi=armhf ++ else ++ gl_cv_host_cpu_c_abi=arm ++ fi ++ rm -fr conftest* ++ ]) ++ ;; ++ ++ hppa1.0 | hppa1.1 | hppa2.0* | hppa64 ) ++ # On hppa, the C compiler may be generating 32-bit code or 64-bit ++ # code. In the latter case, it defines _LP64 and __LP64__. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#ifdef __LP64__ ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [gl_cv_host_cpu_c_abi=hppa64], ++ [gl_cv_host_cpu_c_abi=hppa]) ++ ;; ++ ++ ia64* ) ++ # On ia64 on HP-UX, the C compiler may be generating 64-bit code or ++ # 32-bit code. In the latter case, it defines _ILP32. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#ifdef _ILP32 ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [gl_cv_host_cpu_c_abi=ia64-ilp32], ++ [gl_cv_host_cpu_c_abi=ia64]) ++ ;; ++ ++ mips* ) ++ # We should also check for (_MIPS_SZPTR == 64), but gcc keeps this ++ # at 32. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined _MIPS_SZLONG && (_MIPS_SZLONG == 64) ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [gl_cv_host_cpu_c_abi=mips64], ++ [# In the n32 ABI, _ABIN32 is defined, _ABIO32 is not defined (but ++ # may later get defined by ), and _MIPS_SIM == _ABIN32. ++ # In the 32 ABI, _ABIO32 is defined, _ABIN32 is not defined (but ++ # may later get defined by ), and _MIPS_SIM == _ABIO32. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if (_MIPS_SIM == _ABIN32) ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [gl_cv_host_cpu_c_abi=mipsn32], ++ [gl_cv_host_cpu_c_abi=mips])]) ++ ;; ++ ++ powerpc* ) ++ # Different ABIs are in use on AIX vs. Mac OS X vs. Linux,*BSD. ++ # No need to distinguish them here; the caller may distinguish ++ # them based on the OS. ++ # On powerpc64 systems, the C compiler may still be generating ++ # 32-bit code. And on powerpc-ibm-aix systems, the C compiler may ++ # be generating 64-bit code. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined __powerpc64__ || defined __LP64__ ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [# On powerpc64, there are two ABIs on Linux: The AIX compatible ++ # one and the ELFv2 one. The latter defines _CALL_ELF=2. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined _CALL_ELF && _CALL_ELF == 2 ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [gl_cv_host_cpu_c_abi=powerpc64-elfv2], ++ [gl_cv_host_cpu_c_abi=powerpc64]) ++ ], ++ [gl_cv_host_cpu_c_abi=powerpc]) ++ ;; ++ ++ rs6000 ) ++ gl_cv_host_cpu_c_abi=powerpc ++ ;; ++ ++ riscv32 | riscv64 ) ++ # There are 2 architectures (with variants): rv32* and rv64*. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if __riscv_xlen == 64 ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [cpu=riscv64], ++ [cpu=riscv32]) ++ # There are 6 ABIs: ilp32, ilp32f, ilp32d, lp64, lp64f, lp64d. ++ # Size of 'long' and 'void *': ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined __LP64__ ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [main_abi=lp64], ++ [main_abi=ilp32]) ++ # Float ABIs: ++ # __riscv_float_abi_double: ++ # 'float' and 'double' are passed in floating-point registers. ++ # __riscv_float_abi_single: ++ # 'float' are passed in floating-point registers. ++ # __riscv_float_abi_soft: ++ # No values are passed in floating-point registers. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined __riscv_float_abi_double ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [float_abi=d], ++ [AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined __riscv_float_abi_single ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [float_abi=f], ++ [float_abi='']) ++ ]) ++ gl_cv_host_cpu_c_abi="${cpu}-${main_abi}${float_abi}" ++ ;; ++ ++ s390* ) ++ # On s390x, the C compiler may be generating 64-bit (= s390x) code ++ # or 31-bit (= s390) code. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined __LP64__ || defined __s390x__ ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [gl_cv_host_cpu_c_abi=s390x], ++ [gl_cv_host_cpu_c_abi=s390]) ++ ;; ++ ++ sparc | sparc64 ) ++ # UltraSPARCs running Linux have `uname -m` = "sparc64", but the ++ # C compiler still generates 32-bit code. ++ AC_COMPILE_IFELSE( ++ [AC_LANG_SOURCE( ++ [[#if defined __sparcv9 || defined __arch64__ ++ int ok; ++ #else ++ error fail ++ #endif ++ ]])], ++ [gl_cv_host_cpu_c_abi=sparc64], ++ [gl_cv_host_cpu_c_abi=sparc]) ++ ;; ++ ++ *) ++ gl_cv_host_cpu_c_abi="$host_cpu" ++ ;; ++ esac ++ ]) ++ ++ dnl In most cases, $HOST_CPU and $HOST_CPU_C_ABI are the same. ++ HOST_CPU=`echo "$gl_cv_host_cpu_c_abi" | sed -e 's/-.*//'` ++ HOST_CPU_C_ABI="$gl_cv_host_cpu_c_abi" ++ AC_SUBST([HOST_CPU]) ++ AC_SUBST([HOST_CPU_C_ABI]) ++ ++ # This was ++ # AC_DEFINE_UNQUOTED([__${HOST_CPU}__]) ++ # AC_DEFINE_UNQUOTED([__${HOST_CPU_C_ABI}__]) ++ # earlier, but KAI C++ 3.2d doesn't like this. ++ sed -e 's/-/_/g' >> confdefs.h <. ++dnl Don't make changes that are incompatible with that documentation! ++ ++AC_DEFUN([AM_ICONV_LINKFLAGS_BODY], ++[ ++ dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ AC_REQUIRE([AC_LIB_RPATH]) ++ ++ dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV ++ dnl accordingly. ++ AC_LIB_LINKFLAGS_BODY([iconv]) ++]) ++ ++AC_DEFUN([AM_ICONV_LINK], ++[ ++ dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and ++ dnl those with the standalone portable GNU libiconv installed). ++ AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles ++ ++ dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV ++ dnl accordingly. ++ AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) ++ ++ dnl Add $INCICONV to CPPFLAGS before performing the following checks, ++ dnl because if the user has installed libiconv and not disabled its use ++ dnl via --without-libiconv-prefix, he wants to use it. The first ++ dnl AC_LINK_IFELSE will then fail, the second AC_LINK_IFELSE will succeed. ++ gl_saved_CPPFLAGS="$CPPFLAGS" ++ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV]) ++ ++ AC_CACHE_CHECK([for iconv], [am_cv_func_iconv], [ ++ am_cv_func_iconv="no, consider installing GNU libiconv" ++ am_cv_lib_iconv=no ++ AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#include ++ ]], ++ [[iconv_t cd = iconv_open("",""); ++ iconv(cd,NULL,NULL,NULL,NULL); ++ iconv_close(cd);]])], ++ [am_cv_func_iconv=yes]) ++ if test "$am_cv_func_iconv" != yes; then ++ gl_saved_LIBS="$LIBS" ++ LIBS="$LIBS $LIBICONV" ++ AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#include ++ ]], ++ [[iconv_t cd = iconv_open("",""); ++ iconv(cd,NULL,NULL,NULL,NULL); ++ iconv_close(cd);]])], ++ [am_cv_lib_iconv=yes] ++ [am_cv_func_iconv=yes]) ++ LIBS="$gl_saved_LIBS" ++ fi ++ ]) ++ if test "$am_cv_func_iconv" = yes; then ++ AC_CACHE_CHECK([for working iconv], [am_cv_func_iconv_works], [ ++ dnl This tests against bugs in AIX 5.1, AIX 6.1..7.1, HP-UX 11.11, ++ dnl Solaris 10, macOS 14.4. ++ gl_saved_LIBS="$LIBS" ++ if test $am_cv_lib_iconv = yes; then ++ LIBS="$LIBS $LIBICONV" ++ fi ++ am_cv_func_iconv_works=no ++ for ac_iconv_const in '' 'const'; do ++ AC_RUN_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#include ++ ++#ifndef ICONV_CONST ++# define ICONV_CONST $ac_iconv_const ++#endif ++ ]], ++ [[int result = 0; ++ /* Test against AIX 5.1...7.2 bug: Failures are not distinguishable from ++ successful returns. This is even documented in ++ */ ++ { ++ iconv_t cd_utf8_to_88591 = iconv_open ("ISO8859-1", "UTF-8"); ++ if (cd_utf8_to_88591 != (iconv_t)(-1)) ++ { ++ static ICONV_CONST char input[] = "\342\202\254"; /* EURO SIGN */ ++ char buf[10]; ++ ICONV_CONST char *inptr = input; ++ size_t inbytesleft = strlen (input); ++ char *outptr = buf; ++ size_t outbytesleft = sizeof (buf); ++ size_t res = iconv (cd_utf8_to_88591, ++ &inptr, &inbytesleft, ++ &outptr, &outbytesleft); ++ if (res == 0) ++ result |= 1; ++ iconv_close (cd_utf8_to_88591); ++ } ++ } ++ /* Test against macOS 14.4 bug: Failures are not distinguishable from ++ successful returns. ++ POSIX:2018 says: "The iconv() function shall ... return the number of ++ non-identical conversions performed." ++ But here, the conversion always does transliteration (the suffixes ++ "//TRANSLIT" and "//IGNORE" have no effect, nor does iconvctl()) and ++ does not report when it does a non-identical conversion. */ ++ { ++ iconv_t cd_utf8_to_88591 = iconv_open ("ISO-8859-1", "UTF-8"); ++ if (cd_utf8_to_88591 != (iconv_t)(-1)) ++ { ++ static ICONV_CONST char input[] = "\305\202"; /* LATIN SMALL LETTER L WITH STROKE */ ++ char buf[10]; ++ ICONV_CONST char *inptr = input; ++ size_t inbytesleft = strlen (input); ++ char *outptr = buf; ++ size_t outbytesleft = sizeof (buf); ++ size_t res = iconv (cd_utf8_to_88591, ++ &inptr, &inbytesleft, ++ &outptr, &outbytesleft); ++ /* Here: ++ With glibc, GNU libiconv (including macOS up to 13): res == (size_t)-1, errno == EILSEQ. ++ With musl libc, NetBSD 10, Solaris 11: res == 1. ++ With macOS 14.4: res == 0, output is "l". */ ++ if (res == 0) ++ result |= 2; ++ iconv_close (cd_utf8_to_88591); ++ } ++ } ++ /* Test against Solaris 10 bug: Failures are not distinguishable from ++ successful returns. */ ++ { ++ iconv_t cd_ascii_to_88591 = iconv_open ("ISO8859-1", "646"); ++ if (cd_ascii_to_88591 != (iconv_t)(-1)) ++ { ++ static ICONV_CONST char input[] = "\263"; ++ char buf[10]; ++ ICONV_CONST char *inptr = input; ++ size_t inbytesleft = strlen (input); ++ char *outptr = buf; ++ size_t outbytesleft = sizeof (buf); ++ size_t res = iconv (cd_ascii_to_88591, ++ &inptr, &inbytesleft, ++ &outptr, &outbytesleft); ++ if (res == 0) ++ result |= 4; ++ iconv_close (cd_ascii_to_88591); ++ } ++ } ++ /* Test against AIX 6.1..7.1 bug: Buffer overrun. */ ++ { ++ iconv_t cd_88591_to_utf8 = iconv_open ("UTF-8", "ISO-8859-1"); ++ if (cd_88591_to_utf8 != (iconv_t)(-1)) ++ { ++ static ICONV_CONST char input[] = "\304"; ++ static char buf[2] = { (char)0xDE, (char)0xAD }; ++ ICONV_CONST char *inptr = input; ++ size_t inbytesleft = 1; ++ char *outptr = buf; ++ size_t outbytesleft = 1; ++ size_t res = iconv (cd_88591_to_utf8, ++ &inptr, &inbytesleft, ++ &outptr, &outbytesleft); ++ if (res != (size_t)(-1) || outptr - buf > 1 || buf[1] != (char)0xAD) ++ result |= 8; ++ iconv_close (cd_88591_to_utf8); ++ } ++ } ++#if 0 /* This bug could be worked around by the caller. */ ++ /* Test against HP-UX 11.11 bug: Positive return value instead of 0. */ ++ { ++ iconv_t cd_88591_to_utf8 = iconv_open ("utf8", "iso88591"); ++ if (cd_88591_to_utf8 != (iconv_t)(-1)) ++ { ++ static ICONV_CONST char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337"; ++ char buf[50]; ++ ICONV_CONST char *inptr = input; ++ size_t inbytesleft = strlen (input); ++ char *outptr = buf; ++ size_t outbytesleft = sizeof (buf); ++ size_t res = iconv (cd_88591_to_utf8, ++ &inptr, &inbytesleft, ++ &outptr, &outbytesleft); ++ if ((int)res > 0) ++ result |= 16; ++ iconv_close (cd_88591_to_utf8); ++ } ++ } ++#endif ++ /* Test against HP-UX 11.11 bug: No converter from EUC-JP to UTF-8 is ++ provided. */ ++ { ++ /* Try standardized names. */ ++ iconv_t cd1 = iconv_open ("UTF-8", "EUC-JP"); ++ /* Try IRIX, OSF/1 names. */ ++ iconv_t cd2 = iconv_open ("UTF-8", "eucJP"); ++ /* Try AIX names. */ ++ iconv_t cd3 = iconv_open ("UTF-8", "IBM-eucJP"); ++ /* Try HP-UX names. */ ++ iconv_t cd4 = iconv_open ("utf8", "eucJP"); ++ if (cd1 == (iconv_t)(-1) && cd2 == (iconv_t)(-1) ++ && cd3 == (iconv_t)(-1) && cd4 == (iconv_t)(-1)) ++ result |= 32; ++ if (cd1 != (iconv_t)(-1)) ++ iconv_close (cd1); ++ if (cd2 != (iconv_t)(-1)) ++ iconv_close (cd2); ++ if (cd3 != (iconv_t)(-1)) ++ iconv_close (cd3); ++ if (cd4 != (iconv_t)(-1)) ++ iconv_close (cd4); ++ } ++ return result; ++]])], ++ [am_cv_func_iconv_works=yes], , ++ [case "$host_os" in ++ aix* | hpux*) am_cv_func_iconv_works="guessing no" ;; ++ *) am_cv_func_iconv_works="guessing yes" ;; ++ esac]) ++ test "$am_cv_func_iconv_works" = no || break ++ done ++ LIBS="$gl_saved_LIBS" ++ ]) ++ case "$am_cv_func_iconv_works" in ++ *no) am_func_iconv=no am_cv_lib_iconv=no ;; ++ *) am_func_iconv=yes ;; ++ esac ++ else ++ am_func_iconv=no am_cv_lib_iconv=no ++ fi ++ if test "$am_func_iconv" = yes; then ++ AC_DEFINE([HAVE_ICONV], [1], ++ [Define if you have the iconv() function and it works.]) ++ fi ++ if test "$am_cv_lib_iconv" = yes; then ++ AC_MSG_CHECKING([how to link with libiconv]) ++ AC_MSG_RESULT([$LIBICONV]) ++ else ++ dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV ++ dnl either. ++ CPPFLAGS="$gl_saved_CPPFLAGS" ++ LIBICONV= ++ LTLIBICONV= ++ fi ++ AC_SUBST([LIBICONV]) ++ AC_SUBST([LTLIBICONV]) ++]) ++ ++dnl Define AM_ICONV using AC_DEFUN_ONCE, in order to avoid warnings like ++dnl "warning: AC_REQUIRE: `AM_ICONV' was expanded before it was required". ++AC_DEFUN_ONCE([AM_ICONV], ++[ ++ AM_ICONV_LINK ++ if test "$am_cv_func_iconv" = yes; then ++ AC_CACHE_CHECK([whether iconv is compatible with its POSIX signature], ++ [gl_cv_iconv_nonconst], ++ [AC_COMPILE_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#include ++extern ++#ifdef __cplusplus ++"C" ++#endif ++size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft); ++ ]], ++ [[]])], ++ [gl_cv_iconv_nonconst=yes], ++ [gl_cv_iconv_nonconst=no]) ++ ]) ++ else ++ dnl When compiling GNU libiconv on a system that does not have iconv yet, ++ dnl pick the POSIX compliant declaration without 'const'. ++ gl_cv_iconv_nonconst=yes ++ fi ++ if test $gl_cv_iconv_nonconst = yes; then ++ iconv_arg1="" ++ else ++ iconv_arg1="const" ++ fi ++ AC_DEFINE_UNQUOTED([ICONV_CONST], [$iconv_arg1], ++ [Define as const if the declaration of iconv() needs const.]) ++ dnl Also substitute ICONV_CONST in the gnulib generated . ++ m4_ifdef([gl_ICONV_H_DEFAULTS], ++ [AC_REQUIRE([gl_ICONV_H_DEFAULTS]) ++ if test $gl_cv_iconv_nonconst != yes; then ++ ICONV_CONST="const" ++ fi ++ ]) ++ ++ dnl A summary result, for those packages which want to print a summary at the ++ dnl end of the configuration. ++ if test "$am_func_iconv" = yes; then ++ if test -n "$LIBICONV"; then ++ am_cv_func_iconv_summary='yes, in libiconv' ++ else ++ am_cv_func_iconv_summary='yes, in libc' ++ fi ++ else ++ if test "$am_cv_func_iconv" = yes; then ++ am_cv_func_iconv_summary='not working, consider installing GNU libiconv' ++ else ++ am_cv_func_iconv_summary='no, consider installing GNU libiconv' ++ fi ++ fi ++]) +diff --git a/m4/intlmacosx.m4 b/m4/intlmacosx.m4 +new file mode 100644 +index 000000000..f0920d0ff +--- /dev/null ++++ b/m4/intlmacosx.m4 +@@ -0,0 +1,71 @@ ++# intlmacosx.m4 ++# serial 10 (gettext-0.23) ++dnl Copyright (C) 2004-2014, 2016, 2019-2025 Free Software Foundation, Inc. ++dnl This file is free software; the Free Software Foundation ++dnl gives unlimited permission to copy and/or distribute it, ++dnl with or without modifications, as long as this notice is preserved. ++dnl This file is offered as-is, without any warranty. ++dnl ++dnl This file can be used in projects which are not available under ++dnl the GNU General Public License or the GNU Lesser General Public ++dnl License but which still want to provide support for the GNU gettext ++dnl functionality. ++dnl Please note that the actual code of the GNU gettext library is covered ++dnl by the GNU Lesser General Public License, and the rest of the GNU ++dnl gettext package is covered by the GNU General Public License. ++dnl They are *not* in the public domain. ++ ++dnl Checks for special options needed on Mac OS X. ++dnl Defines INTL_MACOSX_LIBS. ++AC_DEFUN([gt_INTL_MACOSX], ++[ ++ dnl Check for API introduced in Mac OS X 10.4. ++ AC_CACHE_CHECK([for CFPreferencesCopyAppValue], ++ [gt_cv_func_CFPreferencesCopyAppValue], ++ [gt_saved_LIBS="$LIBS" ++ LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" ++ AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[#include ]], ++ [[CFPreferencesCopyAppValue(NULL, NULL)]])], ++ [gt_cv_func_CFPreferencesCopyAppValue=yes], ++ [gt_cv_func_CFPreferencesCopyAppValue=no]) ++ LIBS="$gt_saved_LIBS"]) ++ if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then ++ AC_DEFINE([HAVE_CFPREFERENCESCOPYAPPVALUE], [1], ++ [Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in the CoreFoundation framework.]) ++ fi ++ dnl Don't check for the API introduced in Mac OS X 10.5, CFLocaleCopyCurrent, ++ dnl because in macOS 10.13.4 it has the following behaviour: ++ dnl When two or more languages are specified in the ++ dnl "System Preferences > Language & Region > Preferred Languages" panel, ++ dnl it returns en_CC where CC is the territory (even when English is not among ++ dnl the preferred languages!). What we want instead is what ++ dnl CFLocaleCopyCurrent returned in earlier macOS releases and what ++ dnl CFPreferencesCopyAppValue still returns, namely ll_CC where ll is the ++ dnl first among the preferred languages and CC is the territory. ++ AC_CACHE_CHECK([for CFLocaleCopyPreferredLanguages], [gt_cv_func_CFLocaleCopyPreferredLanguages], ++ [gt_saved_LIBS="$LIBS" ++ LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" ++ AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[#include ]], ++ [[CFLocaleCopyPreferredLanguages();]])], ++ [gt_cv_func_CFLocaleCopyPreferredLanguages=yes], ++ [gt_cv_func_CFLocaleCopyPreferredLanguages=no]) ++ LIBS="$gt_saved_LIBS"]) ++ if test $gt_cv_func_CFLocaleCopyPreferredLanguages = yes; then ++ AC_DEFINE([HAVE_CFLOCALECOPYPREFERREDLANGUAGES], [1], ++ [Define to 1 if you have the Mac OS X function CFLocaleCopyPreferredLanguages in the CoreFoundation framework.]) ++ fi ++ INTL_MACOSX_LIBS= ++ if test $gt_cv_func_CFPreferencesCopyAppValue = yes \ ++ || test $gt_cv_func_CFLocaleCopyPreferredLanguages = yes; then ++ dnl Starting with macOS version 14, CoreFoundation relies on CoreServices, ++ dnl and we have to link it in explicitly, otherwise an exception ++ dnl NSInvalidArgumentException "unrecognized selector sent to instance" ++ dnl occurs. ++ INTL_MACOSX_LIBS="-Wl,-framework -Wl,CoreFoundation -Wl,-framework -Wl,CoreServices" ++ fi ++ AC_SUBST([INTL_MACOSX_LIBS]) ++]) +diff --git a/m4/lib-ld.m4 b/m4/lib-ld.m4 +new file mode 100644 +index 000000000..3714b9ce7 +--- /dev/null ++++ b/m4/lib-ld.m4 +@@ -0,0 +1,170 @@ ++# lib-ld.m4 ++# serial 13 ++dnl Copyright (C) 1996-2003, 2009-2025 Free Software Foundation, Inc. ++dnl This file is free software; the Free Software Foundation ++dnl gives unlimited permission to copy and/or distribute it, ++dnl with or without modifications, as long as this notice is preserved. ++dnl This file is offered as-is, without any warranty. ++ ++dnl Subroutines of libtool.m4, ++dnl with replacements s/_*LT_PATH/AC_LIB_PROG/ and s/lt_/acl_/ to avoid ++dnl collision with libtool.m4. ++ ++dnl From libtool-2.4. Sets the variable with_gnu_ld to yes or no. ++AC_DEFUN([AC_LIB_PROG_LD_GNU], ++[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], [acl_cv_prog_gnu_ld], ++[# I'd rather use --version here, but apparently some GNU lds only accept -v. ++case `$LD -v 2>&1 /dev/null 2>&1 \ ++ && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \ ++ || PATH_SEPARATOR=';' ++ } ++fi ++ ++if test -n "$LD"; then ++ AC_MSG_CHECKING([for ld]) ++elif test "$GCC" = yes; then ++ AC_MSG_CHECKING([for ld used by $CC]) ++elif test "$with_gnu_ld" = yes; then ++ AC_MSG_CHECKING([for GNU ld]) ++else ++ AC_MSG_CHECKING([for non-GNU ld]) ++fi ++if test -n "$LD"; then ++ # Let the user override the test with a path. ++ : ++else ++ AC_CACHE_VAL([acl_cv_path_LD], ++ [ ++ acl_cv_path_LD= # Final result of this test ++ ac_prog=ld # Program to search in $PATH ++ if test "$GCC" = yes; then ++ # Check if gcc -print-prog-name=ld gives a path. ++ case $host in ++ *-*-mingw* | windows*) ++ # gcc leaves a trailing carriage return which upsets mingw ++ acl_output=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; ++ *) ++ acl_output=`($CC -print-prog-name=ld) 2>&5` ;; ++ esac ++ case $acl_output in ++ # Accept absolute paths. ++ [[\\/]]* | ?:[[\\/]]*) ++ re_direlt='/[[^/]][[^/]]*/\.\./' ++ # Canonicalize the pathname of ld ++ acl_output=`echo "$acl_output" | sed 's%\\\\%/%g'` ++ while echo "$acl_output" | grep "$re_direlt" > /dev/null 2>&1; do ++ acl_output=`echo $acl_output | sed "s%$re_direlt%/%"` ++ done ++ # Got the pathname. No search in PATH is needed. ++ acl_cv_path_LD="$acl_output" ++ ac_prog= ++ ;; ++ "") ++ # If it fails, then pretend we aren't using GCC. ++ ;; ++ *) ++ # If it is relative, then search for the first ld in PATH. ++ with_gnu_ld=unknown ++ ;; ++ esac ++ fi ++ if test -n "$ac_prog"; then ++ # Search for $ac_prog in $PATH. ++ acl_saved_IFS="$IFS"; IFS=$PATH_SEPARATOR ++ for ac_dir in $PATH; do ++ IFS="$acl_saved_IFS" ++ test -z "$ac_dir" && ac_dir=. ++ if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then ++ acl_cv_path_LD="$ac_dir/$ac_prog" ++ # Check to see if the program is GNU ld. I'd rather use --version, ++ # but apparently some variants of GNU ld only accept -v. ++ # Break only if it was the GNU/non-GNU ld that we prefer. ++ case `"$acl_cv_path_LD" -v 2>&1 conftest.sh ++ . ./conftest.sh ++ rm -f ./conftest.sh ++ acl_cv_rpath=done ++ ]) ++ wl="$acl_cv_wl" ++ acl_libext="$acl_cv_libext" ++ acl_shlibext="$acl_cv_shlibext" ++ acl_libname_spec="$acl_cv_libname_spec" ++ acl_library_names_spec="$acl_cv_library_names_spec" ++ acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec" ++ acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator" ++ acl_hardcode_direct="$acl_cv_hardcode_direct" ++ acl_hardcode_minus_L="$acl_cv_hardcode_minus_L" ++ dnl Determine whether the user wants rpath handling at all. ++ AC_ARG_ENABLE([rpath], ++ [ --disable-rpath do not hardcode runtime library paths], ++ :, enable_rpath=yes) ++]) ++ ++dnl AC_LIB_FROMPACKAGE(name, package) ++dnl declares that libname comes from the given package. The configure file ++dnl will then not have a --with-libname-prefix option but a ++dnl --with-package-prefix option. Several libraries can come from the same ++dnl package. This declaration must occur before an AC_LIB_LINKFLAGS or similar ++dnl macro call that searches for libname. ++AC_DEFUN([AC_LIB_FROMPACKAGE], ++[ ++ pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ define([acl_frompackage_]NAME, [$2]) ++ popdef([NAME]) ++ pushdef([PACK],[$2]) ++ pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ define([acl_libsinpackage_]PACKUP, ++ m4_ifdef([acl_libsinpackage_]PACKUP, [m4_defn([acl_libsinpackage_]PACKUP)[[, ]]],)[lib$1]) ++ popdef([PACKUP]) ++ popdef([PACK]) ++]) ++ ++dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and ++dnl the libraries corresponding to explicit and implicit dependencies. ++dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables. ++dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found ++dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem. ++AC_DEFUN([AC_LIB_LINKFLAGS_BODY], ++[ ++ AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) ++ pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ pushdef([PACK],[m4_ifdef([acl_frompackage_]NAME, [acl_frompackage_]NAME, lib[$1])]) ++ pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ pushdef([PACKLIBS],[m4_ifdef([acl_frompackage_]NAME, [acl_libsinpackage_]PACKUP, lib[$1])]) ++ dnl By default, look in $includedir and $libdir. ++ use_additional=yes ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" ++ eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" ++ ]) ++ AC_ARG_WITH(PACK[-prefix], ++[[ --with-]]PACK[[-prefix[=DIR] search for ]]PACKLIBS[[ in DIR/include and DIR/lib ++ --without-]]PACK[[-prefix don't search for ]]PACKLIBS[[ in includedir and libdir]], ++[ ++ if test "X$withval" = "Xno"; then ++ use_additional=no ++ else ++ if test "X$withval" = "X"; then ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" ++ eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" ++ ]) ++ else ++ additional_includedir="$withval/include" ++ additional_libdir="$withval/$acl_libdirstem" ++ additional_libdir2="$withval/$acl_libdirstem2" ++ additional_libdir3="$withval/$acl_libdirstem3" ++ fi ++ fi ++]) ++ if test "X$additional_libdir2" = "X$additional_libdir"; then ++ additional_libdir2= ++ fi ++ if test "X$additional_libdir3" = "X$additional_libdir"; then ++ additional_libdir3= ++ fi ++ dnl Search the library and its dependencies in $additional_libdir and ++ dnl $LDFLAGS. Use breadth-first search. ++ LIB[]NAME= ++ LTLIB[]NAME= ++ INC[]NAME= ++ LIB[]NAME[]_PREFIX= ++ dnl HAVE_LIB${NAME} is an indicator that LIB${NAME}, LTLIB${NAME} have been ++ dnl computed. So it has to be reset here. ++ HAVE_LIB[]NAME= ++ rpathdirs= ++ ltrpathdirs= ++ names_already_handled= ++ names_next_round='$1 $2' ++ while test -n "$names_next_round"; do ++ names_this_round="$names_next_round" ++ names_next_round= ++ for name in $names_this_round; do ++ already_handled= ++ for n in $names_already_handled; do ++ if test "$n" = "$name"; then ++ already_handled=yes ++ break ++ fi ++ done ++ if test -z "$already_handled"; then ++ names_already_handled="$names_already_handled $name" ++ dnl See if it was already located by an earlier AC_LIB_LINKFLAGS ++ dnl or AC_LIB_HAVE_LINKFLAGS call. ++ uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./+-|ABCDEFGHIJKLMNOPQRSTUVWXYZ____|'` ++ eval value=\"\$HAVE_LIB$uppername\" ++ if test -n "$value"; then ++ if test "$value" = yes; then ++ eval value=\"\$LIB$uppername\" ++ test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value" ++ eval value=\"\$LTLIB$uppername\" ++ test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value" ++ else ++ dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined ++ dnl that this library doesn't exist. So just drop it. ++ : ++ fi ++ else ++ dnl Search the library lib$name in $additional_libdir and $LDFLAGS ++ dnl and the already constructed $LIBNAME/$LTLIBNAME. ++ found_dir= ++ found_la= ++ found_so= ++ found_a= ++ eval libname=\"$acl_libname_spec\" # typically: libname=lib$name ++ if test -n "$acl_shlibext"; then ++ shrext=".$acl_shlibext" # typically: shrext=.so ++ else ++ shrext= ++ fi ++ if test $use_additional = yes; then ++ for additional_libdir_variable in additional_libdir additional_libdir2 additional_libdir3; do ++ if test "X$found_dir" = "X"; then ++ eval dir=\$$additional_libdir_variable ++ if test -n "$dir"; then ++ dnl The same code as in the loop below: ++ dnl First look for a shared library. ++ if test -n "$acl_shlibext"; then ++ if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then ++ found_dir="$dir" ++ found_so="$dir/$libname$shrext" ++ else ++ if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then ++ ver=`(cd "$dir" && \ ++ for f in "$libname$shrext".*; do echo "$f"; done \ ++ | sed -e "s,^$libname$shrext\\\\.,," \ ++ | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ ++ | sed 1q ) 2>/dev/null` ++ if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then ++ found_dir="$dir" ++ found_so="$dir/$libname$shrext.$ver" ++ fi ++ else ++ eval library_names=\"$acl_library_names_spec\" ++ for f in $library_names; do ++ if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then ++ found_dir="$dir" ++ found_so="$dir/$f" ++ break ++ fi ++ done ++ fi ++ fi ++ fi ++ dnl Then look for a static library. ++ if test "X$found_dir" = "X"; then ++ if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then ++ found_dir="$dir" ++ found_a="$dir/$libname.$acl_libext" ++ fi ++ fi ++ if test "X$found_dir" != "X"; then ++ if test -f "$dir/$libname.la"; then ++ found_la="$dir/$libname.la" ++ fi ++ fi ++ fi ++ fi ++ done ++ fi ++ if test "X$found_dir" = "X"; then ++ for x in $LDFLAGS $LTLIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ case "$x" in ++ -L*) ++ dir=`echo "X$x" | sed -e 's/^X-L//'` ++ dnl First look for a shared library. ++ if test -n "$acl_shlibext"; then ++ if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then ++ found_dir="$dir" ++ found_so="$dir/$libname$shrext" ++ else ++ if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then ++ ver=`(cd "$dir" && \ ++ for f in "$libname$shrext".*; do echo "$f"; done \ ++ | sed -e "s,^$libname$shrext\\\\.,," \ ++ | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ ++ | sed 1q ) 2>/dev/null` ++ if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then ++ found_dir="$dir" ++ found_so="$dir/$libname$shrext.$ver" ++ fi ++ else ++ eval library_names=\"$acl_library_names_spec\" ++ for f in $library_names; do ++ if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then ++ found_dir="$dir" ++ found_so="$dir/$f" ++ break ++ fi ++ done ++ fi ++ fi ++ fi ++ dnl Then look for a static library. ++ if test "X$found_dir" = "X"; then ++ if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then ++ found_dir="$dir" ++ found_a="$dir/$libname.$acl_libext" ++ fi ++ fi ++ if test "X$found_dir" != "X"; then ++ if test -f "$dir/$libname.la"; then ++ found_la="$dir/$libname.la" ++ fi ++ fi ++ ;; ++ esac ++ if test "X$found_dir" != "X"; then ++ break ++ fi ++ done ++ fi ++ if test "X$found_dir" != "X"; then ++ dnl Found the library. ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name" ++ if test "X$found_so" != "X"; then ++ dnl Linking with a shared library. We attempt to hardcode its ++ dnl directory into the executable's runpath, unless it's the ++ dnl standard /usr/lib. ++ if test "$enable_rpath" = no \ ++ || test "X$found_dir" = "X/usr/$acl_libdirstem" \ ++ || test "X$found_dir" = "X/usr/$acl_libdirstem2" \ ++ || test "X$found_dir" = "X/usr/$acl_libdirstem3"; then ++ dnl No hardcoding is needed. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ else ++ dnl Use an explicit option to hardcode DIR into the resulting ++ dnl binary. ++ dnl Potentially add DIR to ltrpathdirs. ++ dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. ++ haveit= ++ for x in $ltrpathdirs; do ++ if test "X$x" = "X$found_dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ ltrpathdirs="$ltrpathdirs $found_dir" ++ fi ++ dnl The hardcoding into $LIBNAME is system dependent. ++ if test "$acl_hardcode_direct" = yes; then ++ dnl Using DIR/libNAME.so during linking hardcodes DIR into the ++ dnl resulting binary. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ else ++ if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then ++ dnl Use an explicit option to hardcode DIR into the resulting ++ dnl binary. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ dnl Potentially add DIR to rpathdirs. ++ dnl The rpathdirs will be appended to $LIBNAME at the end. ++ haveit= ++ for x in $rpathdirs; do ++ if test "X$x" = "X$found_dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ rpathdirs="$rpathdirs $found_dir" ++ fi ++ else ++ dnl Rely on "-L$found_dir". ++ dnl But don't add it if it's already contained in the LDFLAGS ++ dnl or the already constructed $LIBNAME ++ haveit= ++ for x in $LDFLAGS $LIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$found_dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir" ++ fi ++ if test "$acl_hardcode_minus_L" != no; then ++ dnl FIXME: Not sure whether we should use ++ dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" ++ dnl here. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ else ++ dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH ++ dnl here, because this doesn't fit in flags passed to the ++ dnl compiler. So give up. No hardcoding. This affects only ++ dnl very old systems. ++ dnl FIXME: Not sure whether we should use ++ dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" ++ dnl here. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" ++ fi ++ fi ++ fi ++ fi ++ else ++ if test "X$found_a" != "X"; then ++ dnl Linking with a static library. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a" ++ else ++ dnl We shouldn't come here, but anyway it's good to have a ++ dnl fallback. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name" ++ fi ++ fi ++ dnl Assume the include files are nearby. ++ additional_includedir= ++ case "$found_dir" in ++ */$acl_libdirstem | */$acl_libdirstem/) ++ basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'` ++ if test "$name" = '$1'; then ++ LIB[]NAME[]_PREFIX="$basedir" ++ fi ++ additional_includedir="$basedir/include" ++ ;; ++ */$acl_libdirstem2 | */$acl_libdirstem2/) ++ basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem2/"'*$,,'` ++ if test "$name" = '$1'; then ++ LIB[]NAME[]_PREFIX="$basedir" ++ fi ++ additional_includedir="$basedir/include" ++ ;; ++ */$acl_libdirstem3 | */$acl_libdirstem3/) ++ basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem3/"'*$,,'` ++ if test "$name" = '$1'; then ++ LIB[]NAME[]_PREFIX="$basedir" ++ fi ++ additional_includedir="$basedir/include" ++ ;; ++ esac ++ if test "X$additional_includedir" != "X"; then ++ dnl Potentially add $additional_includedir to $INCNAME. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/include, ++ dnl 2. if it's /usr/local/include and we are using GCC on Linux, ++ dnl 3. if it's already present in $CPPFLAGS or the already ++ dnl constructed $INCNAME, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_includedir" != "X/usr/include"; then ++ haveit= ++ if test "X$additional_includedir" = "X/usr/local/include"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux* | gnu* | k*bsd*-gnu) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ for x in $CPPFLAGS $INC[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-I$additional_includedir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test -d "$additional_includedir"; then ++ dnl Really add $additional_includedir to $INCNAME. ++ INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir" ++ fi ++ fi ++ fi ++ fi ++ fi ++ dnl Look for dependencies. ++ if test -n "$found_la"; then ++ dnl Read the .la file. It defines the variables ++ dnl dlname, library_names, old_library, dependency_libs, current, ++ dnl age, revision, installed, dlopen, dlpreopen, libdir. ++ saved_libdir="$libdir" ++ case "$found_la" in ++ */* | *\\*) . "$found_la" ;; ++ *) . "./$found_la" ;; ++ esac ++ libdir="$saved_libdir" ++ dnl We use only dependency_libs. ++ for dep in $dependency_libs; do ++ case "$dep" in ++ -L*) ++ dependency_libdir=`echo "X$dep" | sed -e 's/^X-L//'` ++ dnl Potentially add $dependency_libdir to $LIBNAME and $LTLIBNAME. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/lib, ++ dnl 2. if it's /usr/local/lib and we are using GCC on Linux, ++ dnl 3. if it's already present in $LDFLAGS or the already ++ dnl constructed $LIBNAME, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$dependency_libdir" != "X/usr/$acl_libdirstem" \ ++ && test "X$dependency_libdir" != "X/usr/$acl_libdirstem2" \ ++ && test "X$dependency_libdir" != "X/usr/$acl_libdirstem3"; then ++ haveit= ++ if test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem" \ ++ || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem2" \ ++ || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem3"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux* | gnu* | k*bsd*-gnu) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ haveit= ++ for x in $LDFLAGS $LIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$dependency_libdir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test -d "$dependency_libdir"; then ++ dnl Really add $dependency_libdir to $LIBNAME. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$dependency_libdir" ++ fi ++ fi ++ haveit= ++ for x in $LDFLAGS $LTLIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$dependency_libdir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test -d "$dependency_libdir"; then ++ dnl Really add $dependency_libdir to $LTLIBNAME. ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$dependency_libdir" ++ fi ++ fi ++ fi ++ fi ++ ;; ++ -R*) ++ dir=`echo "X$dep" | sed -e 's/^X-R//'` ++ if test "$enable_rpath" != no; then ++ dnl Potentially add DIR to rpathdirs. ++ dnl The rpathdirs will be appended to $LIBNAME at the end. ++ haveit= ++ for x in $rpathdirs; do ++ if test "X$x" = "X$dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ rpathdirs="$rpathdirs $dir" ++ fi ++ dnl Potentially add DIR to ltrpathdirs. ++ dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. ++ haveit= ++ for x in $ltrpathdirs; do ++ if test "X$x" = "X$dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ ltrpathdirs="$ltrpathdirs $dir" ++ fi ++ fi ++ ;; ++ -l*) ++ dnl Handle this in the next round. ++ dnl But on GNU systems, ignore -lc options, because ++ dnl - linking with libc is the default anyway, ++ dnl - linking with libc.a may produce an error ++ dnl "/usr/bin/ld: dynamic STT_GNU_IFUNC symbol `strcmp' with pointer equality in `/usr/lib/libc.a(strcmp.o)' can not be used when making an executable; recompile with -fPIE and relink with -pie" ++ dnl or may produce an executable that always crashes, see ++ dnl . ++ dep=`echo "X$dep" | sed -e 's/^X-l//'` ++ if test "X$dep" != Xc \ ++ || case $host_os in ++ linux* | gnu* | k*bsd*-gnu) false ;; ++ *) true ;; ++ esac; then ++ names_next_round="$names_next_round $dep" ++ fi ++ ;; ++ *.la) ++ dnl Handle this in the next round. Throw away the .la's ++ dnl directory; it is already contained in a preceding -L ++ dnl option. ++ names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'` ++ ;; ++ *) ++ dnl Most likely an immediate library name. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep" ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep" ++ ;; ++ esac ++ done ++ fi ++ else ++ dnl Didn't find the library; assume it is in the system directories ++ dnl known to the linker and runtime loader. (All the system ++ dnl directories known to the linker should also be known to the ++ dnl runtime loader, otherwise the system is severely misconfigured.) ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name" ++ fi ++ fi ++ fi ++ done ++ done ++ if test "X$rpathdirs" != "X"; then ++ if test -n "$acl_hardcode_libdir_separator"; then ++ dnl Weird platform: only the last -rpath option counts, the user must ++ dnl pass all path elements in one option. We can arrange that for a ++ dnl single library, but not when more than one $LIBNAMEs are used. ++ alldirs= ++ for found_dir in $rpathdirs; do ++ alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir" ++ done ++ dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl. ++ acl_saved_libdir="$libdir" ++ libdir="$alldirs" ++ eval flag=\"$acl_hardcode_libdir_flag_spec\" ++ libdir="$acl_saved_libdir" ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" ++ else ++ dnl The -rpath options are cumulative. ++ for found_dir in $rpathdirs; do ++ acl_saved_libdir="$libdir" ++ libdir="$found_dir" ++ eval flag=\"$acl_hardcode_libdir_flag_spec\" ++ libdir="$acl_saved_libdir" ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" ++ done ++ fi ++ fi ++ if test "X$ltrpathdirs" != "X"; then ++ dnl When using libtool, the option that works for both libraries and ++ dnl executables is -R. The -R options are cumulative. ++ for found_dir in $ltrpathdirs; do ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir" ++ done ++ fi ++ popdef([PACKLIBS]) ++ popdef([PACKUP]) ++ popdef([PACK]) ++ popdef([NAME]) ++]) ++ ++dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR, ++dnl unless already present in VAR. ++dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes ++dnl contains two or three consecutive elements that belong together. ++AC_DEFUN([AC_LIB_APPENDTOVAR], ++[ ++ for element in [$2]; do ++ haveit= ++ for x in $[$1]; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X$element"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ [$1]="${[$1]}${[$1]:+ }$element" ++ fi ++ done ++]) ++ ++dnl For those cases where a variable contains several -L and -l options ++dnl referring to unknown libraries and directories, this macro determines the ++dnl necessary additional linker options for the runtime path. ++dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL]) ++dnl sets LDADDVAR to linker options needed together with LIBSVALUE. ++dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed, ++dnl otherwise linking without libtool is assumed. ++AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS], ++[ ++ AC_REQUIRE([AC_LIB_RPATH]) ++ AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) ++ $1= ++ if test "$enable_rpath" != no; then ++ if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then ++ dnl Use an explicit option to hardcode directories into the resulting ++ dnl binary. ++ rpathdirs= ++ next= ++ for opt in $2; do ++ if test -n "$next"; then ++ dir="$next" ++ dnl No need to hardcode the standard /usr/lib. ++ if test "X$dir" != "X/usr/$acl_libdirstem" \ ++ && test "X$dir" != "X/usr/$acl_libdirstem2" \ ++ && test "X$dir" != "X/usr/$acl_libdirstem3"; then ++ rpathdirs="$rpathdirs $dir" ++ fi ++ next= ++ else ++ case $opt in ++ -L) next=yes ;; ++ -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'` ++ dnl No need to hardcode the standard /usr/lib. ++ if test "X$dir" != "X/usr/$acl_libdirstem" \ ++ && test "X$dir" != "X/usr/$acl_libdirstem2" \ ++ && test "X$dir" != "X/usr/$acl_libdirstem3"; then ++ rpathdirs="$rpathdirs $dir" ++ fi ++ next= ;; ++ *) next= ;; ++ esac ++ fi ++ done ++ if test "X$rpathdirs" != "X"; then ++ if test -n ""$3""; then ++ dnl libtool is used for linking. Use -R options. ++ for dir in $rpathdirs; do ++ $1="${$1}${$1:+ }-R$dir" ++ done ++ else ++ dnl The linker is used for linking directly. ++ if test -n "$acl_hardcode_libdir_separator"; then ++ dnl Weird platform: only the last -rpath option counts, the user ++ dnl must pass all path elements in one option. ++ alldirs= ++ for dir in $rpathdirs; do ++ alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir" ++ done ++ acl_saved_libdir="$libdir" ++ libdir="$alldirs" ++ eval flag=\"$acl_hardcode_libdir_flag_spec\" ++ libdir="$acl_saved_libdir" ++ $1="$flag" ++ else ++ dnl The -rpath options are cumulative. ++ for dir in $rpathdirs; do ++ acl_saved_libdir="$libdir" ++ libdir="$dir" ++ eval flag=\"$acl_hardcode_libdir_flag_spec\" ++ libdir="$acl_saved_libdir" ++ $1="${$1}${$1:+ }$flag" ++ done ++ fi ++ fi ++ fi ++ fi ++ fi ++ AC_SUBST([$1]) ++]) +diff --git a/m4/lib-prefix.m4 b/m4/lib-prefix.m4 +new file mode 100644 +index 000000000..29283534f +--- /dev/null ++++ b/m4/lib-prefix.m4 +@@ -0,0 +1,334 @@ ++# lib-prefix.m4 ++# serial 23 ++dnl Copyright (C) 2001-2005, 2008-2025 Free Software Foundation, Inc. ++dnl This file is free software; the Free Software Foundation ++dnl gives unlimited permission to copy and/or distribute it, ++dnl with or without modifications, as long as this notice is preserved. ++dnl This file is offered as-is, without any warranty. ++ ++dnl From Bruno Haible. ++ ++dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed ++dnl to access previously installed libraries. The basic assumption is that ++dnl a user will want packages to use other packages he previously installed ++dnl with the same --prefix option. ++dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate ++dnl libraries, but is otherwise very convenient. ++AC_DEFUN([AC_LIB_PREFIX], ++[ ++ AC_BEFORE([$0], [AC_LIB_LINKFLAGS]) ++ AC_REQUIRE([AC_PROG_CC]) ++ AC_REQUIRE([AC_CANONICAL_HOST]) ++ AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ dnl By default, look in $includedir and $libdir. ++ use_additional=yes ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ AC_ARG_WITH([lib-prefix], ++[[ --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib ++ --without-lib-prefix don't search for libraries in includedir and libdir]], ++[ ++ if test "X$withval" = "Xno"; then ++ use_additional=no ++ else ++ if test "X$withval" = "X"; then ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ else ++ additional_includedir="$withval/include" ++ additional_libdir="$withval/$acl_libdirstem" ++ fi ++ fi ++]) ++ if test $use_additional = yes; then ++ dnl Potentially add $additional_includedir to $CPPFLAGS. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/include, ++ dnl 2. if it's already present in $CPPFLAGS, ++ dnl 3. if it's /usr/local/include and we are using GCC on Linux, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_includedir" != "X/usr/include"; then ++ haveit= ++ for x in $CPPFLAGS; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-I$additional_includedir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test "X$additional_includedir" = "X/usr/local/include"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux* | gnu* | k*bsd*-gnu) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ if test -d "$additional_includedir"; then ++ dnl Really add $additional_includedir to $CPPFLAGS. ++ CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir" ++ fi ++ fi ++ fi ++ fi ++ dnl Potentially add $additional_libdir to $LDFLAGS. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/lib, ++ dnl 2. if it's already present in $LDFLAGS, ++ dnl 3. if it's /usr/local/lib and we are using GCC on Linux, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then ++ haveit= ++ for x in $LDFLAGS; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$additional_libdir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux*) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ if test -d "$additional_libdir"; then ++ dnl Really add $additional_libdir to $LDFLAGS. ++ LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir" ++ fi ++ fi ++ fi ++ fi ++ fi ++]) ++ ++dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix, ++dnl acl_final_exec_prefix, containing the values to which $prefix and ++dnl $exec_prefix will expand at the end of the configure script. ++AC_DEFUN([AC_LIB_PREPARE_PREFIX], ++[ ++ dnl Unfortunately, prefix and exec_prefix get only finally determined ++ dnl at the end of configure. ++ if test "X$prefix" = "XNONE"; then ++ acl_final_prefix="$ac_default_prefix" ++ else ++ acl_final_prefix="$prefix" ++ fi ++ if test "X$exec_prefix" = "XNONE"; then ++ acl_final_exec_prefix='${prefix}' ++ else ++ acl_final_exec_prefix="$exec_prefix" ++ fi ++ acl_saved_prefix="$prefix" ++ prefix="$acl_final_prefix" ++ eval acl_final_exec_prefix=\"$acl_final_exec_prefix\" ++ prefix="$acl_saved_prefix" ++]) ++ ++dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the ++dnl variables prefix and exec_prefix bound to the values they will have ++dnl at the end of the configure script. ++AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX], ++[ ++ acl_saved_prefix="$prefix" ++ prefix="$acl_final_prefix" ++ acl_saved_exec_prefix="$exec_prefix" ++ exec_prefix="$acl_final_exec_prefix" ++ $1 ++ exec_prefix="$acl_saved_exec_prefix" ++ prefix="$acl_saved_prefix" ++]) ++ ++dnl AC_LIB_PREPARE_MULTILIB creates ++dnl - a function acl_is_expected_elfclass, that tests whether standard input ++dn; has a 32-bit or 64-bit ELF header, depending on the host CPU ABI, ++dnl - 3 variables acl_libdirstem, acl_libdirstem2, acl_libdirstem3, containing ++dnl the basename of the libdir to try in turn, either "lib" or "lib64" or ++dnl "lib/64" or "lib32" or "lib/sparcv9" or "lib/amd64" or similar. ++AC_DEFUN([AC_LIB_PREPARE_MULTILIB], ++[ ++ dnl There is no formal standard regarding lib, lib32, and lib64. ++ dnl On most glibc systems, the current practice is that on a system supporting ++ dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under ++ dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. However, on ++ dnl Arch Linux based distributions, it's the opposite: 32-bit libraries go ++ dnl under $prefix/lib32 and 64-bit libraries go under $prefix/lib. ++ dnl We determine the compiler's default mode by looking at the compiler's ++ dnl library search path. If at least one of its elements ends in /lib64 or ++ dnl points to a directory whose absolute pathname ends in /lib64, we use that ++ dnl for 64-bit ABIs. Similarly for 32-bit ABIs. Otherwise we use the default, ++ dnl namely "lib". ++ dnl On Solaris systems, the current practice is that on a system supporting ++ dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under ++ dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or ++ dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib. ++ AC_REQUIRE([AC_CANONICAL_HOST]) ++ AC_REQUIRE([gl_HOST_CPU_C_ABI_32BIT]) ++ ++ AC_CACHE_CHECK([for ELF binary format], [gl_cv_elf], ++ [AC_EGREP_CPP([Extensible Linking Format], ++ [#if defined __ELF__ || (defined __linux__ && (defined __EDG__ || defined __SUNPRO_C)) ++ Extensible Linking Format ++ #endif ++ ], ++ [gl_cv_elf=yes], ++ [gl_cv_elf=no]) ++ ]) ++ if test $gl_cv_elf = yes; then ++ # Extract the ELF class of a file (5th byte) in decimal. ++ # Cf. https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header ++ if od -A x < /dev/null >/dev/null 2>/dev/null; then ++ # Use POSIX od. ++ func_elfclass () ++ { ++ od -A n -t d1 -j 4 -N 1 ++ } ++ else ++ # Use BSD hexdump. ++ func_elfclass () ++ { ++ dd bs=1 count=1 skip=4 2>/dev/null | hexdump -e '1/1 "%3d "' ++ echo ++ } ++ fi ++ # Use 'expr', not 'test', to compare the values of func_elfclass, because on ++ # Solaris 11 OpenIndiana and Solaris 11 OmniOS, the result is 001 or 002, ++ # not 1 or 2. ++changequote(,)dnl ++ case $HOST_CPU_C_ABI_32BIT in ++ yes) ++ # 32-bit ABI. ++ acl_is_expected_elfclass () ++ { ++ expr "`func_elfclass | sed -e 's/[ ]//g'`" = 1 > /dev/null ++ } ++ ;; ++ no) ++ # 64-bit ABI. ++ acl_is_expected_elfclass () ++ { ++ expr "`func_elfclass | sed -e 's/[ ]//g'`" = 2 > /dev/null ++ } ++ ;; ++ *) ++ # Unknown. ++ acl_is_expected_elfclass () ++ { ++ : ++ } ++ ;; ++ esac ++changequote([,])dnl ++ else ++ acl_is_expected_elfclass () ++ { ++ : ++ } ++ fi ++ ++ dnl Allow the user to override the result by setting acl_cv_libdirstems. ++ AC_CACHE_CHECK([for the common suffixes of directories in the library search path], ++ [acl_cv_libdirstems], ++ [dnl Try 'lib' first, because that's the default for libdir in GNU, see ++ dnl . ++ acl_libdirstem=lib ++ acl_libdirstem2= ++ acl_libdirstem3= ++ case "$host_os" in ++ solaris*) ++ dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment ++ dnl . ++ dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link." ++ dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the ++ dnl symlink is missing, so we set acl_libdirstem2 too. ++ if test $HOST_CPU_C_ABI_32BIT = no; then ++ acl_libdirstem2=lib/64 ++ case "$host_cpu" in ++ sparc*) acl_libdirstem3=lib/sparcv9 ;; ++ i*86 | x86_64) acl_libdirstem3=lib/amd64 ;; ++ esac ++ fi ++ ;; ++ netbsd*) ++ dnl On NetBSD/sparc64, there is a 'sparc' subdirectory that contains ++ dnl 32-bit libraries. ++ if test $HOST_CPU_C_ABI_32BIT != no; then ++ case "$host_cpu" in ++ sparc*) acl_libdirstem2=lib/sparc ;; ++ esac ++ fi ++ ;; ++ *) ++ dnl If $CC generates code for a 32-bit ABI, the libraries are ++ dnl surely under $prefix/lib or $prefix/lib32, not $prefix/lib64. ++ dnl Similarly, if $CC generates code for a 64-bit ABI, the libraries ++ dnl are surely under $prefix/lib or $prefix/lib64, not $prefix/lib32. ++ dnl Find the compiler's search path. However, non-system compilers ++ dnl sometimes have odd library search paths. But we can't simply invoke ++ dnl '/usr/bin/gcc -print-search-dirs' because that would not take into ++ dnl account the -m32/-m31 or -m64 options from the $CC or $CFLAGS. ++ searchpath=`(LC_ALL=C $CC $CPPFLAGS $CFLAGS -print-search-dirs) 2>/dev/null \ ++ | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'` ++ if test $HOST_CPU_C_ABI_32BIT != no; then ++ # 32-bit or unknown ABI. ++ if test -d /usr/lib32; then ++ acl_libdirstem2=lib32 ++ fi ++ fi ++ if test $HOST_CPU_C_ABI_32BIT != yes; then ++ # 64-bit or unknown ABI. ++ if test -d /usr/lib64; then ++ acl_libdirstem3=lib64 ++ fi ++ fi ++ if test -n "$searchpath"; then ++ acl_saved_IFS="${IFS= }"; IFS=":" ++ for searchdir in $searchpath; do ++ if test -d "$searchdir"; then ++ case "$searchdir" in ++ */lib32/ | */lib32 ) acl_libdirstem2=lib32 ;; ++ */lib64/ | */lib64 ) acl_libdirstem3=lib64 ;; ++ */../ | */.. ) ++ # Better ignore directories of this form. They are misleading. ++ ;; ++ *) searchdir=`cd "$searchdir" && pwd` ++ case "$searchdir" in ++ */lib32 ) acl_libdirstem2=lib32 ;; ++ */lib64 ) acl_libdirstem3=lib64 ;; ++ esac ;; ++ esac ++ fi ++ done ++ IFS="$acl_saved_IFS" ++ if test $HOST_CPU_C_ABI_32BIT = yes; then ++ # 32-bit ABI. ++ acl_libdirstem3= ++ fi ++ if test $HOST_CPU_C_ABI_32BIT = no; then ++ # 64-bit ABI. ++ acl_libdirstem2= ++ fi ++ fi ++ ;; ++ esac ++ test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem" ++ test -n "$acl_libdirstem3" || acl_libdirstem3="$acl_libdirstem" ++ acl_cv_libdirstems="$acl_libdirstem,$acl_libdirstem2,$acl_libdirstem3" ++ ]) ++ dnl Decompose acl_cv_libdirstems into acl_libdirstem, acl_libdirstem2, and ++ dnl acl_libdirstem3. ++changequote(,)dnl ++ acl_libdirstem=`echo "$acl_cv_libdirstems" | sed -e 's/,.*//'` ++ acl_libdirstem2=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,//' -e 's/,.*//'` ++ acl_libdirstem3=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,[^,]*,//' -e 's/,.*//'` ++changequote([,])dnl ++]) +diff --git a/m4/nls.m4 b/m4/nls.m4 +new file mode 100644 +index 000000000..c4601415b +--- /dev/null ++++ b/m4/nls.m4 +@@ -0,0 +1,33 @@ ++# nls.m4 ++# serial 6 (gettext-0.24) ++dnl Copyright (C) 1995-2025 Free Software Foundation, Inc. ++dnl This file is free software; the Free Software Foundation ++dnl gives unlimited permission to copy and/or distribute it, ++dnl with or without modifications, as long as this notice is preserved. ++dnl This file is offered as-is, without any warranty. ++dnl ++dnl This file can be used in projects which are not available under ++dnl the GNU General Public License or the GNU Lesser General Public ++dnl License but which still want to provide support for the GNU gettext ++dnl functionality. ++dnl Please note that the actual code of the GNU gettext library is covered ++dnl by the GNU Lesser General Public License, and the rest of the GNU ++dnl gettext package is covered by the GNU General Public License. ++dnl They are *not* in the public domain. ++ ++dnl Authors: ++dnl Ulrich Drepper , 1995-2000. ++dnl Bruno Haible , 2000-2003. ++ ++AC_PREREQ([2.50]) ++ ++AC_DEFUN([AM_NLS], ++[ ++ AC_MSG_CHECKING([whether NLS is requested]) ++ dnl Default is enabled NLS ++ AC_ARG_ENABLE([nls], ++ [ --disable-nls do not use Native Language Support], ++ USE_NLS=$enableval, USE_NLS=yes) ++ AC_MSG_RESULT([$USE_NLS]) ++ AC_SUBST([USE_NLS]) ++]) +diff --git a/m4/po.m4 b/m4/po.m4 +new file mode 100644 +index 000000000..73e0436bd +--- /dev/null ++++ b/m4/po.m4 +@@ -0,0 +1,157 @@ ++# po.m4 ++# serial 34 (gettext-0.24) ++dnl Copyright (C) 1995-2024 Free Software Foundation, Inc. ++dnl This file is free software; the Free Software Foundation ++dnl gives unlimited permission to copy and/or distribute it, ++dnl with or without modifications, as long as this notice is preserved. ++dnl This file is offered as-is, without any warranty. ++dnl ++dnl This file can be used in projects which are not available under ++dnl the GNU General Public License or the GNU Lesser General Public ++dnl License but which still want to provide support for the GNU gettext ++dnl functionality. ++dnl Please note that the actual code of the GNU gettext library is covered ++dnl by the GNU Lesser General Public License, and the rest of the GNU ++dnl gettext package is covered by the GNU General Public License. ++dnl They are *not* in the public domain. ++ ++dnl Authors: ++dnl Ulrich Drepper , 1995-2000. ++dnl Bruno Haible , 2000-2024. ++ ++AC_PREREQ([2.60]) ++ ++dnl Checks for all prerequisites of the po subdirectory. ++AC_DEFUN([AM_PO_SUBDIRS], ++[ ++ AC_REQUIRE([AC_PROG_MAKE_SET])dnl ++ AC_REQUIRE([AC_PROG_INSTALL])dnl ++ AC_REQUIRE([AC_PROG_MKDIR_P])dnl ++ AC_REQUIRE([AC_PROG_SED])dnl ++ AC_REQUIRE([AM_NLS])dnl ++ ++ dnl Release version of the gettext macros. This is used to ensure that ++ dnl the gettext macros and po/Makefile.in.in are in sync. ++ AC_SUBST([GETTEXT_MACRO_VERSION], [0.24]) ++ ++ dnl Perform the following tests also if --disable-nls has been given, ++ dnl because they are needed for "make dist" to work. ++ ++ dnl Search for GNU msgfmt in the PATH. ++ dnl The first test excludes Solaris msgfmt and early GNU msgfmt versions. ++ dnl The second test excludes FreeBSD msgfmt. ++ AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt, ++ [$ac_dir/$ac_word --statistics /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 && ++ (if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], ++ :) ++ AC_PATH_PROG([GMSGFMT], [gmsgfmt], [$MSGFMT]) ++ ++ dnl Test whether it is GNU msgfmt >= 0.15. ++changequote(,)dnl ++ case `$GMSGFMT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in ++ '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) GMSGFMT_015=: ;; ++ *) GMSGFMT_015=$GMSGFMT ;; ++ esac ++changequote([,])dnl ++ AC_SUBST([GMSGFMT_015]) ++ ++ dnl Search for GNU xgettext 0.12 or newer in the PATH. ++ dnl The first test excludes Solaris xgettext and early GNU xgettext versions. ++ dnl The second test excludes FreeBSD xgettext. ++ AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext, ++ [$ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 && ++ (if $ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], ++ :) ++ dnl Remove leftover from FreeBSD xgettext call. ++ rm -f messages.po ++ ++ dnl Test whether it is GNU xgettext >= 0.15. ++changequote(,)dnl ++ case `$XGETTEXT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in ++ '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) XGETTEXT_015=: ;; ++ *) XGETTEXT_015=$XGETTEXT ;; ++ esac ++changequote([,])dnl ++ AC_SUBST([XGETTEXT_015]) ++ ++ dnl Search for GNU msgmerge 0.11 or newer in the PATH. ++ AM_PATH_PROG_WITH_TEST(MSGMERGE, msgmerge, ++ [$ac_dir/$ac_word --update -q /dev/null /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1], :) ++ ++ dnl Test whether it is GNU msgmerge >= 0.20. ++ if LC_ALL=C $MSGMERGE --help | grep ' --for-msgfmt ' >/dev/null; then ++ MSGMERGE_FOR_MSGFMT_OPTION='--for-msgfmt' ++ else ++ dnl Test whether it is GNU msgmerge >= 0.12. ++ if LC_ALL=C $MSGMERGE --help | grep ' --no-fuzzy-matching ' >/dev/null; then ++ MSGMERGE_FOR_MSGFMT_OPTION='--no-fuzzy-matching --no-location --quiet' ++ else ++ dnl With these old versions, $(MSGMERGE) $(MSGMERGE_FOR_MSGFMT_OPTION) is ++ dnl slow. But this is not a big problem, as such old gettext versions are ++ dnl hardly in use any more. ++ MSGMERGE_FOR_MSGFMT_OPTION='--no-location --quiet' ++ fi ++ fi ++ AC_SUBST([MSGMERGE_FOR_MSGFMT_OPTION]) ++ ++ dnl Support for AM_XGETTEXT_OPTION. ++ test -n "${XGETTEXT_EXTRA_OPTIONS+set}" || XGETTEXT_EXTRA_OPTIONS= ++ AC_SUBST([XGETTEXT_EXTRA_OPTIONS]) ++ ++ if test -n "$ALL_LINGUAS"; then ++ test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete" ++ fi ++ ++ dnl Capture the value of LINGUAS because we need it to compute CATALOGS. ++ dnl In the Makefile, call it DESIRED_LINGUAS (because there, LINGUAS denotes ++ dnl the set of available translations, given by the developer). ++ DESIRED_LINGUAS="${LINGUAS-\$(ALL_LINGUAS)}" ++ AC_SUBST([DESIRED_LINGUAS]) ++ ++ AC_CONFIG_COMMANDS([po-directories], [[ ++ for ac_file in $CONFIG_FILES; do ++ # Support "outfile[:infile[:infile...]]" ++ case "$ac_file" in ++ *:*) ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; ++ esac ++ # PO directories have a Makefile.in generated from Makefile.in.in. ++ case "$ac_file" in */Makefile.in) ++ # Adjust a relative srcdir. ++ ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'` ++ ac_dir_suffix=/`echo "$ac_dir"|sed 's%^\./%%'` ++ ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'` ++ # In autoconf-2.13 it is called $ac_given_srcdir. ++ # In autoconf-2.50 it is called $srcdir. ++ test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir" ++ # Treat a directory as a PO directory if and only if it has a ++ # POTFILES.in file. This allows packages to have multiple PO ++ # directories under different names or in different locations. ++ if test -f "$ac_given_srcdir/$ac_dir/POTFILES.in"; then ++ test -n "$as_me" && echo "$as_me: creating $ac_dir/Makefile" || echo "creating $ac_dir/Makefile" ++ cat "$ac_dir/Makefile.in" > "$ac_dir/Makefile" ++ fi ++ ;; ++ esac ++ done]], ++ []) ++]) ++ ++dnl Postprocesses a Makefile in a directory containing PO files. ++AC_DEFUN([AM_POSTPROCESS_PO_MAKEFILE], ++[ ++ sed -e 's,^#distdir:,distdir:,' < "$ac_file" > "$ac_file.tmp" ++ mv "$ac_file.tmp" "$ac_file" ++]) ++ ++dnl Initializes the accumulator used by AM_XGETTEXT_OPTION. ++AC_DEFUN([AM_XGETTEXT_OPTION_INIT], ++[ ++ XGETTEXT_EXTRA_OPTIONS= ++]) ++ ++dnl Registers an option to be passed to xgettext in the po subdirectory. ++AC_DEFUN([AM_XGETTEXT_OPTION], ++[ ++ AC_REQUIRE([AM_XGETTEXT_OPTION_INIT]) ++ XGETTEXT_EXTRA_OPTIONS="$XGETTEXT_EXTRA_OPTIONS $1" ++]) +diff --git a/m4/progtest.m4 b/m4/progtest.m4 +new file mode 100644 +index 000000000..2671eb856 +--- /dev/null ++++ b/m4/progtest.m4 +@@ -0,0 +1,93 @@ ++# progtest.m4 ++# serial 10 (gettext-0.24) ++dnl Copyright (C) 1996-2025 Free Software Foundation, Inc. ++dnl This file is free software; the Free Software Foundation ++dnl gives unlimited permission to copy and/or distribute it, ++dnl with or without modifications, as long as this notice is preserved. ++dnl This file is offered as-is, without any warranty. ++dnl ++dnl This file can be used in projects which are not available under ++dnl the GNU General Public License or the GNU Lesser General Public ++dnl License but which still want to provide support for the GNU gettext ++dnl functionality. ++dnl Please note that the actual code of the GNU gettext library is covered ++dnl by the GNU Lesser General Public License, and the rest of the GNU ++dnl gettext package is covered by the GNU General Public License. ++dnl They are *not* in the public domain. ++ ++dnl Authors: ++dnl Ulrich Drepper , 1996. ++ ++AC_PREREQ([2.53]) ++ ++# Search path for a program which passes the given test. ++ ++dnl AM_PATH_PROG_WITH_TEST(VARIABLE, PROG-TO-CHECK-FOR, ++dnl TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]]) ++AC_DEFUN([AM_PATH_PROG_WITH_TEST], ++[ ++# Prepare PATH_SEPARATOR. ++# The user is always right. ++if test "${PATH_SEPARATOR+set}" != set; then ++ # Determine PATH_SEPARATOR by trying to find /bin/sh in a PATH which ++ # contains only /bin. Note that ksh looks also at the FPATH variable, ++ # so we have to set that as well for the test. ++ PATH_SEPARATOR=: ++ (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \ ++ && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \ ++ || PATH_SEPARATOR=';' ++ } ++fi ++ ++# Find out how to test for executable files. Don't use a zero-byte file, ++# as systems may use methods other than mode bits to determine executability. ++cat >conf$$.file <<_ASEOF ++#! /bin/sh ++exit 0 ++_ASEOF ++chmod +x conf$$.file ++if test -x conf$$.file >/dev/null 2>&1; then ++ ac_executable_p="test -x" ++else ++ ac_executable_p="test -f" ++fi ++rm -f conf$$.file ++ ++# Extract the first word of "$2", so it can be a program name with args. ++set dummy $2; ac_word=[$]2 ++AC_MSG_CHECKING([for $ac_word]) ++AC_CACHE_VAL([ac_cv_path_$1], ++[case "[$]$1" in ++ [[\\/]]* | ?:[[\\/]]*) ++ ac_cv_path_$1="[$]$1" # Let the user override the test with a path. ++ ;; ++ *) ++ gt_saved_IFS="$IFS"; IFS=$PATH_SEPARATOR ++ for ac_dir in m4_if([$5], , $PATH, [$5]); do ++ IFS="$gt_saved_IFS" ++ test -z "$ac_dir" && ac_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if $ac_executable_p "$ac_dir/$ac_word$ac_exec_ext"; then ++ echo "$as_me: trying $ac_dir/$ac_word..." >&AS_MESSAGE_LOG_FD ++ if [$3]; then ++ ac_cv_path_$1="$ac_dir/$ac_word$ac_exec_ext" ++ break 2 ++ fi ++ fi ++ done ++ done ++ IFS="$gt_saved_IFS" ++dnl If no 4th arg is given, leave the cache variable unset, ++dnl so AC_PATH_PROGS will keep looking. ++m4_if([$4], , , [ test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4" ++])dnl ++ ;; ++esac])dnl ++$1="$ac_cv_path_$1" ++if test m4_if([$4], , [-n "[$]$1"], ["[$]$1" != "$4"]); then ++ AC_MSG_RESULT([$][$1]) ++else ++ AC_MSG_RESULT([no]) ++fi ++AC_SUBST([$1])dnl ++]) +-- +2.47.1 + diff --git a/0007-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch b/0002-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch similarity index 99% rename from 0007-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch rename to 0002-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch index c59ae7d..99bafb0 100644 --- a/0007-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch +++ b/0002-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch @@ -1,4 +1,4 @@ -From dffc4f3fa73ee886a057cb450d12b1ee7ad25da9 Mon Sep 17 00:00:00 2001 +From 575246780a0f3bbea399ac72c5feba31bc4c3748 Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Mon, 29 Jul 2013 14:47:56 +0100 Subject: [PATCH] RHEL: Disable unsupported remote drive protocols @@ -180,7 +180,7 @@ index e4e1021db..8419ce78a 100755 rm test-add-uri.out rm test-add-uri.img diff --git a/generator/actions_core.ml b/generator/actions_core.ml -index 53fa129f5..d6b1eb719 100644 +index 2cb8cc430..388366b69 100644 --- a/generator/actions_core.ml +++ b/generator/actions_core.ml @@ -350,22 +350,6 @@ F is interpreted as a local file or device. diff --git a/0002-Update-common-submodule.patch b/0002-Update-common-submodule.patch deleted file mode 100644 index 67df04f..0000000 --- a/0002-Update-common-submodule.patch +++ /dev/null @@ -1,706 +0,0 @@ -From fcd169476f403f9f4f65dddd7c4f05a76b35baeb Mon Sep 17 00:00:00 2001 -From: "Richard W.M. Jones" -Date: Sat, 10 May 2025 18:29:40 +0100 -Subject: [PATCH] Update common submodule - -Adds these commits: - - Richard W.M. Jones (5): - mlstdutils: Modify List.take, List.drop to match OCaml 5.3 - mlstdutils: Rename List.dropwhile -> drop_while, takewhile -> take_while - mlstdutils: Add List.last function - mlstdutils: Move List module first - mlstdutils: Add String.common_prefix, longest_common_prefix ---- - common | 2 +- - contrib/visualize-alignment/tracetops.ml | 2 +- - 2 files changed, 2 insertions(+), 2 deletions(-) - -Submodule common aa797fa13..4c7ae1581: -diff --git a/common/mlstdutils/std_utils.ml b/common/mlstdutils/std_utils.ml -index 8462752..159fc4a 100644 ---- a/common/mlstdutils/std_utils.ml -+++ b/common/mlstdutils/std_utils.ml -@@ -18,6 +18,138 @@ - - open Printf - -+module List = struct -+ include List -+ -+ (* Drop elements from a list while a predicate is true. *) -+ let rec drop_while f = function -+ | [] -> [] -+ | x :: xs when f x -> drop_while f xs -+ | xs -> xs -+ -+ (* Take elements from a list while a predicate is true. *) -+ let rec take_while f = function -+ | x :: xs when f x -> x :: take_while f xs -+ | _ -> [] -+ -+ let take n xs = -+ if n < 0 then invalid_arg "List.take" -+ else if n = 0 then [] -+ else ( -+ (* This optimisation avoids copying xs. *) -+ let len = List.length xs in -+ if len <= n then xs -+ else ( -+ let rec take n = function -+ | x :: xs when n >= 1 -> x :: take (n-1) xs -+ | _ -> [] -+ in -+ take n xs -+ ) -+ ) -+ let rec drop n xs = -+ if n < 0 then invalid_arg "List.drop" -+ else if n = 0 then xs -+ else if xs = [] then [] -+ else drop (n-1) (List.tl xs) -+ -+ let rec last = function -+ | [] -> invalid_arg "List.last" -+ | [x] -> x -+ | _ :: xs -> last xs -+ -+ let rec filter_map f = function -+ | [] -> [] -+ | x :: xs -> -+ match f x with -+ | Some y -> y :: filter_map f xs -+ | None -> filter_map f xs -+ -+ let rec find_map f = function -+ | [] -> raise Not_found -+ | x :: xs -> -+ match f x with -+ | Some y -> y -+ | None -> find_map f xs -+ -+ let rec group_by = function -+ | [] -> [] -+ | (day1, x1) :: (day2, x2) :: rest when day1 = day2 -> -+ let rest = group_by ((day2, x2) :: rest) in -+ let day, xs = List.hd rest in -+ (day, x1 :: xs) :: List.tl rest -+ | (day, x) :: rest -> -+ (day, [x]) :: group_by rest -+ -+ let rec combine3 xs ys zs = -+ match xs, ys, zs with -+ | [], [], [] -> [] -+ | x::xs, y::ys, z::zs -> (x, y, z) :: combine3 xs ys zs -+ | _ -> invalid_arg "combine3" -+ -+ let rec assoc_lbl ?(cmp = Stdlib.compare) ~default x = function -+ | [] -> default -+ | (y, y') :: _ when cmp x y = 0 -> y' -+ | _ :: ys -> assoc_lbl ~cmp ~default x ys -+ -+ let uniq ?(cmp = Stdlib.compare) xs = -+ let rec loop acc = function -+ | [] -> acc -+ | [x] -> x :: acc -+ | x :: (y :: _ as xs) when cmp x y = 0 -> -+ loop acc xs -+ | x :: (y :: _ as xs) -> -+ loop (x :: acc) xs -+ in -+ List.rev (loop [] xs) -+ -+ let remove_duplicates xs = -+ let h = Hashtbl.create (List.length xs) in -+ let rec loop = function -+ | [] -> [] -+ | x :: xs when Hashtbl.mem h x -> xs -+ | x :: xs -> Hashtbl.add h x true; x :: loop xs -+ in -+ loop xs -+ -+ let push_back xsp x = xsp := !xsp @ [x] -+ let push_front x xsp = xsp := x :: !xsp -+ let pop_back xsp = -+ let x, xs = -+ match List.rev !xsp with -+ | x :: xs -> x, xs -+ | [] -> failwith "pop" in -+ xsp := List.rev xs; -+ x -+ let pop_front xsp = -+ let x, xs = -+ match !xsp with -+ | x :: xs -> x, xs -+ | [] -> failwith "shift" in -+ xsp := xs; -+ x -+ -+ let may_push_back xsp x = -+ match x with None -> () | Some x -> push_back xsp x -+ let may_push_front x xsp = -+ match x with None -> () | Some x -> push_front x xsp -+ -+ let push_back_list xsp xs = xsp := !xsp @ xs -+ let push_front_list xs xsp = xsp := xs @ !xsp -+ -+ let make n x = -+ let rec loop acc = function -+ | 0 -> acc -+ | i when i > 0 -> loop (x :: acc) (i-1) -+ | _ -> invalid_arg "make" -+ in -+ loop [] n -+ -+ let same = function -+ | [] -> true -+ | x :: xs -> List.for_all ((=) x) xs -+end -+ - module Char = struct - include Char - -@@ -302,131 +434,23 @@ module String = struct - loop 0 - - let unix2dos str = replace str "\n" "\r\n" --end - --module List = struct -- include List -- -- (* Drop elements from a list while a predicate is true. *) -- let rec dropwhile f = function -- | [] -> [] -- | x :: xs when f x -> dropwhile f xs -- | xs -> xs -- -- (* Take elements from a list while a predicate is true. *) -- let rec takewhile f = function -- | x :: xs when f x -> x :: takewhile f xs -- | _ -> [] -- -- let take n xs = -- if n <= 0 then [] -- else ( -- (* This optimisation avoids copying xs. *) -- let len = List.length xs in -- if len <= n then xs -- else ( -- let rec take n = function -- | x :: xs when n >= 1 -> x :: take (n-1) xs -- | _ -> [] -- in -- take n xs -- ) -- ) -- let rec drop n xs = -- if n <= 0 then xs -- else if xs = [] then [] -- else drop (n-1) (List.tl xs) -- -- let rec filter_map f = function -- | [] -> [] -- | x :: xs -> -- match f x with -- | Some y -> y :: filter_map f xs -- | None -> filter_map f xs -- -- let rec find_map f = function -- | [] -> raise Not_found -- | x :: xs -> -- match f x with -- | Some y -> y -- | None -> find_map f xs -- -- let rec group_by = function -- | [] -> [] -- | (day1, x1) :: (day2, x2) :: rest when day1 = day2 -> -- let rest = group_by ((day2, x2) :: rest) in -- let day, xs = List.hd rest in -- (day, x1 :: xs) :: List.tl rest -- | (day, x) :: rest -> -- (day, [x]) :: group_by rest -- -- let rec combine3 xs ys zs = -- match xs, ys, zs with -- | [], [], [] -> [] -- | x::xs, y::ys, z::zs -> (x, y, z) :: combine3 xs ys zs -- | _ -> invalid_arg "combine3" -- -- let rec assoc_lbl ?(cmp = Stdlib.compare) ~default x = function -- | [] -> default -- | (y, y') :: _ when cmp x y = 0 -> y' -- | _ :: ys -> assoc_lbl ~cmp ~default x ys -- -- let uniq ?(cmp = Stdlib.compare) xs = -- let rec loop acc = function -- | [] -> acc -- | [x] -> x :: acc -- | x :: (y :: _ as xs) when cmp x y = 0 -> -- loop acc xs -- | x :: (y :: _ as xs) -> -- loop (x :: acc) xs -+ let rec longest_common_prefix = function -+ | [] -> "" -+ | [s] -> s -+ | strs -> -+ let strs = List.sort compare strs in -+ let s1 = List.hd strs and s2 = List.last strs in -+ common_prefix s1 s2 -+ and common_prefix s1 s2 = -+ let n1 = length s1 and n2 = length s2 in -+ let n = min n1 n2 in -+ let rec loop i = -+ if i = n then sub s1 0 n -+ else if unsafe_get s1 i <> unsafe_get s2 i then sub s1 0 i -+ else loop (i+1) - in -- List.rev (loop [] xs) -- -- let remove_duplicates xs = -- let h = Hashtbl.create (List.length xs) in -- let rec loop = function -- | [] -> [] -- | x :: xs when Hashtbl.mem h x -> xs -- | x :: xs -> Hashtbl.add h x true; x :: loop xs -- in -- loop xs -- -- let push_back xsp x = xsp := !xsp @ [x] -- let push_front x xsp = xsp := x :: !xsp -- let pop_back xsp = -- let x, xs = -- match List.rev !xsp with -- | x :: xs -> x, xs -- | [] -> failwith "pop" in -- xsp := List.rev xs; -- x -- let pop_front xsp = -- let x, xs = -- match !xsp with -- | x :: xs -> x, xs -- | [] -> failwith "shift" in -- xsp := xs; -- x -- -- let may_push_back xsp x = -- match x with None -> () | Some x -> push_back xsp x -- let may_push_front x xsp = -- match x with None -> () | Some x -> push_front x xsp -- -- let push_back_list xsp xs = xsp := !xsp @ xs -- let push_front_list xs xsp = xsp := xs @ !xsp -- -- let make n x = -- let rec loop acc = function -- | 0 -> acc -- | i when i > 0 -> loop (x :: acc) (i-1) -- | _ -> invalid_arg "make" -- in -- loop [] n -- -- let same = function -- | [] -> true -- | x :: xs -> List.for_all ((=) x) xs -+ loop 0 - end - - let (//) = Filename.concat -diff --git a/common/mlstdutils/std_utils.mli b/common/mlstdutils/std_utils.mli -index 566c5b5..2526100 100644 ---- a/common/mlstdutils/std_utils.mli -+++ b/common/mlstdutils/std_utils.mli -@@ -16,138 +16,6 @@ - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - *) - --module Char : sig -- type t = char -- val chr : int -> char -- val code : char -> int -- val compare: t -> t -> int -- val escaped : char -> string -- val unsafe_chr : int -> char -- -- val lowercase_ascii : char -> char -- val uppercase_ascii : char -> char -- -- val isspace : char -> bool -- (** Return true if char is a whitespace character. *) -- val isdigit : char -> bool -- (** Return true if the character is a digit [[0-9]]. *) -- val isxdigit : char -> bool -- (** Return true if the character is a hex digit [[0-9a-fA-F]]. *) -- val isalpha : char -> bool -- (** Return true if the character is a US ASCII 7 bit alphabetic. *) -- val isalnum : char -> bool -- (** Return true if the character is a US ASCII 7 bit alphanumeric. *) -- -- val hexdigit : char -> int -- (** Return the value of a hex digit. If the char is not in -- the set [[0-9a-fA-F]] then this returns [-1]. *) -- -- val mem : char -> string -> bool -- (** [mem c str] returns true if the byte [c] is contained in [str]. -- -- This is actually the same as {!String.contains} with the -- parameters reversed. *) --end --(** Override the Char module from stdlib. *) -- --module String : sig -- type t = string -- val compare: t -> t -> int -- val concat : string -> string list -> string -- val contains : string -> char -> bool -- val contains_from : string -> int -> char -> bool -- val escaped : string -> string -- val get : string -> int -> char -- val index : string -> char -> int -- val index_from : string -> int -> char -> int -- val iter : (char -> unit) -> string -> unit -- val iteri : (int -> char -> unit) -> string -> unit -- val map : (char -> char) -> string -> string -- val length : string -> int -- val make : int -> char -> string -- val rcontains_from : string -> int -> char -> bool -- val rindex : string -> char -> int -- val rindex_from : string -> int -> char -> int -- val sub : string -> int -> int -> string -- val unsafe_get : string -> int -> char -- -- val lowercase_ascii : string -> string -- val uppercase_ascii : string -> string -- val capitalize_ascii : string -> string -- -- val is_prefix : string -> string -> bool -- (** [is_prefix str prefix] returns true if [prefix] is a prefix of [str]. *) -- val is_suffix : string -> string -> bool -- (** [is_suffix str suffix] returns true if [suffix] is a suffix of [str]. *) -- val find : string -> string -> int -- (** [find str sub] searches for [sub] as a substring of [str]. If -- found it returns the index. If not found, it returns [-1]. *) -- val find_from : string -> int -> string -> int -- (** [find_from str start sub] searches for [sub] as a substring of [str], -- starting at index [start]. If found it returns the index. -- If not found, it returns [-1]. *) -- val replace : string -> string -> string -> string -- (** [replace str s1 s2] replaces all instances of [s1] appearing in -- [str] with [s2]. *) -- val replace_char : string -> char -> char -> string -- (** Replace character in string. *) -- val break : int -> string -> string * string -- (** [break n str] breaks a string at the nth byte, returning the -- first and second parts. If [n] is beyond the end of the -- string it returns [(str, "")]. *) -- val split : string -> string -> string * string -- (** [split sep str] splits [str] at the first occurrence of the -- separator [sep], returning the part before and the part after. -- If separator is not found, return the whole string and an -- empty string. *) -- val nsplit : ?max:int -> string -> string -> string list -- (** [nsplit ?max sep str] splits [str] into multiple strings at each -- separator [sep]. -- -- As with the Perl split function, you can give an optional -- [?max] parameter to limit the number of strings returned. The -- final element of the list will contain the remainder of the -- input string. *) -- val lines_split : string -> string list -- (** [lines_split str] splits [str] into lines, keeping continuation -- characters (i.e. [\] at the end of lines) into account. *) -- val random8 : unit -> string -- (** Return a string of 8 random printable characters. *) -- val triml : ?test:(char -> bool) -> string -> string -- (** Trim left. *) -- val trimr : ?test:(char -> bool) -> string -> string -- (** Trim right. *) -- val trim : ?test:(char -> bool) -> string -> string -- (** Trim left and right. *) -- val chomp : string -> string -- (** If the string ends with [\n], remove it. *) -- val count_chars : char -> string -> int -- (** Count number of times the character occurs in string. *) -- val explode : string -> char list -- (** Explode a string into a list of characters. *) -- val map_chars : (char -> 'a) -> string -> 'a list -- (** Explode string, then map function over the characters. *) -- val implode : char list -> string -- (** Join list of characters into a single string. *) -- val spaces : int -> string -- (** [spaces n] creates a string of n spaces. *) -- val span : string -> string -> int -- val cspan : string -> string -> int -- (** [span str accept] returns the length in bytes of the initial -- segment of [str] which contains only bytes in [accept]. -- -- [cspan str reject] returns the length in bytes of the initial -- segment of [str] which contains only bytes {!i not} in [reject]. -- -- These work exactly like the C functions [strspn] and [strcspn]. *) -- val unix2dos : string -> string -- (** Convert string with ordinary Unix-style line-endings to -- CRLF DOS-style line-endings. -- -- The same as {!String.replace} [str "\n" "\r\n"]. *) --end --(** Override the String module from stdlib. *) -- - module List : sig - val length : 'a list -> int - val hd : 'a list -> 'a -@@ -194,11 +62,11 @@ module List : sig - val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list - val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list - -- val dropwhile : ('a -> bool) -> 'a list -> 'a list -- (** [dropwhile f xs] drops leading elements from [xs] until -+ val drop_while : ('a -> bool) -> 'a list -> 'a list -+ (** [drop_while f xs] drops leading elements from [xs] until - [f] returns false. *) -- val takewhile : ('a -> bool) -> 'a list -> 'a list -- (** [takewhile f xs] takes leading elements from [xs] until -+ val take_while : ('a -> bool) -> 'a list -> 'a list -+ (** [take_while f xs] takes leading elements from [xs] until - [f] returns false. - - For any list [xs] and function [f], -@@ -206,12 +74,21 @@ module List : sig - - val take : int -> 'a list -> 'a list - (** [take n xs] returns the first [n] elements of [xs]. If [xs] is -- shorter than [n], then it returns [xs]. Note it never fails -- for any input. *) -+ shorter than [n], then it returns [xs]. [n] must be non-negative. -+ -+ @raise Invalid_argument if [n] is negative *) - val drop : int -> 'a list -> 'a list - (** [drop n xs] returns the suffix of [xs] after the first [n] - elements. If [xs] is shorter than [n], then it returns the empty -- list. Note it never fails for any input. *) -+ list. [n] must be non-negative. -+ -+ @raise Invalid_argument if [n] is negative *) -+ -+ val last : 'a list -> 'a -+ (** Return the last element in the list (analogous to {!List.hd} but -+ much less efficient). -+ -+ @raise Invalid_argument if the list is empty *) - - val filter_map : ('a -> 'b option) -> 'a list -> 'b list - (** [filter_map f xs] applies [f] to each element of [xs]. If -@@ -302,6 +179,144 @@ module List : sig - end - (** Override the List module from stdlib. *) - -+module Char : sig -+ type t = char -+ val chr : int -> char -+ val code : char -> int -+ val compare: t -> t -> int -+ val escaped : char -> string -+ val unsafe_chr : int -> char -+ -+ val lowercase_ascii : char -> char -+ val uppercase_ascii : char -> char -+ -+ val isspace : char -> bool -+ (** Return true if char is a whitespace character. *) -+ val isdigit : char -> bool -+ (** Return true if the character is a digit [[0-9]]. *) -+ val isxdigit : char -> bool -+ (** Return true if the character is a hex digit [[0-9a-fA-F]]. *) -+ val isalpha : char -> bool -+ (** Return true if the character is a US ASCII 7 bit alphabetic. *) -+ val isalnum : char -> bool -+ (** Return true if the character is a US ASCII 7 bit alphanumeric. *) -+ -+ val hexdigit : char -> int -+ (** Return the value of a hex digit. If the char is not in -+ the set [[0-9a-fA-F]] then this returns [-1]. *) -+ -+ val mem : char -> string -> bool -+ (** [mem c str] returns true if the byte [c] is contained in [str]. -+ -+ This is actually the same as {!String.contains} with the -+ parameters reversed. *) -+end -+(** Override the Char module from stdlib. *) -+ -+module String : sig -+ type t = string -+ val compare: t -> t -> int -+ val concat : string -> string list -> string -+ val contains : string -> char -> bool -+ val contains_from : string -> int -> char -> bool -+ val escaped : string -> string -+ val get : string -> int -> char -+ val index : string -> char -> int -+ val index_from : string -> int -> char -> int -+ val iter : (char -> unit) -> string -> unit -+ val iteri : (int -> char -> unit) -> string -> unit -+ val map : (char -> char) -> string -> string -+ val length : string -> int -+ val make : int -> char -> string -+ val rcontains_from : string -> int -> char -> bool -+ val rindex : string -> char -> int -+ val rindex_from : string -> int -> char -> int -+ val sub : string -> int -> int -> string -+ val unsafe_get : string -> int -> char -+ -+ val lowercase_ascii : string -> string -+ val uppercase_ascii : string -> string -+ val capitalize_ascii : string -> string -+ -+ val is_prefix : string -> string -> bool -+ (** [is_prefix str prefix] returns true if [prefix] is a prefix of [str]. *) -+ val is_suffix : string -> string -> bool -+ (** [is_suffix str suffix] returns true if [suffix] is a suffix of [str]. *) -+ val find : string -> string -> int -+ (** [find str sub] searches for [sub] as a substring of [str]. If -+ found it returns the index. If not found, it returns [-1]. *) -+ val find_from : string -> int -> string -> int -+ (** [find_from str start sub] searches for [sub] as a substring of [str], -+ starting at index [start]. If found it returns the index. -+ If not found, it returns [-1]. *) -+ val replace : string -> string -> string -> string -+ (** [replace str s1 s2] replaces all instances of [s1] appearing in -+ [str] with [s2]. *) -+ val replace_char : string -> char -> char -> string -+ (** Replace character in string. *) -+ val break : int -> string -> string * string -+ (** [break n str] breaks a string at the nth byte, returning the -+ first and second parts. If [n] is beyond the end of the -+ string it returns [(str, "")]. *) -+ val split : string -> string -> string * string -+ (** [split sep str] splits [str] at the first occurrence of the -+ separator [sep], returning the part before and the part after. -+ If separator is not found, return the whole string and an -+ empty string. *) -+ val nsplit : ?max:int -> string -> string -> string list -+ (** [nsplit ?max sep str] splits [str] into multiple strings at each -+ separator [sep]. -+ -+ As with the Perl split function, you can give an optional -+ [?max] parameter to limit the number of strings returned. The -+ final element of the list will contain the remainder of the -+ input string. *) -+ val lines_split : string -> string list -+ (** [lines_split str] splits [str] into lines, keeping continuation -+ characters (i.e. [\] at the end of lines) into account. *) -+ val random8 : unit -> string -+ (** Return a string of 8 random printable characters. *) -+ val triml : ?test:(char -> bool) -> string -> string -+ (** Trim left. *) -+ val trimr : ?test:(char -> bool) -> string -> string -+ (** Trim right. *) -+ val trim : ?test:(char -> bool) -> string -> string -+ (** Trim left and right. *) -+ val chomp : string -> string -+ (** If the string ends with [\n], remove it. *) -+ val count_chars : char -> string -> int -+ (** Count number of times the character occurs in string. *) -+ val explode : string -> char list -+ (** Explode a string into a list of characters. *) -+ val map_chars : (char -> 'a) -> string -> 'a list -+ (** Explode string, then map function over the characters. *) -+ val implode : char list -> string -+ (** Join list of characters into a single string. *) -+ val spaces : int -> string -+ (** [spaces n] creates a string of n spaces. *) -+ val span : string -> string -> int -+ val cspan : string -> string -> int -+ (** [span str accept] returns the length in bytes of the initial -+ segment of [str] which contains only bytes in [accept]. -+ -+ [cspan str reject] returns the length in bytes of the initial -+ segment of [str] which contains only bytes {!i not} in [reject]. -+ -+ These work exactly like the C functions [strspn] and [strcspn]. *) -+ val unix2dos : string -> string -+ (** Convert string with ordinary Unix-style line-endings to -+ CRLF DOS-style line-endings. -+ -+ The same as {!String.replace} [str "\n" "\r\n"]. *) -+ val common_prefix : string -> string -> string -+ (** Return the longest common prefix of two strings. *) -+ val longest_common_prefix : string list -> string -+ (** Return the longest common prefix of all the strings in the list. -+ If the list is empty or there is no common prefix, [""] is -+ returned. If there is only one string in the list, it is returned. *) -+end -+(** Override the String module from stdlib. *) -+ - val ( // ) : string -> string -> string - (** Concatenate directory and filename. *) - -diff --git a/common/mlstdutils/std_utils_tests.ml b/common/mlstdutils/std_utils_tests.ml -index aadab17..abe842b 100644 ---- a/common/mlstdutils/std_utils_tests.ml -+++ b/common/mlstdutils/std_utils_tests.ml -@@ -190,6 +190,37 @@ let () = - assert_equal_string "" (String.chomp "\n"); - assert_equal_string "\n" (String.chomp "\n\n") (* only removes one *) - -+(* Test Std_utils.String.common_prefix, longest_common_prefix. *) -+let () = -+ assert_equal_string "" (String.common_prefix "" ""); -+ assert_equal_string "" (String.common_prefix "" "abc"); -+ assert_equal_string "" (String.common_prefix "abc" ""); -+ assert_equal_string "" (String.common_prefix "hello" "world"); -+ assert_equal_string "abc" (String.common_prefix "abc" "abcde"); -+ assert_equal_string "abc" (String.common_prefix "abcde" "abc"); -+ assert_equal_string "abc" (String.common_prefix "abcde" "abcghi"); -+ assert_equal_string "" (String.longest_common_prefix []); -+ assert_equal_string "" (String.longest_common_prefix [""]); -+ assert_equal_string "abc" (String.longest_common_prefix ["abc"]); -+ assert_equal_string "" (String.longest_common_prefix [""; "abc"]); -+ assert_equal_string "" (String.longest_common_prefix ["abc"; ""]); -+ assert_equal_string "" (String.longest_common_prefix ["hello"; "world"]); -+ assert_equal_string "" -+ (String.longest_common_prefix ["hello"; "there"; "world"]); -+ assert_equal_string "abc" (String.longest_common_prefix ["abc"; "abcde"]); -+ assert_equal_string "abc" (String.longest_common_prefix ["abcde"; "abc"]); -+ assert_equal_string "abc" (String.longest_common_prefix ["abcde"; "abcghi"]); -+ assert_equal_string "abc" -+ (String.longest_common_prefix ["abcde"; "abcghi"; "abc123"]); -+ assert_equal_string "abc" -+ (String.longest_common_prefix ["abc"; "abcghi"; "abc123"]); -+ assert_equal_string "abc" -+ (String.longest_common_prefix ["abcde"; "abc"; "abc123"]); -+ assert_equal_string "abc" -+ (String.longest_common_prefix ["abcde"; "abcde"; "abc"]); -+ assert_equal_string "abc" -+ (String.longest_common_prefix ["abc"; "abc"; "abc"]) -+ - (* Test Std_utils.which. *) - let () = - assert_nonempty_string (which "true"); -@@ -216,3 +247,9 @@ let () = - let () = - assert_bool "List.same []" (List.same (List.make 0 "1")); - assert_bool "List.same [1; 1; ...; 1]" (List.same (List.make 10 1)) -+ -+(* Test List.last. *) -+let () = -+ assert_equal_string "3" (List.last ["1"; "2"; "3"]); -+ assert_equal_string "1" (List.last ["1"]); -+ assert_raises (Invalid_argument "List.last") (fun () -> List.last []) -diff --git a/contrib/visualize-alignment/tracetops.ml b/contrib/visualize-alignment/tracetops.ml -index b838b30f3..102a03580 100755 ---- a/contrib/visualize-alignment/tracetops.ml -+++ b/contrib/visualize-alignment/tracetops.ml -@@ -185,7 +185,7 @@ let ranges = - loop i0 rest - | (false, i1) :: rest -> - let i1 = i1 - 1 in -- let rest = List.dropwhile (function (v, _) -> not v) rest in -+ let rest = List.drop_while (function (v, _) -> not v) rest in - (match rest with - | [] -> [i0, i1] - | (_, i2) :: rest -> (i0, i1) :: loop i2 rest) --- -2.47.1 - diff --git a/0008-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch b/0003-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch similarity index 97% rename from 0008-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch rename to 0003-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch index ba3d066..37bd183 100644 --- a/0008-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch +++ b/0003-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch @@ -1,4 +1,4 @@ -From e55a14036a8d2f7d6c00a55e9e781855bfc7e180 Mon Sep 17 00:00:00 2001 +From 67bda9410ac10e83203e017a1a4873650dc4f232 Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 7 Jul 2015 09:28:03 -0400 Subject: [PATCH] RHEL: Reject use of libguestfs-winsupport features except for diff --git a/0003-Update-common-submodule.patch b/0003-Update-common-submodule.patch deleted file mode 100644 index 5462e4f..0000000 --- a/0003-Update-common-submodule.patch +++ /dev/null @@ -1,248 +0,0 @@ -From c4ebeee5053a2f4ac87968121c29b64a596d42aa Mon Sep 17 00:00:00 2001 -From: "Richard W.M. Jones" -Date: Sun, 11 May 2025 12:37:23 +0100 -Subject: [PATCH] Update common submodule - -Pull in these commits which require minor changes: - - Richard W.M. Jones (3): - mlstdutils: Remove Std_utils.identity - mlstdutils: Remove Std_utils.protect - mlstdutils: Remove List.filter_map ---- - common | 2 +- - daemon/btrfs.ml | 4 ++-- - daemon/cryptsetup.ml | 2 +- - daemon/filearch.ml | 2 +- - daemon/inspect_utils.ml | 6 +++--- - daemon/sfdisk.ml | 2 +- - 6 files changed, 9 insertions(+), 9 deletions(-) - -Submodule common 4c7ae1581..3a05f1a7a: -diff --git a/common/mlstdutils/std_utils.ml b/common/mlstdutils/std_utils.ml -index 159fc4a..39b5bc9 100644 ---- a/common/mlstdutils/std_utils.ml -+++ b/common/mlstdutils/std_utils.ml -@@ -58,13 +58,6 @@ module List = struct - | [x] -> x - | _ :: xs -> last xs - -- let rec filter_map f = function -- | [] -> [] -- | x :: xs -> -- match f x with -- | Some y -> y :: filter_map f xs -- | None -> filter_map f xs -- - let rec find_map f = function - | [] -> raise Not_found - | x :: xs -> -@@ -463,8 +456,6 @@ let ( /^ ) = Int64.div - let ( &^ ) = Int64.logand - let ( ~^ ) = Int64.lognot - --external identity : 'a -> 'a = "%identity" -- - let roundup64 i a = let a = a -^ 1L in (i +^ a) &^ (~^ a) - let div_roundup64 i a = (i +^ a -^ 1L) /^ a - -@@ -628,13 +619,6 @@ let unique = let i = ref 0 in fun () -> incr i; !i - - type ('a, 'b) maybe = Either of 'a | Or of 'b - --let protect ~f ~finally = -- let r = -- try Either (f ()) -- with exn -> Or exn in -- finally (); -- match r with Either ret -> ret | Or exn -> raise exn -- - type 'a return = { return: 'b. 'a -> 'b } [@@unboxed] - let with_return (type a) f = - let exception Return of a in -@@ -691,15 +675,15 @@ let wrap () = !wrap - - let with_open_in filename f = - let chan = open_in filename in -- protect ~f:(fun () -> f chan) ~finally:(fun () -> close_in chan) -+ Fun.protect (fun () -> f chan) ~finally:(fun () -> close_in chan) - - let with_open_out filename f = - let chan = open_out filename in -- protect ~f:(fun () -> f chan) ~finally:(fun () -> close_out chan) -+ Fun.protect (fun () -> f chan) ~finally:(fun () -> close_out chan) - - let with_openfile filename flags perms f = - let fd = Unix.openfile filename flags perms in -- protect ~f:(fun () -> f fd) ~finally:(fun () -> Unix.close fd) -+ Fun.protect (fun () -> f fd) ~finally:(fun () -> Unix.close fd) - - let read_whole_file path = - let buf = Buffer.create 16384 in -diff --git a/common/mlstdutils/std_utils.mli b/common/mlstdutils/std_utils.mli -index 2526100..04c780a 100644 ---- a/common/mlstdutils/std_utils.mli -+++ b/common/mlstdutils/std_utils.mli -@@ -31,6 +31,7 @@ module List : sig - val map : ('a -> 'b) -> 'a list -> 'b list - val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list - val rev_map : ('a -> 'b) -> 'a list -> 'b list -+ val filter_map : ('a -> 'b option) -> 'a list -> 'b list - val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a - val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b - val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit -@@ -90,9 +91,6 @@ module List : sig - - @raise Invalid_argument if the list is empty *) - -- val filter_map : ('a -> 'b option) -> 'a list -> 'b list -- (** [filter_map f xs] applies [f] to each element of [xs]. If -- [f x] returns [Some y] then [y] is added to the returned list. *) - val find_map : ('a -> 'b option) -> 'a list -> 'b - (** [find_map f xs] applies [f] to each element of [xs] until - [f x] returns [Some y]. It returns [y]. If we exhaust the -@@ -331,8 +329,6 @@ val ( &^ ) : int64 -> int64 -> int64 - val ( ~^ ) : int64 -> int64 - (** Various int64 operators. *) - --external identity : 'a -> 'a = "%identity" -- - val roundup64 : int64 -> int64 -> int64 - (** [roundup64 i a] returns [i] rounded up to the next multiple of [a]. *) - val div_roundup64 : int64 -> int64 -> int64 -@@ -371,18 +367,6 @@ val unique : unit -> int - type ('a, 'b) maybe = Either of 'a | Or of 'b - (** Like the Haskell [Either] type. *) - --val protect : f:(unit -> 'a) -> finally:(unit -> unit) -> 'a --(** Execute [~f] and afterwards execute [~finally]. -- -- If [~f] throws an exception then [~finally] is run and the -- original exception from [~f] is re-raised. -- -- If [~finally] throws an exception, then the original exception -- is lost. (NB: Janestreet core {!Exn.protectx}, on which this -- function is modelled, doesn't throw away the exception in this -- case, but requires a lot more work by the caller. Perhaps we -- will change this in future.) *) -- - type 'a return = { return: 'b. 'a -> 'b } [@@unboxed] - val with_return : ('a return -> 'a) -> 'a - (** {v -diff --git a/common/mlstdutils/std_utils_tests.ml b/common/mlstdutils/std_utils_tests.ml -index abe842b..10046bd 100644 ---- a/common/mlstdutils/std_utils_tests.ml -+++ b/common/mlstdutils/std_utils_tests.ml -@@ -40,7 +40,7 @@ let assert_raises exn fn = - ) - - let assert_equal_string = -- assert_equal ~printer:identity -+ assert_equal ~printer:Fun.id - let assert_equal_int = - assert_equal ~printer:(fun x -> string_of_int x) - let assert_equal_int64 = -diff --git a/common/mlutils/c_utils_unit_tests.ml b/common/mlutils/c_utils_unit_tests.ml -index 961dac5..50c7e44 100644 ---- a/common/mlutils/c_utils_unit_tests.ml -+++ b/common/mlutils/c_utils_unit_tests.ml -@@ -42,7 +42,7 @@ let assert_raises exn fn = - - (* Test drive_name function. *) - let () = -- let printer = identity in -+ let printer = Fun.id in - assert_equal ~printer "a" (drive_name 0); - assert_equal ~printer "z" (drive_name 25); - assert_equal ~printer "aa" (drive_name 26); -@@ -74,7 +74,7 @@ let () = - - (* Test shell_unquote function. *) - let () = -- let printer = identity in -+ let printer = Fun.id in - assert_equal ~printer "a" (shell_unquote "a"); - assert_equal ~printer "b" (shell_unquote "'b'"); - assert_equal ~printer "c" (shell_unquote "\"c\""); -diff --git a/daemon/btrfs.ml b/daemon/btrfs.ml -index 3f9d8308a..35e0b1765 100644 ---- a/daemon/btrfs.ml -+++ b/daemon/btrfs.ml -@@ -48,7 +48,7 @@ let rec with_mounted mountable f = - rmdir tmpdir - in - -- protect ~finally ~f:(fun () -> mount_cmd tmpdir; f tmpdir) -+ Fun.protect ~finally (fun () -> mount_cmd tmpdir; f tmpdir) - in - - match mountable.m_type with -@@ -124,4 +124,4 @@ let btrfs_subvolume_get_default mountable = - with_mounted mountable ( - fun mp -> command "btrfs" ["subvolume"; "get-default"; mp] - ) in -- sscanf out "ID %Ld" identity -+ sscanf out "ID %Ld" Fun.id -diff --git a/daemon/cryptsetup.ml b/daemon/cryptsetup.ml -index ac2cf066e..9c0149b48 100644 ---- a/daemon/cryptsetup.ml -+++ b/daemon/cryptsetup.ml -@@ -56,7 +56,7 @@ let cryptsetup_open ?(readonly = false) ?crypttype ?cipher device key mapname = - Option.iter (fun s -> List.push_back_list args ["--cipher"; s]) cipher; - - (* Make sure we always remove the temporary file. *) -- protect ~f:(fun () -> ignore (command "cryptsetup" !args)) -+ Fun.protect (fun () -> ignore (command "cryptsetup" !args)) - ~finally:(fun () -> unlink keyfile); - - udev_settle () -diff --git a/daemon/filearch.ml b/daemon/filearch.ml -index 6eed7d396..f45392b5f 100644 ---- a/daemon/filearch.ml -+++ b/daemon/filearch.ml -@@ -116,7 +116,7 @@ and cpio_arch magic orig_path path = - let tmpdir = Mkdtemp.temp_dir "filearch" in - let finally () = ignore (Sys.command (sprintf "rm -rf %s" (quote tmpdir))) in - -- protect ~finally ~f:( -+ Fun.protect ~finally ( - fun () -> - (* Construct a command to extract named binaries from the initrd file. *) - let cmd = -diff --git a/daemon/inspect_utils.ml b/daemon/inspect_utils.ml -index 1aa762050..5ef8bfa25 100644 ---- a/daemon/inspect_utils.ml -+++ b/daemon/inspect_utils.ml -@@ -57,8 +57,8 @@ let rec with_augeas ?name configfiles f = - Augeas.create (Sysroot.sysroot ()) None - [Augeas.AugSaveNoop; Augeas.AugNoLoad] in - -- protect -- ~f:(fun () -> -+ Fun.protect -+ (fun () -> - (* Tell Augeas to only load configfiles and no other files. This - * prevents a rogue guest from performing a denial of service attack - * by having large, over-complicated configuration files which are -@@ -179,4 +179,4 @@ let with_hive hive_filename f = - | Some f -> f :: flags in - let flags = if verbose () then Hivex.OPEN_VERBOSE :: flags else flags in - let h = Hivex.open_file hive_filename flags in -- protect ~f:(fun () -> f h (Hivex.root h)) ~finally:(fun () -> Hivex.close h) -+ Fun.protect (fun () -> f h (Hivex.root h)) ~finally:(fun () -> Hivex.close h) -diff --git a/daemon/sfdisk.ml b/daemon/sfdisk.ml -index c694c328c..3265d1e83 100644 ---- a/daemon/sfdisk.ml -+++ b/daemon/sfdisk.ml -@@ -35,7 +35,7 @@ let part_get_mbr_id device partnum = - udev_settle (); - - (* It's printed in hex, possibly with a leading space. *) -- sscanf out " %x" identity -+ sscanf out " %x" Fun.id - - let part_get_gpt_type device partnum = - if partnum <= 0 then --- -2.47.1 - diff --git a/0009-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch b/0004-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch similarity index 90% rename from 0009-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch rename to 0004-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch index 7306af0..ee4a33f 100644 --- a/0009-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch +++ b/0004-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch @@ -1,4 +1,4 @@ -From b3c5978cdf583fba4dfc36f5ebc4d7248b5b0bfb Mon Sep 17 00:00:00 2001 +From 33529af903969a9957214e39bc6b1c78f02a7b98 Mon Sep 17 00:00:00 2001 From: "Richard W.M. Jones" Date: Tue, 13 May 2025 17:28:25 +0100 Subject: [PATCH] RHEL: appliance/init: Run depmod -a to rebuild kernel module diff --git a/0004-ocaml-dep.sh.in-Remove-mlgettext-subdirectory.patch b/0004-ocaml-dep.sh.in-Remove-mlgettext-subdirectory.patch deleted file mode 100644 index 55731ea..0000000 --- a/0004-ocaml-dep.sh.in-Remove-mlgettext-subdirectory.patch +++ /dev/null @@ -1,25 +0,0 @@ -From 464b8915e9e9b871d64446b5dfc8a806f3d87883 Mon Sep 17 00:00:00 2001 -From: "Richard W.M. Jones" -Date: Sun, 11 May 2025 15:01:06 +0100 -Subject: [PATCH] ocaml-dep.sh.in: Remove mlgettext subdirectory - -Libguestfs does not use ocaml-gettext at all. ---- - ocaml-dep.sh.in | 1 - - 1 file changed, 1 deletion(-) - -diff --git a/ocaml-dep.sh.in b/ocaml-dep.sh.in -index a9c093bb0..8cdfd76ba 100755 ---- a/ocaml-dep.sh.in -+++ b/ocaml-dep.sh.in -@@ -33,7 +33,6 @@ set -e - # directories must have unique names (eg. not ‘Utils’) else - # dependencies don't get built right. - include_dirs=" --common/mlgettext - common/mlpcre - common/mlstdutils - common/mlutils --- -2.47.1 - diff --git a/0005-Update-common-submodule.patch b/0005-Update-common-submodule.patch deleted file mode 100644 index 70f05ee..0000000 --- a/0005-Update-common-submodule.patch +++ /dev/null @@ -1,531 +0,0 @@ -From f9edfc9a18eec134a38872166bb2e3dac51a8d18 Mon Sep 17 00:00:00 2001 -From: "Richard W.M. Jones" -Date: Sun, 11 May 2025 21:21:56 +0100 -Subject: [PATCH] Update common submodule - -This pulls in the commits below, requiring us to replace all uses of -String.is_prefix and String.is_suffix. - -Mostly done with Perl like this, and carefully checked by hand -afterwards since this doesn't get everything right: - - $ perl -pi.bak -e 's/String.is_prefix ([^[:space:]\)]+) ([^[:space:]\)]+)/String.starts_with \2 \1/g' -- `git ls-files` - - Richard W.M. Jones (3): - mlstdutils: Fix comment that still referred to the old function names - mldrivers: Link to gettext-stub if ocaml-gettext is enabled - mlstdutils: Rename String.is_prefix -> starts_with, is_suffix -> ends_with ---- - common | 2 +- - daemon/cryptsetup.ml | 2 +- - daemon/devsparts.ml | 18 +++++++++--------- - daemon/findfs.ml | 4 ++-- - daemon/inspect_fs_unix.ml | 10 +++++----- - daemon/inspect_fs_unix_fstab.ml | 30 +++++++++++++++--------------- - daemon/inspect_fs_windows.ml | 8 ++++---- - daemon/ldm.ml | 2 +- - daemon/listfs.ml | 8 ++++---- - daemon/md.ml | 2 +- - daemon/mount_utils.ml | 4 ++-- - daemon/sfdisk.ml | 8 ++++---- - daemon/utils.ml | 6 +++--- - generator/daemon.ml | 2 +- - 14 files changed, 53 insertions(+), 53 deletions(-) - -Submodule common 3a05f1a7a..d4a81e9dd: -diff --git a/common/mlstdutils/std_utils.ml b/common/mlstdutils/std_utils.ml -index 39b5bc9..4850a55 100644 ---- a/common/mlstdutils/std_utils.ml -+++ b/common/mlstdutils/std_utils.ml -@@ -214,11 +214,11 @@ module String = struct - Bytes.unsafe_set b 0 (Char.uppercase_ascii (Bytes.unsafe_get b 0)); - Bytes.to_string b - -- let is_prefix str prefix = -+ let starts_with ~prefix str = - let n = length prefix in - length str >= n && sub str 0 n = prefix - -- let is_suffix str suffix = -+ let ends_with ~suffix str = - let sufflen = length suffix - and len = length str in - len >= sufflen && sub str (len - sufflen) sufflen = suffix -@@ -824,7 +824,7 @@ let unix_like = function - | "hurd" - | "linux" - | "minix" -> true -- | typ when String.is_suffix typ "bsd" -> true -+ | typ when String.ends_with "bsd" typ -> true - | _ -> false - - (** Return the last part of a string, after the specified separator. *) -diff --git a/common/mlstdutils/std_utils.mli b/common/mlstdutils/std_utils.mli -index 04c780a..fe6bf1a 100644 ---- a/common/mlstdutils/std_utils.mli -+++ b/common/mlstdutils/std_utils.mli -@@ -71,7 +71,7 @@ module List : sig - [f] returns false. - - For any list [xs] and function [f], -- [xs = takewhile f xs @ dropwhile f xs] *) -+ [xs = take_while f xs @ drop_while f xs] *) - - val take : int -> 'a list -> 'a list - (** [take n xs] returns the first [n] elements of [xs]. If [xs] is -@@ -236,10 +236,10 @@ module String : sig - val uppercase_ascii : string -> string - val capitalize_ascii : string -> string - -- val is_prefix : string -> string -> bool -- (** [is_prefix str prefix] returns true if [prefix] is a prefix of [str]. *) -- val is_suffix : string -> string -> bool -- (** [is_suffix str suffix] returns true if [suffix] is a suffix of [str]. *) -+ val starts_with : prefix:string -> string -> bool -+ (** Return true if [prefix] is a prefix of [str]. *) -+ val ends_with : suffix:string -> string -> bool -+ (** Return true if [suffix] is a suffix of [str]. *) - val find : string -> string -> int - (** [find str sub] searches for [sub] as a substring of [str]. If - found it returns the index. If not found, it returns [-1]. *) -diff --git a/common/mlstdutils/std_utils_tests.ml b/common/mlstdutils/std_utils_tests.ml -index 10046bd..133c672 100644 ---- a/common/mlstdutils/std_utils_tests.ml -+++ b/common/mlstdutils/std_utils_tests.ml -@@ -87,21 +87,23 @@ let () = - assert_bool "Char.mem" (not (Char.mem 'd' "abc")); - assert_bool "Char.mem" (not (Char.mem 'a' "")) - --(* Test Std_utils.String.is_prefix. *) -+(* Test Std_utils.String.starts_with. *) - let () = -- assert_bool "String.is_prefix,," (String.is_prefix "" ""); -- assert_bool "String.is_prefix,foo," (String.is_prefix "foo" ""); -- assert_bool "String.is_prefix,foo,foo" (String.is_prefix "foo" "foo"); -- assert_bool "String.is_prefix,foo123,foo" (String.is_prefix "foo123" "foo"); -- assert_bool "not (String.is_prefix,,foo" (not (String.is_prefix "" "foo")) -+ assert_bool "String.starts_with,," (String.starts_with "" ""); -+ assert_bool "String.starts_with,foo," (String.starts_with "" "foo"); -+ assert_bool "String.starts_with,foo,foo" (String.starts_with "foo" "foo"); -+ assert_bool "String.starts_with,foo123,foo" -+ (String.starts_with "foo" "foo123"); -+ assert_bool "not (String.starts_with,,foo" -+ (not (String.starts_with "foo" "")) - --(* Test Std_utils.String.is_suffix. *) -+(* Test Std_utils.String.ends_with. *) - let () = -- assert_bool "String.is_suffix,," (String.is_suffix "" ""); -- assert_bool "String.is_suffix,foo," (String.is_suffix "foo" ""); -- assert_bool "String.is_suffix,foo,foo" (String.is_suffix "foo" "foo"); -- assert_bool "String.is_suffix,123foo,foo" (String.is_suffix "123foo" "foo"); -- assert_bool "not String.is_suffix,,foo" (not (String.is_suffix "" "foo")) -+ assert_bool "String.ends_with,," (String.ends_with "" ""); -+ assert_bool "String.ends_with,foo," (String.ends_with "" "foo"); -+ assert_bool "String.ends_with,foo,foo" (String.ends_with "foo" "foo"); -+ assert_bool "String.ends_with,123foo,foo" (String.ends_with "foo" "123foo"); -+ assert_bool "not String.ends_with,,foo" (not (String.ends_with "foo" "")) - - (* Test Std_utils.String.find. *) - let () = -diff --git a/daemon/cryptsetup.ml b/daemon/cryptsetup.ml -index 9c0149b48..6f677aef0 100644 ---- a/daemon/cryptsetup.ml -+++ b/daemon/cryptsetup.ml -@@ -63,7 +63,7 @@ let cryptsetup_open ?(readonly = false) ?crypttype ?cipher device key mapname = - - let cryptsetup_close device = - (* Must be /dev/mapper/... *) -- if not (String.is_prefix device "/dev/mapper/") then -+ if not (String.starts_with "/dev/mapper/" device) then - failwithf "%s: you must call this on the /dev/mapper device created by cryptsetup-open" device; - - let mapname = String.sub device 12 (String.length device - 12) in -diff --git a/daemon/devsparts.ml b/daemon/devsparts.ml -index 639e163d4..6b45ebc8e 100644 ---- a/daemon/devsparts.ml -+++ b/daemon/devsparts.ml -@@ -38,18 +38,18 @@ let map_block_devices f = - fun file -> - let dev = Unix_utils.Realpath.realpath (sprintf "%s/%s" path file) in - (* Ignore non-/dev devices, and return without /dev/ prefix. *) -- if String.is_prefix dev "/dev/" then -+ if String.starts_with "/dev/" dev then - Some (String.sub dev 5 (String.length dev - 5)) - else - None - ) devs in - let devs = List.filter ( - fun dev -> -- String.is_prefix dev "sd" || -- String.is_prefix dev "hd" || -- String.is_prefix dev "ubd" || -- String.is_prefix dev "vd" || -- String.is_prefix dev "sr" -+ String.starts_with "sd" dev || -+ String.starts_with "hd" dev || -+ String.starts_with "ubd" dev || -+ String.starts_with "vd" dev || -+ String.starts_with "sr" dev - ) devs in - - (* Ignore the root device. *) -@@ -81,7 +81,7 @@ let map_md_devices f = - let devs = Array.to_list devs in - let devs = List.filter ( - fun dev -> -- String.is_prefix dev "md" && -+ String.starts_with "md" dev && - String.length dev >= 3 && Char.isdigit dev.[2] - ) devs in - List.map f devs -@@ -111,7 +111,7 @@ and add_partitions dev = - (* Look in /sys/block// for entries starting with - * , eg. /sys/block/sda/sda1. - *) -- let parts = List.filter (fun part -> String.is_prefix part dev) parts in -+ let parts = List.filter (fun part -> String.starts_with dev part) parts in - let parts = List.map ((^) "/dev/") parts in - sort_device_names parts - -@@ -133,7 +133,7 @@ let is_whole_device device = - (* A 'whole' block device will have a symlink to the device in its - * /sys/block directory - *) -- assert (String.is_prefix device "/dev/"); -+ assert (String.starts_with "/dev/" device); - let device = String.sub device 5 (String.length device - 5) in - let devpath = sprintf "/sys/block/%s/device" device in - -diff --git a/daemon/findfs.ml b/daemon/findfs.ml -index d5752869c..087aad27f 100644 ---- a/daemon/findfs.ml -+++ b/daemon/findfs.ml -@@ -46,8 +46,8 @@ and findfs tag str = - (* Trim trailing \n if present. *) - let out = String.trim out in - -- if String.is_prefix out "/dev/mapper/" || -- String.is_prefix out "/dev/dm-" then ( -+ if String.starts_with "/dev/mapper/" out || -+ String.starts_with "/dev/dm-" out then ( - match Lvm_utils.lv_canonical out with - | None -> - (* Ignore the case where 'out' doesn't appear to be an LV. -diff --git a/daemon/inspect_fs_unix.ml b/daemon/inspect_fs_unix.ml -index e27863e86..952a7cd15 100644 ---- a/daemon/inspect_fs_unix.ml -+++ b/daemon/inspect_fs_unix.ml -@@ -163,7 +163,7 @@ and distro_of_os_release_id = function - | "opencloudos" -> Some DISTRO_OPENCLOUDOS - | "tencentos" -> Some DISTRO_TENCENTOS - | "opensuse" -> Some DISTRO_OPENSUSE -- | s when String.is_prefix s "opensuse-" -> Some DISTRO_OPENSUSE -+ | s when String.starts_with "opensuse-" s -> Some DISTRO_OPENSUSE - | "pardus" -> Some DISTRO_PARDUS - | "pld" -> Some DISTRO_PLD_LINUX - | "rhel" -> Some DISTRO_RHEL -@@ -593,7 +593,7 @@ and check_hostname_from_file filename = - - let hostname = Chroot.f chroot read_small_file filename in - -- let keep_line line = line <> "" && not (String.is_prefix line "#") in -+ let keep_line line = line <> "" && not (String.starts_with "#" line) in - let lines = Option.map (List.filter keep_line) hostname in - match lines with - | None | Some [] -> None -@@ -699,11 +699,11 @@ and check_hostname_freebsd () = - let rec loop = function - | [] -> - raise Not_found -- | line :: _ when String.is_prefix line "hostname=\"" || -- String.is_prefix line "hostname='" -> -+ | line :: _ when String.starts_with "hostname=\"" line || -+ String.starts_with "hostname='" line -> - let len = String.length line - 10 - 1 in - String.sub line 10 len -- | line :: _ when String.is_prefix line "hostname=" -> -+ | line :: _ when String.starts_with "hostname=" line -> - let len = String.length line - 9 in - String.sub line 9 len - | _ :: lines -> -diff --git a/daemon/inspect_fs_unix_fstab.ml b/daemon/inspect_fs_unix_fstab.ml -index 395a1c794..1ec7cb1c1 100644 ---- a/daemon/inspect_fs_unix_fstab.ml -+++ b/daemon/inspect_fs_unix_fstab.ml -@@ -82,13 +82,13 @@ and check_fstab_entry md_map root_mountable os_type aug entry = - * /dev/iso9660/FREEBSD_INSTALL can be found in FreeBSD's - * installation discs. - *) -- if (String.is_prefix spec "/dev/fd" && -+ if (String.starts_with "/dev/fd" spec && - String.length spec >= 8 && Char.isdigit spec.[7]) || -- (String.is_prefix spec "/dev/cd" && -+ (String.starts_with "/dev/cd" spec && - String.length spec >= 8 && Char.isdigit spec.[7]) || - spec = "/dev/floppy" || - spec = "/dev/cdrom" || -- String.is_prefix spec "/dev/iso9660/" then -+ String.starts_with "/dev/iso9660/" spec then - return None; - - let mp = aug_get_noerrors aug (entry ^ "/file") in -@@ -103,20 +103,20 @@ and check_fstab_entry md_map root_mountable os_type aug entry = - if verbose () then eprintf "check_fstab_entry: mp=%s\n%!" mp; - - (* Ignore certain mountpoints. *) -- if String.is_prefix mp "/dev/" || -+ if String.starts_with "/dev/" mp || - mp = "/dev" || -- String.is_prefix mp "/media/" || -- String.is_prefix mp "/proc/" || -+ String.starts_with "/media/" mp || -+ String.starts_with "/proc/" mp || - mp = "/proc" || -- String.is_prefix mp "/selinux/" || -+ String.starts_with "/selinux/" mp || - mp = "/selinux" || -- String.is_prefix mp "/sys/" || -+ String.starts_with "/sys/" mp || - mp = "/sys" then - return None; - - let mountable = - (* Resolve UUID= and LABEL= to the actual device. *) -- if String.is_prefix spec "UUID=" then ( -+ if String.starts_with "UUID=" spec then ( - let uuid = String.sub spec 5 (String.length spec - 5) in - let uuid = shell_unquote uuid in - (* Just ignore the device if the UUID cannot be resolved. *) -@@ -125,7 +125,7 @@ and check_fstab_entry md_map root_mountable os_type aug entry = - with - Failure _ -> return None - ) -- else if String.is_prefix spec "LABEL=" then ( -+ else if String.starts_with "LABEL=" spec then ( - let label = String.sub spec 6 (String.length spec - 6) in - let label = shell_unquote label in - (* Just ignore the device if the label cannot be resolved. *) -@@ -135,7 +135,7 @@ and check_fstab_entry md_map root_mountable os_type aug entry = - Failure _ -> return None - ) - (* EFI partition UUIDs and labels. *) -- else if String.is_prefix spec "PARTUUID=" then ( -+ else if String.starts_with "PARTUUID=" spec then ( - let uuid = String.sub spec 9 (String.length spec - 9) in - let uuid = shell_unquote uuid in - (* Just ignore the device if the UUID cannot be resolved. *) -@@ -144,7 +144,7 @@ and check_fstab_entry md_map root_mountable os_type aug entry = - with - Failure _ -> return None - ) -- else if String.is_prefix spec "PARTLABEL=" then ( -+ else if String.starts_with "PARTLABEL=" spec then ( - let label = String.sub spec 10 (String.length spec - 10) in - let label = shell_unquote label in - (* Just ignore the device if the label cannot be resolved. *) -@@ -161,7 +161,7 @@ and check_fstab_entry md_map root_mountable os_type aug entry = - else if spec = "/dev/root" || (is_bsd && mp = "/") then - root_mountable - (* Resolve guest block device names. *) -- else if String.is_prefix spec "/dev/" then -+ else if String.starts_with "/dev/" spec then - resolve_fstab_device spec md_map os_type - (* In OpenBSD's fstab you can specify partitions - * on a disk by appending a period and a partition -@@ -347,7 +347,7 @@ and resolve_fstab_device spec md_map os_type = - eprintf "resolve_fstab_device: %s matched %s\n%!" spec what - in - -- if String.is_prefix spec "/dev/mapper" then ( -+ if String.starts_with "/dev/mapper" spec then ( - debug_matching "/dev/mapper"; - (* LVM2 does some strange munging on /dev/mapper paths for VGs and - * LVs which contain '-' character: -@@ -398,7 +398,7 @@ and resolve_fstab_device spec md_map os_type = - ) - - (* Ubuntu 22+ uses /dev/disk/by-uuid/ followed by a UUID. *) -- else if String.is_prefix spec "/dev/disk/by-uuid/" then ( -+ else if String.starts_with "/dev/disk/by-uuid/" spec then ( - debug_matching "diskbyuuid"; - let uuid = String.sub spec 18 (String.length spec - 18) in - try -diff --git a/daemon/inspect_fs_windows.ml b/daemon/inspect_fs_windows.ml -index 8bcda5eb8..dbaf4c362 100644 ---- a/daemon/inspect_fs_windows.ml -+++ b/daemon/inspect_fs_windows.ml -@@ -94,11 +94,11 @@ and get_windows_systemroot_from_boot_ini boot_ini_path = - *) - let rec loop = function - | [] -> None -- | str :: rest when String.is_prefix str "[operating systems]" -> -+ | str :: rest when String.starts_with "[operating systems]" str -> - let rec loop2 = function - | [] -> [] -- | str :: rest when String.is_prefix str "multi(" || -- String.is_prefix str "scsi(" -> -+ | str :: rest when String.starts_with "multi(" str || -+ String.starts_with "scsi(" str -> - str :: loop2 rest - | _ -> [] - in -@@ -340,7 +340,7 @@ and get_drive_mappings h root data = - let device = - if typ = Hivex.REG_BINARY then ( - if String.length blob >= 24 && -- String.is_prefix blob "DMIO:ID:" (* GPT *) then -+ String.starts_with "DMIO:ID:" blob (* GPT *) then - map_registry_disk_blob_gpt (Lazy.force partitions) blob - else if String.length blob = 12 then - map_registry_disk_blob_mbr (Lazy.force devices) blob -diff --git a/daemon/ldm.ml b/daemon/ldm.ml -index 0aa9bc9de..2710f71c2 100644 ---- a/daemon/ldm.ml -+++ b/daemon/ldm.ml -@@ -38,7 +38,7 @@ and list prefix = - let dir = Sys.readdir "/dev/mapper" in - let dir = Array.to_list dir in - let dir = -- List.filter (fun d -> String.is_prefix d prefix) dir in -+ List.filter (fun d -> String.starts_with prefix d) dir in - let dir = List.map ((^) "/dev/mapper/") dir in - List.sort compare dir - ) -diff --git a/daemon/listfs.ml b/daemon/listfs.ml -index dfc5ad5a5..0139e927d 100644 ---- a/daemon/listfs.ml -+++ b/daemon/listfs.ml -@@ -73,18 +73,18 @@ let rec list_filesystems () = - *) - and is_not_partitioned_device device = - let device = -- if String.is_prefix device "/dev/mapper/" then -+ if String.starts_with "/dev/mapper/" device then - Unix_utils.Realpath.realpath device - else - device in -- assert (String.is_prefix device "/dev/"); -+ assert (String.starts_with "/dev/" device); - let dev_name = String.sub device 5 (String.length device - 5) in - let dev_dir = "/sys/block/" ^ dev_name in - - (* Open the device's directory under /sys/block/ and - * look for entries starting with , eg. /sys/block/sda/sda1 - *) -- let is_device_partition file = String.is_prefix file dev_name in -+ let is_device_partition file = String.starts_with dev_name file in - let files = Array.to_list (Sys.readdir dev_dir) in - let has_partition = List.exists is_device_partition files in - -@@ -157,7 +157,7 @@ and check_with_vfs_type ret device = - * for things which are members of some RAID or LVM set, most - * importantly "LVM2_member" which is a PV. - *) -- else if String.is_suffix vfs_type "_member" then -+ else if String.ends_with "_member" vfs_type then - () - - (* Ignore encrypted partitions. These are also containers, as above. *) -diff --git a/daemon/md.ml b/daemon/md.ml -index b4ba3b442..f2679a02d 100644 ---- a/daemon/md.ml -+++ b/daemon/md.ml -@@ -68,7 +68,7 @@ let md_detail md = - * remainder to lower case. - *) - let key = -- if String.is_prefix key "MD_" then -+ if String.starts_with "MD_" key then - String.sub key 3 (String.length key - 3) - else - key in -diff --git a/daemon/mount_utils.ml b/daemon/mount_utils.ml -index 57d3eb6cf..dab34d037 100644 ---- a/daemon/mount_utils.ml -+++ b/daemon/mount_utils.ml -@@ -61,8 +61,8 @@ let rec umount_all () = - let mp = proc_unmangle_path mp in - - (* Allow a mount directory like "/sysroot" or "/sysroot/..." *) -- if (sysroot_len > 0 && String.is_prefix mp sysroot) || -- (String.is_prefix mp sysroot && -+ if (sysroot_len > 0 && String.starts_with sysroot mp) || -+ (String.starts_with sysroot mp && - String.length mp > sysroot_len && - mp.[sysroot_len] = '/') then - List.push_front mp mps -diff --git a/daemon/sfdisk.ml b/daemon/sfdisk.ml -index 3265d1e83..bdba9dc17 100644 ---- a/daemon/sfdisk.ml -+++ b/daemon/sfdisk.ml -@@ -142,22 +142,22 @@ let part_get_gpt_attributes device partnum = - let out = String.sub out 1 (len-1) in - loop out acc - ) -- else if String.is_prefix out "RequiredPartition" then ( -+ else if String.starts_with "RequiredPartition" out then ( - let acc = 0 :: acc in - let out = String.sub out 17 (len-17) in - loop out acc - ) -- else if String.is_prefix out "NoBlockIOProtocol" then ( -+ else if String.starts_with "NoBlockIOProtocol" out then ( - let acc = 1 :: acc in - let out = String.sub out 17 (len-17) in - loop out acc - ) -- else if String.is_prefix out "LegacyBIOSBootable" then ( -+ else if String.starts_with "LegacyBIOSBootable" out then ( - let acc = 2 :: acc in - let out = String.sub out 18 (len-18) in - loop out acc - ) -- else if String.is_prefix out "GUID:" then ( -+ else if String.starts_with "GUID:" out then ( - let out = String.sub out 5 (len-5) in - loop out acc - ) -diff --git a/daemon/utils.ml b/daemon/utils.ml -index 71d1cf25c..40584c9f1 100644 ---- a/daemon/utils.ml -+++ b/daemon/utils.ml -@@ -85,11 +85,11 @@ let commandr ?(fold_stdout_on_stderr = false) prog args = - if verbose () then ( - if stdout <> "" then ( - eprintf "command: %s: stdout:\n%s%!" prog stdout; -- if not (String.is_suffix stdout "\n") then eprintf "\n%!" -+ if not (String.ends_with "\n" stdout) then eprintf "\n%!" - ); - if stderr <> "" then ( - eprintf "command: %s: stderr:\n%s%!" prog stderr; -- if not (String.is_suffix stderr "\n") then eprintf "\n%!" -+ if not (String.ends_with "\n" stderr) then eprintf "\n%!" - ) - ); - -@@ -114,7 +114,7 @@ let command ?fold_stdout_on_stderr prog args = - let split_device_partition dev = - (* Skip /dev/ prefix if present. *) - let dev = -- if String.is_prefix dev "/dev/" then -+ if String.starts_with "/dev/" dev then - String.sub dev 5 (String.length dev - 5) - else dev in - -diff --git a/generator/daemon.ml b/generator/daemon.ml -index da5593ce1..6221531d2 100644 ---- a/generator/daemon.ml -+++ b/generator/daemon.ml -@@ -511,7 +511,7 @@ let rec generate_daemon_caml_interface modname () = - generate_header OCamlStyle GPLv2plus; - - let is_ocaml_module_function = function -- | { impl = OCaml m } when String.is_prefix m (modname ^ ".") -> true -+ | { impl = OCaml m } when String.starts_with (modname ^ ".") m -> true - | { impl = OCaml _ } -> false - | { impl = C } -> false - in --- -2.47.1 - diff --git a/0006-docs-Update-release-notes-for-1.56.patch b/0006-docs-Update-release-notes-for-1.56.patch deleted file mode 100644 index 1a96409..0000000 --- a/0006-docs-Update-release-notes-for-1.56.patch +++ /dev/null @@ -1,57 +0,0 @@ -From 1c2b94f09521698ac35fc282f7e03b8cedbf094b Mon Sep 17 00:00:00 2001 -From: "Richard W.M. Jones" -Date: Tue, 13 May 2025 13:14:00 +0100 -Subject: [PATCH] docs: Update release notes for 1.56 - ---- - docs/guestfs-release-notes-1.56.pod | 13 +++++++++++++ - 1 file changed, 13 insertions(+) - -diff --git a/docs/guestfs-release-notes-1.56.pod b/docs/guestfs-release-notes-1.56.pod -index 12380df0d..bab14c139 100644 ---- a/docs/guestfs-release-notes-1.56.pod -+++ b/docs/guestfs-release-notes-1.56.pod -@@ -18,6 +18,8 @@ Add support for TencentOS (Denise Cheng). - Inspection of Ubuntu 22+ guests that use a split F configuration - now works properly (thanks Jaroslav Spanko, Daniel Berrange). - -+Inspecting guests that have duplicated root mountpoints now works. -+ - =head2 API - - New C and C APIs which allow you to capture -@@ -66,6 +68,9 @@ dependencies (thanks Mohamed Akram). - When using C<./configure --disable-daemon> we no longer require augeas - and hivex (thanks Mohamed Akram). - -+C support has been dropped. The project is unmaintained -+upstream. -+ - =head2 Internals - - The tests were modified to use a set of common functions and remove -@@ -86,6 +91,9 @@ Some deprecated autoconf macros are no longer used. - We no longer emit a false warning about C when creating a - block device. - -+Some internal OCaml List and String functions that we used have been -+replaced by ones from the OCaml stdlib, reducing code maintenance. -+ - =head2 Bugs fixed - - =begin comment -@@ -116,6 +124,11 @@ fstrim on a RHEL 7.2-created XFS filesystem does not trim as much as expected - - Run fstrim twice to work around incorrect fstrim behaviour in RHEL 9 kernel - -+=item L -+ -+virt-v2v fails with mount exited with status 32: mount: /sysroot: -+/dev/sda2 already mounted on /sysroot. [rhel-9.7] -+ - =item L - - 1.54.0: gdisk/test-expand-gpt.pl fails --- -2.47.1 - diff --git a/libguestfs.spec b/libguestfs.spec index 6569496..5d5fb2c 100644 --- a/libguestfs.spec +++ b/libguestfs.spec @@ -41,7 +41,7 @@ ExcludeArch: %{ix86} Summary: Access and modify virtual machine disk images Name: libguestfs Epoch: 1 -Version: 1.55.11 +Version: 1.55.12 Release: 1%{?dist} License: LGPL-2.1-or-later @@ -80,15 +80,10 @@ Source8: copy-patches.sh # https://github.com/libguestfs/libguestfs/commits/rhel-10.1 # Patches. -Patch0001: 0001-appliance-Remove-zfs-fuse.patch -Patch0002: 0002-Update-common-submodule.patch -Patch0003: 0003-Update-common-submodule.patch -Patch0004: 0004-ocaml-dep.sh.in-Remove-mlgettext-subdirectory.patch -Patch0005: 0005-Update-common-submodule.patch -Patch0006: 0006-docs-Update-release-notes-for-1.56.patch -Patch0007: 0007-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch -Patch0008: 0008-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch -Patch0009: 0009-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch +Patch0001: 0001-m4-Add-junk-required-to-make-AM_GNU_GETTEXT-work.patch +Patch0002: 0002-RHEL-Disable-unsupported-remote-drive-protocols-RHBZ.patch +Patch0003: 0003-RHEL-Reject-use-of-libguestfs-winsupport-features-ex.patch +Patch0004: 0004-RHEL-appliance-init-Run-depmod-a-to-rebuild-kernel-m.patch BuildRequires: autoconf, automake, libtool, gettext-devel @@ -1076,8 +1071,8 @@ rm ocaml/html/.gitignore %changelog -* Tue May 13 2025 Richard W.M. Jones - 1:1.55.11-1 -- Rebase to libguestfs 1.55.11 +* Tue May 13 2025 Richard W.M. Jones - 1:1.55.12-1 +- Rebase to libguestfs 1.55.12 resolves: RHEL-81733 - Include host kernel information in libguestfs debugging output resolves: RHEL-83026 @@ -1088,6 +1083,8 @@ rm ocaml/html/.gitignore - Fix gating test - Fix inspection with duplicated root mountpoint resolves: RHEL-90170 +- Add btrfs-scrub-full API + resolves: RHEL-91936 * Tue Nov 26 2024 Richard W.M. Jones - 1:1.54.0-5 - Rebase to libguestfs 1.54.0 diff --git a/sources b/sources index 2317097..31a585f 100644 --- a/sources +++ b/sources @@ -1,2 +1,2 @@ -SHA512 (libguestfs-1.55.11.tar.gz) = 3c2bf753ad1bf9dd1809f50e9e39dd154e97a33de7848b9d08feac23f543cc1100b928f1533a6ea4882125202793694c2917ea5561ccbd0c72154a7313cf9050 -SHA512 (libguestfs-1.55.11.tar.gz.sig) = 42764c07832f02349f8d28482aa2aefd394b66b940d84765623491879b8960b22f567c51565f32dab204cc83aa8fa26b46fd181c10a43da05db29d2ee704deb0 +SHA512 (libguestfs-1.55.12.tar.gz) = 87f7c209e5b5787c212746a1fb434342b75b9dd80dd4fc01b53877150f7d194d3d856b0acac0606236029601b595e2c0db8af582b00364cf162e91394c74be10 +SHA512 (libguestfs-1.55.12.tar.gz.sig) = 177730330cf94cf2a3d17fee3427482b2206d824f24928d4a5fa4bf0ef3248f319d648a17fa337f23af7b9c39b62b86eab6d0465454efda7b3c6e5a306a74c99