diff options
Diffstat (limited to 'package/libxslt/patches/patch-ltmain_sh')
| -rw-r--r-- | package/libxslt/patches/patch-ltmain_sh | 494 |
1 files changed, 494 insertions, 0 deletions
diff --git a/package/libxslt/patches/patch-ltmain_sh b/package/libxslt/patches/patch-ltmain_sh new file mode 100644 index 000000000..6a8633366 --- /dev/null +++ b/package/libxslt/patches/patch-ltmain_sh @@ -0,0 +1,494 @@ +--- libxslt-1.1.37.orig/ltmain.sh 2022-08-17 15:33:08.000000000 +0200 ++++ libxslt-1.1.37/ltmain.sh 2023-01-04 18:05:32.281243849 +0100 +@@ -31,7 +31,7 @@ + + PROGRAM=libtool + PACKAGE=libtool +-VERSION="2.4.6 Debian-2.4.6-14" ++VERSION=2.4.6 + package_revision=2.4.6 + + +@@ -387,7 +387,7 @@ EXIT_SKIP=77 # $? = 77 is used to indi + # putting '$debug_cmd' at the start of all your functions, you can get + # bash to show function call trace with: + # +-# debug_cmd='echo "${FUNCNAME[0]} $*" >&2' bash your-script-name ++# debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name + debug_cmd=${debug_cmd-":"} + exit_cmd=: + +@@ -1370,7 +1370,7 @@ func_lt_ver () + #! /bin/sh + + # Set a version string for this script. +-scriptversion=2015-10-07.11; # UTC ++scriptversion=2014-01-07.03; # UTC + + # A portable, pluggable option parser for Bourne shell. + # Written by Gary V. Vaughan, 2010 +@@ -1530,8 +1530,6 @@ func_run_hooks () + { + $debug_cmd + +- _G_rc_run_hooks=false +- + case " $hookable_fns " in + *" $1 "*) ;; + *) func_fatal_error "'$1' does not support hook funcions.n" ;; +@@ -1540,16 +1538,16 @@ func_run_hooks () + eval _G_hook_fns=\$$1_hooks; shift + + for _G_hook in $_G_hook_fns; do +- if eval $_G_hook '"$@"'; then +- # store returned options list back into positional +- # parameters for next 'cmd' execution. +- eval _G_hook_result=\$${_G_hook}_result +- eval set dummy "$_G_hook_result"; shift +- _G_rc_run_hooks=: +- fi ++ eval $_G_hook '"$@"' ++ ++ # store returned options list back into positional ++ # parameters for next 'cmd' execution. ++ eval _G_hook_result=\$${_G_hook}_result ++ eval set dummy "$_G_hook_result"; shift + done + +- $_G_rc_run_hooks && func_run_hooks_result=$_G_hook_result ++ func_quote_for_eval ${1+"$@"} ++ func_run_hooks_result=$func_quote_for_eval_result + } + + +@@ -1559,16 +1557,10 @@ func_run_hooks () + ## --------------- ## + + # In order to add your own option parsing hooks, you must accept the +-# full positional parameter list in your hook function, you may remove/edit +-# any options that you action, and then pass back the remaining unprocessed ++# full positional parameter list in your hook function, remove any ++# options that you action, and then pass back the remaining unprocessed + # options in '<hooked_function_name>_result', escaped suitably for +-# 'eval'. In this case you also must return $EXIT_SUCCESS to let the +-# hook's caller know that it should pay attention to +-# '<hooked_function_name>_result'. Returning $EXIT_FAILURE signalizes that +-# arguments are left untouched by the hook and therefore caller will ignore the +-# result variable. +-# +-# Like this: ++# 'eval'. Like this: + # + # my_options_prep () + # { +@@ -1578,11 +1570,9 @@ func_run_hooks () + # usage_message=$usage_message' + # -s, --silent don'\''t print informational messages + # ' +-# # No change in '$@' (ignored completely by this hook). There is +-# # no need to do the equivalent (but slower) action: +-# # func_quote_for_eval ${1+"$@"} +-# # my_options_prep_result=$func_quote_for_eval_result +-# false ++# ++# func_quote_for_eval ${1+"$@"} ++# my_options_prep_result=$func_quote_for_eval_result + # } + # func_add_hook func_options_prep my_options_prep + # +@@ -1591,37 +1581,25 @@ func_run_hooks () + # { + # $debug_cmd + # +-# args_changed=false +-# + # # Note that for efficiency, we parse as many options as we can + # # recognise in a loop before passing the remainder back to the + # # caller on the first unrecognised argument we encounter. + # while test $# -gt 0; do + # opt=$1; shift + # case $opt in +-# --silent|-s) opt_silent=: +-# args_changed=: +-# ;; ++# --silent|-s) opt_silent=: ;; + # # Separate non-argument short options: + # -s*) func_split_short_opt "$_G_opt" + # set dummy "$func_split_short_opt_name" \ + # "-$func_split_short_opt_arg" ${1+"$@"} + # shift +-# args_changed=: + # ;; +-# *) # Make sure the first unrecognised option "$_G_opt" +-# # is added back to "$@", we could need that later +-# # if $args_changed is true. +-# set dummy "$_G_opt" ${1+"$@"}; shift; break ;; ++# *) set dummy "$_G_opt" "$*"; shift; break ;; + # esac + # done + # +-# if $args_changed; then +-# func_quote_for_eval ${1+"$@"} +-# my_silent_option_result=$func_quote_for_eval_result +-# fi +-# +-# $args_changed ++# func_quote_for_eval ${1+"$@"} ++# my_silent_option_result=$func_quote_for_eval_result + # } + # func_add_hook func_parse_options my_silent_option + # +@@ -1633,32 +1611,16 @@ func_run_hooks () + # $opt_silent && $opt_verbose && func_fatal_help "\ + # '--silent' and '--verbose' options are mutually exclusive." + # +-# false ++# func_quote_for_eval ${1+"$@"} ++# my_option_validation_result=$func_quote_for_eval_result + # } + # func_add_hook func_validate_options my_option_validation + # +-# You'll also need to manually amend $usage_message to reflect the extra ++# You'll alse need to manually amend $usage_message to reflect the extra + # options you parse. It's preferable to append if you can, so that + # multiple option parsing hooks can be added safely. + + +-# func_options_finish [ARG]... +-# ---------------------------- +-# Finishing the option parse loop (call 'func_options' hooks ATM). +-func_options_finish () +-{ +- $debug_cmd +- +- _G_func_options_finish_exit=false +- if func_run_hooks func_options ${1+"$@"}; then +- func_options_finish_result=$func_run_hooks_result +- _G_func_options_finish_exit=: +- fi +- +- $_G_func_options_finish_exit +-} +- +- + # func_options [ARG]... + # --------------------- + # All the functions called inside func_options are hookable. See the +@@ -1668,28 +1630,17 @@ func_options () + { + $debug_cmd + +- _G_rc_options=false +- +- for my_func in options_prep parse_options validate_options options_finish +- do +- if eval func_$my_func '${1+"$@"}'; then +- eval _G_res_var='$'"func_${my_func}_result" +- eval set dummy "$_G_res_var" ; shift +- _G_rc_options=: +- fi +- done ++ func_options_prep ${1+"$@"} ++ eval func_parse_options \ ++ ${func_options_prep_result+"$func_options_prep_result"} ++ eval func_validate_options \ ++ ${func_parse_options_result+"$func_parse_options_result"} + +- # Save modified positional parameters for caller. As a top-level +- # options-parser function we always need to set the 'func_options_result' +- # variable (regardless the $_G_rc_options value). +- if $_G_rc_options; then +- func_options_result=$_G_res_var +- else +- func_quote_for_eval ${1+"$@"} +- func_options_result=$func_quote_for_eval_result +- fi ++ eval func_run_hooks func_options \ ++ ${func_validate_options_result+"$func_validate_options_result"} + +- $_G_rc_options ++ # save modified positional parameters for caller ++ func_options_result=$func_run_hooks_result + } + + +@@ -1698,9 +1649,9 @@ func_options () + # All initialisations required before starting the option parse loop. + # Note that when calling hook functions, we pass through the list of + # positional parameters. If a hook function modifies that list, and +-# needs to propagate that back to rest of this script, then the complete ++# needs to propogate that back to rest of this script, then the complete + # modified list must be put in 'func_run_hooks_result' before +-# returning $EXIT_SUCCESS (otherwise $EXIT_FAILURE is returned). ++# returning. + func_hookable func_options_prep + func_options_prep () + { +@@ -1710,14 +1661,10 @@ func_options_prep () + opt_verbose=false + opt_warning_types= + +- _G_rc_options_prep=false +- if func_run_hooks func_options_prep ${1+"$@"}; then +- _G_rc_options_prep=: +- # save modified positional parameters for caller +- func_options_prep_result=$func_run_hooks_result +- fi ++ func_run_hooks func_options_prep ${1+"$@"} + +- $_G_rc_options_prep ++ # save modified positional parameters for caller ++ func_options_prep_result=$func_run_hooks_result + } + + +@@ -1731,20 +1678,18 @@ func_parse_options () + + func_parse_options_result= + +- _G_rc_parse_options=false + # this just eases exit handling + while test $# -gt 0; do + # Defer to hook functions for initial option parsing, so they + # get priority in the event of reusing an option name. +- if func_run_hooks func_parse_options ${1+"$@"}; then +- eval set dummy "$func_run_hooks_result"; shift +- _G_rc_parse_options=: +- fi ++ func_run_hooks func_parse_options ${1+"$@"} ++ ++ # Adjust func_parse_options positional parameters to match ++ eval set dummy "$func_run_hooks_result"; shift + + # Break out of the loop if we already parsed every option. + test $# -gt 0 || break + +- _G_match_parse_options=: + _G_opt=$1 + shift + case $_G_opt in +@@ -1759,10 +1704,7 @@ func_parse_options () + ;; + + --warnings|--warning|-W) +- if test $# = 0 && func_missing_arg $_G_opt; then +- _G_rc_parse_options=: +- break +- fi ++ test $# = 0 && func_missing_arg $_G_opt && break + case " $warning_categories $1" in + *" $1 "*) + # trailing space prevents matching last $1 above +@@ -1815,25 +1757,15 @@ func_parse_options () + shift + ;; + +- --) _G_rc_parse_options=: ; break ;; ++ --) break ;; + -*) func_fatal_help "unrecognised option: '$_G_opt'" ;; +- *) set dummy "$_G_opt" ${1+"$@"}; shift +- _G_match_parse_options=false +- break +- ;; ++ *) set dummy "$_G_opt" ${1+"$@"}; shift; break ;; + esac +- +- $_G_match_parse_options && _G_rc_parse_options=: + done + +- +- if $_G_rc_parse_options; then +- # save modified positional parameters for caller +- func_quote_for_eval ${1+"$@"} +- func_parse_options_result=$func_quote_for_eval_result +- fi +- +- $_G_rc_parse_options ++ # save modified positional parameters for caller ++ func_quote_for_eval ${1+"$@"} ++ func_parse_options_result=$func_quote_for_eval_result + } + + +@@ -1846,21 +1778,16 @@ func_validate_options () + { + $debug_cmd + +- _G_rc_validate_options=false +- + # Display all warnings if -W was not given. + test -n "$opt_warning_types" || opt_warning_types=" $warning_categories" + +- if func_run_hooks func_validate_options ${1+"$@"}; then +- # save modified positional parameters for caller +- func_validate_options_result=$func_run_hooks_result +- _G_rc_validate_options=: +- fi ++ func_run_hooks func_validate_options ${1+"$@"} + + # Bail if the options were screwed! + $exit_cmd $EXIT_FAILURE + +- $_G_rc_validate_options ++ # save modified positional parameters for caller ++ func_validate_options_result=$func_run_hooks_result + } + + +@@ -2141,12 +2068,12 @@ include the following information: + compiler: $LTCC + compiler flags: $LTCFLAGS + linker: $LD (gnu? $with_gnu_ld) +- version: $progname $scriptversion Debian-2.4.6-14 ++ version: $progname (GNU libtool) 2.4.6 + automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q` + autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q` + + Report bugs to <bug-libtool@gnu.org>. +-GNU libtool home page: <http://www.gnu.org/s/libtool/>. ++GNU libtool home page: <http://www.gnu.org/software/libtool/>. + General help using GNU software: <http://www.gnu.org/gethelp/>." + exit 0 + } +@@ -2343,8 +2270,6 @@ libtool_options_prep () + nonopt= + preserve_args= + +- _G_rc_lt_options_prep=: +- + # Shorthand for --mode=foo, only valid as the first argument + case $1 in + clean|clea|cle|cl) +@@ -2368,18 +2293,11 @@ libtool_options_prep () + uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u) + shift; set dummy --mode uninstall ${1+"$@"}; shift + ;; +- *) +- _G_rc_lt_options_prep=false +- ;; + esac + +- if $_G_rc_lt_options_prep; then +- # Pass back the list of options. +- func_quote_for_eval ${1+"$@"} +- libtool_options_prep_result=$func_quote_for_eval_result +- fi +- +- $_G_rc_lt_options_prep ++ # Pass back the list of options. ++ func_quote_for_eval ${1+"$@"} ++ libtool_options_prep_result=$func_quote_for_eval_result + } + func_add_hook func_options_prep libtool_options_prep + +@@ -2391,12 +2309,9 @@ libtool_parse_options () + { + $debug_cmd + +- _G_rc_lt_parse_options=false +- + # Perform our own loop to consume as many options as possible in + # each iteration. + while test $# -gt 0; do +- _G_match_lt_parse_options=: + _G_opt=$1 + shift + case $_G_opt in +@@ -2471,22 +2386,15 @@ libtool_parse_options () + func_append preserve_args " $_G_opt" + ;; + +- # An option not handled by this hook function: +- *) set dummy "$_G_opt" ${1+"$@"} ; shift +- _G_match_lt_parse_options=false +- break +- ;; ++ # An option not handled by this hook function: ++ *) set dummy "$_G_opt" ${1+"$@"}; shift; break ;; + esac +- $_G_match_lt_parse_options && _G_rc_lt_parse_options=: + done + +- if $_G_rc_lt_parse_options; then +- # save modified positional parameters for caller +- func_quote_for_eval ${1+"$@"} +- libtool_parse_options_result=$func_quote_for_eval_result +- fi + +- $_G_rc_lt_parse_options ++ # save modified positional parameters for caller ++ func_quote_for_eval ${1+"$@"} ++ libtool_parse_options_result=$func_quote_for_eval_result + } + func_add_hook func_parse_options libtool_parse_options + +@@ -7364,16 +7272,10 @@ func_mode_link () + # -tp=* Portland pgcc target processor selection + # --sysroot=* for sysroot support + # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization +- # -specs=* GCC specs files + # -stdlib=* select c++ std lib with clang +- # -fsanitize=* Clang/GCC memory and address sanitizer +- # -fuse-ld=* Linker select flags for GCC +- # -static-* direct GCC to link specific libraries statically +- # -fcilkplus Cilk Plus language extension features for C/C++ + -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ + -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \ +- -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \ +- -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus) ++ -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*) + func_quote_for_eval "$arg" + arg=$func_quote_for_eval_result + func_append compile_command " $arg" +@@ -7666,10 +7568,7 @@ func_mode_link () + case $pass in + dlopen) libs=$dlfiles ;; + dlpreopen) libs=$dlprefiles ;; +- link) +- libs="$deplibs %DEPLIBS%" +- test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs" +- ;; ++ link) libs="$deplibs %DEPLIBS% $dependency_libs" ;; + esac + fi + if test lib,dlpreopen = "$linkmode,$pass"; then +@@ -7988,19 +7887,19 @@ func_mode_link () + # It is a libtool convenience library, so add in its objects. + func_append convenience " $ladir/$objdir/$old_library" + func_append old_convenience " $ladir/$objdir/$old_library" +- tmp_libs= +- for deplib in $dependency_libs; do +- deplibs="$deplib $deplibs" +- if $opt_preserve_dup_deps; then +- case "$tmp_libs " in +- *" $deplib "*) func_append specialdeplibs " $deplib" ;; +- esac +- fi +- func_append tmp_libs " $deplib" +- done + elif test prog != "$linkmode" && test lib != "$linkmode"; then + func_fatal_error "'$lib' is not a convenience library" + fi ++ tmp_libs= ++ for deplib in $dependency_libs; do ++ deplibs="$deplib $deplibs" ++ if $opt_preserve_dup_deps; then ++ case "$tmp_libs " in ++ *" $deplib "*) func_append specialdeplibs " $deplib" ;; ++ esac ++ fi ++ func_append tmp_libs " $deplib" ++ done + continue + fi # $pass = conv + +@@ -8924,9 +8823,6 @@ func_mode_link () + revision=$number_minor + lt_irix_increment=no + ;; +- *) +- func_fatal_configuration "$modename: unknown library version type '$version_type'" +- ;; + esac + ;; + no) |