Version in base suite: 5.8.1-1
Base version: xz-utils_5.8.1-1
Target version: xz-utils_5.8.3-0+deb13u1
Base file: /srv/ftp-master.debian.org/ftp/pool/main/x/xz-utils/xz-utils_5.8.1-1.dsc
Target file: /srv/ftp-master.debian.org/policy/pool/main/x/xz-utils/xz-utils_5.8.3-0+deb13u1.dsc
/srv/release.debian.org/tmp/TeSVVlQ6nq/xz-utils-5.8.3/po/es.gmo |binary
xz-utils-5.8.3/CMakeLists.txt | 143
xz-utils-5.8.3/COPYING.GPLv2 | 9
xz-utils-5.8.3/COPYING.LGPLv2.1 | 9
xz-utils-5.8.3/ChangeLog | 2063 +++++
xz-utils-5.8.3/Makefile.in | 18
xz-utils-5.8.3/NEWS | 126
xz-utils-5.8.3/THANKS | 407 -
xz-utils-5.8.3/aclocal.m4 | 74
xz-utils-5.8.3/build-aux/compile | 35
xz-utils-5.8.3/build-aux/config.guess | 17
xz-utils-5.8.3/build-aux/config.sub | 28
xz-utils-5.8.3/build-aux/depcomp | 8
xz-utils-5.8.3/build-aux/install-sh | 6
xz-utils-5.8.3/build-aux/ltmain.sh | 207
xz-utils-5.8.3/build-aux/manconv.sh | 8
xz-utils-5.8.3/build-aux/missing | 8
xz-utils-5.8.3/build-aux/test-driver | 8
xz-utils-5.8.3/cmake/tuklib_cpucores.cmake | 4
xz-utils-5.8.3/cmake/tuklib_integer.cmake | 245
xz-utils-5.8.3/cmake/tuklib_physmem.cmake | 2
xz-utils-5.8.3/config.h.in | 10
xz-utils-5.8.3/configure | 3998 +++++-----
xz-utils-5.8.3/configure.ac | 37
xz-utils-5.8.3/debian/changelog | 13
xz-utils-5.8.3/debian/control | 2
xz-utils-5.8.3/debian/gbp.conf | 49
xz-utils-5.8.3/debian/salsa-ci.yml | 22
xz-utils-5.8.3/debug/Makefile.in | 6
xz-utils-5.8.3/doc/man/txt/lzmainfo.txt | 41
xz-utils-5.8.3/doc/man/txt/xz.txt | 3133 +++----
xz-utils-5.8.3/doc/man/txt/xzdec.txt | 110
xz-utils-5.8.3/doc/man/txt/xzdiff.txt | 54
xz-utils-5.8.3/doc/man/txt/xzgrep.txt | 81
xz-utils-5.8.3/doc/man/txt/xzless.txt | 48
xz-utils-5.8.3/doc/man/txt/xzmore.txt | 37
xz-utils-5.8.3/doxygen/Doxyfile | 8
xz-utils-5.8.3/lib/Makefile.in | 6
xz-utils-5.8.3/m4/libtool.m4 | 640 +
xz-utils-5.8.3/m4/ltoptions.m4 | 56
xz-utils-5.8.3/m4/ltsugar.m4 | 2
xz-utils-5.8.3/m4/ltversion.m4 | 12
xz-utils-5.8.3/m4/lt~obsolete.m4 | 2
xz-utils-5.8.3/m4/tuklib_integer.m4 | 146
xz-utils-5.8.3/po/Makevars | 2
xz-utils-5.8.3/po/POTFILES.in | 1
xz-utils-5.8.3/po/ca.po | 148
xz-utils-5.8.3/po/cs.po | 148
xz-utils-5.8.3/po/da.po | 148
xz-utils-5.8.3/po/de.po | 148
xz-utils-5.8.3/po/eo.po | 148
xz-utils-5.8.3/po/es.po | 158
xz-utils-5.8.3/po/fi.po | 148
xz-utils-5.8.3/po/fr.po | 148
xz-utils-5.8.3/po/hr.po | 148
xz-utils-5.8.3/po/hu.po | 148
xz-utils-5.8.3/po/it.po | 148
xz-utils-5.8.3/po/ka.po | 148
xz-utils-5.8.3/po/ko.po | 148
xz-utils-5.8.3/po/nl.po | 148
xz-utils-5.8.3/po/pl.po | 148
xz-utils-5.8.3/po/pt.po | 148
xz-utils-5.8.3/po/pt_BR.po | 148
xz-utils-5.8.3/po/ro.po | 148
xz-utils-5.8.3/po/sr.po | 148
xz-utils-5.8.3/po/sv.po | 148
xz-utils-5.8.3/po/tr.po | 148
xz-utils-5.8.3/po/uk.po | 148
xz-utils-5.8.3/po/vi.po | 148
xz-utils-5.8.3/po/xz.pot | 150
xz-utils-5.8.3/po/zh_CN.po | 148
xz-utils-5.8.3/po/zh_TW.po | 148
xz-utils-5.8.3/po4a/ar.po | 3905 +++++++++
xz-utils-5.8.3/po4a/de.po | 14
xz-utils-5.8.3/po4a/fr.po | 9
xz-utils-5.8.3/po4a/it.po | 15
xz-utils-5.8.3/po4a/ko.po | 17
xz-utils-5.8.3/po4a/man/ar/lzmainfo.1 | 41
xz-utils-5.8.3/po4a/man/ar/xz.1 | 1791 ++++
xz-utils-5.8.3/po4a/man/ar/xzdec.1 | 77
xz-utils-5.8.3/po4a/man/ar/xzdiff.1 | 52
xz-utils-5.8.3/po4a/man/ar/xzgrep.1 | 89
xz-utils-5.8.3/po4a/man/ar/xzless.1 | 45
xz-utils-5.8.3/po4a/man/ar/xzmore.1 | 47
xz-utils-5.8.3/po4a/man/de/xz.1 | 18
xz-utils-5.8.3/po4a/man/fr/xz.1 | 17
xz-utils-5.8.3/po4a/man/it/xz.1 | 19
xz-utils-5.8.3/po4a/man/ko/xz.1 | 10
xz-utils-5.8.3/po4a/man/pt_BR/xz.1 | 17
xz-utils-5.8.3/po4a/man/ro/lzmainfo.1 | 1
xz-utils-5.8.3/po4a/man/ro/xz.1 | 21
xz-utils-5.8.3/po4a/man/ro/xzdec.1 | 1
xz-utils-5.8.3/po4a/man/ro/xzdiff.1 | 1
xz-utils-5.8.3/po4a/man/ro/xzgrep.1 | 1
xz-utils-5.8.3/po4a/man/ro/xzless.1 | 1
xz-utils-5.8.3/po4a/man/ro/xzmore.1 | 1
xz-utils-5.8.3/po4a/man/sr/xz.1 | 54
xz-utils-5.8.3/po4a/man/sr/xzdiff.1 | 11
xz-utils-5.8.3/po4a/man/sr/xzgrep.1 | 15
xz-utils-5.8.3/po4a/man/sr/xzless.1 | 8
xz-utils-5.8.3/po4a/man/sr/xzmore.1 | 8
xz-utils-5.8.3/po4a/man/sv/lzmainfo.1 | 42
xz-utils-5.8.3/po4a/man/sv/xz.1 | 1954 ++++
xz-utils-5.8.3/po4a/man/sv/xzdec.1 | 87
xz-utils-5.8.3/po4a/man/sv/xzdiff.1 | 54
xz-utils-5.8.3/po4a/man/sv/xzgrep.1 | 92
xz-utils-5.8.3/po4a/man/sv/xzless.1 | 47
xz-utils-5.8.3/po4a/man/sv/xzmore.1 | 48
xz-utils-5.8.3/po4a/man/uk/xz.1 | 18
xz-utils-5.8.3/po4a/po4a.conf | 2
xz-utils-5.8.3/po4a/pt_BR.po | 14
xz-utils-5.8.3/po4a/ro.po | 18
xz-utils-5.8.3/po4a/sr.po | 83
xz-utils-5.8.3/po4a/sv.po | 3904 +++++++++
xz-utils-5.8.3/po4a/uk.po | 15
xz-utils-5.8.3/po4a/update-po | 2
xz-utils-5.8.3/po4a/xz-man.pot | 11
xz-utils-5.8.3/src/Makefile.in | 6
xz-utils-5.8.3/src/common/my_landlock.h | 45
xz-utils-5.8.3/src/common/mythread.h | 3
xz-utils-5.8.3/src/common/tuklib_gettext.h | 4
xz-utils-5.8.3/src/common/tuklib_integer.h | 19
xz-utils-5.8.3/src/common/tuklib_mbstr_wrap.h | 4
xz-utils-5.8.3/src/common/tuklib_open_stdxxx.h | 2
xz-utils-5.8.3/src/common/w32_application.manifest.comments.txt | 2
xz-utils-5.8.3/src/liblzma/Makefile.am | 4
xz-utils-5.8.3/src/liblzma/Makefile.in | 10
xz-utils-5.8.3/src/liblzma/api/Makefile.in | 6
xz-utils-5.8.3/src/liblzma/api/lzma/base.h | 6
xz-utils-5.8.3/src/liblzma/api/lzma/container.h | 38
xz-utils-5.8.3/src/liblzma/api/lzma/version.h | 2
xz-utils-5.8.3/src/liblzma/check/crc32_arm64.h | 5
xz-utils-5.8.3/src/liblzma/check/crc32_fast.c | 4
xz-utils-5.8.3/src/liblzma/check/crc64_fast.c | 10
xz-utils-5.8.3/src/liblzma/check/crc_common.h | 19
xz-utils-5.8.3/src/liblzma/check/crc_x86_clmul.h | 2
xz-utils-5.8.3/src/liblzma/common/alone_decoder.c | 6
xz-utils-5.8.3/src/liblzma/common/filter_common.c | 4
xz-utils-5.8.3/src/liblzma/common/index.c | 21
xz-utils-5.8.3/src/liblzma/common/lzip_decoder.c | 3
xz-utils-5.8.3/src/liblzma/common/outqueue.h | 1
xz-utils-5.8.3/src/liblzma/common/stream_decoder_mt.c | 79
xz-utils-5.8.3/src/liblzma/common/vli_decoder.c | 2
xz-utils-5.8.3/src/liblzma/liblzma.pc.in | 1
xz-utils-5.8.3/src/liblzma/lzma/lzma_common.h | 4
xz-utils-5.8.3/src/liblzma/lzma/lzma_decoder.h | 11
xz-utils-5.8.3/src/liblzma/rangecoder/range_decoder.h | 7
xz-utils-5.8.3/src/liblzma/validate_map.sh | 4
xz-utils-5.8.3/src/lzmainfo/Makefile.in | 6
xz-utils-5.8.3/src/scripts/Makefile.in | 6
xz-utils-5.8.3/src/scripts/xzdiff.in | 6
xz-utils-5.8.3/src/scripts/xzgrep.in | 2
xz-utils-5.8.3/src/scripts/xzless.in | 2
xz-utils-5.8.3/src/scripts/xzmore.in | 4
xz-utils-5.8.3/src/xz/Makefile.in | 6
xz-utils-5.8.3/src/xz/args.c | 1
xz-utils-5.8.3/src/xz/file_io.c | 4
xz-utils-5.8.3/src/xz/hardware.c | 72
xz-utils-5.8.3/src/xz/list.c | 2
xz-utils-5.8.3/src/xz/main.c | 10
xz-utils-5.8.3/src/xz/message.h | 4
xz-utils-5.8.3/src/xz/sandbox.c | 26
xz-utils-5.8.3/src/xz/signals.c | 17
xz-utils-5.8.3/src/xz/util.c | 4
xz-utils-5.8.3/src/xz/xz.1 | 9
xz-utils-5.8.3/src/xzdec/Makefile.in | 6
xz-utils-5.8.3/src/xzdec/xzdec.c | 2
xz-utils-5.8.3/tests/Makefile.in | 8
xz-utils-5.8.3/tests/ossfuzz/config/fuzz_decode_stream_mt.options | 4
xz-utils-5.8.3/tests/test_bcj_exact_size.c | 2
xz-utils-5.8.3/tests/test_block_header.c | 2
xz-utils-5.8.3/tests/test_index.c | 35
xz-utils-5.8.3/tests/test_suffix.sh | 4
xz-utils-5.8.3/windows/build.bash | 4
174 files changed, 22642 insertions(+), 6438 deletions(-)
dpkg-source: warning: cannot verify inline signature for /srv/release.debian.org/tmp/tmpc5tfjs1h/xz-utils_5.8.1-1.dsc: no acceptable signature found
dpkg-source: warning: cannot verify inline signature for /srv/release.debian.org/tmp/tmpc5tfjs1h/xz-utils_5.8.3-0+deb13u1.dsc: no acceptable signature found
diff -Nru xz-utils-5.8.1/CMakeLists.txt xz-utils-5.8.3/CMakeLists.txt
--- xz-utils-5.8.1/CMakeLists.txt 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/CMakeLists.txt 2026-03-31 15:27:00.000000000 +0000
@@ -77,7 +77,7 @@
#
#############################################################################
-cmake_minimum_required(VERSION 3.20...3.31 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.20...4.2 FATAL_ERROR)
include(CMakePushCheckState)
include(CheckIncludeFile)
@@ -85,6 +85,7 @@
include(CheckStructHasMember)
include(CheckCSourceCompiles)
include(CheckCCompilerFlag)
+include(CheckLinkerFlag)
include(cmake/tuklib_large_file_support.cmake)
include(cmake/tuklib_integer.cmake)
include(cmake/tuklib_cpucores.cmake)
@@ -403,11 +404,13 @@
# Add warning options for GCC or Clang. Keep this in sync with configure.ac.
+# Check for MSVC so that these won't be added with clang-cl with which -Wall
+# means -Weverything.
#
# NOTE: add_compile_options() doesn't affect the feature checks;
# only the new targets being created use these flags. Thus
# the -Werror usage in checks won't be break because of these.
-if(CMAKE_C_COMPILER_ID MATCHES GNU|Clang)
+if(NOT MSVC AND CMAKE_C_COMPILER_ID MATCHES GNU|Clang)
foreach(OPT -Wall
-Wextra
-Wvla
@@ -441,13 +444,13 @@
-Wc11-extensions
-Wc2x-compat
-Wc2x-extensions
- -Wpre-c2x-compat
-Warray-bounds-pointer-arithmetic
-Wassign-enum
-Wconditional-uninitialized
-Wdocumentation
-Wduplicate-enum
-Wempty-translation-unit
+ -Wextra-semi-stmt
-Wflexible-array-extensions
-Wmissing-variable-declarations
-Wnewline-eof
@@ -465,6 +468,23 @@
endforeach()
endif()
+# Enable more warnings with MSVC and clang-cl but disable a few too:
+# - C4100: unused function arguments
+# - C4127: conditional expression is a constant
+# - C4200: C99/C11 flexible array member
+# - C4244: Integer conversion
+# - C4267: Integer conversion
+# - C4996: getenv() and a few other functions
+#
+# With clang-cl, some warnings have to be disabled with clang-style options.
+if(MSVC)
+ add_compile_options(/W4 /wd4100 /wd4127 /wd4200 /wd4244 /wd4267 /wd4996)
+ if(CMAKE_C_COMPILER_ID MATCHES Clang)
+ add_compile_options(-Wno-unused-parameter
+ -Wno-deprecated-declarations)
+ endif()
+endif()
+
#############################################################################
# liblzma
@@ -484,7 +504,7 @@
# auto Autodetect between no, generic, and linux
# yes Force on by autodetecting between linux and generic
# no Disable symbol versioning
- # generic FreeBSD, most Linux/glibc systems, and GNU/Hurd
+ # generic FreeBSD, some Linux/glibc systems, and GNU/Hurd
# linux Linux/glibc with extra symbol versions for compatibility
# with binaries that have been linked against a liblzma version
# that has been patched with "xz-5.2.2-compat-libs.patch" from
@@ -541,7 +561,7 @@
# somewhere in the string).
#
# NVIDIA HPC Compiler doesn't support symbol versioning but
- # it uses the linked from the system so the linker script
+ # it uses the linker from the system so the linker script
# can still be used to get the generic symbol versioning.
set(SYMBOL_VERSIONING "generic")
@@ -556,6 +576,21 @@
set(SYMBOL_VERSIONING "generic")
endif()
endif()
+
+ if(NOT SYMBOL_VERSIONING STREQUAL "no")
+ # If features are disabled in liblzma, some symbols may be missing.
+ # LLVM's lld defaults to --no-undefined-version and the build breaks
+ # if not all symbols in the version script exist. That is good for
+ # catching errors like typos, but in our case the downside is too big.
+ # Avoid the problem by using --undefined-version if the linker
+ # supports it.
+ #
+ # GNU ld has had --no-undefined-version for a long time but it's not
+ # the default. The opposite option --undefined-version was only added
+ # in 2022, thus we must use --undefined-version conditionally.
+ check_linker_flag(C "-Wl,--undefined-version"
+ HAVE_LINKER_FLAG_UNDEFINED_VERSION)
+ endif()
endif()
set(LIBLZMA_API_HEADERS
@@ -1363,6 +1398,13 @@
check_symbol_exists(getauxval sys/auxv.h HAVE_GETAUXVAL)
tuklib_add_definition_if(liblzma HAVE_GETAUXVAL)
+ # With getauxval() we also need HWCAP_CRC32 which was
+ # added in glibc 2.24.
+ if(HAVE_GETAUXVAL)
+ check_symbol_exists(HWCAP_CRC32 sys/auxv.h HAVE_HWCAP_CRC32)
+ tuklib_add_definition_if(liblzma HAVE_HWCAP_CRC32)
+ endif()
+
# elf_aux_info() is supported on FreeBSD and OpenBSD >= 7.6.
check_symbol_exists(elf_aux_info sys/auxv.h HAVE_ELF_AUX_INFO)
tuklib_add_definition_if(liblzma HAVE_ELF_AUX_INFO)
@@ -1480,6 +1522,9 @@
# NOTE: Set it explicitly to 1 to make it clear that versioning is
# done unconditionally in the C files.
target_compile_definitions(liblzma PRIVATE HAVE_SYMBOL_VERSIONS_LINUX=1)
+ if(HAVE_LINKER_FLAG_UNDEFINED_VERSION)
+ target_link_options(liblzma PRIVATE "-Wl,--undefined-version")
+ endif()
target_link_options(liblzma PRIVATE
"-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/src/liblzma/liblzma_linux.map"
)
@@ -1487,6 +1532,9 @@
LINK_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/liblzma/liblzma_linux.map"
)
elseif(BUILD_SHARED_LIBS AND SYMBOL_VERSIONING STREQUAL "generic")
+ if(HAVE_LINKER_FLAG_UNDEFINED_VERSION)
+ target_link_options(liblzma PRIVATE "-Wl,--undefined-version")
+ endif()
target_link_options(liblzma PRIVATE
"-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/src/liblzma/liblzma_generic.map"
)
@@ -2171,8 +2219,13 @@
tuklib_progname(xz)
tuklib_mbstr(xz)
- check_symbol_exists(optreset getopt.h HAVE_OPTRESET)
- tuklib_add_definition_if(xz HAVE_OPTRESET)
+ if(HAVE_GETOPT_LONG)
+ check_symbol_exists(optreset getopt.h HAVE_OPTRESET)
+ tuklib_add_definition_if(xz HAVE_OPTRESET)
+ endif()
+
+ check_symbol_exists(getrlimit sys/resource.h HAVE_GETRLIMIT)
+ tuklib_add_definition_if(xz HAVE_GETRLIMIT)
check_symbol_exists(posix_fadvise fcntl.h HAVE_POSIX_FADVISE)
tuklib_add_definition_if(xz HAVE_POSIX_FADVISE)
@@ -2345,51 +2398,49 @@
set(XZ_POSIX_SHELL "${POSIX_SHELL_DEFAULT}" CACHE STRING
"Shell to use for scripts (xzgrep and others)")
- # Guess the extra path to add from XZ_POSIX_SHELL. Autotools-based build
- # has a separate option --enable-path-for-scripts=PREFIX but this is
- # enough for Solaris.
- set(enable_path_for_scripts)
- get_filename_component(POSIX_SHELL_DIR "${XZ_POSIX_SHELL}" DIRECTORY)
-
- if(NOT POSIX_SHELL_DIR MATCHES "^/bin$|^/usr/bin$")
- set(enable_path_for_scripts "PATH=${POSIX_SHELL_DIR}:\$PATH")
- endif()
-
- set(XZDIFF_LINKS xzcmp)
- set(XZGREP_LINKS xzegrep xzfgrep)
- set(XZMORE_LINKS)
- set(XZLESS_LINKS)
-
- if(XZ_TOOL_SYMLINKS_LZMA)
- list(APPEND XZDIFF_LINKS lzdiff lzcmp)
- list(APPEND XZGREP_LINKS lzgrep lzegrep lzfgrep)
- list(APPEND XZMORE_LINKS lzmore)
- list(APPEND XZLESS_LINKS lzless)
- endif()
-
- set(xz "xz")
- set(POSIX_SHELL "${XZ_POSIX_SHELL}")
-
- foreach(S xzdiff xzgrep xzmore xzless)
- configure_file("src/scripts/${S}.in" "${S}"
- @ONLY
- NEWLINE_STYLE LF
- FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
- GROUP_READ GROUP_EXECUTE
- WORLD_READ WORLD_EXECUTE)
+ if(ENABLE_SCRIPTS)
+ # Guess the extra path to add from XZ_POSIX_SHELL. Autotools-based
+ # build has a separate option --enable-path-for-scripts=PREFIX but
+ # this is enough for Solaris.
+ set(enable_path_for_scripts)
+ get_filename_component(POSIX_SHELL_DIR "${XZ_POSIX_SHELL}" DIRECTORY)
+
+ if(NOT POSIX_SHELL_DIR MATCHES "^/bin$|^/usr/bin$")
+ set(enable_path_for_scripts "PATH=${POSIX_SHELL_DIR}:\$PATH")
+ endif()
+
+ set(XZDIFF_LINKS xzcmp)
+ set(XZGREP_LINKS xzegrep xzfgrep)
+ set(XZMORE_LINKS)
+ set(XZLESS_LINKS)
+
+ if(XZ_TOOL_SYMLINKS_LZMA)
+ list(APPEND XZDIFF_LINKS lzdiff lzcmp)
+ list(APPEND XZGREP_LINKS lzgrep lzegrep lzfgrep)
+ list(APPEND XZMORE_LINKS lzmore)
+ list(APPEND XZLESS_LINKS lzless)
+ endif()
+
+ set(xz "xz")
+ set(POSIX_SHELL "${XZ_POSIX_SHELL}")
+
+ foreach(S xzdiff xzgrep xzmore xzless)
+ configure_file("src/scripts/${S}.in" "${S}"
+ @ONLY
+ NEWLINE_STYLE LF
+ FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
+ GROUP_READ GROUP_EXECUTE
+ WORLD_READ WORLD_EXECUTE)
- if(ENABLE_SCRIPTS)
install(PROGRAMS "${CMAKE_CURRENT_BINARY_DIR}/${S}"
DESTINATION "${CMAKE_INSTALL_BINDIR}"
COMPONENT scripts_Runtime)
- endif()
- endforeach()
+ endforeach()
- unset(xz)
- unset(POSIX_SHELL)
- unset(enable_path_for_scripts)
+ unset(xz)
+ unset(POSIX_SHELL)
+ unset(enable_path_for_scripts)
- if(ENABLE_SCRIPTS)
my_install_symlinks(scripts_Runtime "${CMAKE_INSTALL_BINDIR}"
xzdiff "" "${XZDIFF_LINKS}")
diff -Nru xz-utils-5.8.1/COPYING.GPLv2 xz-utils-5.8.3/COPYING.GPLv2
--- xz-utils-5.8.1/COPYING.GPLv2 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/COPYING.GPLv2 2026-03-31 15:27:00.000000000 +0000
@@ -2,7 +2,7 @@
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
@@ -304,8 +304,7 @@
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ with this program; if not, see .
Also add information on how to contact you by electronic and paper mail.
@@ -329,8 +328,8 @@
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
- , 1 April 1989
- Ty Coon, President of Vice
+ , 1 April 1989
+ Moe Ghoul, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
diff -Nru xz-utils-5.8.1/COPYING.LGPLv2.1 xz-utils-5.8.3/COPYING.LGPLv2.1
--- xz-utils-5.8.1/COPYING.LGPLv2.1 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/COPYING.LGPLv2.1 2026-03-31 15:27:00.000000000 +0000
@@ -2,7 +2,7 @@
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
@@ -484,8 +484,7 @@
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ License along with this library; if not, see .
Also add information on how to contact you by electronic and paper mail.
@@ -496,7 +495,7 @@
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
- , 1 April 1990
- Ty Coon, President of Vice
+ , 1 April 1990
+ Moe Ghoul, President of Vice
That's all there is to it!
diff -Nru xz-utils-5.8.1/ChangeLog xz-utils-5.8.3/ChangeLog
--- xz-utils-5.8.1/ChangeLog 2025-04-03 11:36:55.000000000 +0000
+++ xz-utils-5.8.3/ChangeLog 2026-03-31 15:27:26.000000000 +0000
@@ -1,3 +1,2066 @@
+commit 4b73f2ec19a99ef465282fbce633e8deb33691b3
+Author: Lasse Collin
+Date: 2026-03-31 17:26:16 +0300
+
+ Bump version and soname for 5.8.3
+
+ src/liblzma/Makefile.am | 2 +-
+ src/liblzma/api/lzma/version.h | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+commit 97b7440006d69a30048ff1ffc29fc7a0615e5d51
+Author: Lasse Collin
+Date: 2026-03-31 17:26:16 +0300
+
+ Add NEWS for 5.8.3
+
+ NEWS | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 54 insertions(+)
+
+commit 8e1022cfb1d177e482e487c202a0ab43dee761a3
+Author: Lasse Collin
+Date: 2026-03-31 17:10:47 +0300
+
+ Translations: Run "make -C po update-po"
+
+ Update the PO files to contain the comment fix from 4e76651dbaf6.
+
+ po/ca.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/cs.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/da.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/de.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/eo.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/es.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/fi.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/fr.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/hr.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/hu.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/it.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/ka.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/ko.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/nl.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/pl.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/pt.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/pt_BR.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/ro.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/sr.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/sv.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/tr.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/uk.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/vi.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/zh_CN.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ po/zh_TW.po | 148 ++++++++++++++++++++++++++++++------------------------------
+ 25 files changed, 1850 insertions(+), 1850 deletions(-)
+
+commit a3ea8832bec11128597c454f5d14d05ef6010e3f
+Author: Lasse Collin
+Date: 2026-03-29 20:29:40 +0300
+
+ Tests: Add a test for the lzma_index_prealloc() + lzma_index_append() bug
+
+ tests/test_index.c | 35 +++++++++++++++++++++++++++++++++++
+ 1 file changed, 35 insertions(+)
+
+commit c8c22869e780ff57c96b46939c3d79ff99395f87
+Author: Lasse Collin
+Date: 2026-03-29 19:11:21 +0300
+
+ liblzma: Fix a buffer overflow in lzma_index_append()
+
+ If lzma_index_decoder() was used to decode an Index that contained no
+ Records, the resulting lzma_index had an invalid internal "prealloc"
+ value. If lzma_index_append() was called on this lzma_index, too
+ little memory would be allocated and a buffer overflow would occur.
+
+ While this combination of the API functions is meant to work, in the
+ real-world apps this call sequence is rare or might not exist at all.
+
+ This bug is older than xz 5.0.0, so all stable releases are affected.
+
+ Reported-by: GitHub user christos-spearbit
+
+ src/liblzma/common/index.c | 21 +++++++++++++++++++++
+ 1 file changed, 21 insertions(+)
+
+commit a37658bec72ed581a683b7498a75a70122b831b0
+Author: Lasse Collin
+Date: 2026-03-27 21:15:12 +0200
+
+ CMake: Adjust warnings with MSVC and clang-cl
+
+ When using clang-cl, avoid the long list of warning options used with
+ GCC and Clang because, for MSVC compatibility, clang-cl's -Wall behaves
+ like -Weverything.
+
+ Add warning options for MSVC. Use them with clang-cl too.
+
+ CMakeLists.txt | 21 ++++++++++++++++++++-
+ 1 file changed, 20 insertions(+), 1 deletion(-)
+
+commit 9e499f714cade4beade31c86dcb0de9fc72d0562
+Author: Lasse Collin
+Date: 2026-03-27 21:14:50 +0200
+
+ CI: Don't disable individual warnings with clang-cl
+
+ .github/workflows/msvc.yml | 13 -------------
+ 1 file changed, 13 deletions(-)
+
+commit 1e00837f72e0551ab73927642a8f61aad80c958d
+Author: Lasse Collin
+Date: 2026-03-22 12:02:48 +0200
+
+ CI: Add Haiku
+
+ .github/workflows/haiku.yml | 38 ++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 38 insertions(+)
+
+commit 8082851b7848ac32fea7bc7cfb84d9b3ef5537b0
+Author: Lasse Collin
+Date: 2026-03-22 11:30:20 +0200
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit 3cdd412bcea6bb5b4c5d41d2b4104230a5a9569c
+Author: Lasse Collin
+Date: 2026-03-22 11:29:30 +0200
+
+ CI: Update MSYS2
+
+ Closes: https://github.com/tukaani-project/xz/pull/213
+
+ .github/workflows/msys2.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit e38a4af340ca9738923a511b7e35b6390c03ec50
+Author: Lasse Collin
+Date: 2026-03-22 11:29:23 +0200
+
+ CI: Update Solaris
+
+ Closes: https://github.com/tukaani-project/xz/pull/213
+
+ .github/workflows/solaris.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 40b1599217cc4f7cca6f48e0c32e709b9abd3639
+Author: Lasse Collin
+Date: 2026-03-22 11:29:14 +0200
+
+ CI: Update OpenBSD
+
+ Closes: https://github.com/tukaani-project/xz/pull/213
+
+ .github/workflows/openbsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 3aaf2f136c3fcf1140b9dfa584640778be789abc
+Author: Lasse Collin
+Date: 2026-03-22 11:29:08 +0200
+
+ CI: Update NetBSD
+
+ Closes: https://github.com/tukaani-project/xz/pull/213
+
+ .github/workflows/netbsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit b5c26a249d21d293b441b21d22a1a81e7eec436a
+Author: Lasse Collin
+Date: 2026-03-22 11:28:58 +0200
+
+ CI: Update FreeBSD
+
+ Closes: https://github.com/tukaani-project/xz/pull/213
+
+ .github/workflows/freebsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 1a73f4f917f25d19ae557f49af2fddd9ef9f0a4a
+Author: Lasse Collin
+Date: 2026-03-22 11:28:47 +0200
+
+ CI: Update DragonFly BSD
+
+ Closes: https://github.com/tukaani-project/xz/pull/213
+
+ .github/workflows/dragonflybsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 5d61c5a3cf3be88b16179900ac5be82011a3a6bb
+Author: Salman Muin Kayser Chishti <13schishti@gmail.com>
+Date: 2026-02-28 09:10:46 +0000
+
+ CI: Upgrade GitHub Actions for Node 24 compatibility
+
+ Signed-off-by: Salman Muin Kayser Chishti <13schishti@gmail.com>
+ Closes: https://github.com/tukaani-project/xz/pull/212
+
+ .github/workflows/ci.yml | 4 ++--
+ .github/workflows/cifuzz.yml | 2 +-
+ .github/workflows/coverity.yml | 2 +-
+ .github/workflows/dragonflybsd.yml | 2 +-
+ .github/workflows/freebsd.yml | 2 +-
+ .github/workflows/msvc.yml | 2 +-
+ .github/workflows/msys2.yml | 4 ++--
+ .github/workflows/netbsd.yml | 2 +-
+ .github/workflows/openbsd.yml | 2 +-
+ .github/workflows/solaris.yml | 2 +-
+ 10 files changed, 12 insertions(+), 12 deletions(-)
+
+commit 0ac3b93387c0191919ffa38de5f49f6b28164b35
+Author: Lasse Collin
+Date: 2026-03-25 19:03:00 +0200
+
+ xz: Prevent an integer overflow in --files and --files0
+
+ This requires a filename (or something that pretends to be a filename)
+ of at least 2 GiB on a 32-bit platform, and that realloc() to
+ SIZE_MAX / 2 + 1 bytes has succeeded.
+
+ Fixes: https://github.com/tukaani-project/xz/pull/218
+
+ src/xz/main.c | 10 ++++++++++
+ 1 file changed, 10 insertions(+)
+
+commit 2faa141bdb47be94da2eae6df6f08858999a5911
+Author: Lasse Collin
+Date: 2026-03-23 23:43:56 +0200
+
+ tuklib_integer: Fix inefficient aligned_writeXXne
+
+ The __builtin_assume_aligned was applied to the wrong argument which
+ made aligned writes worse on strict-align archs.
+
+ Aligned writes aren't used in liblzma, so this bug didn't matter in
+ this package; tuklib_integer.h is meant to be usable elsewhere too.
+
+ src/common/tuklib_integer.h | 19 +++++++++----------
+ 1 file changed, 9 insertions(+), 10 deletions(-)
+
+commit 685538271e3e213a18c5a925654aaa32c0b69f1e
+Author: Lasse Collin
+Date: 2026-03-22 10:22:09 +0200
+
+ Build: Remove -Wpre-c2x-compat
+
+ It makes clang -std=gnu23 noisy about bool. It's also noisy about
+ [[__fallthrough__]] which is only used in C23 mode.
+
+ Reported-by: Collin Funk
+
+ CMakeLists.txt | 1 -
+ configure.ac | 1 -
+ 2 files changed, 2 deletions(-)
+
+commit 3a78a82bd380c26bc7afda7565216c3383cedefe
+Author: Collin Funk
+Date: 2026-03-15 23:24:59 -0700
+
+ xz: Don't fsync directories on QNX
+
+ On QNX calling fsync on a directory fails with EINVAL. This causes the
+ following test failure:
+
+ $ cat tests/test_suffix.sh.log
+ /data/home/root/xz-5.8.2/src/xz/.libs/lt-xz: suffix_temp: Synchronizing the directory of the file failed: Invalid argument
+ Failed to decompress a file with a suffix set in raw format
+ FAIL test_suffix.sh (exit status: 1)
+
+ Closes: https://github.com/tukaani-project/xz/pull/216
+
+ src/xz/file_io.c | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit bfc5f12a84a2a9df774ed16cd6eb58fd5ab24646
+Author: Lasse Collin
+Date: 2026-02-25 17:33:42 +0200
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit 5553509f1a53ee160ea3bc871c716a75ba0b1ea0
+Author: Lasse Collin
+Date: 2026-02-25 00:00:49 +0200
+
+ liblzma: Fix a copy-paste error in commented-out code
+
+ Fixes: https://github.com/dotnet/runtime/pull/124003#discussion_r2841960994
+ Fixes: 96b663f67c0e ("liblzma: Refactor CRC comments.")
+
+ src/liblzma/check/crc32_fast.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 4e76651dbaf6a0159f2117482d778ff69127fdea
+Author: Lasse Collin
+Date: 2026-02-24 18:34:19 +0200
+
+ Fix typos and grammar in comments and docs
+
+ Fixes: https://github.com/dotnet/runtime/pull/124003#discussion_r2789354505
+ Fixes: https://github.com/dotnet/runtime/pull/124003#discussion_r2789354515
+ Fixes: https://github.com/dotnet/runtime/pull/124003#discussion_r2820960196
+
+ po/Makevars | 2 +-
+ src/common/tuklib_gettext.h | 4 ++--
+ src/common/tuklib_mbstr_wrap.h | 4 ++--
+ src/common/w32_application.manifest.comments.txt | 2 +-
+ 4 files changed, 6 insertions(+), 6 deletions(-)
+
+commit cd8a6231d084ee9ce0a7a285f99dc5721d1f4317
+Author: Lasse Collin
+Date: 2026-02-24 18:24:29 +0200
+
+ tuklib_open_stdxxx: Fix a typo in macro name
+
+ It doesn't matter in this package, but it's good to fix it still.
+
+ Fixes: https://github.com/dotnet/runtime/pull/124003#discussion_r2782313660
+
+ src/common/tuklib_open_stdxxx.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit bf5d32f489fd7f33b2a629f9b78f5157301b49d8
+Author: Lasse Collin
+Date: 2026-02-24 18:22:25 +0200
+
+ CMake: Fix a wrong #define
+
+ HAVE_SYS_PARAM_H was misspelled HAVE_PARAM_H. This might have broken
+ the build on systems where sysctl() is used to detect the amount of RAM
+ or the number of processor cores/threads.
+
+ The cpuset code for FreeBSD doesn't need the macro it so it was removed.
+
+ Fixes: https://github.com/dotnet/runtime/pull/124003#discussion_r2782313680
+ Fixes: https://github.com/dotnet/runtime/pull/124003#discussion_r2782313704
+ Fixes: 7e3493d40eac ("Build: Add very limited experimental CMake support.")
+
+ cmake/tuklib_cpucores.cmake | 4 ++--
+ cmake/tuklib_physmem.cmake | 2 +-
+ 2 files changed, 3 insertions(+), 3 deletions(-)
+
+commit b0f3b64a25bcd3a6a4cebc00866dea86590fac3e
+Author: Radek Zikmund
+Date: 2026-02-12 15:24:15 +0100
+
+ liblzma/MSVC: Add a cast to fix a warning (C4057) with __cpuid()
+
+ __cpuid from MSVC (and also the old Intel ICC) use int[], while
+ __get_cpuid from in GCC and Clang use unsigned int[].
+ Adding a cast is the simplest fix.
+
+ Link: https://github.com/tukaani-project/xz/pull/208
+
+ src/liblzma/check/crc_x86_clmul.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit b51d67f4a95f41ae3a64973acc0e44b9f078512f
+Author: Radek Zikmund
+Date: 2026-02-23 17:50:00 +0100
+
+ CMake: Guard script configure_file() calls with ENABLE_SCRIPTS
+
+ The configure_file() calls for xzdiff, xzgrep, xzmore, and xzless
+ were running unconditionally within the if(UNIX) block, even when
+ ENABLE_SCRIPTS was OFF. This would cause a build failure if the
+ src/scripts/*.in files were not present. Deleting those files can
+ simplify license compliance when the scripts aren't needed.
+
+ Move the foreach loop and related code inside if(ENABLE_SCRIPTS) guard
+ so that configure_file() is only called when scripts are actually needed.
+ This is mostly whitespace changes to adjust the indentation.
+
+ Co-authored-by: Lasse Collin
+ Closes: https://github.com/tukaani-project/xz/pull/210
+
+ CMakeLists.txt | 68 ++++++++++++++++++++++++++++------------------------------
+ 1 file changed, 33 insertions(+), 35 deletions(-)
+
+commit 1007bf08b5fddf088b3131e692210af4b4b7fd8c
+Author: Lasse Collin
+Date: 2026-02-04 12:28:07 +0200
+
+ Translations: Add Arabic man page translations
+
+ Rendering of bidirectional text from man pages might not work perfectly
+ in all cases.
+
+ po4a/ar.po | 3905 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ po4a/po4a.conf | 2 +-
+ 2 files changed, 3906 insertions(+), 1 deletion(-)
+
+commit 54147ad65af12d9e4f60a8ce59094a8a30ad5919
+Author: Lasse Collin
+Date: 2026-01-25 13:51:09 +0200
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit d6bdb446f8da47ac2af8c309de8e7c80beae850e
+Author: Lasse Collin
+Date: 2026-01-25 13:30:46 +0200
+
+ liblzma: Add the "License" property to liblzma.pc
+
+ The "License" property is a pkgconf extension. See pc(5).
+ pkg-config 0.29.2 (2017) ignores unrecognized properties so this
+ commit shouldn't create compatibility issues.
+
+ pkgconf provides bomtool which uses the "License" property to generate
+ a software bill of materials. In pkgconf.git there is spdxtool for the
+ same task but with different output format.
+
+ The pkgconf extensions "Copyright" and "Maintainer" would also be
+ used by bomtool and spdxtool, but I don't want to add those properties
+ at least for now.
+
+ Co-authored-by: Nobuhiro Iwamatsu
+ Closes: https://github.com/tukaani-project/xz/pull/178
+
+ src/liblzma/liblzma.pc.in | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit 687bd3e30fbe54ae906d06a93e7f2aa8b121aa7b
+Author: Lasse Collin
+Date: 2026-01-25 12:14:46 +0200
+
+ Update THANKS
+
+ THANKS | 2 ++
+ 1 file changed, 2 insertions(+)
+
+commit b80b6343a4b7df6bf56dcf07715f9f536af93306
+Author: Lasse Collin
+Date: 2026-01-25 12:14:25 +0200
+
+ liblzma: Don't try to use x86-64 inline asm on ARM64EC
+
+ Reported-by: Chase Knowlden
+ Fixes: https://github.com/tukaani-project/xz/issues/206
+
+ src/liblzma/rangecoder/range_decoder.h | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit 47fb9d84c052912ca10dc9843cb296c860b182ac
+Author: Pino Toscano
+Date: 2025-12-30 19:59:55 +0100
+
+ Autotools: Enable x86 assembler on Hurd by default
+
+ It has been enabled in Debian GNU/Hurd for 15+ years with no issues.
+ Hence, enable it by default also in the upstream sources.
+
+ The CMake build already had it enabled.
+
+ Link: https://salsa.debian.org/debian/xz-utils/-/blob/debian/5.8.2-2/debian/rules?ref_type=tags#L98
+ Closes: https://github.com/tukaani-project/xz/pull/204
+
+ configure.ac | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 9f4c5a0d4817c9c7011cdfd00cfbe0ddda66a455
+Author: Lasse Collin
+Date: 2025-12-17 14:49:12 +0200
+
+ doc/SHA256SUMS: Add 5.8.2
+
+ doc/SHA256SUMS | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+commit 3d078b52adbff566ccfc51067dfbf742ecf3ef86
+Author: Lasse Collin
+Date: 2025-12-17 13:36:42 +0200
+
+ Bump version and soname for 5.8.2
+
+ src/liblzma/Makefile.am | 2 +-
+ src/liblzma/api/lzma/version.h | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+commit fb14afd5c9bf14d8c67ee11e4139885072071ddd
+Author: Lasse Collin
+Date: 2025-12-17 13:36:35 +0200
+
+ Add NEWS for 5.8.2
+
+ NEWS | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 72 insertions(+)
+
+commit 590f4713b29f0236ab944487f40069355a515dbc
+Author: Lasse Collin
+Date: 2025-12-16 11:30:35 +0200
+
+ CMake: Bump maximum policy version to 4.2
+
+ CMP0186 is curious but we aren't affected.
+
+ CMakeLists.txt | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 26d22ed16b6e38ce8ed45cb29076f454cd488762
+Author: Lasse Collin
+Date: 2025-12-10 19:20:05 +0200
+
+ tuklib_integer/CMake: Log a message about unaligned access check
+
+ cmake/tuklib_integer.cmake | 8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+commit f7381cf927576164c17be4e4c1edeec3cdaca7cf
+Author: Lasse Collin
+Date: 2025-12-10 19:11:27 +0200
+
+ tuklib_integer/CMake: Don't run unaligned access checks unnecessarily
+
+ If the cache variable TUKLIB_FAST_UNALIGNED_ACCESS is already set,
+ the autodetection result isn't needed because the option() command
+ does nothing when the cache variable is already set.
+
+ This is largely white space change to indent the if...endif block.
+
+ cmake/tuklib_integer.cmake | 226 +++++++++++++++++++++++----------------------
+ 1 file changed, 117 insertions(+), 109 deletions(-)
+
+commit dc1a421ce35f10b9a0c00d1bd42f1fdac0c3e9eb
+Author: Lasse Collin
+Date: 2025-12-10 16:49:55 +0200
+
+ tuklib_integer: Use CMAKE_C_COMPILER_ARCHITECTURE_ID when available
+
+ CMake >= 4.1 sets CMAKE__COMPILER_ARCHITECTURE_ID on many
+ platforms. The list of possible values are documented. Use this
+ variable when available. On older CMake versions CMAKE_SYSTEM_PROCESSOR
+ is still used, thus the regexes have to include values like ^amd64 still.
+
+ With old CMake versions, checking CMAKE_C_COMPILER_ARCHITECTURE_ID
+ is somewhat useful with MSVC because CMAKE_SYSTEM_PROCESSOR might
+ not match the target architecture.
+
+ cmake/tuklib_integer.cmake | 13 ++++++++++++-
+ 1 file changed, 12 insertions(+), 1 deletion(-)
+
+commit c690101dddd784b75224a8935f56cd163d3e90a3
+Author: Lasse Collin
+Date: 2025-12-10 16:49:55 +0200
+
+ tuklib_integer: Autodetect when -mstrict-align is used with GCC on ARM64
+
+ On ARM64, support for fast unaligned memory access was autodetected by
+ checking if __ARM_FEATURE_UNALIGNED is defined. However, at least GCC
+ versions up to 15.2.0 define the macro even when -mstrict-align has
+ been specified. Thus, autodetection with GCC doesn't work correctly,
+ and binaries built using -mstrict-align can be much slower than they
+ need to be, unless the user also passes --disable-unaligned-access
+ to configure or -DTUKLIB_FAST_UNALIGNED_ACCESS=OFF to cmake.
+
+ See the GCC bug:
+
+ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111555
+
+ Workaround the issue by using heuristics with GCC on ARM64.
+
+ With Clang, the detection using __ARM_FEATURE_UNALIGNED works.
+ It also works with GCC on 32-bit ARM.
+
+ Fixes: e5f13a66567b ("tuklib_integer: Autodetect support for unaligned access on ARM.")
+
+ cmake/tuklib_integer.cmake | 63 ++++++++++++++++++++++++++++++-------
+ m4/tuklib_integer.m4 | 78 +++++++++++++++++++++++++++++++++++-----------
+ 2 files changed, 110 insertions(+), 31 deletions(-)
+
+commit d9b318f5b8a3524e90ac17471e79db7de012caf5
+Author: Lasse Collin
+Date: 2025-12-09 18:02:23 +0200
+
+ CI: Update MSYS2
+
+ .github/workflows/msys2.yml | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 700e32f1b7dd6d674f12bbdabc35a3bc4a2860f5
+Author: Lasse Collin
+Date: 2025-12-09 18:02:05 +0200
+
+ CI: Update DragonFly BSD
+
+ .github/workflows/dragonflybsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit a7b749389c64dfbee1c29d88e61e71186b472784
+Author: Lasse Collin
+Date: 2025-12-09 17:58:52 +0200
+
+ CI: Update Solaris
+
+ .github/workflows/solaris.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit e0b3c6ee0ab3243e48291e5f9b6333c3d052311d
+Author: Lasse Collin
+Date: 2025-12-09 17:56:58 +0200
+
+ CI: Update NetBSD
+
+ .github/workflows/netbsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit fbc1046248cfe3c730437ba7d98dde89b0eced3e
+Author: Lasse Collin
+Date: 2025-12-09 17:54:54 +0200
+
+ CI: Update OpenBSD
+
+ .github/workflows/openbsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 8f0579ba5650bbbfa88a04adf8115b8fb4aff476
+Author: Lasse Collin
+Date: 2025-12-09 17:52:01 +0200
+
+ CI: Update FreeBSD
+
+ .github/workflows/freebsd.yml | 4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+commit f8424b0416266c393c84a315e3bdedbc19efa0a8
+Author: Lasse Collin
+Date: 2025-12-09 17:40:05 +0200
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit c4340692d4490ff80e897d4840fadc033c46d81a
+Author: Lasse Collin
+Date: 2025-12-09 13:01:36 +0200
+
+ Translations: Add src/xz/sandbox.c to POTFILES.in
+
+ There are no strings to translate in that file now, but it's good to
+ list it anyway in case translatable strings are added in the future.
+
+ Fixes: 374868d81d47 ("xz: Move sandboxing code to sandbox.c and improve Landlock sandbox.")
+
+ po/POTFILES.in | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit b8af36920b0857c0329f61414df5989093386db1
+Author: Lasse Collin
+Date: 2025-12-09 12:55:45 +0200
+
+ xz: Never translate "Failed to enable the sandbox"
+
+ This was already the case in practice because I had forgotten to list
+ src/xz/sandbox.c in po/POTFILES.in. However, it seems better to never
+ translate this particular error message. It should almost never occur
+ and if it does, an untranslated message is should make it easier to
+ find bug reports about it.
+
+ src/xz/sandbox.c | 24 +++++++++++++++---------
+ 1 file changed, 15 insertions(+), 9 deletions(-)
+
+commit 5a7fc1af3d9ec115f796cba110eb78e63ff1df5c
+Author: Lasse Collin
+Date: 2025-12-09 12:27:15 +0200
+
+ Translations: Update the Swedish man page translations
+
+ po4a/sv.po | 15 +++++----------
+ 1 file changed, 5 insertions(+), 10 deletions(-)
+
+commit 88531e5463d9f028387a11b78d53c9c269e6a3a0
+Author: Lasse Collin
+Date: 2025-12-09 12:26:24 +0200
+
+ Translations: Update the Romanian man page translations
+
+ po4a/ro.po | 18 +++++++-----------
+ 1 file changed, 7 insertions(+), 11 deletions(-)
+
+commit 8a817277192e6379a8c6f2eefbaed65c6b7d92fa
+Author: Lasse Collin
+Date: 2025-12-09 12:13:36 +0200
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit 1ec43aa7810d159ed76a6188b17c0bb474ca5ab5
+Author: Lasse Collin
+Date: 2025-12-09 12:13:36 +0200
+
+ CMake: Autodetect unaligned access support on LoongArch
+
+ This still relies on CMAKE_SYSTEM_PROCESSOR. CMake 4.1 added more
+ CMAKE__COMPILER_ARCHITECTURE_ID values to detect the arch in
+ a more defined manner, but 4.1 is too new to require for now.
+
+ Thanks-to: Li Chenggang
+ Closes: https://github.com/tukaani-project/xz/pull/186
+
+ cmake/tuklib_integer.cmake | 81 ++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 81 insertions(+)
+
+commit 7971566247914ec1854b125ff99c2a617f5c1e3a
+Author: Lasse Collin
+Date: 2025-12-09 12:13:36 +0200
+
+ Autotools: Autodetect unaligned access support on LoongArch
+
+ According to [1] sections 7.4, 8.1, and 8.2, desktop and server
+ processors support fast unaligned access, but embedded systems likely
+ don't.
+
+ It's important that TUKLIB_FAST_UNALIGNED_ACCESS isn't defined when
+ -mstrict-align is in use because it will result in slower binaries
+ even if running on a processor that supports fast unaligned access.
+ It's because compilers will translate multibyte memcpy() to multiple
+ byte-by-byte instructions instead of wider loads and stores. The
+ compression times from [2] show this well:
+
+ Unaligned access CFLAGS Compression time
+ enabled -O2 -mno-strict-align 66.1 s
+ disabled -O2 -mno-strict-align 79.5 s
+ disabled -O2 -mstrict-align 79.9 s
+ enabled -O2 -mstrict-align 129.1 s
+
+ There currently (GCC 15.2) is no preprocessor macro on LoongArch
+ to detect if -mstrict-align or -mno-strict-align is in effect (the
+ default is -mno-strict-align). Use heuristics to detect which of the
+ flags is in effect.
+
+ [1] https://github.com/loongson/la-softdev-convention/blob/v0.2/la-softdev-convention.adoc
+ [2] https://github.com/tukaani-project/xz/pull/186#issuecomment-3494570304
+
+ Thanks-to: Li Chenggang
+ Thanks-to: Xi Ruoyao
+ See: https://github.com/tukaani-project/xz/pull/186
+
+ m4/tuklib_integer.m4 | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 68 insertions(+)
+
+commit 338f952c0039b153a1fbdf6a535c4bd6a61f33cd
+Author: Lasse Collin
+Date: 2025-11-26 13:50:57 +0200
+
+ xz: Silence clang -Wunreachable-code-break
+
+ Fixes: a165d7df1964 ("xz: Add a new --filters-help option.")
+
+ src/xz/args.c | 1 -
+ 1 file changed, 1 deletion(-)
+
+commit 723cee44d076281bce9c3d7bd2c17b0680bd8884
+Author: Lasse Collin
+Date: 2025-11-26 13:50:57 +0200
+
+ liblzma: Remove unwanted semicolons
+
+ These didn't affect control flow.
+
+ src/liblzma/common/vli_decoder.c | 2 +-
+ src/liblzma/lzma/lzma_common.h | 4 ++--
+ src/liblzma/rangecoder/range_decoder.h | 6 +++---
+ 3 files changed, 6 insertions(+), 6 deletions(-)
+
+commit 524f6a7384f15e52ec13c72adbdf18ddeecbc735
+Author: Lasse Collin
+Date: 2025-11-26 13:50:57 +0200
+
+ Tests: Remove an unwanted semicolon from a macro definition
+
+ It didn't affect control flow.
+
+ Fixes: fe3bd438fb11 ("Tests: Fix memory leaks in test_block_header.")
+
+ tests/test_block_header.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 0f41a28bfab98d1f5171ee5c9da6dfdc15f62549
+Author: Lasse Collin
+Date: 2025-11-26 13:50:57 +0200
+
+ Build: Use -Wextra-semi-stmt when supported
+
+ CMakeLists.txt | 1 +
+ configure.ac | 1 +
+ 2 files changed, 2 insertions(+)
+
+commit 91170c8cab72b94a697f5228f4df13483ef5be91
+Author: Lasse Collin
+Date: 2025-11-26 13:50:57 +0200
+
+ CI: Add clang-cl
+
+ Fixes: https://github.com/tukaani-project/xz/issues/18#issuecomment-3577456136
+
+ .github/workflows/msvc.yml | 46 ++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 46 insertions(+)
+
+commit a3c6cb09113de978b971cbdacf5c4890d4237c28
+Author: Lasse Collin
+Date: 2025-11-26 13:50:57 +0200
+
+ xz/Windows: Add a missing #include to fix the build with clang-cl
+
+ Fixes: https://github.com/tukaani-project/xz/issues/18#issuecomment-1986829734
+ Fixes: https://github.com/tukaani-project/xz/issues/18#issuecomment-3577456136
+
+ src/xz/util.c | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+commit c410ccc62511ec95b20639defb10650ef9b75e8c
+Author: Lasse Collin
+Date: 2025-11-25 21:05:37 +0200
+
+ xz: Check return value of sigaction() before calling raise()
+
+ Fixes: Coverity CID 456022
+
+ src/xz/signals.c | 10 ++++++++--
+ 1 file changed, 8 insertions(+), 2 deletions(-)
+
+commit 6cc2da0a4b180b71cb6e781c897052def103ad3e
+Author: Lasse Collin
+Date: 2025-11-02 12:57:00 +0200
+
+ liblzma: Refactor a loop in lzma_filters_copy()
+
+ Arguably it's nicer if i doesn't wrap around when the loop terminates.
+
+ Fixes: Coverity CID 464589
+ Fixes: 6d118a0b9def ("Add lzma_filters_copy().")
+
+ src/liblzma/common/filter_common.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 90b67853d57562c5ad4fdb3215ceb9b9bd3958bf
+Author: Lasse Collin
+Date: 2025-11-02 12:17:50 +0200
+
+ liblzma: Silence two Coverity warnings
+
+ lzma_lzma_decoder_memusage() returns UINT64_MAX if lc/lp/pb aren't
+ valid. alone_decoder.c and lzip_decoder.c didn't check the return
+ value because in both it is known that lc/lp/pb are valid. Make them
+ call the _nocheck() variant instead which skips the validation (it
+ already existed for LZMA2's internal use).
+
+ Fixes: Coverity CID 464658
+ Fixes: Coverity CID 897069
+
+ src/liblzma/common/alone_decoder.c | 6 ++++--
+ src/liblzma/common/lzip_decoder.c | 3 ++-
+ src/liblzma/lzma/lzma_decoder.h | 11 ++++++-----
+ 3 files changed, 12 insertions(+), 8 deletions(-)
+
+commit be365b701024b9acbfef4035c6433a0fbb4be823
+Author: Lasse Collin
+Date: 2025-11-02 12:17:50 +0200
+
+ liblzma: Fix a harmless read of shared variable without mutex
+
+ The partial_update_mode enumeration had three states, _DISABLED,
+ _START, and _ENABLED. Main thread changed it from _DISABLED to _START
+ while holding a mutex. Once set to _START, worker thread changed it
+ to _ENABLED without a mutex. Later main thread read it without a mutex,
+ so it could see either _START or _ENABLED. However, it made no
+ difference because the main thread checked for != _DISABLED, so
+ it didn't matter if it saw _START or _ENABLED.
+
+ Nevertheless, such things must not be done. It's clear it was a mistake
+ because there were two comments that directly contradicted each
+ other about how the variable was accessed.
+
+ Split the enumeration into two booleans:
+
+ - partial_update_enabled: A worker thread locks the mutex to read
+ this variable and the main thread locks the mutex to change the
+ value. Because only the main thread modifies the variable, the
+ main thread can read the value without locking the mutex.
+ This variable replaces the _DISABLED -> _START transition.
+
+ - partial_update_started is for worker thread's internal use and thus
+ needs no mutex. This replaces the _START -> _ENABLED transition.
+
+ Fixes: Coverity CID 456025
+ Fixes: bd93b776c1bd ("liblzma: Fix a deadlock in threaded decoder.")
+
+ src/liblzma/common/stream_decoder_mt.c | 79 +++++++++++++++-------------------
+ 1 file changed, 34 insertions(+), 45 deletions(-)
+
+commit 2686554da0103580a472919220931c397b1d1f7a
+Author: Lasse Collin
+Date: 2025-11-02 12:17:50 +0200
+
+ CI: Add Coverity Scan
+
+ Co-authored-by: Lasse Collin
+ Fixes: https://github.com/tukaani-project/xz/issues/198
+
+ .github/workflows/coverity.yml | 38 ++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 38 insertions(+)
+
+commit 1b30734c9c08a3f628574d172f1a6034277a2163
+Author: Lasse Collin
+Date: 2025-11-25 13:55:35 +0200
+
+ Change the sorting order in THANKS
+
+ In short, sort the names with this command (-k1,1 isn't needed because
+ the lines with names start with " -"):
+
+ LC_ALL=en_US.UTF-8 sort -k2,2 -k3,3 -k4,4 -k5,5
+
+ When THANKS was created, I wrote the names as "First Last" and attempted
+ to keep them sorted by last name / surname / family name. This works
+ with many names in THANKS, but it becomes complicated with names that
+ don't fit that pattern. For example, names that are written as
+ "Last First" can be manually sorted by family name, but only if one
+ knows which part of the name is the family name.[*] And of course,
+ the concept of first/last name doesn't apply to all names.
+
+ [*] xz had a co-maintainer who could help me with such names,
+ but fortunately he isn't working on the project anymore.
+
+ Adding the names in chronological order could have worked too, although
+ if something is contributed by multiple people, one would still have to
+ decide how to sort the names within the batch. Another downside would
+ be that if THANKS is updated in more than one work-in-progress branch,
+ merge conflicts would occur more often.
+
+ Don't attempt to sort by last name. Let's be happy that people tend to
+ provide names that can be expressed in a reasonable number of printable
+ Unicode characters. In practice, people have been even nicer: if the
+ native language doesn't use a Latin script alphabet, people often provide
+ a transliterated name (only or in addition to the original spelling),
+ which is very much appreciated by those who don't know the native script.
+
+ Treat the names as opaque strings or space-separated strings for sorting
+ purposes. This means that most names will now be sorted by first name.
+ There still are many choices how to sort:
+
+ (1) LC_ALL=en_US.UTF-8 sort
+
+ The project is in English, so this may sound like a logical choice.
+ However, spaces have a lower weight than letters, which results in
+ this order:
+
+ - A Ba
+ - Ab C
+ - A Bc
+ - A Bd
+
+ (2) LC_ALL=en_US.UTF-8 sort -k2,2
+
+ This first sorts by the first word and then by the rest of the
+ string. It's -k2,2 instead of -k1,1 to skip the leading dash.
+
+ - A Ba
+ - A Bc
+ - A Bd
+ - Ab C
+
+ I like this more than (1). One could add -k3,3 -k4,4 -k5,5 ... too.
+ With current THANKS it makes no difference but it might some day.
+
+ NOTE: The ordering in en_US.UTF-8 can differ between libc versions
+ and operating systems. Luckily it's not a big deal in THANKS.
+
+ (3) LC_ALL=en_US.UTF-8 sort -f -k2,2
+
+ Passing -f (--ignore-case) to sort affects sorting of single-byte
+ characters but not multibyte characters (GNU coreutils 9.9):
+
+ No -f With -f LC_ALL=C
+ Aa A.A A.A
+ A.A Aa Aa
+ Ää Ää Ä.Ä
+ Ä.Ä Ä.Ä Ää
+
+ In GNU coreutils, the THANKS file is sorted using "sort -f -k1,1".
+ There is also a basic check that the en_US.UTF-8 locale is
+ behaving as expected.
+
+ (4) LC_ALL=C sort
+
+ This sorts by byte order which in UTF-8 is the same as Unicode
+ code point order. With the strings in (1) and (2), this produces
+ the same result as in (2). The difference in (3) can be seen above.
+
+ The results differ from en_US.UTF-8 when a name component starts
+ with a lower case ASCII letter (like "von" or "de"). Worse, any
+ non-ASCII characters sort after ASCII chars. These properties might
+ look weird in English language text, although it's good to remember
+ that en_US.UTF-8 sorting can appear weird too if one's native
+ language isn't English.
+
+ The choice between (2) and (4) was difficult but I went with (2).
+
+ ;-)
+
+ THANKS | 414 ++++++++++++++++++++++++++++++++---------------------------------
+ 1 file changed, 207 insertions(+), 207 deletions(-)
+
+commit 8bb516887c1912106a72db96216cab46954e6190
+Author: Lasse Collin
+Date: 2025-11-23 20:39:28 +0200
+
+ Landlock: Add missing #ifdefs
+
+ The build was broken on distros that have an old .
+
+ Fixes: 2b2652e914b1 ("Landlock: Workaround a bug in RHEL 9 kernel")
+
+ src/common/my_landlock.h | 6 ++++++
+ 1 file changed, 6 insertions(+)
+
+commit 23c95c6a7c374962103dbd35cb79fdd5a6fe8b52
+Author: Lasse Collin
+Date: 2025-11-23 20:13:50 +0200
+
+ Update THANKS
+
+ THANKS | 2 ++
+ 1 file changed, 2 insertions(+)
+
+commit 2b2652e914b1c38d4c009a8dcac11dfee9c7e008
+Author: Lasse Collin
+Date: 2025-11-23 20:13:49 +0200
+
+ Landlock: Workaround a bug in RHEL 9 kernel
+
+ If one runs xz 5.8.0 or 5.8.1 from some other distribution in a container
+ on RHEL 9, xz will fail with the message "Failed to enable the sandbox".
+
+ RHEL 9 kernel since 5.14.0-603.el9 (2025-07-30) claims to support
+ Landlock ABI version 6, but it lacks support for LANDLOCK_SCOPE_SIGNAL.
+ The issue is still present in 5.14.0-643.el9 (2025-11-22). Red Hat is
+ aware of the issue, but I don't know when it will be fixed.
+
+ The sandbox is meant to be transparent to users, thus there isn't and
+ won't be a command line option to disable it. Instead, add a workaround
+ to keep xz working on the buggy RHEL 9 kernels.
+
+ Reported-by: Richard W.M. Jones
+ Thanks-to: Pavel Raiskup
+ Tested-by: Orgad Shaneh
+ Tested-by: Richard W.M. Jones
+ Fixes: https://github.com/tukaani-project/xz/issues/199
+ Link: https://issues.redhat.com/browse/RHEL-125143
+ Link: https://bugzilla.redhat.com/show_bug.cgi?id=2407105
+ Link: https://lists.fedoraproject.org/archives/list/devel@lists.fedoraproject.org/message/65BDSY56R5ZJRTUC4B6CIVCVLY4LG4ME/
+
+ src/common/my_landlock.h | 27 ++++++++++++++++++++++++++-
+ 1 file changed, 26 insertions(+), 1 deletion(-)
+
+commit ee75c76958dd891906745125590563ab64e85995
+Author: Lasse Collin
+Date: 2025-11-23 20:13:37 +0200
+
+ Landlock: Cache the ABI version
+
+ In xz it can avoid up to two syscalls that query the ABI version.
+
+ src/common/my_landlock.h | 14 +++++++++++++-
+ 1 file changed, 13 insertions(+), 1 deletion(-)
+
+commit f57b1716cd0853474980c90a892204dee9bdea1a
+Author: Lasse Collin
+Date: 2025-11-03 14:52:45 +0200
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit 211cde09236165dbd379644753337be1de64b151
+Author: Lasse Collin
+Date: 2025-11-03 12:41:31 +0200
+
+ mythread.h: Fix the build on Emscripten when threading is disabled
+
+ To make a non-threaded liblzma-only build work with WASI SDK,
+ and mythread_sigmask() were omitted from mythread.h in the commit
+ 81db3b889830. This broke non-threaded full build with Emscripten because
+ src/xz/signals.c needs mythread_sigmask() (liblzma-only build was fine).
+
+ If __wasm__ is defined, omit and mythread_sigmask() in
+ non-threaded builds only when __EMSCRIPTEN__ isn't defined.
+
+ Reported-by: Marcus Tillmanns
+ Thanks-to: ChanTsune
+ Fixes: https://github.com/tukaani-project/xz/issues/161
+ Fixes: 81db3b889830 ("mythread.h: Disable signal functions in builds targeting Wasm + WASI.")
+
+ src/common/mythread.h | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit cbf50a99e3f0c2735fd573e166baf37df063b37b
+Author: Lasse Collin
+Date: 2025-11-03 11:56:32 +0200
+
+ Translations: Update the Serbian man page translations
+
+ The earlier bug fixes are now included in the Translation Project.
+
+ po4a/sr.po | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 68d1591187512d8872615c8a904d43073440d93f
+Author: Lasse Collin
+Date: 2025-11-02 19:40:55 +0200
+
+ xz: Silence a compiler warning when signals_block_count is unused
+
+ Move the static variable signals_block_count to the #ifndef block
+ that already has the functions that need the variable.
+
+ src/xz/signals.c | 7 ++++---
+ 1 file changed, 4 insertions(+), 3 deletions(-)
+
+commit beca015891fbd22657663ec23809184dda0677cd
+Author: Lasse Collin
+Date: 2025-11-02 17:45:20 +0200
+
+ xz: Silence a warning from Clang on glibc systems
+
+ Fixes: e8838b2f5922 ("xz: Look at resource limits when determining the default memlimit")
+
+ src/xz/hardware.c | 13 +++++++++++++
+ 1 file changed, 13 insertions(+)
+
+commit 3e394278ed537575b5db43c09989c6ca99f762de
+Author: Lasse Collin
+Date: 2025-11-02 14:37:52 +0200
+
+ Translations: Update the Serbian man page translations
+
+ Preserve the bug fixes made in 71ad5e82888f and 4f52e7387012 because
+ upstream hasn't included them.
+
+ po4a/sr.po | 17 ++++++-----------
+ 1 file changed, 6 insertions(+), 11 deletions(-)
+
+commit ace28e35732fc43f58ea1aac146fdb73084f2548
+Author: Lasse Collin
+Date: 2025-11-02 14:27:10 +0200
+
+ Translations: Update the Korean man page translations
+
+ po4a/ko.po | 17 ++++++-----------
+ 1 file changed, 6 insertions(+), 11 deletions(-)
+
+commit ffd14a099f0d8c92d4f74018d3a52bd2327df4db
+Author: Lasse Collin
+Date: 2025-11-02 14:24:43 +0200
+
+ Translations: Update the Italian man page translations
+
+ po4a/it.po | 15 +++++----------
+ 1 file changed, 5 insertions(+), 10 deletions(-)
+
+commit 6f3152874ee375b581aa858fccab7865dcbf6403
+Author: Lasse Collin
+Date: 2025-11-02 14:12:23 +0200
+
+ Translations: Update the Ukrainian man page translations
+
+ po4a/uk.po | 15 +++++----------
+ 1 file changed, 5 insertions(+), 10 deletions(-)
+
+commit ef67e051d71938a23713d9782a3f0c470ac51b1e
+Author: Lasse Collin
+Date: 2025-09-28 18:32:05 +0300
+
+ liblzma: Fix build on old Linux/glibc on ARM64
+
+ getauxval() can be available even if HWCAP_CRC32 isn't #defined, so
+ both have to be checked. HWCAP_CRC32 was added in glibc 2.24 (2016).
+
+ Fixes: https://github.com/tukaani-project/xz/issues/190
+
+ CMakeLists.txt | 7 +++++++
+ configure.ac | 6 +++++-
+ src/liblzma/check/crc32_arm64.h | 5 +++--
+ src/liblzma/check/crc_common.h | 3 ++-
+ 4 files changed, 17 insertions(+), 4 deletions(-)
+
+commit 71c2ede383f6dc6661b8a9d844f4bcf81c563643
+Author: Lasse Collin
+Date: 2025-10-31 14:36:26 +0200
+
+ CI: Update Solaris
+
+ .github/workflows/solaris.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 02da8de0edddd31a3e9818c2200b97c446d6eb5b
+Author: Lasse Collin
+Date: 2025-10-31 14:32:47 +0200
+
+ CI: Update DragonFly BSD
+
+ .github/workflows/dragonflybsd.yml | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+commit 75b18d325f6a993eac2d5f44c7aad941aa20df94
+Author: Lasse Collin
+Date: 2025-10-31 14:30:24 +0200
+
+ CI: Update NetBSD
+
+ .github/workflows/netbsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 0102072915f38e747ee55aa9c52351dfe81b8c14
+Author: Lasse Collin
+Date: 2025-10-31 14:21:37 +0200
+
+ CI: Update FreeBSD
+
+ .github/workflows/freebsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 83419783a67a6097c7d5ed5663734c04eb8c8b55
+Author: Lasse Collin
+Date: 2025-10-31 14:17:30 +0200
+
+ CI: Update OpenBSD
+
+ .github/workflows/openbsd.yml | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+commit 3b5f5af9bcd9b5752608a099fcfab331c0c613b3
+Author: Lasse Collin
+Date: 2025-10-26 12:07:34 +0200
+
+ Update THANKS
+
+ THANKS | 2 ++
+ 1 file changed, 2 insertions(+)
+
+commit e8838b2f59221f46bf34c79431d286e8ac34fb8b
+Author: Kirill A. Korinsky
+Date: 2025-10-26 12:07:34 +0200
+
+ xz: Look at resource limits when determining the default memlimit
+
+ When no memory usage limits have been set by the user, the default
+ for multithreaded mode has been 1/4 of total RAM. If this limit is
+ too high and memory allocation fails, liblzma (and xz) fail. Perhaps
+ liblzma should handle it better by reducing the number of threads
+ and continuing with the amount of memory it can allocate, but currently
+ that isn't the case.
+
+ If resource limits were set to about 1/4 of RAM or lower, then xz
+ could fail for the above reason. This commit makes xz look at
+ RLIMIT_DATA, RLIMIT_AS, and RLIMIT_VMEM when they are available,
+ and set the limit 64 MiB below the lowest of those limits. This is
+ more or less a hack just like the 1/4-of-RAM method is, but this is
+ simple and quick to implement.
+
+ On Linux, there are other limits like cgroup v2 memory.max which
+ can still make xz fail. The same is likely possible with FreeBSD's
+ rctl(8).
+
+ Co-authored-by: Lasse Collin
+ Thanks-to: Fangrui Song
+ Fixes: https://github.com/tukaani-project/xz/issues/195
+ Closes: https://github.com/tukaani-project/xz/pull/196
+
+ CMakeLists.txt | 3 +++
+ configure.ac | 4 ++--
+ src/xz/hardware.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 64 insertions(+), 2 deletions(-)
+
+commit 8d26b72915e0d373f898b55935505857c30dbdb3
+Author: Lasse Collin
+Date: 2025-10-01 12:46:26 +0300
+
+ CI: Remove windows-2019 (which had VS 2019)
+
+ GitHub has removed the runner image.
+
+ A breakage with CLMUL CRC code occurred with VS 2019 but not 2022,
+ see b5a5d9e3f702. MS supports VS 2019 for a few more years, so it's
+ unfortunate that it can no longer be tested on GitHub.
+
+ .github/workflows/msvc.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 32412bd2a42fda639765c3046e91f964e286b6d9
+Author: Lasse Collin
+Date: 2025-09-29 19:34:58 +0300
+
+ Update THANKS
+
+ THANKS | 3 +++
+ 1 file changed, 3 insertions(+)
+
+commit eaa150df9803c982adf28d4533c7a4264ea17757
+Author: Lakshmi-Surekha
+Date: 2025-07-17 23:27:06 -0500
+
+ xz: Don't fsync() directories on AIX
+
+ It fails with EBADF.
+
+ Fixes: https://github.com/tukaani-project/xz/issues/188
+ Closes: https://github.com/tukaani-project/xz/pull/189
+
+ src/xz/file_io.c | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit 61b114e92f53b7977aad69f8a7130fc25d8a80e5
+Author: Lasse Collin
+Date: 2025-09-29 18:37:19 +0300
+
+ liblzma: Document that lzma_allocator.free(opaque, NULL) is possible
+
+ It feels better to fix the docs than change the code because this
+ way newly-written applications will be forced to be compatible with
+ the lzma_allocator behavior of old liblzma versions. It can matter
+ if someone builds the application against an older liblzma version.
+
+ Fixes: https://github.com/tukaani-project/xz/issues/183
+
+ src/liblzma/api/lzma/base.h | 4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+commit 6d287a3ae90e1b990294f3d5264003d81e853c5e
+Author: Simon Josefsson
+Date: 2025-08-26 09:41:02 +0200
+
+ Update GPLv2 and LGPLv2.1 copies from gnu.org
+
+ Closes: https://github.com/tukaani-project/xz/pull/194
+
+ COPYING.GPLv2 | 9 ++++-----
+ COPYING.LGPLv2.1 | 9 ++++-----
+ 2 files changed, 8 insertions(+), 10 deletions(-)
+
+commit 41a421dbadf13af2a59aaafa43836026b83340a7
+Author: Lasse Collin
+Date: 2025-05-24 12:07:13 +0300
+
+ tests/test_suffix.sh: Avoid variables in printf format string
+
+ tests/test_suffix.sh | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit a2c6aa8764a2e5248572d461305bd05c5950bf94
+Author: Lasse Collin
+Date: 2025-05-24 12:02:09 +0300
+
+ build-aux/manconv.sh: Add quotes
+
+ build-aux/manconv.sh | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+commit 8e4153253eea2b5a9466467b2ce0249e56277c9a
+Author: Lasse Collin
+Date: 2025-05-24 12:01:35 +0300
+
+ windows/build.bash: Add quotes
+
+ In this case they aren't needed but it's better style.
+
+ windows/build.bash | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 37a57a926dd1ae6cde1544d8487e27982d2db4a4
+Author: Lasse Collin
+Date: 2025-05-24 12:00:13 +0300
+
+ po4a/update-po: Ensure that a glob won't expand to a command line option
+
+ po4a/update-po | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit e3ba73034a3f8e414882af39d62f479e9717e061
+Author: Lasse Collin
+Date: 2025-05-24 11:57:23 +0300
+
+ liblzma: validate_map.sh: Catch some unlikely errors
+
+ src/liblzma/validate_map.sh | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 067cecdea69067973e44dc1afb9be763faccecb2
+Author: Lasse Collin
+Date: 2025-05-24 11:55:59 +0300
+
+ CI: Catch unsupported arguments in ci_build.bash
+
+ build-aux/ci_build.bash | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+commit 4fc6208abebfe6b8c8348c412b4bcc594ae11c88
+Author: Lasse Collin
+Date: 2025-05-13 20:42:26 +0300
+
+ Scripts: Add shellcheck directives to silence warnings
+
+ Set also shell because the xz*.in files start with '#!@POSIX_SHELL@'.
+
+ SC1003 and SC2016 are only info messages, not warnings. Several other
+ shellcheck info messages remain. They are safe to ignore, but I didn't
+ want to disable them now.
+
+ Partially-fixes: https://github.com/tukaani-project/xz/issues/174
+
+ src/scripts/xzdiff.in | 4 ++++
+ src/scripts/xzgrep.in | 2 ++
+ src/scripts/xzless.in | 2 ++
+ src/scripts/xzmore.in | 2 ++
+ 4 files changed, 10 insertions(+)
+
+commit 7844aff1a838362403b332c3a68d5732a192923a
+Author: Lasse Collin
+Date: 2025-05-03 22:45:15 +0300
+
+ Scripts: Silence two shellcheck warnings
+
+ src/scripts/xzdiff.in | 2 +-
+ src/scripts/xzmore.in | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+commit 4d439aaeed5c991fbc1ff78d7616e179c30fca1d
+Author: Lasse Collin
+Date: 2025-09-29 17:29:23 +0300
+
+ Translations: Add Swedish man page translations
+
+ po4a/po4a.conf | 2 +-
+ po4a/sv.po | 3909 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 3910 insertions(+), 1 deletion(-)
+
+commit dd4a1b259936880e04669b43e778828b60619860
+Author: Lasse Collin
+Date: 2025-05-23 13:09:14 +0300
+
+ CI: Add timeout-minutes
+
+ Sometimes the VM workflows (like FreeBSD VM on Ubuntu) get stuck
+ and the default timeout is six hours. While at it, set a sensible
+ timeout for all workflows.
+
+ .github/workflows/ci.yml | 1 +
+ .github/workflows/cifuzz.yml | 1 +
+ .github/workflows/dragonflybsd.yml | 1 +
+ .github/workflows/freebsd.yml | 1 +
+ .github/workflows/msvc.yml | 1 +
+ .github/workflows/msys2.yml | 1 +
+ .github/workflows/netbsd.yml | 1 +
+ .github/workflows/openbsd.yml | 1 +
+ .github/workflows/solaris.yml | 1 +
+ 9 files changed, 9 insertions(+)
+
+commit d660fe5d56a804b0ef3eea550fdcd51dbe17e45b
+Author: Lasse Collin
+Date: 2025-05-23 12:25:36 +0300
+
+ liblzma: Fix grammar in API docs
+
+ Fixes: a27920002dbc ("liblzma: Add generic support for input seeking (LZMA_SEEK).")
+
+ src/liblzma/api/lzma/base.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit ab45bdf4322879dc2859b1f66f1f8cf89cdebe2c
+Author: Lasse Collin
+Date: 2025-05-21 16:07:01 +0300
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit f0239936532d40be05e75384c37fb8d6c1bb4ff6
+Author: Lasse Collin
+Date: 2025-05-21 16:07:01 +0300
+
+ CMake: With symbol versioning, try to pass --undefined-version to linker
+
+ Fixes: https://github.com/tukaani-project/xz/issues/180
+ Fixes: https://bugs.gentoo.org/956119
+
+ CMakeLists.txt | 22 ++++++++++++++++++++++
+ 1 file changed, 22 insertions(+)
+
+commit 377be0ea7a1d0ec3572a7f9a5f9ed42adeaa4503
+Author: Lasse Collin
+Date: 2025-05-21 16:07:01 +0300
+
+ Build: With symbol versioning, try to pass --undefined-version to linker
+
+ Fixes: https://github.com/tukaani-project/xz/issues/180
+ Fixes: https://bugs.gentoo.org/956119
+
+ configure.ac | 23 +++++++++++++++++++++++
+ src/liblzma/Makefile.am | 2 ++
+ 2 files changed, 25 insertions(+)
+
+commit ff49c82176ca53646a1cbbbb4efc35a542745812
+Author: Lasse Collin
+Date: 2025-05-21 14:48:18 +0300
+
+ CMake: Fix comments
+
+ CMakeLists.txt | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 71ad5e82888fdfa0fe11defa4f46cb0fc90dc326
+Author: Lasse Collin
+Date: 2025-05-21 13:14:04 +0300
+
+ Translations: Update Serbian man page translations
+
+ Compared to the file in the Translation Project, I still had to apply
+ a few fixes that were needed with the previous (5.7.1-dev1) version too:
+
+ - Remove two extra '<' characters that break the build with po4a.
+
+ - Don't translate XZ_DEFAULTS and XZ_OPT environment variable names.
+
+ po4a/sr.po | 70 ++++++++++++++++++++------------------------------------------
+ 1 file changed, 22 insertions(+), 48 deletions(-)
+
+commit 31a983ad4774054074b300f55ff519484ff182c2
+Author: Lasse Collin
+Date: 2025-05-21 12:55:28 +0300
+
+ Update po/.gitignore
+
+ po/.gitignore | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit d9e70da25ac761544146bc2fbab6443e1a080bf4
+Author: Lasse Collin
+Date: 2025-05-21 12:54:42 +0300
+
+ Translations: Update the Spanish translation
+
+ po/es.po | 10 +++++-----
+ 1 file changed, 5 insertions(+), 5 deletions(-)
+
+commit dbfb925c8198087afb3527e6c57b66fae1a980bb
+Author: Lasse Collin
+Date: 2025-05-03 12:37:28 +0300
+
+ Tests: Silence a warning from GCC 15.1
+
+ It was (probably) intentionally without the null terminator, but the test
+ works with null terminator too (the test still fails with xz <= 5.0.3),
+ so simply omit one character to silence the warning.
+
+ tests/test_bcj_exact_size.c:30:32: error: initializer-string for array of ‘unsigned char’ truncates NUL terminator but destination lacks ‘nonstring’ attribute (17 chars into 16 available) [-Werror=unterminated-string-initialization]
+ 30 | const uint8_t in[16] = "0123456789ABCDEF";
+ | ^~~~~~~~~~~~~~~~~~
+
+ Fixes: d8db706acb83 ("liblzma: Fix possibility of incorrect LZMA_BUF_ERROR.")
+ Fixes: https://github.com/tukaani-project/xz/issues/176
+
+ tests/test_bcj_exact_size.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 7c12726c51b2b7d77329dd72a29ecb1ec262b918
+Author: Lasse Collin
+Date: 2025-04-28 18:16:14 +0300
+
+ Update THANKS
+
+ THANKS | 2 ++
+ 1 file changed, 2 insertions(+)
+
+commit 1bd7361a043bd652ee5d0ebafd23459c57f57993
+Author: Lasse Collin
+Date: 2025-04-25 17:32:03 +0300
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit 5cc2e479eb447a444f5ab005fc36b7f275c75eb5
+Author: Guillaume Outters
+Date: 2025-04-25 02:55:08 +0200
+
+ xz, xzdec: Capsicum sandbox: Fix incorrect use of cap_rights_clear()
+
+ cap_rights_clear() with no additional arguments acts as a no-op, so
+ instead of removing all capability rights from STDIN_FILENO, the same
+ rights were allowed for STDIN_FILENO as were allowed for src_fd.
+
+ Fixes: a0eecc235d3b ("xz: Make Capsicum sandbox more strict with stdin and stdout.")
+ (The commit message says "stdout". It should have said "stderr".)
+
+ src/xz/sandbox.c | 2 +-
+ src/xzdec/xzdec.c | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+commit 56aa9a07968a6a73fada6f9b96122c5165829f3b
+Author: Lasse Collin
+Date: 2025-04-22 21:12:50 +0300
+
+ CI: Valgrind: Improve the skipping of traced child processes
+
+ Use --trace-children-skip instead of --trace-children-skip-by-arg
+ so that the skipping is only done based on the executable names.
+ (--trace-children-skip-by-arg can match other args than argv[0].)
+
+ Update the list of executables to skip to match what the scripts run.
+
+ Do not skip bash or sh. If Valgrind didn't trace the shell, then the
+ xz and xzdec programs run by the shell wouldn't be analyzed either.
+
+ Fixes: 7e99856f66c0 ("CI: Speed up Valgrind job by using --trace-children-skip-by-arg=...")
+
+ .github/workflows/ci.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit f33da20b75a45caad25c9a4daf7906e4f056ce91
+Author: Lasse Collin
+Date: 2025-04-22 21:12:50 +0300
+
+ CI: Valgrind: Test with static liblzma
+
+ If shared liblzma is built, tests/test_* and src/xz/xz are wrapper
+ scripts created by Libtool. The wrappers set library search path
+ so that the freshly-built shared library is found.
+
+ With a static liblzma, no wrapper scripts are needed, and Libtool
+ places the real executables to the aforementioned locations. This
+ speeds up the tests under Valgrind dramatically.
+
+ Fixes: 6c095a98fbec ("ci: test Valgrind")
+
+ .github/workflows/ci.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 5606fa89f91ca1d0d53e339d88f574fc731049c1
+Author: Lasse Collin
+Date: 2025-04-22 21:12:50 +0300
+
+ CI: Add Ubuntu on ARM64
+
+ .github/workflows/ci.yml | 27 ++++++++++++++++-----------
+ 1 file changed, 16 insertions(+), 11 deletions(-)
+
+commit ec047a65a068087cc6f71133df414858f6886121
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ Doxygen: Update the comment about tested versions
+
+ doxygen/Doxyfile | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 4f86e77bef8918b0c64183590609357a275558d8
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ Doxygen: Set HAVE_DOT = NO
+
+ Debian and Ubuntu have a patch that changes the upstream default to
+ HAVE_DOT = YES. Undo it to have more consistent results across distros.
+
+ This was noticed in Ubuntu CI runner where "doxygen" tried to run "dot"
+ but that failed due to "dot" not being installed. "doxygen" still
+ finished with exit status 0 until the commit that turned warnings to
+ errors with WARN_AS_ERROR = FAIL_ON_WARNINGS.
+
+ doxygen/Doxyfile | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+commit ff96542d1c78f744d992be5890c95d90b2d19047
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ Doxygen: Treat warnings as errors
+
+ Also set WARN_IF_UNDOCUMENTED = NO because even the API headers have
+ a few things that won't have their own docs.
+
+ doxygen/Doxyfile | 2 ++
+ 1 file changed, 2 insertions(+)
+
+commit a6711d1c4ad681aad985372d01a7deb21b4a1b8b
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ Doxygen: Fix errors and some warnings in internal docs
+
+ src/liblzma/check/crc32_fast.c | 2 +-
+ src/liblzma/check/crc64_fast.c | 2 +-
+ src/liblzma/common/outqueue.h | 1 +
+ src/xz/list.c | 2 ++
+ src/xz/message.h | 4 ++++
+ 5 files changed, 9 insertions(+), 2 deletions(-)
+
+commit 8efd80adfcd65dfea086c1008452c6424b30b78c
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ CI: Use --disable-sandbox instead of --enable-sandbox=no
+
+ It's the same thing, just a style difference.
+
+ build-aux/ci_build.bash | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit a2e47c7a59d835ba80beef53b986d45e99ecd94a
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ CI: Support Doxygen in ci_build.bash
+
+ build-aux/ci_build.bash | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+commit 9048e724945a3dfbf86d7f97437113f27ea41c63
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ CI: Add Doxygen dependency to CMake builds on Ubuntu and macOS
+
+ .github/workflows/ci.yml | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit d8e9dc63a6124336e72a849b8104ba60720f0fe2
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ CI: Support XZ_NLS=OFF with CMake
+
+ build-aux/ci_build.bash | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit ffa9fadecc85d21308aebac7b070fb5be791190f
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ CI: Revise MSYS2
+
+ Re-enable CLANG64 environment. Add CLANGARM64. Don't add MINGW64
+ to slightly reduce the number of runner VMs needed.
+
+ Install the required packages using the setup-msys2 action instead
+ of running the commands separately.
+
+ Test Autotools and CMake in the same job to reduce the number of VMs.
+ This doesn't slow it down too much because the msys2-setup step is
+ needed by both. However, do only the full builds on ARM64 because
+ those runners seem to be slower.
+
+ Test fewer build configurations. The point of testing on MSYS2 is to
+ catch Windows-related issues. It should be enough that the more unusual
+ build configurations are tested in ci.yml.
+
+ Run the build commands directly instead of using ci_build.bash. This
+ makes it easier to see what commands are run even if it is a little
+ more verbose now.
+
+ Run the workflow automatically when commit are pushed to master.
+ With the fewer build variants it's not too slow.
+
+ .github/workflows/msys2.yml | 197 +++++++++++++++++++++++++-------------------
+ 1 file changed, 110 insertions(+), 87 deletions(-)
+
+commit 6f2aaa77daef7b408dc0d9c9a534373a30da7a50
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ CI: Rename the MSYS2 workflow file
+
+ .github/workflows/{windows-ci.yml => msys2.yml} | 0
+ 1 file changed, 0 insertions(+), 0 deletions(-)
+
+commit 09110ad4c74f3ee1b4b0355d92b703525eddd3ff
+Author: Lasse Collin
+Date: 2025-04-22 16:21:50 +0300
+
+ CI: Enable assertions on NetBSD + CMake
+
+ .github/workflows/netbsd.yml | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 516b90f6e1beb243dd76adc82da0ee47e525f863
+Author: Lasse Collin
+Date: 2025-04-21 12:23:37 +0300
+
+ liblzma: Update lzma_lzip_decoder() docs about trailing data
+
+ Don't say that the .lz format allows trailing data. According to the
+ lzip 1.25 manual, trailing data isn't part of the file format at all.
+ However, tools are still expected to behave as usefully as possible
+ when there is trailing data.
+
+ Fix the description of lzip >= 1.20 behavior when some of the first
+ bytes of trailing data match the magic bytes. While the lzip 1.25 manual
+ recommends that none of the first four bytes in trailing data should
+ match the magic bytes, the default behavior of lzip 1.25 treats
+ trailing data as a corrupt member header only if two or three bytes
+ match the magic bytes; one matching byte isn't enough.
+
+ Reported-by: Antonio Diaz Diaz
+ Link: https://www.mail-archive.com/xz-devel@tukaani.org/msg00702.html
+
+ src/liblzma/api/lzma/container.h | 23 +++++++++++------------
+ 1 file changed, 11 insertions(+), 12 deletions(-)
+
+commit c330220d47dc09a5bab805d22654c8c0a73d21a9
+Author: Lasse Collin
+Date: 2025-04-21 11:21:08 +0300
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit 6cc7672c2238e7fc66bba33cff50cecd30411063
+Author: Lasse Collin
+Date: 2025-04-17 20:36:33 +0300
+
+ CI: Add DragonflyBSD
+
+ .github/workflows/dragonflybsd.yml | 39 ++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 39 insertions(+)
+
+commit 07dc50913725496bd89178539190292a66e18710
+Author: Lasse Collin
+Date: 2025-04-17 20:36:33 +0300
+
+ CI: Update Solaris
+
+ .github/workflows/solaris.yml | 37 +++++++++++++++++++------------------
+ 1 file changed, 19 insertions(+), 18 deletions(-)
+
+commit cfcaae1945c0c33df86477138746e68428972a53
+Author: Lasse Collin
+Date: 2025-04-17 20:36:33 +0300
+
+ CI: Update OpenBSD
+
+ Use --disable-nls --enable-external-sha256 because those are used
+ in the xz Makefile in the OpenBSD ports tree.
+
+ .github/workflows/openbsd.yml | 46 +++++++++++++++++++++++--------------------
+ 1 file changed, 25 insertions(+), 21 deletions(-)
+
+commit 5240fcfee3b1386029a26629d75f1465b9e85ca3
+Author: Lasse Collin
+Date: 2025-04-17 20:36:33 +0300
+
+ CI: Update NetBSD
+
+ For variety, use CMake and Ninja.
+
+ .github/workflows/netbsd.yml | 43 +++++++++++++++++++++++++------------------
+ 1 file changed, 25 insertions(+), 18 deletions(-)
+
+commit 85ff0cf0ce11b017af21c040330f6a0c09ef7f77
+Author: Lasse Collin
+Date: 2025-04-17 20:36:33 +0300
+
+ CI: Update FreeBSD
+
+ ARM64 was left commented out because it's slow under both
+ ubuntu-latest (x86-64) and ubuntu-24.04-arm (aarch64) hosts.
+
+ .github/workflows/freebsd.yml | 61 +++++++++++++++++++++++++++++--------------
+ 1 file changed, 42 insertions(+), 19 deletions(-)
+
+commit 907ac2215db1613312dc292219bac798d76394f4
+Author: Lasse Collin
+Date: 2025-04-11 17:25:53 +0300
+
+ CI: Specify only the main version of the standard GH actions
+
+ .github/workflows/ci.yml | 4 ++--
+ .github/workflows/msvc.yml | 2 +-
+ 2 files changed, 3 insertions(+), 3 deletions(-)
+
+commit b0d0e624740b92415f78274702b5b5bfbffe4543
+Author: Lasse Collin
+Date: 2025-04-11 17:15:08 +0300
+
+ CI: Add 'permissions' to ci.yml and msvc.yml
+
+ .github/workflows/ci.yml | 2 ++
+ .github/workflows/msvc.yml | 2 ++
+ 2 files changed, 4 insertions(+)
+
+commit 1edc14e8ca4fc1f25ee43f17f290c045df7f49e0
+Author: Sam James
+Date: 2025-04-10 23:15:31 +0300
+
+ CI: Add CIFuzz
+
+ xz is already part of OSS-Fuzz, but OSS-Fuzz provides & encourages [0]
+ its 'CIFuzz' service to test individual commits.
+
+ [0] https://google.github.io/oss-fuzz/getting-started/continuous-integration/
+
+ Co-authored-by: Lasse Collin
+
+ .github/workflows/cifuzz.yml | 54 ++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 54 insertions(+)
+
+commit 35e06c4c426c6cc3866a9003e87a122eb78bccf2
+Author: Lasse Collin
+Date: 2025-04-12 15:31:01 +0300
+
+ CMake: Don't check for optreset if using replacement getopt_long
+
+ If had optreset but not getopt_long, xz used optreset while
+ the replacement getopt_long doesn't support optreset. I'm not aware of
+ any relevant system where bug is possible. Autotools build didn't have
+ this bug.
+
+ Fixes: af66cd585902 ("CMake: Add support for replacement getopt_long (lib/getopt*).")
+
+ CMakeLists.txt | 6 ++++--
+ 1 file changed, 4 insertions(+), 2 deletions(-)
+
+commit 99f4b9db9dfc3dabad330df6242e4632c42393c6
+Author: Lasse Collin
+Date: 2025-04-17 18:33:10 +0300
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit dd006a67e593cb5d3dec5180face7e3010fe78da
+Author: Lasse Collin
+Date: 2025-04-17 18:30:26 +0300
+
+ liblzma: Update the lzma_lzip_decoder() docs about sync flush marker
+
+ src/liblzma/api/lzma/container.h | 15 +++++++--------
+ 1 file changed, 7 insertions(+), 8 deletions(-)
+
+commit f59c5859600b5dfeaa618fcc04e9e3bb2b005f5c
+Author: Lasse Collin
+Date: 2025-04-17 18:16:40 +0300
+
+ xz: Don't mention lzip's sync flush marker on the man page
+
+ The sync flush marker isn't valid in .lz files. The sync flush marker
+ may be used by lzlib, but the resulting streams are only meant to be
+ decoded by lzlib itself. lzlib's docs make this clear.
+
+ Reported-by: Antonio Diaz Diaz
+ Link: https://www.mail-archive.com/xz-devel@tukaani.org/msg00700.html
+ Link: https://www.mail-archive.com/xz-devel@tukaani.org/msg00701.html
+
+ src/xz/xz.1 | 9 +--------
+ 1 file changed, 1 insertion(+), 8 deletions(-)
+
+commit 49258439b4ead6866798c1ebf8a083ec9ec04520
+Author: Lasse Collin
+Date: 2025-04-17 18:15:48 +0300
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit a69fbd3aaebc15dc5912e64724e5abfcef09bcdf
+Author: Lasse Collin
+Date: 2025-04-10 20:13:07 +0300
+
+ CI: MSVC: Use fewer runners for the same number of tests
+
+ Using eight runners seems wasteful. Using only two runners isn't
+ much slower due to the runner startup overhead.
+
+ Also add a comment about the test that fails without b5a5d9e3f702.
+
+ .github/workflows/msvc.yml | 66 ++++++++++++++++++++++++++++++++++++++--------
+ 1 file changed, 55 insertions(+), 11 deletions(-)
+
+commit 8a300d1c4fc644af482fb679044794c3e3f6f3e5
+Author: Lasse Collin
+Date: 2025-04-10 20:10:31 +0300
+
+ Update THANKS
+
+ THANKS | 1 +
+ 1 file changed, 1 insertion(+)
+
+commit b5a5d9e3f7022e546cdfd4ddc42fe4cc56839c05
+Author: Lasse Collin
+Date: 2025-04-07 22:36:58 +0300
+
+ liblzma: Disable CLMUL CRC on old MSVC targeting 32-bit x86
+
+ On GitHub runners, VS 2019 16.11 (MSVC 19.29.30158) results in
+ test failures. VS 2022 17.13 (MSVC 19.43.34808) works.
+
+ In xz 5.6.x there was a #pragma-based workaround for MSVC builds for
+ 32-bit x86. Another method was thought to work with the new rewritten
+ CLMUL CRC. Apparently it doesn't. Keep it simple and disable CLMUL CRC
+ with any non-recent MSVC when building for 32-bit x86.
+
+ Fixes: 54eaea5ea49b ("liblzma: x86 CLMUL CRC: Rewrite")
+ Fixes: https://github.com/tukaani-project/xz/issues/171
+ Reported-by: Andrew Murray
+
+ src/liblzma/check/crc_common.h | 16 +++++++++++++---
+ 1 file changed, 13 insertions(+), 3 deletions(-)
+
+commit c5fd88dfc3d2b4178dc6da65b02a63a4ef9280c5
+Author: Lasse Collin
+Date: 2025-04-07 22:36:58 +0300
+
+ liblzma: Remove MSVC hack from CLMUL CRC
+
+ It's not enough with MSVC 19.29 (VS 2019) even if the hack was also
+ applied to the CRC32 code. The tests crash when built for 32-bit x86.
+
+ src/liblzma/check/crc64_fast.c | 8 --------
+ 1 file changed, 8 deletions(-)
+
+commit 49ba8c69ea7f928aded77bd856085c85a8d26156
+Author: Lasse Collin
+Date: 2025-04-07 22:36:52 +0300
+
+ CI: Test 32/64-bit x86 builds with Visual Studio 2019 and 2022
+
+ .github/workflows/msvc.yml | 45 +++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 45 insertions(+)
+
+commit 1176a19df6b1585b51131b0e2570e03f1fc14f46
+Author: Lasse Collin
+Date: 2025-04-04 20:08:37 +0300
+
+ Tests: Add fuzz_decode_stream_mt.options
+
+ tests/ossfuzz/config/fuzz_decode_stream_mt.options | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+commit c3cb1e53a114ac944f559fe7cac45dbf48cca156
+Author: Lasse Collin
+Date: 2025-04-03 15:06:07 +0300
+
+ doc/SHA256SUMS: Add 5.8.1
+
+ doc/SHA256SUMS | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
commit a522a226545730551f7e7c2685fab27cf567746c
Author: Lasse Collin
Date: 2025-04-03 14:34:43 +0300
diff -Nru xz-utils-5.8.1/Makefile.in xz-utils-5.8.3/Makefile.in
--- xz-utils-5.8.1/Makefile.in 2025-04-03 11:35:21.000000000 +0000
+++ xz-utils-5.8.3/Makefile.in 2026-03-31 15:27:10.000000000 +0000
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.17 from Makefile.am.
+# Makefile.in generated by automake 1.18.1 from Makefile.am.
# @configure_input@
-# Copyright (C) 1994-2024 Free Software Foundation, Inc.
+# Copyright (C) 1994-2025 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -322,6 +322,7 @@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
+LINKER_FLAG_UNDEFINED_VERSION = @LINKER_FLAG_UNDEFINED_VERSION@
LIPO = @LIPO@
LN_EXEEXT = @LN_EXEEXT@
LN_S = @LN_S@
@@ -697,6 +698,7 @@
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
-rm -f cscope.out cscope.in.out cscope.po.out cscope.files
+
distdir: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) distdir-am
@@ -780,6 +782,10 @@
tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
$(am__post_remove_distdir)
+dist-bzip3: distdir
+ tardir=$(distdir) && $(am__tar) | bzip3 -c >$(distdir).tar.bz3
+ $(am__post_remove_distdir)
+
dist-lzip: distdir
tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
$(am__post_remove_distdir)
@@ -824,6 +830,8 @@
eval GZIP= gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
*.tar.bz2*) \
bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
+ *.tar.bz3*) \
+ bzip3 -dc $(distdir).tar.bz3 | $(am__untar) ;;\
*.tar.lz*) \
lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
*.tar.xz*) \
@@ -1015,9 +1023,9 @@
.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
am--refresh check check-am clean clean-cscope clean-generic \
clean-libtool cscope cscopelist-am ctags ctags-am dist \
- dist-all dist-bzip2 dist-gzip dist-hook dist-lzip dist-shar \
- dist-tarZ dist-xz dist-zip dist-zstd distcheck distclean \
- distclean-generic distclean-hdr distclean-libtool \
+ dist-all dist-bzip2 dist-bzip3 dist-gzip dist-hook dist-lzip \
+ dist-shar dist-tarZ dist-xz dist-zip dist-zstd distcheck \
+ distclean distclean-generic distclean-hdr distclean-libtool \
distclean-tags distcleancheck distdir distuninstallcheck dvi \
dvi-am html html-am info info-am install install-am \
install-data install-data-am install-dist_docDATA \
diff -Nru xz-utils-5.8.1/NEWS xz-utils-5.8.3/NEWS
--- xz-utils-5.8.1/NEWS 2025-04-03 11:35:07.000000000 +0000
+++ xz-utils-5.8.3/NEWS 2026-03-31 15:27:00.000000000 +0000
@@ -2,6 +2,132 @@
XZ Utils Release Notes
======================
+5.8.3 (2026-03-31)
+
+ IMPORTANT: This includes a fix for CVE-2026-34743 which affects all
+ XZ Utils versions since 5.0.0. No new 5.2.x, 5.4.x, or 5.6.x
+ releases will be made, but the fix is in the v5.2, v5.4, and v5.6
+ branches in the xz Git repository.
+
+ * liblzma:
+
+ - Fix a buffer overflow in lzma_index_append(): If
+ lzma_index_decoder() was used to decode an Index that
+ contained no Records, the resulting lzma_index was left in
+ a state where where a subsequent lzma_index_append() would
+ allocate too little memory, and a buffer overflow would occur.
+
+ The lzma_index functions are rarely used by applications
+ directly. In the few applications that do use these functions,
+ the combination of function calls required to trigger this bug
+ are unlikely to exist, because there typically is no reason to
+ append Records to a decoded lzma_index. Thus, it's likely that
+ this bug cannot be triggered in any real-world application.
+
+ The bug was reported and discovered by Cantina using their
+ AppSec agent, Apex.
+
+ - Fix the build on Windows ARM64EC.
+
+ - Add "License: 0BSD" to liblzma.pc.
+
+ * xz:
+
+ - Fix invalid memory access in --files and --files0. All of
+ the following must be true to trigger it:
+
+ 1. A string being read (which supposedly is a filename) is
+ at least SIZE_MAX / 2 bytes long. This size is plausible
+ on 32-bit platforms (2 GiB - 1 B).
+
+ 2. realloc(ptr, SIZE_MAX / 2 + 1) must succeed.
+ On glibc >= 2.30 it shouldn't because the value
+ exceeds PTRDIFF_MAX.
+
+ 3. An integer overflow results in a realloc(ptr, 0) call.
+ If it doesn't return NULL, then invalid memory access
+ will occur.
+
+ - On QNX, don't use fsync() on directories because it fails.
+
+ * Autotools: Enable 32-bit x86 assembler on Hurd by default.
+ It was already enabled in the CMake-based build.
+
+ * Translations: Add Arabic man page translations.
+
+
+5.8.2 (2025-12-17)
+
+ * liblzma:
+
+ - Fix the build on ARM64 on glibc versions older than
+ 2.24 (2016). They don't have HWCAP_CRC32 in .
+
+ - Disable CLMUL CRC code when building for 32-bit x86 with
+ old MSVC versions. This avoids a compiler bug. The exact
+ compiler version in which the issue was fixed is unknown,
+ but VS 2022 17.13 (MSVC 19.43.34808) is known to work, so
+ CLMUL CRC on 32-bit x86 is disabled with MSVC versions
+ older than that.
+
+ * xz:
+
+ - Add a workaround for Red Hat Enterprise Linux 9 kernel bug
+ which made xz fail with "xz: Failed to enable the sandbox".
+ It only occurs with xz 5.8.0 and 5.8.1 binaries built for
+ other distros. For example, running Debian 13 in a container
+ on RHEL/CentOS 9 would trigger the issue.
+
+ The bug was introduced in RHEL 9 kernel 5.14.0-603.el9
+ (2025-07-30) and fixed in 5.14.0-648.el9 (2025-12-05).
+ However, as of writing, the fixed kernel isn't available
+ to RHEL 9 users yet, so including the workaround in this
+ xz release seems reasonable. The workaround will be removed
+ when it's no longer needed.
+
+ xzdec was also affected by this issue.
+
+ - On AIX, don't use fsync() on directories because it fails.
+
+ - Fix the build on Emscripten.
+
+ - Fix the build on clang-cl on Windows.
+
+ - Take resource limits (RLIMIT_DATA, RLIMIT_AS, and RLIMIT_VMEM)
+ into account when determining the default memory usage limit
+ for multithreaded mode. This should prevent xz from failing
+ when a resource limit has been set to a value that is less
+ than 1/4 of total RAM. Other memory limits can still trigger
+ the same issue, for example, Linux cgroup v2 memory.max.
+
+ * Build systems:
+
+ - When symbol versioning is enabled, pass --undefined-version
+ to the linker if the option is supported. This fixes the
+ build when using LLVM's lld and some liblzma features have
+ been disabled at build time.
+
+ - ARM64: Fix autodetection of fast unaligned memory access when
+ using GCC and -mstrict-align is in effect. Previously the
+ build systems would incorrectly guess that unaligned access
+ is fast, which would result in much slower binaries than
+ needed. The fix is a workaround for GCC bug 111555;
+ autodetection already worked with Clang.
+
+ - LoongArch: Autodetect if fast unaligned memory access is
+ supported. This can improve compression speed by 15 % (but
+ not decompression speed).
+
+ * Translations:
+
+ - Update the Spanish translation.
+
+ - Add Swedish man page translations.
+
+ - Update Italian, Korean, Romanian, Serbian, and Ukrainian
+ man page translations.
+
+
5.8.1 (2025-04-03)
IMPORTANT: This includes a security fix for CVE-2025-31115 which
diff -Nru xz-utils-5.8.1/THANKS xz-utils-5.8.3/THANKS
--- xz-utils-5.8.1/THANKS 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/THANKS 2026-03-31 15:27:00.000000000 +0000
@@ -3,225 +3,248 @@
======
Some people have helped more, some less, but nevertheless everyone's help
-has been important. :-) In alphabetical order:
- - Mark Adler
- - Kian-Meng Ang
- - H. Peter Anvin
- - Jeff Bastian
- - Nelson H. F. Beebe
- - Karl Beldan
- - Karl Berry
- - Anders F. Björklund
- - Emmanuel Blot
- - Melanie Blower
+has been important. :-)
+ - Adam Borowski
+ - Adam Walling
+ - Adrien Nader
+ - Agostino Sarubbo
- Alexander Bluhm
- - Martin Blumenstingl
+ - Alexander M. Greenham
+ - Alexander Neumann
+ - Alexandre Sauvé
+ - Alexey Tourbin
+ - Anders F. Björklund
+ - Andraž 'ruskie' Levstik
+ - Andre Noll
+ - Andreas K. Hüttel
+ - Andreas Müller
+ - Andreas Schwab
+ - Andreas Zieringer
+ - Andrej Skenderija
+ - Andres Freund
+ - Andrew Dudman
+ - Andrew Murray
+ - Antoine Cœur
+ - Anton Kochkov
+ - Antonio Diaz Diaz
+ - Arkadiusz Miskiewicz
+ - Asgeir Storesund Nilsen
+ - Aziz Chaudhry
+ - Bela Lubkin
- Ben Boeckel
- - Jakub Bogusz
- - Adam Borowski
- - Maarten Bosmans
- - Roel Bouckaert
- - Lukas Braune
- Benjamin Buch
- - Trent W. Buck
- - Kevin R. Bulgrien
- - James Buren
- - David Burklund
- - Frank Busse
- - Daniel Mealha Cabrita
- - Milo Casagrande
+ - Benno Schulenberg
+ - Bernhard Reutner-Fischer
+ - Bert Wesarg
+ - Bhargava Shastry
+ - Bill Glessner
+ - Bjarni Ingi Gislason
+ - Boud Roukema
+ - Brad Smith
+ - Bruce Stark
+ - Cary Lewis
+ - Charles Wilson
+ - Chase Knowlden
+ - Chenxi Mao
+ - Chien Wong
+ - Chris Donawa
+ - Chris McCrohan
+ - Christian Hesse
+ - Christian Kujau
+ - Christian von Roques
+ - Christian Weisgerber
+ - Christoph Junghans
+ - Collin Funk
+ - Conley Moorhous
+ - Cristian Rodríguez
- Cristiano Ceglia
- - Marek Černocký
- - Tomer Chachamu
- - Vitaly Chikunov
- - Antoine Cœur
+ - Dan Shechter
+ - Dan Stromberg
+ - Dan Weiss
+ - Daniel Leonard
+ - Daniel Mealha Cabrita
+ - Daniel Packard
+ - Daniel Richard G.
+ - David Burklund
+ - Denis Excoffier
+ - Derwin McGeary
+ - Dexter Castor Döpping
+ - Diederik de Haas
+ - Diego Elio Pettenò
+ - Dimitri Papadopoulos Orfanos
+ - Dirk Müller
+ - Douglas Thor
+ - Ed Maste
+ - Elbert Pol
+ - Eli Schwartz
- Elijah Almeida Coimbra
+ - Émilie Labbé
+ - Emmanuel Blot
+ - Eric Lindblad
+ - Eric S. Raymond
+ - Étienne Mollier
+ - Evan Nemerson
+ - Fangrui Song
- Felix Collin
- - Ryan Colyer
- - Marcus Comstedt
- - Vincent Cruz
+ - Filip Palian
+ - Firas Khalil Khana
+ - François Etcheverry
+ - Frank Busse
+ - Frank Prochnow
+ - Fredrik Wikstrom
- Gabi Davar
- - Ron Desmond
- - İhsan Doğan
- - Chris Donawa
- - Andrew Dudman
- - Markus Duft
- - İsmail Dönmez
- - Dexter Castor Döpping
- - Paul Eggert
- - Robert Elz
- - Gilles Espinasse
- - Denis Excoffier
- - Vincent Fazio
- - Michael Felt
- - Sean Fenian
- - Michael Fox
- - Andres Freund
- - Mike Frysinger
- - Collin Funk
- - Daniel Richard G.
- - Tomasz Gajc
- - Bjarni Ingi Gislason
- - John Paul Adrian Glaubitz
- - Bill Glessner
- - Matthew Good
- - Michał Górny
- - Jason Gorski
- - Alexander M. Greenham
- - Juan Manuel Guerrero
- Gabriela Gutierrez
- - Diederik de Haas
- - Jan Terje Hansen
- - Tobias Lahrmann Hansen
- - Joachim Henke
- - Lizandro Heredia
- - Christian Hesse
- - Vincenzo Innocente
- - Peter Ivanov
- - Nicholas Jackson
- - Sam James
+ - Gilles Espinasse
+ - Gregory Margo
+ - Guillaume Outters
+ - Guiorgy Potskhishvili
+ - H. Peter Anvin
- Hajin Jang
- Hans Jansen
- - Jouk Jansen
- - Jun I Jin
- - Christoph Junghans
- - Kiyoshi Kanazawa
- - Joona Kannisto
- - Per Øyvind Karlsen
- - Firas Khalil Khana
- - Iouri Kharon
- - Kim Jinyeong
- - Thomas Klausner
- - Richard Koch
- - Anton Kochkov
- Harri K. Koskinen
- - Ville Koskinen
- - Sergey Kosukhin
- - Marcin Kowalczyk
- - Jan Kratochvil
- - Christian Kujau
- - Stephan Kulow
- - Ilya Kurdyukov
- - Peter Lawler
- - James M Leddy
- - Kelvin Lee
- - Vincent Lefevre
- Hin-Tak Leung
- - Andraž 'ruskie' Levstik
- - Cary Lewis
- - Wim Lewis
- - Xin Li
- - Yifeng Li
- - Eric Lindblad
- - Lorenzo De Liso
- H.J. Lu
- - Bela Lubkin
- - Chenxi Mao
- - Gregory Margo
- - Julien Marrec
- - Pierre-Yves Martin
- - Ed Maste
- - Martin Matuška
- - Scott McAllister
- - Chris McCrohan
- - Derwin McGeary
+ - Hongbo Ni
+ - Igor Pavlov
+ - İhsan Doğan
+ - Ilya Kurdyukov
+ - Iouri Kharon
+ - İsmail Dönmez
- Ivan A. Melnikov
+ - Jakub Bogusz
+ - James Buren
+ - James M Leddy
+ - Jan Kratochvil
+ - Jan Terje Hansen
+ - Jason Gorski
+ - Jeff Bastian
+ - Jeffrey Walton
+ - Jeroen Roovers
- Jim Meyering
- - Arkadiusz Miskiewicz
- - Nathan Moinvaziri
- - Étienne Mollier
- - Conley Moorhous
- - Dirk Müller
- - Rainer Müller
- - Andrew Murray
- - Rafał Mużyło
- - Adrien Nader
- - Evan Nemerson
- - Alexander Neumann
- - Hongbo Ni
+ - Jim Wilcoxson
+ - Joachim Henke
+ - John Paul Adrian Glaubitz
- Jonathan Nieder
- - Asgeir Storesund Nilsen
- - Andre Noll
- - Ruarí Ødegaard
- - Peter O'Gorman
- - Dimitri Papadopoulos Orfanos
- - Daniel Packard
- - Filip Palian
- - Peter Pallinger
+ - Jonathan Stott
+ - Joona Kannisto
+ - Jouk Jansen
+ - Juan Manuel Guerrero
+ - Jukka Salmi
+ - Julien Marrec
+ - Jun I Jin
- Kai Pastor
+ - Karl Beldan
+ - Karl Berry
- Keith Patton
- - Rui Paulo
- - Igor Pavlov
- - Diego Elio Pettenò
- - Elbert Pol
- - Guiorgy Potskhishvili
- - Mikko Pouru
- - Frank Prochnow
- - Rich Prohaska
- - Trần Ngọc Quân
- - Pavel Raiskup
+ - Kelvin Lee
+ - Kevin R. Bulgrien
+ - Kian-Meng Ang
+ - Kim Jinyeong
+ - Kirill A. Korinsky
+ - Kiyoshi Kanazawa
+ - Lars Wirzenius
+ - Li Chenggang
+ - Lizandro Heredia
+ - Loganaden Velvindron
+ - Lorenzo De Liso
+ - Lukas Braune
+ - Maarten Bosmans
+ - Maksym Vatsyk
+ - Marcin Kowalczyk
+ - Marcus Comstedt
+ - Marcus Tillmanns
+ - Marek Černocký
+ - Mark Adler
+ - Mark Wielaard
+ - Markus Duft
+ - Markus Rickert
+ - Martin Blumenstingl
+ - Martin Matuška
+ - Martin Storsjö
+ - Martin Väth
+ - Mathieu Vachon
+ - Matthew Good
- Matthieu Rakotojaona
+ - Melanie Blower
+ - Michael Felt
+ - Michael Fox
+ - Michał Górny
+ - Mike Frysinger
+ - Mikko Pouru
+ - Milo Casagrande
+ - Mohammed Adnène Trojette
+ - Nathan Moinvaziri
+ - Nelson H. F. Beebe
+ - Nicholas Jackson
+ - Nobuhiro Iwamatsu
- Ole André Vadla Ravnås
- - Eric S. Raymond
+ - Orange Tsai
+ - Orgad Shaneh
+ - Patrick J. Volkerding
+ - Paul Eggert
+ - Paul Townsend
+ - Pavel Raiskup
+ - Per Øyvind Karlsen
+ - Peter Ivanov
+ - Peter Lawler
+ - Peter O'Gorman
+ - Peter Pallinger
+ - Peter Seiderer
+ - Pierre-Yves Martin
+ - Pilorz Wojciech
+ - Pino Toscano
+ - Pippijn van Steenhoven
+ - Radek Zikmund
+ - Rafał Mużyło
+ - Rainer Müller
+ - Ralf Wildenhues
+ - Rich Prohaska
+ - Richard Koch
+ - Richard W.M. Jones
+ - Robert Elz
- Robert Readman
- - Bernhard Reutner-Fischer
- - Markus Rickert
- - Cristian Rodríguez
- - Jeroen Roovers
- - Christian von Roques
- - Boud Roukema
- - Torsten Rupp
+ - Roel Bouckaert
+ - Ron Desmond
+ - Ruarí Ødegaard
+ - Rui Paulo
+ - Ryan Colyer
+ - Ryan Young
+ - Salman Muin Kayser Chishti
+ - Sam James
+ - Scott McAllister
+ - Sean Fenian
+ - Sebastian Andrzej Siewior
+ - Sergey Kosukhin
+ - Simon Josefsson
+ - Siteshwar Vashisht
+ - Steffen Nurpmeso
+ - Stephan Kulow
- Stephen Sachs
- - Jukka Salmi
- - Agostino Sarubbo
- - Vijay Sarvepalli
- - Alexandre Sauvé
- - Benno Schulenberg
- - Andreas Schwab
- - Eli Schwartz
- - Peter Seiderer
- - Bhargava Shastry
- - Dan Shechter
- Stuart Shelton
- - Sebastian Andrzej Siewior
- - Andrej Skenderija
- - Ville Skyttä
- - Brad Smith
- - Bruce Stark
- - Pippijn van Steenhoven
+ - Taiki Tsunekawa
+ - Thomas Klausner
+ - Tobias Lahrmann Hansen
- Tobias Stoeckmann
- - Martin Storsjö
- - Jonathan Stott
- - Dan Stromberg
- - Douglas Thor
+ - Tomasz Gajc
+ - Tomer Chachamu
+ - Torsten Rupp
+ - Trần Ngọc Quân
+ - Trent W. Buck
+ - Victoria Alexia
+ - Vijay Sarvepalli
+ - Ville Koskinen
+ - Ville Skyttä
+ - Vincent Cruz
+ - Vincent Fazio
+ - Vincent Lefevre
- Vincent Torri
- - Alexey Tourbin
- - Paul Townsend
- - Mohammed Adnène Trojette
- - Orange Tsai
- - Taiki Tsunekawa
- - Mathieu Vachon
- - Maksym Vatsyk
- - Loganaden Velvindron
- - Patrick J. Volkerding
- - Martin Väth
- - Adam Walling
- - Jeffrey Walton
- - Christian Weisgerber
- - Dan Weiss
- - Bert Wesarg
- - Mark Wielaard
- - Fredrik Wikstrom
- - Jim Wilcoxson
- - Ralf Wildenhues
- - Charles Wilson
- - Lars Wirzenius
- Vincent Wixsom
- - Pilorz Wojciech
- - Chien Wong
+ - Vincenzo Innocente
+ - Vitaly Chikunov
+ - Wim Lewis
- Xi Ruoyao
- - Ryan Young
- - Andreas Zieringer
+ - Xin Li
+ - Yifeng Li
- 榆柳松 (ZhengSen Wang)
Companies:
diff -Nru xz-utils-5.8.1/aclocal.m4 xz-utils-5.8.3/aclocal.m4
--- xz-utils-5.8.1/aclocal.m4 2025-04-03 11:35:18.000000000 +0000
+++ xz-utils-5.8.3/aclocal.m4 2026-03-31 15:27:10.000000000 +0000
@@ -1,6 +1,6 @@
-# generated automatically by aclocal 1.17 -*- Autoconf -*-
+# generated automatically by aclocal 1.18.1 -*- Autoconf -*-
-# Copyright (C) 1996-2024 Free Software Foundation, Inc.
+# Copyright (C) 1996-2025 Free Software Foundation, Inc.
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -14,13 +14,13 @@
m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
m4_ifndef([AC_AUTOCONF_VERSION],
[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
-m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.72],,
-[m4_warning([this file was generated for autoconf 2.72.
+m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.73],,
+[m4_warning([this file was generated for autoconf 2.73.
You have another version of autoconf. It may work, but is not guaranteed to.
If you have problems, you may need to regenerate the build system entirely.
To do so, use the procedure documented by the package, typically 'autoreconf'.])])
-# Copyright (C) 2002-2024 Free Software Foundation, Inc.
+# Copyright (C) 2002-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -32,10 +32,10 @@
# generated from the m4 files accompanying Automake X.Y.
# (This private macro should not be called outside this file.)
AC_DEFUN([AM_AUTOMAKE_VERSION],
-[am__api_version='1.17'
+[am__api_version='1.18'
dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
dnl require some minimum version. Point them to the right macro.
-m4_if([$1], [1.17], [],
+m4_if([$1], [1.18.1], [],
[AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
])
@@ -51,14 +51,14 @@
# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
-[AM_AUTOMAKE_VERSION([1.17])dnl
+[AM_AUTOMAKE_VERSION([1.18.1])dnl
m4_ifndef([AC_AUTOCONF_VERSION],
[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
# Figure out how to run the assembler. -*- Autoconf -*-
-# Copyright (C) 2001-2024 Free Software Foundation, Inc.
+# Copyright (C) 2001-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -78,7 +78,7 @@
# AM_AUX_DIR_EXPAND -*- Autoconf -*-
-# Copyright (C) 2001-2024 Free Software Foundation, Inc.
+# Copyright (C) 2001-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -130,7 +130,7 @@
# AM_CONDITIONAL -*- Autoconf -*-
-# Copyright (C) 1997-2024 Free Software Foundation, Inc.
+# Copyright (C) 1997-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -161,7 +161,7 @@
Usually this means the macro was only invoked conditionally.]])
fi])])
-# Copyright (C) 1999-2024 Free Software Foundation, Inc.
+# Copyright (C) 1999-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -352,7 +352,7 @@
# Generate code to set up dependency tracking. -*- Autoconf -*-
-# Copyright (C) 1999-2024 Free Software Foundation, Inc.
+# Copyright (C) 1999-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -420,7 +420,7 @@
# Do all the work for Automake. -*- Autoconf -*-
-# Copyright (C) 1996-2024 Free Software Foundation, Inc.
+# Copyright (C) 1996-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -520,8 +520,9 @@
AC_REQUIRE([AC_PROG_MAKE_SET])dnl
AC_REQUIRE([AM_SET_LEADING_DOT])dnl
_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
- [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
- [_AM_PROG_TAR([v7])])])
+ [_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
+ [_AM_IF_OPTION([tar-v7], [_AM_PROG_TAR([v7])],
+ [_AM_PROG_TAR([ustar])])])])
_AM_IF_OPTION([no-dependencies],,
[AC_PROVIDE_IFELSE([AC_PROG_CC],
[_AM_DEPENDENCIES([CC])],
@@ -597,7 +598,7 @@
done
echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
-# Copyright (C) 2001-2024 Free Software Foundation, Inc.
+# Copyright (C) 2001-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -618,7 +619,7 @@
fi
AC_SUBST([install_sh])])
-# Copyright (C) 2003-2024 Free Software Foundation, Inc.
+# Copyright (C) 2003-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -639,7 +640,7 @@
# Check to see how 'make' treats includes. -*- Autoconf -*-
-# Copyright (C) 2001-2024 Free Software Foundation, Inc.
+# Copyright (C) 2001-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -682,7 +683,7 @@
# Fake the existence of programs that GNU maintainers use. -*- Autoconf -*-
-# Copyright (C) 1997-2024 Free Software Foundation, Inc.
+# Copyright (C) 1997-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -716,7 +717,7 @@
# Helper functions for option handling. -*- Autoconf -*-
-# Copyright (C) 2001-2024 Free Software Foundation, Inc.
+# Copyright (C) 2001-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -745,7 +746,7 @@
AC_DEFUN([_AM_IF_OPTION],
[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
-# Copyright (C) 1999-2024 Free Software Foundation, Inc.
+# Copyright (C) 1999-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -777,7 +778,10 @@
break
fi
done
- rm -f core conftest*
+ # aligned with autoconf, so not including core; see bug#72225.
+ rm -f -r a.out a.exe b.out conftest.$ac_ext conftest.$ac_objext \
+ conftest.dSYM conftest1.$ac_ext conftest1.$ac_objext conftest1.dSYM \
+ conftest2.$ac_ext conftest2.$ac_objext conftest2.dSYM
unset am_i])
if test "$am_cv_prog_cc_c_o" != yes; then
# Losing compiler, so override with the script.
@@ -792,7 +796,7 @@
# For backward compatibility.
AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
-# Copyright (C) 2022-2024 Free Software Foundation, Inc.
+# Copyright (C) 2022-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -808,7 +812,7 @@
AC_SUBST(am__rm_f_notfound)
])
-# Copyright (C) 2001-2024 Free Software Foundation, Inc.
+# Copyright (C) 2001-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -827,7 +831,7 @@
# Check to make sure that the build environment is sane. -*- Autoconf -*-
-# Copyright (C) 1996-2024 Free Software Foundation, Inc.
+# Copyright (C) 1996-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -996,10 +1000,12 @@
'
case `pwd` in
*[[\\\"\#\$\&\'\`$am_lf]]*)
+ AC_MSG_RESULT([no])
AC_MSG_ERROR([unsafe absolute working directory name]);;
esac
case $srcdir in
*[[\\\"\#\$\&\'\`$am_lf\ \ ]]*)
+ AC_MSG_RESULT([no])
AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
esac
@@ -1052,7 +1058,7 @@
rm -f conftest.file
])
-# Copyright (C) 2009-2024 Free Software Foundation, Inc.
+# Copyright (C) 2009-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -1121,9 +1127,13 @@
# empty being verbose).
AC_DEFUN([AM_SILENT_RULES],
[AC_REQUIRE([_AM_SILENT_RULES])
-AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1])])
+AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1])m4_newline
+dnl We intentionally force a newline after the assignment, since a) nothing
+dnl good can come of more text following, and b) that was the behavior
+dnl before 1.17. See https://bugs.gnu.org/72267.
+])
-# Copyright (C) 2001-2024 Free Software Foundation, Inc.
+# Copyright (C) 2001-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -1151,7 +1161,7 @@
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
AC_SUBST([INSTALL_STRIP_PROGRAM])])
-# Copyright (C) 2006-2024 Free Software Foundation, Inc.
+# Copyright (C) 2006-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -1170,7 +1180,7 @@
# Check how to create a tarball. -*- Autoconf -*-
-# Copyright (C) 2004-2024 Free Software Foundation, Inc.
+# Copyright (C) 2004-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -1305,7 +1315,7 @@
AC_SUBST([am__untar])
]) # _AM_PROG_TAR
-# Copyright (C) 2022-2024 Free Software Foundation, Inc.
+# Copyright (C) 2022-2025 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
diff -Nru xz-utils-5.8.1/build-aux/compile xz-utils-5.8.3/build-aux/compile
--- xz-utils-5.8.1/build-aux/compile 2025-04-03 11:35:21.000000000 +0000
+++ xz-utils-5.8.3/build-aux/compile 2026-03-31 15:27:10.000000000 +0000
@@ -1,9 +1,9 @@
#! /bin/sh
# Wrapper for compilers which do not understand '-c -o'.
-scriptversion=2024-06-19.01; # UTC
+scriptversion=2025-06-18.21; # UTC
-# Copyright (C) 1999-2024 Free Software Foundation, Inc.
+# Copyright (C) 1999-2025 Free Software Foundation, Inc.
# Written by Tom Tromey .
#
# This program is free software; you can redistribute it and/or modify
@@ -37,11 +37,11 @@
file_conv=
-# func_file_conv build_file lazy
+# func_file_conv build_file unneeded_conversions
# Convert a $build file to $host form and store it in $file
# Currently only supports Windows hosts. If the determined conversion
-# type is listed in (the comma separated) LAZY, no conversion will
-# take place.
+# type is listed in (the comma separated) UNNEEDED_CONVERSIONS, no
+# conversion will take place.
func_file_conv ()
{
file=$1
@@ -51,9 +51,20 @@
# lazily determine how to convert abs files
case `uname -s` in
MINGW*)
- file_conv=mingw
+ if test -n "$MSYSTEM" && (cygpath --version) >/dev/null 2>&1; then
+ # MSYS2 environment.
+ file_conv=cygwin
+ else
+ # Original MinGW environment.
+ file_conv=mingw
+ fi
;;
- CYGWIN* | MSYS*)
+ MSYS*)
+ # Old MSYS environment, or MSYS2 with 32-bit MSYS2 shell.
+ file_conv=cygwin
+ ;;
+ CYGWIN*)
+ # Cygwin environment.
file_conv=cygwin
;;
*)
@@ -63,12 +74,14 @@
fi
case $file_conv/,$2, in
*,$file_conv,*)
+ # This is the optimization mentioned above:
+ # If UNNEEDED_CONVERSIONS contains $file_conv, don't convert.
;;
mingw/*)
file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
;;
- cygwin/* | msys/*)
- file=`cygpath -m "$file" || echo "$file"`
+ cygwin/*)
+ file=`cygpath -w "$file" || echo "$file"`
;;
wine/*)
file=`winepath -w "$file" || echo "$file"`
@@ -343,9 +356,9 @@
# Local Variables:
# mode: shell-script
# sh-indentation: 2
-# eval: (add-hook 'before-save-hook 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp nil t)
# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-format: "%Y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:
diff -Nru xz-utils-5.8.1/build-aux/config.guess xz-utils-5.8.3/build-aux/config.guess
--- xz-utils-5.8.1/build-aux/config.guess 2025-04-03 11:35:29.000000000 +0000
+++ xz-utils-5.8.3/build-aux/config.guess 2026-03-31 15:27:12.000000000 +0000
@@ -1,10 +1,10 @@
#! /bin/sh
# Attempt to guess a canonical system name.
-# Copyright 1992-2024 Free Software Foundation, Inc.
+# Copyright 1992-2025 Free Software Foundation, Inc.
# shellcheck disable=SC2006,SC2268 # see below for rationale
-timestamp='2024-07-27'
+timestamp='2025-07-10'
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
@@ -60,7 +60,7 @@
GNU config.guess ($timestamp)
Originally written by Per Bothner.
-Copyright 1992-2024 Free Software Foundation, Inc.
+Copyright 1992-2025 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
@@ -1597,8 +1597,11 @@
*:Unleashed:*:*)
GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE
;;
- *:Ironclad:*:*)
- GUESS=$UNAME_MACHINE-unknown-ironclad
+ x86_64:[Ii]ronclad:*:*|i?86:[Ii]ronclad:*:*)
+ GUESS=$UNAME_MACHINE-pc-ironclad-mlibc
+ ;;
+ *:[Ii]ronclad:*:*)
+ GUESS=$UNAME_MACHINE-unknown-ironclad-mlibc
;;
esac
@@ -1808,8 +1811,8 @@
exit 1
# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp nil t)
# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-format: "%Y-%02m-%02d"
# time-stamp-end: "'"
# End:
diff -Nru xz-utils-5.8.1/build-aux/config.sub xz-utils-5.8.3/build-aux/config.sub
--- xz-utils-5.8.1/build-aux/config.sub 2025-04-03 11:35:29.000000000 +0000
+++ xz-utils-5.8.3/build-aux/config.sub 2026-03-31 15:27:12.000000000 +0000
@@ -1,10 +1,10 @@
#! /bin/sh
# Configuration validation subroutine script.
-# Copyright 1992-2024 Free Software Foundation, Inc.
+# Copyright 1992-2025 Free Software Foundation, Inc.
# shellcheck disable=SC2006,SC2268,SC2162 # see below for rationale
-timestamp='2024-05-27'
+timestamp='2025-07-10'
# This file is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
@@ -76,7 +76,7 @@
version="\
GNU config.sub ($timestamp)
-Copyright 1992-2024 Free Software Foundation, Inc.
+Copyright 1992-2025 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
@@ -145,6 +145,7 @@
| kfreebsd*-gnu* \
| knetbsd*-gnu* \
| kopensolaris*-gnu* \
+ | ironclad-* \
| linux-* \
| managarm-* \
| netbsd*-eabi* \
@@ -242,7 +243,6 @@
| rombug \
| semi \
| sequent* \
- | siemens \
| sgi* \
| siemens \
| sim \
@@ -261,7 +261,7 @@
basic_machine=$field1-$field2
basic_os=
;;
- zephyr*)
+ tock* | zephyr*)
basic_machine=$field1-unknown
basic_os=$field2
;;
@@ -1194,7 +1194,7 @@
xscale-* | xscalee[bl]-*)
cpu=`echo "$cpu" | sed 's/^xscale/arm/'`
;;
- arm64-* | aarch64le-*)
+ arm64-* | aarch64le-* | arm64_32-*)
cpu=aarch64
;;
@@ -1321,6 +1321,7 @@
| i960 \
| ia16 \
| ia64 \
+ | intelgt \
| ip2k \
| iq2000 \
| javascript \
@@ -1522,6 +1523,10 @@
kernel=nto
os=`echo "$basic_os" | sed -e 's|nto|qnx|'`
;;
+ ironclad*)
+ kernel=ironclad
+ os=`echo "$basic_os" | sed -e 's|ironclad|mlibc|'`
+ ;;
linux*)
kernel=linux
os=`echo "$basic_os" | sed -e 's|linux|gnu|'`
@@ -1976,6 +1981,7 @@
| atheos* \
| auroraux* \
| aux* \
+ | banan_os* \
| beos* \
| bitrig* \
| bme* \
@@ -2022,7 +2028,6 @@
| ios* \
| iris* \
| irix* \
- | ironclad* \
| isc* \
| its* \
| l4re* \
@@ -2118,6 +2123,7 @@
| sysv* \
| tenex* \
| tirtos* \
+ | tock* \
| toppers* \
| tops10* \
| tops20* \
@@ -2214,6 +2220,8 @@
;;
uclinux-uclibc*- | uclinux-gnu*- )
;;
+ ironclad-mlibc*-)
+ ;;
managarm-mlibc*- | managarm-kernel*- )
;;
windows*-msvc*-)
@@ -2249,6 +2257,8 @@
;;
*-eabi*- | *-gnueabi*-)
;;
+ ios*-simulator- | tvos*-simulator- | watchos*-simulator- )
+ ;;
none--*)
# None (no kernel, i.e. freestanding / bare metal),
# can be paired with an machine code file format
@@ -2347,8 +2357,8 @@
exit
# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp nil t)
# time-stamp-start: "timestamp='"
-# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-format: "%Y-%02m-%02d"
# time-stamp-end: "'"
# End:
diff -Nru xz-utils-5.8.1/build-aux/depcomp xz-utils-5.8.3/build-aux/depcomp
--- xz-utils-5.8.1/build-aux/depcomp 2025-04-03 11:35:22.000000000 +0000
+++ xz-utils-5.8.3/build-aux/depcomp 2026-03-31 15:27:10.000000000 +0000
@@ -1,9 +1,9 @@
#! /bin/sh
# depcomp - compile a program generating dependencies as side-effects
-scriptversion=2024-06-19.01; # UTC
+scriptversion=2025-06-18.21; # UTC
-# Copyright (C) 1999-2024 Free Software Foundation, Inc.
+# Copyright (C) 1999-2025 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
@@ -784,9 +784,9 @@
# Local Variables:
# mode: shell-script
# sh-indentation: 2
-# eval: (add-hook 'before-save-hook 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp nil t)
# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-format: "%Y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:
diff -Nru xz-utils-5.8.1/build-aux/install-sh xz-utils-5.8.3/build-aux/install-sh
--- xz-utils-5.8.1/build-aux/install-sh 2025-04-03 11:35:21.000000000 +0000
+++ xz-utils-5.8.3/build-aux/install-sh 2026-03-31 15:27:10.000000000 +0000
@@ -1,7 +1,7 @@
#!/bin/sh
# install - install a program, script, or datafile
-scriptversion=2024-06-19.01; # UTC
+scriptversion=2025-06-18.21; # UTC
# This originates from X11R5 (mit/util/scripts/install.sh), which was
# later released in X11R6 (xc/config/util/install.sh) with the
@@ -533,9 +533,9 @@
done
# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp nil t)
# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-format: "%Y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:
diff -Nru xz-utils-5.8.1/build-aux/ltmain.sh xz-utils-5.8.3/build-aux/ltmain.sh
--- xz-utils-5.8.1/build-aux/ltmain.sh 2025-04-03 11:35:14.000000000 +0000
+++ xz-utils-5.8.3/build-aux/ltmain.sh 2026-03-31 15:27:09.000000000 +0000
@@ -2,11 +2,11 @@
## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
## by inline-source v2019-02-19.15
-# libtool (GNU libtool) 2.5.4.1-baa1-dirty
+# libtool (GNU libtool) 2.6.0
# Provide generalized library-building support services.
# Written by Gordon Matzigkeit , 1996
-# Copyright (C) 1996-2019, 2021-2024 Free Software Foundation, Inc.
+# Copyright (C) 1996-2019, 2021-2025 Free Software Foundation, Inc.
# This is free software; see the source for copying conditions. There is NO
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
@@ -31,8 +31,8 @@
PROGRAM=libtool
PACKAGE=libtool
-VERSION=2.5.4.1-baa1-dirty
-package_revision=2.5.4.1
+VERSION=2.6.0
+package_revision=2.6.0
## ------ ##
@@ -2215,7 +2215,7 @@
# End:
# Set a version string.
-scriptversion='(GNU libtool) 2.5.4.1-baa1-dirty'
+scriptversion='(GNU libtool) 2.6.0'
# func_version
# ------------
@@ -2299,6 +2299,22 @@
func_usage_message
$ECHO "$long_help_message
+If a TAG is supplied, it must use one of the tag names below:
+
+ Tag Name Language Name
+ CC C
+ CXX C++
+ OBJC Objective-C
+ OBJCXX Objective-C++
+ GCJ Java
+ F77 Fortran 77
+ FC Fortran
+ GO Go
+ RC Windows Resource
+
+If you do not see a tag name associated with your programming language, then
+you are using a compiler that $progname does not support.
+
MODE must be one of the following:
clean remove files from the build directory
@@ -2723,7 +2739,7 @@
case $host_os in
# Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
# see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
- cygwin* | mingw* | windows* | pw32* | cegcc* | solaris2* | os2*)
+ cygwin* | mingw* | windows* | pw32* | cegcc* | solaris2* | os2* | *linux*)
# don't eliminate duplications in $postdeps and $predeps
opt_duplicate_compiler_generated_deps=:
;;
@@ -2999,8 +3015,9 @@
# was found and let the user know that the "--tag" command
# line option must be used.
if test -z "$tagname"; then
- func_echo "unable to infer tagged configuration"
- func_fatal_error "specify a tag with '--tag'"
+ func_echo "unable to infer tagged configuration with compiler."
+ func_echo "Possible use of unsupported compiler."
+ func_fatal_error "specify a tag with '--tag'. For more information, try '$progname --help'."
# else
# func_verbose "using $tagname tagged configuration"
fi
@@ -3162,13 +3179,41 @@
{
$debug_cmd
- # awkward: cmd appends spaces to result
+ # Compatibility for original MSYS
+ if test "Xone" = "X$lt_cv_cmd_slashes"; then
+ func_convert_core_msys_to_w32_result=`( cmd /c echo "$1" ) 2>/dev/null |
+ $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
+ else # Assume 'lt_cv_cmd_slashes = "two"'
func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
$SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
+ fi
+ if test "$?" -ne 0; then
+ # on failure, ensure result is empty
+ func_convert_core_msys_to_w32_result=
+ fi
}
#end: func_convert_core_msys_to_w32
+# func_convert_core_msys_to_w32_with_cygpath ARG
+# Convert file name or path ARG with cygpath from MSYS format to w32
+# format. Return result in func_convert_core_msys_to_w32_with_cygpath_result.
+func_convert_core_msys_to_w32_with_cygpath ()
+{
+ $debug_cmd
+
+ # Since MSYS2 is packaged with cygpath, call cygpath in $PATH; no need
+ # to use LT_CYGPATH in this case.
+ func_convert_core_msys_to_w32_result=`cygpath "$@" 2>/dev/null |
+ $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
+ if test "$?" -ne 0; then
+ # on failure, ensure result is empty
+ func_convert_core_msys_to_w32_result=
+ fi
+}
+#end: func_convert_core_msys_to_w32_with_cygpath
+
+
# func_convert_file_check ARG1 ARG2
# Verify that ARG1 (a file name in $build format) was converted to $host
# format in ARG2. Otherwise, emit an error message, but continue (resetting
@@ -3303,8 +3348,13 @@
func_to_host_file_result=$1
if test -n "$1"; then
- func_convert_core_msys_to_w32 "$1"
- func_to_host_file_result=$func_convert_core_msys_to_w32_result
+ if test "Xyes" = "X$cygpath_installed"; then
+ func_convert_core_msys_to_w32_with_cygpath -w "$1"
+ func_to_host_file_result=$func_convert_core_msys_to_w32_with_cygpath_result
+ else
+ func_convert_core_msys_to_w32 "$1"
+ func_to_host_file_result=$func_convert_core_msys_to_w32_result
+ fi
fi
func_convert_file_check "$1" "$func_to_host_file_result"
}
@@ -3355,8 +3405,13 @@
func_to_host_file_result=$1
if test -n "$1"; then
- func_convert_core_msys_to_w32 "$1"
- func_cygpath -u "$func_convert_core_msys_to_w32_result"
+ if test "Xyes" = "X$cygpath_installed"; then
+ func_convert_core_msys_to_w32_with_cygpath -w "$1"
+ func_cygpath -u "$func_convert_core_msys_to_w32_with_cygpath_result"
+ else
+ func_convert_core_msys_to_w32 "$1"
+ func_cygpath -u "$func_convert_core_msys_to_w32_result"
+ fi
func_to_host_file_result=$func_cygpath_result
fi
func_convert_file_check "$1" "$func_to_host_file_result"
@@ -3457,8 +3512,13 @@
# and winepath ignores them completely.
func_stripname : : "$1"
func_to_host_path_tmp1=$func_stripname_result
- func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
- func_to_host_path_result=$func_convert_core_msys_to_w32_result
+ if test "Xyes" = "X$cygpath_installed"; then
+ func_convert_core_msys_to_w32_with_cygpath -w -p "$func_to_host_path_tmp1"
+ func_to_host_path_result=$func_convert_core_msys_to_w32_with_cygpath_result
+ else
+ func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+ func_to_host_path_result=$func_convert_core_msys_to_w32_result
+ fi
func_convert_path_check : ";" \
"$func_to_host_path_tmp1" "$func_to_host_path_result"
func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
@@ -3522,8 +3582,13 @@
# See func_convert_path_msys_to_w32:
func_stripname : : "$1"
func_to_host_path_tmp1=$func_stripname_result
- func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
- func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
+ if test "Xyes" = "X$cygpath_installed"; then
+ func_convert_core_msys_to_w32_with_cygpath -w -p "$func_to_host_path_tmp1"
+ func_cygpath -u -p "$func_convert_core_msys_to_w32_with_cygpath_result"
+ else
+ func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+ func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
+ fi
func_to_host_path_result=$func_cygpath_result
func_convert_path_check : : \
"$func_to_host_path_tmp1" "$func_to_host_path_result"
@@ -4455,6 +4520,14 @@
fi
echo
+ echo "After a 'make install' for many GNU/Linux systems, 'ldconfig LIBDIR'"
+ echo "may need to be executed to help locate newly installed libraries,"
+ echo "but you should consult with a system administrator before updating"
+ echo "the shared library cache as this should be done with great care"
+ echo "and consideration. (See the 'Platform-specific configuration notes'"
+ echo "section of the documentation for more information.)"
+ echo
+
echo "See any operating system documentation about shared libraries for"
case $host in
solaris2.[6789]|solaris2.1[0-9])
@@ -4529,7 +4602,7 @@
prev=$arg
fi
;;
- -g | -m | -o)
+ -g | -m | -o | -S | -t)
prev=$arg
;;
-s)
@@ -5045,7 +5118,7 @@
# Prepare the list of exported symbols
if test -z "$export_symbols"; then
- export_symbols=$output_objdir/$outputname.exp
+ export_symbols=$output_objdir/$outputname.expsym
$opt_dry_run || {
$RM $export_symbols
eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
@@ -5058,8 +5131,8 @@
}
else
$opt_dry_run || {
- eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
- eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+ eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.expsym"'
+ eval '$GREP -f "$output_objdir/$outputname.expsym" < "$nlist" > "$nlist"T'
eval '$MV "$nlist"T "$nlist"'
case $host in
*cygwin* | *mingw* | *windows* | *cegcc* )
@@ -5979,6 +6052,7 @@
# define getcwd _getcwd
# define putenv _putenv
# define S_IXUSR _S_IEXEC
+# define MSVC_ISDIR(m)(((m) & S_IFMT) == S_IFDIR)
#elif defined __MINGW32__
# define setmode _setmode
# define stat _stat
@@ -6374,8 +6448,13 @@
if ((!path) || (!*path))
return 0;
- if ((stat (path, &st) >= 0)
+#ifdef _MSC_VER
+ if ((stat (path, &st) >= 0) && !MSVC_ISDIR (st.st_mode)
&& (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
+#else
+ if ((stat (path, &st) >= 0) && !S_ISDIR (st.st_mode)
+ && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
+#endif
return 1;
else
return 0;
@@ -7280,8 +7359,13 @@
continue
;;
xlinker)
- func_append linker_flags " $qarg"
- func_append compiler_flags " $wl$qarg"
+ func_append linker_flags "$qarg,"
+ # Args in the var 'compiler_flags' causes warnings in MSVC
+ func_cc_basename "$CC"
+ case $func_cc_basename_result in
+ cl|cl.exe) ;;
+ *) func_append compiler_flags " $wl$qarg" ;;
+ esac
prev=
func_append compile_command " $wl$qarg"
func_append finalize_command " $wl$qarg"
@@ -7525,8 +7609,6 @@
*-*-cygwin* | *-*-mingw* | *-*-windows* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
# The PATH hackery in wrapper scripts is required on Windows
# and Darwin in order for the loader to find any dlls it needs.
- func_warning "'-no-install' is ignored for $host"
- func_warning "assuming '-no-fast-install' instead"
fast_install=no
;;
*) no_install=yes ;;
@@ -7648,6 +7730,11 @@
arg=$func_stripname_result
;;
+ -Wl,--as-needed|-Wl,--no-as-needed)
+ deplibs="$deplibs $arg"
+ continue
+ ;;
+
-Wl,*)
func_stripname '-Wl,' '' "$arg"
args=$func_stripname_result
@@ -7657,8 +7744,13 @@
IFS=$save_ifs
func_quote_arg pretty "$flag"
func_append arg " $wl$func_quote_arg_result"
- func_append compiler_flags " $wl$func_quote_arg_result"
- func_append linker_flags " $func_quote_arg_result"
+ # Args in the var 'compiler_flags' causes warnings in MSVC
+ func_cc_basename "$CC"
+ case $func_cc_basename_result in
+ cl|cl.exe) ;;
+ *) func_append compiler_flags " $wl$func_quote_arg_result" ;;
+ esac
+ func_append linker_flags "$func_quote_arg_result,"
done
IFS=$save_ifs
func_stripname ' ' '' "$arg"
@@ -7704,6 +7796,7 @@
# @file GCC response files
# -tp=* Portland pgcc target processor selection
# --sysroot=* for sysroot support
+ # --target=* for target architecture support
# -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
# -specs=* GCC specs files
# -stdlib=* select c++ std lib with clang
@@ -7721,15 +7814,15 @@
# --unwindlib=* select unwinder library with clang
# -f{file|debug|macro|profile}-prefix-map=* needed for lto linking
# -Wa,* Pass flags directly to the assembler
- # -Werror, -Werror=* Report (specified) warnings as errors
+ # -W* Warnings, needed for lto
-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=*| \
+ -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*|--target=*| \
-O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-no-canonical-prefixes| \
-stdlib=*|-rtlib=*|--unwindlib=*| \
-specs=*|-fsanitize=*|-fno-sanitize*|-shared-libsan|-static-libsan| \
-ffile-prefix-map=*|-fdebug-prefix-map=*|-fmacro-prefix-map=*|-fprofile-prefix-map=*| \
-fdiagnostics-color*|-frecord-gcc-switches| \
- -fuse-ld=*|-static-*|-fcilkplus|-Wa,*|-Werror|-Werror=*)
+ -fuse-ld=*|-static-*|-fcilkplus|-W*)
func_quote_arg pretty "$arg"
arg=$func_quote_arg_result
func_append compile_command " $arg"
@@ -8070,6 +8163,15 @@
lib=
found=false
case $deplib in
+ -Wl,--as-needed|-Wl,--no-as-needed)
+ if test prog,link = "$linkmode,$pass"; then
+ compile_deplibs="$deplib $compile_deplibs"
+ finalize_deplibs="$deplib $finalize_deplibs"
+ else
+ deplibs="$deplib $deplibs"
+ fi
+ continue
+ ;;
-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
|-threads|-fopenmp|-fopenmp=*|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
if test prog,link = "$linkmode,$pass"; then
@@ -8228,8 +8330,15 @@
fi
case $linkmode in
lib)
- # Linking convenience modules into shared libraries is allowed,
- # but linking other static libraries is non-portable.
+ # Linking convenience modules and compiler provided static libraries
+ # into shared libraries is allowed, but linking other static
+ # libraries is non-portable.
+ case $deplib in
+ */libgcc*.$libext | */libclang_rt*.$libext)
+ deplibs="$deplib $deplibs"
+ continue
+ ;;
+ esac
case " $dlpreconveniencelibs " in
*" $deplib "*) ;;
*)
@@ -9312,29 +9421,21 @@
esac
# Check that each of the things are valid numbers.
- case $current in
- 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
- *)
- func_error "CURRENT '$current' must be a nonnegative integer"
+ if echo "$current" | $EGREP -v '(^0$)|(^[1-9]$)|(^[1-9][0-9]{1,4}$)' > /dev/null; then
+ func_error "CURRENT '$current' must be a nonnegative integer and <= 5 digits"
func_fatal_error "'$vinfo' is not valid version information"
- ;;
- esac
+ fi
- case $revision in
- 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
- *)
- func_error "REVISION '$revision' must be a nonnegative integer"
+ # Currently limiting revision length by Unix epoch time in nanoseconds.
+ if echo "$revision" | $EGREP -v '(^0$)|(^[1-9]$)|(^[1-9][0-9]{1,18}$)' > /dev/null; then
+ func_error "REVISION '$revision' must be a nonnegative integer and <= 19 digits"
func_fatal_error "'$vinfo' is not valid version information"
- ;;
- esac
+ fi
- case $age in
- 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;;
- *)
- func_error "AGE '$age' must be a nonnegative integer"
+ if echo "$age" | $EGREP -v '(^0$)|(^[1-9]$)|(^[1-9][0-9]{1,4}$)' > /dev/null; then
+ func_error "AGE '$age' must be a nonnegative integer and <= 5 digits"
func_fatal_error "'$vinfo' is not valid version information"
- ;;
- esac
+ fi
if test "$age" -gt "$current"; then
func_error "AGE '$age' is greater than the current interface number '$current'"
@@ -10022,7 +10123,7 @@
if test -z "$export_symbols"; then
if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
func_verbose "generating symbol list for '$libname.la'"
- export_symbols=$output_objdir/$libname.exp
+ export_symbols=$output_objdir/$libname.expsym
$opt_dry_run || $RM $export_symbols
cmds=$export_symbols_cmds
save_ifs=$IFS; IFS='~'
@@ -10288,7 +10389,7 @@
${skipped_export-false} && {
func_verbose "generating symbol list for '$libname.la'"
- export_symbols=$output_objdir/$libname.exp
+ export_symbols=$output_objdir/$libname.expsym
$opt_dry_run || $RM $export_symbols
libobjs=$output
# Append the command to create the export file.
diff -Nru xz-utils-5.8.1/build-aux/manconv.sh xz-utils-5.8.3/build-aux/manconv.sh
--- xz-utils-5.8.1/build-aux/manconv.sh 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/build-aux/manconv.sh 2026-03-31 15:27:00.000000000 +0000
@@ -42,12 +42,12 @@
groff -t -mandoc -Tutf8 -P-c | col -bx
;;
ps)
- sed "$SED_PD" | groff -dpaper=$PAPER -t -mandoc \
- -rC1 -rS$FONT -Tps -P-p$PAPER
+ sed "$SED_PD" | groff -dpaper="$PAPER" -t -mandoc \
+ -rC1 -rS"$FONT" -Tps -P-p"$PAPER"
;;
pdf)
- sed "$SED_PD" | groff -dpaper=$PAPER -t -mandoc \
- -rC1 -rS$FONT -Tps -P-p$PAPER | ps2pdf - -
+ sed "$SED_PD" | groff -dpaper="$PAPER" -t -mandoc \
+ -rC1 -rS"$FONT" -Tps -P-p"$PAPER" | ps2pdf - -
;;
*)
echo 'Invalid arguments' >&2
diff -Nru xz-utils-5.8.1/build-aux/missing xz-utils-5.8.3/build-aux/missing
--- xz-utils-5.8.1/build-aux/missing 2025-04-03 11:35:21.000000000 +0000
+++ xz-utils-5.8.3/build-aux/missing 2026-03-31 15:27:10.000000000 +0000
@@ -1,11 +1,11 @@
#! /bin/sh
# Common wrapper for a few potentially missing GNU and other programs.
-scriptversion=2024-06-07.14; # UTC
+scriptversion=2025-06-18.21; # UTC
# shellcheck disable=SC2006,SC2268 # we must support pre-POSIX shells
-# Copyright (C) 1996-2024 Free Software Foundation, Inc.
+# Copyright (C) 1996-2025 Free Software Foundation, Inc.
# Originally written by Fran,cois Pinard , 1996.
# This program is free software; you can redistribute it and/or modify
@@ -228,9 +228,9 @@
exit $st
# Local variables:
-# eval: (add-hook 'before-save-hook 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp nil t)
# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-format: "%Y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:
diff -Nru xz-utils-5.8.1/build-aux/test-driver xz-utils-5.8.3/build-aux/test-driver
--- xz-utils-5.8.1/build-aux/test-driver 2025-04-03 11:35:22.000000000 +0000
+++ xz-utils-5.8.3/build-aux/test-driver 2026-03-31 15:27:10.000000000 +0000
@@ -1,9 +1,9 @@
#! /bin/sh
# test-driver - basic testsuite driver script.
-scriptversion=2024-06-19.01; # UTC
+scriptversion=2025-06-18.21; # UTC
-# Copyright (C) 2011-2024 Free Software Foundation, Inc.
+# Copyright (C) 2011-2025 Free Software Foundation, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
@@ -152,9 +152,9 @@
# Local Variables:
# mode: shell-script
# sh-indentation: 2
-# eval: (add-hook 'before-save-hook 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp nil t)
# time-stamp-start: "scriptversion="
-# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-format: "%Y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC0"
# time-stamp-end: "; # UTC"
# End:
diff -Nru xz-utils-5.8.1/cmake/tuklib_cpucores.cmake xz-utils-5.8.3/cmake/tuklib_cpucores.cmake
--- xz-utils-5.8.1/cmake/tuklib_cpucores.cmake 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/cmake/tuklib_cpucores.cmake 2026-03-31 15:27:00.000000000 +0000
@@ -65,7 +65,7 @@
"
TUKLIB_CPUCORES_CPUSET)
if(TUKLIB_CPUCORES_CPUSET)
- set(TUKLIB_CPUCORES_DEFINITIONS "HAVE_PARAM_H;TUKLIB_CPUCORES_CPUSET"
+ set(TUKLIB_CPUCORES_DEFINITIONS "TUKLIB_CPUCORES_CPUSET"
CACHE INTERNAL "")
return()
endif()
@@ -109,7 +109,7 @@
if(TUKLIB_CPUCORES_SYSCTL)
if(HAVE_SYS_PARAM_H)
set(TUKLIB_CPUCORES_DEFINITIONS
- "HAVE_PARAM_H;TUKLIB_CPUCORES_SYSCTL"
+ "HAVE_SYS_PARAM_H;TUKLIB_CPUCORES_SYSCTL"
CACHE INTERNAL "")
else()
set(TUKLIB_CPUCORES_DEFINITIONS
diff -Nru xz-utils-5.8.1/cmake/tuklib_integer.cmake xz-utils-5.8.3/cmake/tuklib_integer.cmake
--- xz-utils-5.8.1/cmake/tuklib_integer.cmake 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/cmake/tuklib_integer.cmake 2026-03-31 15:27:00.000000000 +0000
@@ -14,6 +14,69 @@
include(CheckIncludeFile)
include(CheckSymbolExists)
+# An internal helper for tuklib_integer that attempts to detect if
+# -mstrict-align or -mno-strict-align is in effect. This sets the
+# cache variable TUKLIB_INTEGER_STRICT_ALIGN to ON if OBJDUMP_REGEX
+# matches the objdump output of a check program. Otherwise it is set to OFF.
+function(tuklib_integer_internal_strict_align OBJDUMP_REGEX)
+ if(NOT DEFINED TUKLIB_INTEGER_STRICT_ALIGN)
+ # Build a static library because then the function won't be optimized
+ # away, and there won't be any unrelated startup code either.
+ set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+ # CMake >= 3.25 wouldn't require us to create a temporary file,
+ # but the following method is compatible with 3.20.
+ file(WRITE "${CMAKE_BINARY_DIR}/tuklib_integer_strict_align.c" "
+ #include
+ unsigned int check_strict_align(const void *p)
+ {
+ unsigned int i;
+ memcpy(&i, p, sizeof(i));
+ return i;
+ }
+ ")
+
+ # Force -O2 because memcpy() won't be optimized out if optimizations
+ # are disabled.
+ try_compile(
+ TRY_COMPILE_RESULT
+ "${CMAKE_BINARY_DIR}"
+ "${CMAKE_BINARY_DIR}/tuklib_integer_strict_align.c"
+ COMPILE_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}"
+ CMAKE_FLAGS "-DCOMPILE_DEFINITIONS=${CMAKE_REQUIRED_FLAGS} -O2"
+ COPY_FILE "${CMAKE_BINARY_DIR}/tuklib_integer_strict_align.a"
+ )
+
+ if(NOT TRY_COMPILE_RESULT)
+ message(FATAL_ERROR
+ "Compilation of the strict align check failed. "
+ "Either the specified compiler flags are broken "
+ "or ${CMAKE_CURRENT_FUNCTION_LIST_FILE} has a bug.")
+ endif()
+
+ # Use WORKING_DIRECTORY instead of passing the full path to objdump.
+ # This ensures that the pathname won't affect the objdump output,
+ # which could result in an unwanted regex match in the next step.
+ execute_process(
+ COMMAND "${CMAKE_OBJDUMP}" -d "tuklib_integer_strict_align.a"
+ WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+ OUTPUT_VARIABLE OBJDUMP_OUTPUT
+ RESULT_VARIABLE OBJDUMP_RESULT
+ )
+
+ # FIXME? Should we remove the temporary files here?
+
+ # Look for instructions that load unsigned bytes. If none are found,
+ # assume that -mno-strict-align is in effect.
+ if(OBJDUMP_RESULT STREQUAL "0" AND
+ OBJDUMP_OUTPUT MATCHES "${OBJDUMP_REGEX}")
+ set(TUKLIB_INTEGER_STRICT_ALIGN ON CACHE INTERNAL "")
+ else()
+ set(TUKLIB_INTEGER_STRICT_ALIGN OFF CACHE INTERNAL "")
+ endif()
+ endif()
+endfunction()
+
function(tuklib_integer TARGET_OR_ALL)
# Check for endianness. Unlike the Autoconf's AC_C_BIGENDIAN, this doesn't
# support Apple universal binaries. The CMake module will leave the
@@ -60,61 +123,145 @@
endif()
endif()
- # Guess that unaligned access is fast on these archs:
- # - 32/64-bit x86 / x86-64
- # - 32/64-bit big endian PowerPC
- # - 64-bit little endian PowerPC
- # - Some 32-bit ARM
- # - Some 64-bit ARM64 (AArch64)
- # - Some 32/64-bit RISC-V
- #
- # CMake doesn't provide a standardized/normalized list of processor arch
- # names. For example, x86-64 may be "x86_64" (Linux), "AMD64" (Windows),
- # or even "EM64T" (64-bit WinXP).
+ # Autodetect if unaligned memory access is fast when the cache variable
+ # TUKLIB_FAST_UNALIGNED_ACCESS isn't set. The result is stored in
+ # FAST_UNALIGNED_GUESS. Assume that unaligned access shouldn't be used.
+ # Initialize the variable here so that it's never undefined in the
+ # option() command after the if()...endif() block.
set(FAST_UNALIGNED_GUESS OFF)
- string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" PROCESSOR)
+ if(NOT DEFINED TUKLIB_FAST_UNALIGNED_ACCESS)
+ message(CHECK_START "Check if unaligned memory access should be used")
- # There is no ^ in the first regex branch to allow "i" at the beginning
- # so it can match "i386" to "i786", and "x86_64".
- if(PROCESSOR MATCHES "[x34567]86|^x64|^amd64|^em64t")
- set(FAST_UNALIGNED_GUESS ON)
-
- elseif(PROCESSOR MATCHES "^powerpc|^ppc")
- if(WORDS_BIGENDIAN OR PROCESSOR MATCHES "64")
- set(FAST_UNALIGNED_GUESS ON)
- endif()
-
- elseif(PROCESSOR MATCHES "^arm|^aarch64|^riscv")
- # On 32-bit and 64-bit ARM, GCC and Clang
- # #define __ARM_FEATURE_UNALIGNED if
- # unaligned access is supported.
+ # Guess that unaligned access is fast on these archs:
+ # - 32/64-bit x86 / x86-64
+ # - 32/64-bit big endian PowerPC
+ # - 64-bit little endian PowerPC
+ # - 32/64-bit Loongarch (*)
+ # - Some 32-bit ARM
+ # - Some 64-bit ARM64 (AArch64)
+ # - Some 32/64-bit RISC-V
#
- # Exception: GCC at least up to 13.2.0
- # defines it even when using -mstrict-align
- # so in that case this autodetection goes wrong.
- # Most of the time -mstrict-align isn't used so it
- # shouldn't be a common problem in practice. See:
- # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111555
+ # (*) See sections 7.4, 8.1, and 8.2:
+ # https://github.com/loongson/la-softdev-convention/blob/v0.2/la-softdev-convention.adoc
#
- # RISC-V C API Specification says that if
- # __riscv_misaligned_fast is defined then
- # unaligned access is known to be fast.
+ # That is, desktop and server processors likely support
+ # unaligned access in hardware but embedded processors
+ # might not. GCC defaults to -mno-strict-align and so
+ # do majority of GNU/Linux distributions. As of
+ # GCC 15.2, there is no predefined macro to detect
+ # if -mstrict-align or -mno-strict-align is in effect.
+ # We use heuristics based on compiler output.
#
- # MSVC is handled as a special case: We assume that
- # 32/64-bit ARM supports fast unaligned access.
- # If MSVC gets RISC-V support then this will assume
- # fast unaligned access on RISC-V too.
- check_c_source_compiles("
- #if !defined(__ARM_FEATURE_UNALIGNED) \
- && !defined(__riscv_misaligned_fast) \
- && !defined(_MSC_VER)
- compile error
- #endif
- int main(void) { return 0; }
- "
- TUKLIB_FAST_UNALIGNED_DEFINED_BY_PREPROCESSOR)
- if(TUKLIB_FAST_UNALIGNED_DEFINED_BY_PREPROCESSOR)
+ # CMake < 4.1 doesn't provide a standardized/normalized list of arch
+ # names. For example, x86-64 may be "x86_64" (Linux),
+ # "AMD64" (Windows), or even "EM64T" (64-bit WinXP).
+ string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" PROCESSOR)
+
+ # CMake 4.1 made CMAKE__COMPILER_ARCHITECTURE_ID useful on many
+ # targets. In earlier versions it's still useful with MSVC with which
+ # CMAKE_SYSTEM_PROCESSOR can refer to the build machine.
+ if(NOT CMAKE_C_COMPILER_ARCHITECTURE_ID STREQUAL "")
+ # CMake 4.2.0 docs say that the list typically has only one entry
+ # except possibly on macOS. On macOS, most (all?) archs support
+ # unaligned access. Just pick the first one from the list.
+ list(GET CMAKE_C_COMPILER_ARCHITECTURE_ID 0 PROCESSOR)
+ string(TOLOWER "${PROCESSOR}" PROCESSOR)
+ endif()
+
+ # There is no ^ in the first regex branch to allow "i" at
+ # the beginning so it can match "i386" to "i786", and "x86_64".
+ if(PROCESSOR MATCHES "[x34567]86|^x64|^amd64|^em64t")
set(FAST_UNALIGNED_GUESS ON)
+
+ elseif(PROCESSOR MATCHES "^powerpc|^ppc")
+ if(WORDS_BIGENDIAN OR PROCESSOR MATCHES "64")
+ set(FAST_UNALIGNED_GUESS ON)
+ endif()
+
+ elseif(PROCESSOR MATCHES "^arm|^riscv" AND
+ NOT PROCESSOR MATCHES "^arm64")
+ # On 32-bit ARM, GCC and Clang # #define __ARM_FEATURE_UNALIGNED
+ # if and only if unaligned access is supported.
+ #
+ # RISC-V C API Specification says that if
+ # __riscv_misaligned_fast is defined then
+ # unaligned access is known to be fast.
+ #
+ # MSVC is handled as a special case: We assume that
+ # 32-bit ARM supports fast unaligned access.
+ # If MSVC gets RISC-V support then this will assume
+ # fast unaligned access on RISC-V too.
+ check_c_source_compiles("
+ #if !defined(__ARM_FEATURE_UNALIGNED) \
+ && !defined(__riscv_misaligned_fast) \
+ && !defined(_MSC_VER)
+ compile error
+ #endif
+ int main(void) { return 0; }
+ "
+ TUKLIB_FAST_UNALIGNED_DEFINED_BY_PREPROCESSOR)
+ if(TUKLIB_FAST_UNALIGNED_DEFINED_BY_PREPROCESSOR)
+ set(FAST_UNALIGNED_GUESS ON)
+ endif()
+
+ elseif(PROCESSOR MATCHES "^aarch64|^arm64")
+ # On ARM64, Clang defines __ARM_FEATURE_UNALIGNED if and only if
+ # unaligned access is supported. However, GCC (at least up to 15.2.0)
+ # defines it even when using -mstrict-align, so autodetection with
+ # this macro doesn't work with GCC on ARM64. (It does work on
+ # 32-bit ARM.) See:
+ #
+ # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111555
+ #
+ # We need three checks:
+ #
+ # 1. If __ARM_FEATURE_UNALIGNED is defined and the
+ # compiler isn't GCC, unaligned access is enabled.
+ # If the compiler is MSVC, unaligned access is
+ # enabled even without __ARM_FEATURE_UNALIGNED.
+ check_c_source_compiles("
+ #if defined(__ARM_FEATURE_UNALIGNED) \
+ && (!defined(__GNUC__) || defined(__clang__))
+ #elif defined(_MSC_VER)
+ #else
+ compile error
+ #endif
+ int main(void) { return 0; }
+ "
+ TUKLIB_FAST_UNALIGNED_DEFINED_BY_PREPROCESSOR)
+ if(TUKLIB_FAST_UNALIGNED_DEFINED_BY_PREPROCESSOR)
+ set(FAST_UNALIGNED_GUESS ON)
+ else()
+ # 2. If __ARM_FEATURE_UNALIGNED is not defined,
+ # unaligned access is disabled.
+ check_c_source_compiles("
+ #ifdef __ARM_FEATURE_UNALIGNED
+ compile error
+ #endif
+ int main(void) { return 0; }
+ "
+ TUKLIB_FAST_UNALIGNED_NOT_DEFINED_BY_PREPROCESSOR)
+ if(NOT TUKLIB_FAST_UNALIGNED_NOT_DEFINED_BY_PREPROCESSOR)
+ # 3. Use heuristics to detect if -mstrict-align is
+ # in effect when building with GCC.
+ tuklib_integer_internal_strict_align("[ \t]ldrb[ \t]")
+ if(NOT TUKLIB_INTEGER_STRICT_ALIGN)
+ set(FAST_UNALIGNED_GUESS ON)
+ endif()
+ endif()
+ endif()
+
+ elseif(PROCESSOR MATCHES "^loongarch")
+ tuklib_integer_internal_strict_align("[ \t]ld\\.bu[ \t]")
+ if(NOT TUKLIB_INTEGER_STRICT_ALIGN)
+ set(FAST_UNALIGNED_GUESS ON)
+ endif()
+ endif()
+
+ if(FAST_UNALIGNED_GUESS)
+ message(CHECK_PASS "yes")
+ else()
+ message(CHECK_PASS "no")
endif()
endif()
diff -Nru xz-utils-5.8.1/cmake/tuklib_physmem.cmake xz-utils-5.8.3/cmake/tuklib_physmem.cmake
--- xz-utils-5.8.1/cmake/tuklib_physmem.cmake 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/cmake/tuklib_physmem.cmake 2026-03-31 15:27:00.000000000 +0000
@@ -101,7 +101,7 @@
if(TUKLIB_PHYSMEM_SYSCTL)
if(HAVE_SYS_PARAM_H)
set(TUKLIB_PHYSMEM_DEFINITIONS
- "HAVE_PARAM_H;TUKLIB_PHYSMEM_SYSCTL"
+ "HAVE_SYS_PARAM_H;TUKLIB_PHYSMEM_SYSCTL"
CACHE INTERNAL "")
else()
set(TUKLIB_PHYSMEM_DEFINITIONS
diff -Nru xz-utils-5.8.1/config.h.in xz-utils-5.8.3/config.h.in
--- xz-utils-5.8.1/config.h.in 2025-04-03 11:35:21.000000000 +0000
+++ xz-utils-5.8.3/config.h.in 2026-03-31 15:27:10.000000000 +0000
@@ -171,9 +171,15 @@
/* Define to 1 if you have the 'getopt_long' function. */
#undef HAVE_GETOPT_LONG
+/* Define to 1 if you have the 'getrlimit' function. */
+#undef HAVE_GETRLIMIT
+
/* Define if the GNU gettext() function is already present or preinstalled. */
#undef HAVE_GETTEXT
+/* Define to 1 if 'HWCAP_CRC32' is declared in . */
+#undef HAVE_HWCAP_CRC32
+
/* Define if you have the iconv() function and it works. */
#undef HAVE_ICONV
@@ -471,6 +477,10 @@
#ifndef _ALL_SOURCE
# undef _ALL_SOURCE
#endif
+/* Enable extensions on Cosmopolitan Libc. */
+#ifndef _COSMO_SOURCE
+# undef _COSMO_SOURCE
+#endif
/* Enable general extensions on macOS. */
#ifndef _DARWIN_C_SOURCE
# undef _DARWIN_C_SOURCE
diff -Nru xz-utils-5.8.1/configure xz-utils-5.8.3/configure
--- xz-utils-5.8.1/configure 2025-04-03 11:35:20.000000000 +0000
+++ xz-utils-5.8.3/configure 2026-03-31 15:27:10.000000000 +0000
@@ -1,11 +1,11 @@
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.72 for XZ Utils 5.8.1.
+# Generated by GNU Autoconf 2.73 for XZ Utils 5.8.3.
#
# Report bugs to .
#
#
-# Copyright (C) 1992-1996, 1998-2017, 2020-2023 Free Software Foundation,
+# Copyright (C) 1992-1996, 1998-2017, 2020-2026 Free Software Foundation,
# Inc.
#
#
@@ -22,7 +22,7 @@
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
- # is contrary to our usage. Disable this feature.
+ # contradicts POSIX and common usage. Disable this.
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else case e in #(
@@ -109,7 +109,7 @@
as_myself=$0
fi
if test ! -f "$as_myself"; then
- printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+ printf '%s\n' "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
exit 1
fi
@@ -131,10 +131,13 @@
*x* ) as_opts=-x ;;
* ) as_opts= ;;
esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+case $# in # ((
+ 0) exec $CONFIG_SHELL $as_opts "$as_myself" ;;
+ *) exec $CONFIG_SHELL $as_opts "$as_myself" "$@" ;;
+esac
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed 'exec'.
-printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
+printf '%s\n' "$0: could not re-execute with $CONFIG_SHELL" >&2
exit 255
fi
# We don't want this to propagate to other subprocesses.
@@ -145,7 +148,7 @@
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
- # is contrary to our usage. Disable this feature.
+ # contradicts POSIX and common usage. Disable this.
alias -g '\${1+\"\$@\"}'='\"\$@\"'
setopt NO_GLOB_SUBST
else case e in #(
@@ -263,22 +266,25 @@
*x* ) as_opts=-x ;;
* ) as_opts= ;;
esac
-exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+case $# in # ((
+ 0) exec $CONFIG_SHELL $as_opts "$as_myself" ;;
+ *) exec $CONFIG_SHELL $as_opts "$as_myself" "$@" ;;
+esac
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed 'exec'.
-printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
+printf '%s\n' "$0: could not re-execute with $CONFIG_SHELL" >&2
exit 255
fi
if test x$as_have_required = xno
then :
- printf "%s\n" "$0: This script requires a shell more modern than all"
- printf "%s\n" "$0: the shells that I found on your system."
+ printf '%s\n' "$0: This script requires a shell more modern than all"
+ printf '%s\n' "$0: the shells that I found on your system."
if test ${ZSH_VERSION+y} ; then
- printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should"
- printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later."
+ printf '%s\n' "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+ printf '%s\n' "$0: be upgraded to zsh 4.3.4 or later."
else
- printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and xz@tukaani.org
+ printf '%s\n' "$0: Please tell bug-autoconf@gnu.org and xz@tukaani.org
$0: about your system, including any error possibly output
$0: before this message. Then install a modern shell, or
$0: manually run the script under such a shell if you do
@@ -339,7 +345,7 @@
as_dirs=
while :; do
case $as_dir in #(
- *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+ *\'*) as_qdir=`printf '%s\n' "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
*) as_qdir=$as_dir;;
esac
as_dirs="'$as_qdir' $as_dirs"
@@ -348,7 +354,7 @@
X"$as_dir" : 'X\(//\)[^/]' \| \
X"$as_dir" : 'X\(//\)$' \| \
X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$as_dir" |
+printf '%s\n' X"$as_dir" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
@@ -431,9 +437,9 @@
as_status=$1; test $as_status -eq 0 && as_status=1
if test "$4"; then
as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
fi
- printf "%s\n" "$as_me: error: $2" >&2
+ printf '%s\n' "$as_me: error: $2" >&2
as_fn_exit $as_status
} # as_fn_error
@@ -460,7 +466,7 @@
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
X"$0" : 'X\(//\)$' \| \
X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X/"$0" |
+printf '%s\n' X/"$0" |
sed '/^.*\/\([^/][^/]*\)\/*$/{
s//\1/
q
@@ -506,7 +512,7 @@
s/-\n.*//
' >$as_me.lineno &&
chmod +x "$as_me.lineno" ||
- { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+ { printf '%s\n' "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
# If we had to re-execute with $CONFIG_SHELL, we're ensured to have
# already done that, so ensure we don't try to do so again and fall
@@ -520,29 +526,6 @@
exit
}
-
-# Determine whether it's possible to make 'echo' print without a newline.
-# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
-# for compatibility with existing Makefiles.
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
- case `echo 'xy\c'` in
- *c*) ECHO_T=' ';; # ECHO_T is single tab character.
- xy) ECHO_C='\c';;
- *) echo `echo ksh88 bug on AIX 6.1` > /dev/null
- ECHO_T=' ';;
- esac;;
-*)
- ECHO_N='-n';;
-esac
-
-# For backward compatibility with old third-party macros, we provide
-# the shell variables $as_echo and $as_echo_n. New code should use
-# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
-as_echo='printf %s\n'
-as_echo_n='printf %s'
-
rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
rm -f conf$$.dir/conf$$.file
@@ -603,6 +586,7 @@
# Initializations.
#
ac_default_prefix=/usr/local
+ac_clean_CONFIG_STATUS=
ac_clean_files=
ac_config_libobj_dir=.
LIBOBJS=
@@ -614,8 +598,8 @@
# Identity of this package.
PACKAGE_NAME='XZ Utils'
PACKAGE_TARNAME='xz'
-PACKAGE_VERSION='5.8.1'
-PACKAGE_STRING='XZ Utils 5.8.1'
+PACKAGE_VERSION='5.8.3'
+PACKAGE_STRING='XZ Utils 5.8.3'
PACKAGE_BUGREPORT='xz@tukaani.org'
PACKAGE_URL='https://tukaani.org/xz/'
@@ -653,7 +637,7 @@
ac_header_c_list=
gt_needs=
-enable_year2038=no
+: ${enable_year2038:=no}
ac_subst_vars='am__EXEEXT_FALSE
am__EXEEXT_TRUE
LTLIBOBJS
@@ -686,6 +670,7 @@
MSGFMT
GETTEXT_MACRO_VERSION
USE_NLS
+LINKER_FLAG_UNDEFINED_VERSION
COND_SYMVERS_GENERIC_FALSE
COND_SYMVERS_GENERIC_TRUE
COND_SYMVERS_LINUX_FALSE
@@ -904,13 +889,13 @@
build_vendor
build_cpu
build
+ECHO_T
+ECHO_N
+ECHO_C
target_alias
host_alias
build_alias
LIBS
-ECHO_T
-ECHO_N
-ECHO_C
DEFS
mandir
localedir
@@ -978,6 +963,7 @@
enable_static
enable_pic
with_pic
+enable_cxx_stdlib
enable_fast_install
enable_aix_soname
with_aix_soname
@@ -1117,7 +1103,7 @@
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid feature name: '$ac_useropt'"
ac_useropt_orig=$ac_useropt
- ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+ ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"enable_$ac_useropt"
@@ -1143,7 +1129,7 @@
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid feature name: '$ac_useropt'"
ac_useropt_orig=$ac_useropt
- ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+ ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"enable_$ac_useropt"
@@ -1356,7 +1342,7 @@
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid package name: '$ac_useropt'"
ac_useropt_orig=$ac_useropt
- ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+ ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"with_$ac_useropt"
@@ -1372,7 +1358,7 @@
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid package name: '$ac_useropt'"
ac_useropt_orig=$ac_useropt
- ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+ ac_useropt=`printf '%s\n' "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"with_$ac_useropt"
@@ -1416,9 +1402,9 @@
*)
# FIXME: should be removed in autoconf 3.0.
- printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2
+ printf '%s\n' "$as_me: WARNING: you should use --build, --host, --target" >&2
expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
- printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2
+ printf '%s\n' "$as_me: WARNING: invalid host type: $ac_option" >&2
: "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
;;
@@ -1426,7 +1412,7 @@
done
if test -n "$ac_prev"; then
- ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+ ac_option=--`printf '%s\n' $ac_prev | sed 's/_/-/g'`
as_fn_error $? "missing argument to $ac_option"
fi
@@ -1434,7 +1420,7 @@
case $enable_option_checking in
no) ;;
fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
- *) printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+ *) printf '%s\n' "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
esac
fi
@@ -1498,7 +1484,7 @@
X"$as_myself" : 'X\(//\)[^/]' \| \
X"$as_myself" : 'X\(//\)$' \| \
X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$as_myself" |
+printf '%s\n' X"$as_myself" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
@@ -1555,7 +1541,7 @@
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
-'configure' configures XZ Utils 5.8.1 to adapt to many kinds of systems.
+'configure' configures XZ Utils 5.8.3 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
@@ -1626,7 +1612,7 @@
if test -n "$ac_init_help"; then
case $ac_init_help in
- short | recursive ) echo "Configuration of XZ Utils 5.8.1:";;
+ short | recursive ) echo "Configuration of XZ Utils 5.8.3:";;
esac
cat <<\_ACEOF
@@ -1709,6 +1695,10 @@
--enable-static[=PKGS] build static libraries [default=yes]
--enable-pic[=PKGS] try to use only PIC/non-PIC objects [default=use
both]
+ --enable-cxx-stdlib[=PKGS]
+ let the compiler frontend decide what standard
+ libraries to link when building C++ shared libraries
+ and modules [default=no]
--enable-fast-install[=PKGS]
optimize for fast installation [default=yes]
--enable-aix-soname=aix|svr4|both
@@ -1785,9 +1775,9 @@
case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
- ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
+ ac_dir_suffix=/`printf '%s\n' "$ac_dir" | sed 's|^\.[\\/]||'`
# A ".." for each directory in $ac_dir_suffix.
- ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+ ac_top_builddir_sub=`printf '%s\n' "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
case $ac_top_builddir_sub in
"") ac_top_builddir_sub=. ac_top_build_prefix= ;;
*) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
@@ -1824,7 +1814,7 @@
echo &&
$SHELL "$ac_srcdir/configure" --help=recursive
else
- printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+ printf '%s\n' "$as_me: WARNING: no configuration information is in $ac_dir" >&2
fi || ac_status=$?
cd "$ac_pwd" || { ac_status=$?; break; }
done
@@ -1833,10 +1823,10 @@
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
-XZ Utils configure 5.8.1
-generated by GNU Autoconf 2.72
+XZ Utils configure 5.8.3
+generated by GNU Autoconf 2.73
-Copyright (C) 2023 Free Software Foundation, Inc.
+Copyright (C) 2026 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
@@ -1860,7 +1850,7 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_compile") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
@@ -1868,7 +1858,7 @@
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
@@ -1876,7 +1866,7 @@
then :
ac_retval=0
else case e in #(
- e) printf "%s\n" "$as_me: failed program was:" >&5
+ e) printf '%s\n' "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1 ;;
@@ -1894,7 +1884,7 @@
ac_fn_c_check_header_compile ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
printf %s "checking for $2... " >&6; }
if eval test \${$3+y}
then :
@@ -1916,8 +1906,8 @@
esac
fi
eval ac_res=\$$3
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf '%s\n' "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_header_compile
@@ -1935,7 +1925,7 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_link") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
@@ -1943,7 +1933,7 @@
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
@@ -1954,7 +1944,7 @@
then :
ac_retval=0
else case e in #(
- e) printf "%s\n" "$as_me: failed program was:" >&5
+ e) printf '%s\n' "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1 ;;
@@ -1982,7 +1972,7 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
@@ -1990,7 +1980,7 @@
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } > conftest.i && {
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
test ! -s conftest.err
@@ -1998,7 +1988,7 @@
then :
ac_retval=0
else case e in #(
- e) printf "%s\n" "$as_me: failed program was:" >&5
+ e) printf '%s\n' "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1 ;;
@@ -2015,7 +2005,7 @@
ac_fn_c_check_func ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
printf %s "checking for $2... " >&6; }
if eval test \${$3+y}
then :
@@ -2067,8 +2057,8 @@
esac
fi
eval ac_res=\$$3
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf '%s\n' "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_func
@@ -2086,26 +2076,26 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
{ { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; }
then :
ac_retval=0
else case e in #(
- e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5
- printf "%s\n" "$as_me: failed program was:" >&5
+ e) printf '%s\n' "$as_me: program exited with status $ac_status" >&5
+ printf '%s\n' "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=$ac_status ;;
@@ -2124,7 +2114,7 @@
ac_fn_c_check_type ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
printf %s "checking for $2... " >&6; }
if eval test \${$3+y}
then :
@@ -2170,8 +2160,8 @@
esac
fi
eval ac_res=\$$3
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf '%s\n' "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_type
@@ -2183,7 +2173,7 @@
ac_fn_c_find_uintX_t ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for uint$2_t" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for uint$2_t" >&5
printf %s "checking for uint$2_t... " >&6; }
if eval test \${$3+y}
then :
@@ -2229,8 +2219,8 @@
esac
fi
eval ac_res=\$$3
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf '%s\n' "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_find_uintX_t
@@ -2242,7 +2232,7 @@
ac_fn_c_find_intX_t ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for int$2_t" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for int$2_t" >&5
printf %s "checking for int$2_t... " >&6; }
if eval test \${$3+y}
then :
@@ -2312,8 +2302,8 @@
esac
fi
eval ac_res=\$$3
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf '%s\n' "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_find_intX_t
@@ -2520,7 +2510,7 @@
ac_fn_c_check_member ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $2.$3" >&5
printf %s "checking for $2.$3... " >&6; }
if eval test \${$4+y}
then :
@@ -2570,8 +2560,8 @@
esac
fi
eval ac_res=\$$4
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf '%s\n' "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_member
@@ -2584,7 +2574,7 @@
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
as_decl_name=`echo $2|sed 's/ *(.*//'`
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $as_decl_name is declared" >&5
printf %s "checking whether $as_decl_name is declared... " >&6; }
if eval test \${$3+y}
then :
@@ -2624,8 +2614,8 @@
esac
fi
eval ac_res=\$$3
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf '%s\n' "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_check_decl
@@ -2634,7 +2624,7 @@
do
case $ac_arg in
*\'*)
- ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+ ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
as_fn_append ac_configure_args_raw " '$ac_arg'"
done
@@ -2646,15 +2636,15 @@
ac_unsafe_z='|&;<>()$`\\"*?[ '' ' # This string ends in space, tab.
ac_unsafe_a="$ac_unsafe_z#~"
ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g"
- ac_configure_args_raw=` printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;;
+ ac_configure_args_raw=` printf '%s\n' "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;;
esac
cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
-It was created by XZ Utils $as_me 5.8.1, which was
-generated by GNU Autoconf 2.72. Invocation command line was
+It was created by XZ Utils $as_me 5.8.3, which was
+generated by GNU Autoconf 2.73. Invocation command line was
$ $0$ac_configure_args_raw
@@ -2694,7 +2684,7 @@
*/) ;;
*) as_dir=$as_dir/ ;;
esac
- printf "%s\n" "PATH: $as_dir"
+ printf '%s\n' "PATH: $as_dir"
done
IFS=$as_save_IFS
@@ -2729,7 +2719,7 @@
| -silent | --silent | --silen | --sile | --sil)
continue ;;
*\'*)
- ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+ ac_arg=`printf '%s\n' "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
case $ac_pass in
1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
@@ -2758,31 +2748,22 @@
{ ac_configure_args0=; unset ac_configure_args0;}
{ ac_configure_args1=; unset ac_configure_args1;}
-# When interrupted or exit'd, cleanup temporary files, and complete
-# config.log. We remove comments because anyway the quotes in there
-# would cause problems or look ugly.
-# WARNING: Use '\'' to represent an apostrophe within the trap.
-# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
-trap 'exit_status=$?
- # Sanitize IFS.
- IFS=" "" $as_nl"
- # Save into config.log some information that might help in debugging.
- {
- echo
-
- printf "%s\n" "## ---------------- ##
-## Cache variables. ##
-## ---------------- ##"
- echo
- # The following way of writing the cache mishandles newlines in values,
+# Dump the cache to stdout. It can be in a pipe (this is a requirement).
+ac_cache_dump ()
+{
+ # The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
(
- for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+ for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
eval ac_val=\$$ac_var
case $ac_val in #(
*${as_nl}*)
case $ac_var in #(
- *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+ *_cv_*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+printf '%s\n' "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
esac
case $ac_var in #(
_ | IFS | as_nl) ;; #(
@@ -2791,67 +2772,95 @@
esac ;;
esac
done
+
(set) 2>&1 |
- case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+ case $as_nl`(ac_space=' '; set) 2>&1` in #(
*${as_nl}ac_space=\ *)
+ # 'set' does not quote correctly, so add quotes: double-quote
+ # substitution turns \\\\ into \\, and sed turns \\ into \.
sed -n \
- "s/'\''/'\''\\\\'\'''\''/g;
- s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+ "s/'/'\\\\''/g;
+ s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
;; #(
*)
+ # 'set' quotes correctly as required by POSIX, so do not add quotes.
sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
;;
esac |
sort
)
- echo
+}
- printf "%s\n" "## ----------------- ##
+# Print debugging info to stdout.
+ac_dump_debugging_info ()
+{
+ echo
+
+ printf '%s\n' "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+ echo
+ ac_cache_dump
+ echo
+
+ printf '%s\n' "## ----------------- ##
## Output variables. ##
## ----------------- ##"
+ echo
+ for ac_var in $ac_subst_vars
+ do
+ eval ac_val=\$$ac_var
+ case $ac_val in
+ *\'*) ac_val=`printf '%s\n' "$ac_val" | sed "s/'/'\\\\\\\\''/g"`;;
+ esac
+ printf '%s\n' "$ac_var='$ac_val'"
+ done | sort
+ echo
+
+ if test -n "$ac_subst_files"; then
+ printf '%s\n' "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
echo
- for ac_var in $ac_subst_vars
+ for ac_var in $ac_subst_files
do
eval ac_val=\$$ac_var
case $ac_val in
- *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+ *\'*) ac_val=`printf '%s\n' "$ac_val" | sed "s/'/'\\\\\\\\''/g"`;;
esac
- printf "%s\n" "$ac_var='\''$ac_val'\''"
+ printf '%s\n' "$ac_var='$ac_val'"
done | sort
echo
+ fi
- if test -n "$ac_subst_files"; then
- printf "%s\n" "## ------------------- ##
-## File substitutions. ##
-## ------------------- ##"
- echo
- for ac_var in $ac_subst_files
- do
- eval ac_val=\$$ac_var
- case $ac_val in
- *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
- esac
- printf "%s\n" "$ac_var='\''$ac_val'\''"
- done | sort
- echo
- fi
-
- if test -s confdefs.h; then
- printf "%s\n" "## ----------- ##
+ if test -s confdefs.h; then
+ printf '%s\n' "## ----------- ##
## confdefs.h. ##
## ----------- ##"
- echo
- cat confdefs.h
- echo
- fi
- test "$ac_signal" != 0 &&
- printf "%s\n" "$as_me: caught signal $ac_signal"
- printf "%s\n" "$as_me: exit $exit_status"
- } >&5
- rm -f core *.core core.conftest.* &&
+ echo
+ cat confdefs.h
+ echo
+ fi
+ test "$ac_signal" != 0 &&
+ printf '%s\n' "$as_me: caught signal $ac_signal"
+ printf '%s\n' "$as_me: exit $exit_status"
+}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.
+ac_exit_trap ()
+{
+ exit_status=
+ # Sanitize IFS.
+ IFS=" "" $as_nl"
+ # Save into config.log some information that might help in debugging.
+ ac_dump_debugging_info >&5
+ eval "rm -f $ac_clean_CONFIG_STATUS core *.core core.conftest.*" &&
rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
exit $exit_status
-' 0
+}
+
+trap 'ac_exit_trap $?' 0
for ac_signal in 1 2 13 15; do
trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
done
@@ -2860,21 +2869,21 @@
# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -f -r conftest* confdefs.h
-printf "%s\n" "/* confdefs.h */" > confdefs.h
+printf '%s\n' "/* confdefs.h */" > confdefs.h
# Predefined preprocessor variables.
-printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h
+printf '%s\n' "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h
-printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h
+printf '%s\n' "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h
-printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h
+printf '%s\n' "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h
-printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h
+printf '%s\n' "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h
-printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h
+printf '%s\n' "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h
-printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h
+printf '%s\n' "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h
# Let the site file select an alternate cache file if it wants to.
@@ -2896,12 +2905,12 @@
ac_site_file=./$ac_site_file ;;
esac
if test -f "$ac_site_file" && test -r "$ac_site_file"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
-printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+printf '%s\n' "$as_me: loading site script $ac_site_file" >&6;}
sed 's/^/| /' "$ac_site_file" >&5
. "$ac_site_file" \
- || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ || { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error $? "failed to load site script $ac_site_file
See 'config.log' for more details" "$LINENO" 5; }
fi
@@ -2911,27 +2920,120 @@
# Some versions of bash will fail to source /dev/null (special files
# actually), so we avoid doing that. DJGPP emulates it as a regular file.
if test /dev/null != "$cache_file" && test -f "$cache_file"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
-printf "%s\n" "$as_me: loading cache $cache_file" >&6;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+printf '%s\n' "$as_me: loading cache $cache_file" >&6;}
case $cache_file in
[\\/]* | ?:[\\/]* ) . "$cache_file";;
*) . "./$cache_file";;
esac
fi
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
-printf "%s\n" "$as_me: creating cache $cache_file" >&6;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+printf '%s\n' "$as_me: creating cache $cache_file" >&6;}
>$cache_file
fi
+# Test code for whether the C compiler supports C23 (global declarations)
+ac_c_conftest_c23_globals='
+/* Does the compiler advertise conformance to C17 or earlier?
+ Although GCC 14 does not do that, even with -std=gnu23,
+ it is close enough, and defines __STDC_VERSION == 202000L. */
+#if !defined __STDC_VERSION__ || __STDC_VERSION__ <= 201710L
+# error "Compiler advertises conformance to C17 or earlier"
+#endif
+
+// Check alignas.
+char alignas (double) c23_aligned_as_double;
+char alignas (0) c23_no_special_alignment;
+extern char c23_aligned_as_int;
+char alignas (0) alignas (int) c23_aligned_as_int;
+
+// Check alignof.
+enum
+{
+ c23_int_alignment = alignof (int),
+ c23_int_array_alignment = alignof (int[100]),
+ c23_char_alignment = alignof (char)
+};
+static_assert (0 < -alignof (int), "alignof is signed");
+
+int function_with_unnamed_parameter (int) { return 0; }
+
+void c23_noreturn ();
+
+/* Test parsing of string and char UTF-8 literals (including hex escapes).
+ The parens pacify GCC 15. */
+bool use_u8 = (!sizeof u8"\xFF") == (!u8'\''x'\'');
+
+bool check_that_bool_works = true | false | !nullptr;
+#if !true
+# error "true does not work in #if"
+#endif
+#if false
+#elifdef __STDC_VERSION__
+#else
+# error "#elifdef does not work"
+#endif
+
+#ifndef __has_c_attribute
+# error "__has_c_attribute not defined"
+#endif
+
+#ifndef __has_include
+# error "__has_include not defined"
+#endif
+
+#define LPAREN() (
+#define FORTY_TWO(x) 42
+#define VA_OPT_TEST(r, x, ...) __VA_OPT__ (FORTY_TWO r x))
+static_assert (VA_OPT_TEST (LPAREN (), 0, <:-) == 42);
+
+static_assert (0b101010 == 42);
+static_assert (0B101010 == 42);
+static_assert (0xDEAD'\''BEEF == 3'\''735'\''928'\''559);
+static_assert (0.500'\''000'\''000 == 0.5);
+
+enum unsignedish : unsigned int { uione = 1 };
+static_assert (0 < -uione);
+
+#include
+constexpr nullptr_t null_pointer = nullptr;
+
+static typeof (1 + 1L) two () { return 2; }
+static long int three () { return 3; }
+'
+
+# Test code for whether the C compiler supports C23 (body of main).
+ac_c_conftest_c23_main='
+ {
+ label_before_declaration:
+ int arr[10] = {};
+ if (arr[0])
+ goto label_before_declaration;
+ if (!arr[0])
+ goto label_at_end_of_block;
+ label_at_end_of_block:
+ }
+ ok |= !null_pointer;
+ ok |= two != three;
+'
+
+# Test code for whether the C compiler supports C23 (complete).
+ac_c_conftest_c23_program="${ac_c_conftest_c23_globals}
+
+int
+main (int, char **)
+{
+ int ok = 0;
+ ${ac_c_conftest_c23_main}
+ return ok;
+}
+"
+
# Test code for whether the C compiler supports C89 (global declarations)
ac_c_conftest_c89_globals='
-/* Does the compiler advertise C89 conformance?
- Do not test the value of __STDC__, because some compilers set it to 0
- while being otherwise adequately conformant. */
-#if !defined __STDC__
-# error "Compiler does not advertise C89 conformance"
-#endif
+/* Do not test the value of __STDC__, because some compilers define it to 0
+ or do not define it, while otherwise adequately conforming. */
#include
#include
@@ -3011,7 +3113,8 @@
// Check varargs macros. These examples are taken from C99 6.10.3.5.
// dprintf is used instead of fprintf to avoid needing to declare
-// FILE and stderr.
+// FILE and stderr, and "aND" is used instead of "and" to work around
+// GCC bug 40564 which is irrelevant here.
#define debug(...) dprintf (2, __VA_ARGS__)
#define showlist(...) puts (#__VA_ARGS__)
#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
@@ -3022,7 +3125,7 @@
int y = 5678;
debug ("Flag");
debug ("X = %d\n", x);
- showlist (The first, second, and third items.);
+ showlist (The first, second, aND third items.);
report (x>y, "x is %d but y is %d", x, y);
}
@@ -3110,15 +3213,15 @@
// Check restrict.
if (test_restrict ("String literal") == 0)
success = true;
- char *restrict newvar = "Another string";
+ const char *restrict newvar = "Another string";
// Check varargs.
success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234);
test_varargs_macros ();
// Check flexible array members.
- struct incomplete_array *ia =
- malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
+ static struct incomplete_array *volatile incomplete_array_pointer;
+ struct incomplete_array *ia = incomplete_array_pointer;
ia->datasize = 10;
for (int i = 0; i < ia->datasize; ++i)
ia->data[i] = i * 1.234;
@@ -3134,13 +3237,12 @@
ni.number = 58;
- int dynamic_array[ni.number];
- dynamic_array[0] = argv[0][0];
- dynamic_array[ni.number - 1] = 543;
+ // Do not test for VLAs, as some otherwise-conforming compilers lack them.
+ // C code should instead use __STDC_NO_VLA__; see Autoconf manual.
// work around unused variable warnings
ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\''
- || dynamic_array[ni.number - 1] != 543);
+ || ni.number != 58);
'
# Test code for whether the C compiler supports C11 (global declarations)
@@ -3276,7 +3378,7 @@
# $ac_aux_dir_candidates and give up.
ac_missing_aux_files=""
ac_first_candidate=:
-printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5
+printf '%s\n' "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in $ac_aux_dir_candidates
@@ -3289,7 +3391,7 @@
esac
as_found=:
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: trying $as_dir" >&5
ac_aux_dir_found=yes
ac_install_sh=
for ac_aux in $ac_aux_files
@@ -3300,13 +3402,13 @@
if test x"$ac_aux" = x"install-sh"
then
if test -f "${as_dir}install-sh"; then
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}install-sh found" >&5
ac_install_sh="${as_dir}install-sh -c"
elif test -f "${as_dir}install.sh"; then
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}install.sh found" >&5
ac_install_sh="${as_dir}install.sh -c"
elif test -f "${as_dir}shtool"; then
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}shtool found" >&5
ac_install_sh="${as_dir}shtool install -c"
else
ac_aux_dir_found=no
@@ -3318,7 +3420,7 @@
fi
else
if test -f "${as_dir}${ac_aux}"; then
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: ${as_dir}${ac_aux} found" >&5
else
ac_aux_dir_found=no
if $ac_first_candidate; then
@@ -3371,38 +3473,44 @@
eval ac_new_val=\$ac_env_${ac_var}_value
case $ac_old_set,$ac_new_set in
set,)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5
-printf "%s\n" "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5
+printf '%s\n' "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;}
ac_cache_corrupted=: ;;
,set)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5
-printf "%s\n" "$as_me: error: '$ac_var' was not set in the previous run" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5
+printf '%s\n' "$as_me: error: '$ac_var' was not set in the previous run" >&2;}
ac_cache_corrupted=: ;;
,);;
*)
if test "x$ac_old_val" != "x$ac_new_val"; then
# differences in whitespace do not lead to failure.
- ac_old_val_w=`echo x $ac_old_val`
- ac_new_val_w=`echo x $ac_new_val`
+ ac_old_val_w=
+ for ac_val in x $ac_old_val; do
+ ac_old_val_w="$ac_old_val_w $ac_val"
+ done
+ ac_new_val_w=
+ for ac_val in x $ac_new_val; do
+ ac_new_val_w="$ac_new_val_w $ac_val"
+ done
if test "$ac_old_val_w" != "$ac_new_val_w"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5
-printf "%s\n" "$as_me: error: '$ac_var' has changed since the previous run:" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5
+printf '%s\n' "$as_me: error: '$ac_var' has changed since the previous run:" >&2;}
ac_cache_corrupted=:
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5
-printf "%s\n" "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5
+printf '%s\n' "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;}
eval $ac_var=\$ac_old_val
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: former value: '$ac_old_val'" >&5
-printf "%s\n" "$as_me: former value: '$ac_old_val'" >&2;}
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: current value: '$ac_new_val'" >&5
-printf "%s\n" "$as_me: current value: '$ac_new_val'" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: former value: '$ac_old_val'" >&5
+printf '%s\n' "$as_me: former value: '$ac_old_val'" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: current value: '$ac_new_val'" >&5
+printf '%s\n' "$as_me: current value: '$ac_new_val'" >&2;}
fi;;
esac
# Pass precious variables to config.status.
if test "$ac_new_set" = set; then
case $ac_new_val in
- *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+ *\'*) ac_arg=$ac_var=`printf '%s\n' "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
*) ac_arg=$ac_var=$ac_new_val ;;
esac
case " $ac_configure_args " in
@@ -3412,10 +3520,10 @@
fi
done
if $ac_cache_corrupted; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
-printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+printf '%s\n' "$as_me: error: changes in the environment can compromise the build" >&2;}
as_fn_error $? "run '${MAKE-make} distclean' and/or 'rm $cache_file'
and start over" "$LINENO" 5
fi
@@ -3423,6 +3531,23 @@
## Main body of script. ##
## -------------------- ##
+
+# Determine whether it's possible to make 'echo' print without a newline.
+# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
+# for compatibility with existing Makefiles.
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+ case `echo 'xy\c'` in
+ *c*) ECHO_T=' ';; # ECHO_T is single tab character.
+ xy) ECHO_C='\c';;
+ *) echo `echo ksh88 bug on AIX 6.1` > /dev/null
+ ECHO_T=' ';;
+ esac;;
+*)
+ ECHO_N='-n';;
+esac
+
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
@@ -3449,7 +3574,7 @@
$SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 ||
as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
printf %s "checking build system type... " >&6; }
if test ${ac_cv_build+y}
then :
@@ -3465,8 +3590,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
-printf "%s\n" "$ac_cv_build" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
+printf '%s\n' "$ac_cv_build" >&6; }
case $ac_cv_build in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
@@ -3482,10 +3607,10 @@
# except with old shells:
build_os=$*
IFS=$ac_save_IFS
-case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+case $build_os in *\ *) build_os=`printf '%s\n' "$build_os" | sed 's/ /-/g'`;; esac
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
printf %s "checking host system type... " >&6; }
if test ${ac_cv_host+y}
then :
@@ -3500,8 +3625,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
-printf "%s\n" "$ac_cv_host" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
+printf '%s\n' "$ac_cv_host" >&6; }
case $ac_cv_host in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
@@ -3517,7 +3642,7 @@
# except with old shells:
host_os=$*
IFS=$ac_save_IFS
-case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+case $host_os in *\ *) host_os=`printf '%s\n' "$host_os" | sed 's/ /-/g'`;; esac
@@ -3560,7 +3685,7 @@
# Debugging #
#############
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if debugging code should be compiled" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if debugging code should be compiled" >&5
printf %s "checking if debugging code should be compiled... " >&6; }
# Check whether --enable-debug was given.
if test ${enable_debug+y}
@@ -3572,14 +3697,14 @@
fi
if test "x$enable_debug" = xyes; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else
-printf "%s\n" "#define NDEBUG 1" >>confdefs.h
+printf '%s\n' "#define NDEBUG 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -3624,7 +3749,7 @@
enable_encoder_riscv=no
enable_decoder_riscv=no
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which encoders to build" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking which encoders to build" >&5
printf %s "checking which encoders to build... " >&6; }
# Check whether --enable-encoders was given.
if test ${enable_encoders+y}
@@ -3638,8 +3763,8 @@
enable_encoders=`echo "$enable_encoders" | sed 's/,/ /g'`
if test "x$enable_encoders" = xno || test "x$enable_encoders" = x; then
enable_encoders=no
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: (none)" >&5
-printf "%s\n" "(none)" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: (none)" >&5
+printf '%s\n' "(none)" >&6; }
else
for arg in $enable_encoders
do
@@ -3648,94 +3773,94 @@
enable_filter_lzma1=yes
enable_encoder_lzma1=yes
-printf "%s\n" "#define HAVE_ENCODER_LZMA1 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_LZMA1 1" >>confdefs.h
;;
lzma2)
enable_filter_lzma2=yes
enable_encoder_lzma2=yes
-printf "%s\n" "#define HAVE_ENCODER_LZMA2 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_LZMA2 1" >>confdefs.h
;;
delta)
enable_filter_delta=yes
enable_encoder_delta=yes
-printf "%s\n" "#define HAVE_ENCODER_DELTA 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_DELTA 1" >>confdefs.h
;;
x86)
enable_filter_x86=yes
enable_encoder_x86=yes
-printf "%s\n" "#define HAVE_ENCODER_X86 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_X86 1" >>confdefs.h
;;
powerpc)
enable_filter_powerpc=yes
enable_encoder_powerpc=yes
-printf "%s\n" "#define HAVE_ENCODER_POWERPC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_POWERPC 1" >>confdefs.h
;;
ia64)
enable_filter_ia64=yes
enable_encoder_ia64=yes
-printf "%s\n" "#define HAVE_ENCODER_IA64 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_IA64 1" >>confdefs.h
;;
arm)
enable_filter_arm=yes
enable_encoder_arm=yes
-printf "%s\n" "#define HAVE_ENCODER_ARM 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_ARM 1" >>confdefs.h
;;
armthumb)
enable_filter_armthumb=yes
enable_encoder_armthumb=yes
-printf "%s\n" "#define HAVE_ENCODER_ARMTHUMB 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_ARMTHUMB 1" >>confdefs.h
;;
arm64)
enable_filter_arm64=yes
enable_encoder_arm64=yes
-printf "%s\n" "#define HAVE_ENCODER_ARM64 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_ARM64 1" >>confdefs.h
;;
sparc)
enable_filter_sparc=yes
enable_encoder_sparc=yes
-printf "%s\n" "#define HAVE_ENCODER_SPARC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_SPARC 1" >>confdefs.h
;;
riscv)
enable_filter_riscv=yes
enable_encoder_riscv=yes
-printf "%s\n" "#define HAVE_ENCODER_RISCV 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODER_RISCV 1" >>confdefs.h
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "unknown filter: $arg" "$LINENO" 5
;;
esac
done
-printf "%s\n" "#define HAVE_ENCODERS 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ENCODERS 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_encoders" >&5
-printf "%s\n" "$enable_encoders" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_encoders" >&5
+printf '%s\n' "$enable_encoders" >&6; }
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which decoders to build" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking which decoders to build" >&5
printf %s "checking which decoders to build... " >&6; }
# Check whether --enable-decoders was given.
if test ${enable_decoders+y}
@@ -3749,8 +3874,8 @@
enable_decoders=`echo "$enable_decoders" | sed 's/,/ /g'`
if test "x$enable_decoders" = xno || test "x$enable_decoders" = x; then
enable_decoders=no
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: (none)" >&5
-printf "%s\n" "(none)" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: (none)" >&5
+printf '%s\n' "(none)" >&6; }
else
for arg in $enable_decoders
do
@@ -3759,91 +3884,91 @@
enable_filter_lzma1=yes
enable_decoder_lzma1=yes
-printf "%s\n" "#define HAVE_DECODER_LZMA1 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_LZMA1 1" >>confdefs.h
;;
lzma2)
enable_filter_lzma2=yes
enable_decoder_lzma2=yes
-printf "%s\n" "#define HAVE_DECODER_LZMA2 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_LZMA2 1" >>confdefs.h
;;
delta)
enable_filter_delta=yes
enable_decoder_delta=yes
-printf "%s\n" "#define HAVE_DECODER_DELTA 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_DELTA 1" >>confdefs.h
;;
x86)
enable_filter_x86=yes
enable_decoder_x86=yes
-printf "%s\n" "#define HAVE_DECODER_X86 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_X86 1" >>confdefs.h
;;
powerpc)
enable_filter_powerpc=yes
enable_decoder_powerpc=yes
-printf "%s\n" "#define HAVE_DECODER_POWERPC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_POWERPC 1" >>confdefs.h
;;
ia64)
enable_filter_ia64=yes
enable_decoder_ia64=yes
-printf "%s\n" "#define HAVE_DECODER_IA64 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_IA64 1" >>confdefs.h
;;
arm)
enable_filter_arm=yes
enable_decoder_arm=yes
-printf "%s\n" "#define HAVE_DECODER_ARM 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_ARM 1" >>confdefs.h
;;
armthumb)
enable_filter_armthumb=yes
enable_decoder_armthumb=yes
-printf "%s\n" "#define HAVE_DECODER_ARMTHUMB 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_ARMTHUMB 1" >>confdefs.h
;;
arm64)
enable_filter_arm64=yes
enable_decoder_arm64=yes
-printf "%s\n" "#define HAVE_DECODER_ARM64 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_ARM64 1" >>confdefs.h
;;
sparc)
enable_filter_sparc=yes
enable_decoder_sparc=yes
-printf "%s\n" "#define HAVE_DECODER_SPARC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_SPARC 1" >>confdefs.h
;;
riscv)
enable_filter_riscv=yes
enable_decoder_riscv=yes
-printf "%s\n" "#define HAVE_DECODER_RISCV 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODER_RISCV 1" >>confdefs.h
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "unknown filter: $arg" "$LINENO" 5
;;
esac
done
-printf "%s\n" "#define HAVE_DECODERS 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DECODERS 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_decoders" >&5
-printf "%s\n" "$enable_decoders" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_decoders" >&5
+printf '%s\n' "$enable_decoders" >&6; }
fi
if test "x$enable_encoder_lzma2$enable_encoder_lzma1" = xyesno \
@@ -4235,7 +4360,7 @@
enable_match_finder_bt4=no
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which match finders to build" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking which match finders to build" >&5
printf %s "checking which match finders to build... " >&6; }
# Check whether --enable-match-finders was given.
if test ${enable_match_finders+y}
@@ -4258,45 +4383,45 @@
hc3)
enable_match_finder_hc3=yes
-printf "%s\n" "#define HAVE_MF_HC3 1" >>confdefs.h
+printf '%s\n' "#define HAVE_MF_HC3 1" >>confdefs.h
;;
hc4)
enable_match_finder_hc4=yes
-printf "%s\n" "#define HAVE_MF_HC4 1" >>confdefs.h
+printf '%s\n' "#define HAVE_MF_HC4 1" >>confdefs.h
;;
bt2)
enable_match_finder_bt2=yes
-printf "%s\n" "#define HAVE_MF_BT2 1" >>confdefs.h
+printf '%s\n' "#define HAVE_MF_BT2 1" >>confdefs.h
;;
bt3)
enable_match_finder_bt3=yes
-printf "%s\n" "#define HAVE_MF_BT3 1" >>confdefs.h
+printf '%s\n' "#define HAVE_MF_BT3 1" >>confdefs.h
;;
bt4)
enable_match_finder_bt4=yes
-printf "%s\n" "#define HAVE_MF_BT4 1" >>confdefs.h
+printf '%s\n' "#define HAVE_MF_BT4 1" >>confdefs.h
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "unknown match finder: $arg" "$LINENO" 5
;;
esac
done
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_match_finders" >&5
-printf "%s\n" "$enable_match_finders" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_match_finders" >&5
+printf '%s\n' "$enable_match_finders" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: (none because not building any LZ-based encoder)" >&5
-printf "%s\n" "(none because not building any LZ-based encoder)" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: (none because not building any LZ-based encoder)" >&5
+printf '%s\n' "(none because not building any LZ-based encoder)" >&6; }
fi
@@ -4310,7 +4435,7 @@
enable_check_crc64=no
enable_check_sha256=no
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which integrity checks to build" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking which integrity checks to build" >&5
printf %s "checking which integrity checks to build... " >&6; }
# Check whether --enable-checks was given.
if test ${enable_checks+y}
@@ -4323,8 +4448,8 @@
enable_checks=`echo "$enable_checks" | sed 's/,/ /g'`
if test "x$enable_checks" = xno || test "x$enable_checks" = x; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: (none)" >&5
-printf "%s\n" "(none)" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: (none)" >&5
+printf '%s\n' "(none)" >&6; }
else
for arg in $enable_checks
do
@@ -4332,30 +4457,30 @@
crc32)
enable_check_crc32=yes
-printf "%s\n" "#define HAVE_CHECK_CRC32 1" >>confdefs.h
+printf '%s\n' "#define HAVE_CHECK_CRC32 1" >>confdefs.h
;;
crc64)
enable_check_crc64=yes
-printf "%s\n" "#define HAVE_CHECK_CRC64 1" >>confdefs.h
+printf '%s\n' "#define HAVE_CHECK_CRC64 1" >>confdefs.h
;;
sha256)
enable_check_sha256=yes
-printf "%s\n" "#define HAVE_CHECK_SHA256 1" >>confdefs.h
+printf '%s\n' "#define HAVE_CHECK_SHA256 1" >>confdefs.h
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "unknown integrity check: $arg" "$LINENO" 5
;;
esac
done
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_checks" >&5
-printf "%s\n" "$enable_checks" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_checks" >&5
+printf '%s\n' "$enable_checks" >&6; }
fi
if test "x$enable_check_crc32" = xno ; then
as_fn_error $? "For now, the CRC32 check must always be enabled." "$LINENO" 5
@@ -4386,7 +4511,7 @@
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if external SHA-256 should be used" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if external SHA-256 should be used" >&5
printf %s "checking if external SHA-256 should be used... " >&6; }
# Check whether --enable-external-sha256 was given.
if test ${enable_external_sha256+y}
@@ -4401,11 +4526,11 @@
enable_external_sha256=no
fi
if test "x$enable_external_sha256" = xyes; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -4413,7 +4538,7 @@
# MicroLZMA #
#############
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if MicroLZMA support should be built" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if MicroLZMA support should be built" >&5
printf %s "checking if MicroLZMA support should be built... " >&6; }
# Check whether --enable-microlzma was given.
if test ${enable_microlzma+y}
@@ -4426,12 +4551,12 @@
case $enable_microlzma in
yes | no)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_microlzma" >&5
-printf "%s\n" "$enable_microlzma" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_microlzma" >&5
+printf '%s\n' "$enable_microlzma" >&6; }
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "--enable-microlzma accepts only 'yes' or 'no'." "$LINENO" 5
;;
esac
@@ -4449,7 +4574,7 @@
# .lz (lzip) format support #
#############################
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if .lz (lzip) decompression support should be built" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if .lz (lzip) decompression support should be built" >&5
printf %s "checking if .lz (lzip) decompression support should be built... " >&6; }
# Check whether --enable-lzip-decoder was given.
if test ${enable_lzip_decoder+y}
@@ -4462,17 +4587,17 @@
if test "x$enable_decoder_lzma1" != xyes; then
enable_lzip_decoder=no
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no because LZMA1 decoder is disabled" >&5
-printf "%s\n" "no because LZMA1 decoder is disabled" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no because LZMA1 decoder is disabled" >&5
+printf '%s\n' "no because LZMA1 decoder is disabled" >&6; }
elif test "x$enable_lzip_decoder" = xyes; then
-printf "%s\n" "#define HAVE_LZIP_DECODER 1" >>confdefs.h
+printf '%s\n' "#define HAVE_LZIP_DECODER 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$enable_lzip_decoder" = xyes; then
COND_LZIP_DECODER_TRUE=
@@ -4488,7 +4613,7 @@
# Assembler optimizations #
###########################
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if assembler optimizations should be used" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if assembler optimizations should be used" >&5
printf %s "checking if assembler optimizations should be used... " >&6; }
# Check whether --enable-assembler was given.
if test ${enable_assembler+y}
@@ -4504,7 +4629,7 @@
case $host_os in
# Darwin should work too but only if not creating universal
# binaries. Solaris x86 could work too but I cannot test.
- linux* | *bsd* | mingw* | cygwin | msys | *djgpp*)
+ linux* | gnu* | *bsd* | mingw* | cygwin | msys | *djgpp*)
case $host_cpu in
i?86) enable_assembler=x86 ;;
esac
@@ -4514,18 +4639,18 @@
case $enable_assembler in
x86)
-printf "%s\n" "#define HAVE_CRC_X86_ASM 1" >>confdefs.h
+printf '%s\n' "#define HAVE_CRC_X86_ASM 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: x86" >&5
-printf "%s\n" "x86" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: x86" >&5
+printf '%s\n' "x86" >&6; }
;;
no)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "--enable-assembler accepts only 'yes', 'no', or 'x86' (32-bit)." "$LINENO" 5
;;
esac
@@ -4588,7 +4713,7 @@
# Size optimization #
#####################
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if small size is preferred over speed" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if small size is preferred over speed" >&5
printf %s "checking if small size is preferred over speed... " >&6; }
# Check whether --enable-small was given.
if test ${enable_small+y}
@@ -4601,15 +4726,15 @@
if test "x$enable_small" = xyes; then
-printf "%s\n" "#define HAVE_SMALL 1" >>confdefs.h
+printf '%s\n' "#define HAVE_SMALL 1" >>confdefs.h
elif test "x$enable_small" != xno; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "--enable-small accepts only 'yes' or 'no'" "$LINENO" 5
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_small" >&5
-printf "%s\n" "$enable_small" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_small" >&5
+printf '%s\n' "$enable_small" >&6; }
if test "x$enable_small" = xyes; then
COND_SMALL_TRUE=
COND_SMALL_FALSE='#'
@@ -4624,7 +4749,7 @@
# Threading #
#############
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if threading support is wanted" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if threading support is wanted" >&5
printf %s "checking if threading support is wanted... " >&6; }
# Check whether --enable-threads was given.
if test ${enable_threads+y}
@@ -4652,16 +4777,16 @@
case $enable_threads in
posix | win95 | vista)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes, $enable_threads" >&5
-printf "%s\n" "yes, $enable_threads" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes, $enable_threads" >&5
+printf '%s\n' "yes, $enable_threads" >&6; }
;;
no)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "--enable-threads only accepts 'yes', 'no', 'posix', 'win95', or 'vista'" "$LINENO" 5
;;
esac
@@ -4677,7 +4802,7 @@
# created with "xz -9". It would be slightly safer to guess a lower value,
# but most systems, on which we don't have any way to determine the amount
# of RAM, will probably have at least 128 MiB of RAM.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how much RAM to assume if the real amount is unknown" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how much RAM to assume if the real amount is unknown" >&5
printf %s "checking how much RAM to assume if the real amount is unknown... " >&6; }
# Check whether --enable-assume-ram was given.
if test ${enable_assume_ram+y}
@@ -4690,14 +4815,14 @@
assume_ram_check=`echo "$enable_assume_ram" | tr -d 0123456789`
if test -z "$enable_assume_ram" || test -n "$assume_ram_check"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "--enable-assume-ram accepts only an integer argument" "$LINENO" 5
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_assume_ram MiB" >&5
-printf "%s\n" "$enable_assume_ram MiB" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_assume_ram MiB" >&5
+printf '%s\n' "$enable_assume_ram MiB" >&6; }
-printf "%s\n" "#define ASSUME_RAM $enable_assume_ram" >>confdefs.h
+printf '%s\n' "#define ASSUME_RAM $enable_assume_ram" >>confdefs.h
@@ -4857,7 +4982,7 @@
# Sandboxing #
##############
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if sandboxing should be used" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if sandboxing should be used" >&5
printf %s "checking if sandboxing should be used... " >&6; }
# Check whether --enable-sandbox was given.
if test ${enable_sandbox+y}
@@ -4871,20 +4996,20 @@
case $enable_xzdec-$enable_xz-$enable_sandbox in
no-no-*)
enable_sandbox=no
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, --disable-xz and --disable-xzdec was used" >&5
-printf "%s\n" "no, --disable-xz and --disable-xzdec was used" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no, --disable-xz and --disable-xzdec was used" >&5
+printf '%s\n' "no, --disable-xz and --disable-xzdec was used" >&6; }
;;
*-*-auto)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: maybe (autodetect)" >&5
-printf "%s\n" "maybe (autodetect)" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: maybe (autodetect)" >&5
+printf '%s\n' "maybe (autodetect)" >&6; }
;;
*-*-no | *-*-capsicum | *-*-pledge | *-*-landlock)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_sandbox" >&5
-printf "%s\n" "$enable_sandbox" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_sandbox" >&5
+printf '%s\n' "$enable_sandbox" >&6; }
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "--enable-sandbox only accepts 'auto', 'no', 'capsicum', 'pledge', or 'landlock'." "$LINENO" 5
;;
esac
@@ -4934,7 +5059,7 @@
;;
esac
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a shell that conforms to POSIX" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a shell that conforms to POSIX" >&5
printf %s "checking for a shell that conforms to POSIX... " >&6; }
if test ${gl_cv_posix_shell+y}
then :
@@ -4977,8 +5102,8 @@
done ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_posix_shell" >&5
-printf "%s\n" "$gl_cv_posix_shell" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_posix_shell" >&5
+printf '%s\n' "$gl_cv_posix_shell" >&6; }
if test "$gl_cv_posix_shell" != no; then
POSIX_SHELL=$gl_cv_posix_shell
@@ -5002,7 +5127,7 @@
# https://debbugs.gnu.org/cgi/bugreport.cgi?bug=17354
# The -Wno-unsupported is used to silence warnings about missing
# "subdir-objects".
-am__api_version='1.17'
+am__api_version='1.18'
# Find a good install program. We prefer a C program (faster),
@@ -5019,7 +5144,7 @@
# OS/2's system install, which has a completely different semantic
# ./install, which can be erroneously created by make from ./install.sh.
# Reject install programs that cannot install multiple files.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
printf %s "checking for a BSD-compatible install... " >&6; }
if test -z "$INSTALL"; then
if test ${ac_cv_path_install+y}
@@ -5042,8 +5167,8 @@
?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
/usr/ucb/* ) ;;
*)
- # OSF1 and SCO ODT 3.0 have their own names for install.
- # Don't use installbsd from OSF since it installs stuff as root
+ # OSF/1 and SCO ODT 3.0 have their own names for install.
+ # Don't use installbsd from OSF/1 since it installs stuff as root
# by default.
for ac_prog in ginstall scoinst install; do
for ac_exec_ext in '' $ac_executable_extensions; do
@@ -5093,8 +5218,8 @@
INSTALL=$ac_install_sh
fi
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
-printf "%s\n" "$INSTALL" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
+printf '%s\n' "$INSTALL" >&6; }
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
# It thinks the first close brace ends the variable substitution.
@@ -5104,7 +5229,7 @@
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether sleep supports fractional seconds" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether sleep supports fractional seconds" >&5
printf %s "checking whether sleep supports fractional seconds... " >&6; }
if test ${am_cv_sleep_fractional_seconds+y}
then :
@@ -5120,10 +5245,10 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_sleep_fractional_seconds" >&5
-printf "%s\n" "$am_cv_sleep_fractional_seconds" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_sleep_fractional_seconds" >&5
+printf '%s\n' "$am_cv_sleep_fractional_seconds" >&6; }
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking filesystem timestamp resolution" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking filesystem timestamp resolution" >&5
printf %s "checking filesystem timestamp resolution... " >&6; }
if test ${am_cv_filesystem_timestamp_resolution+y}
then :
@@ -5175,9 +5300,9 @@
# if, for instance, CONFIG_SHELL is bash and it inherits a
# broken ls alias from the environment. This has actually
# happened. Such a system could not be considered "sane".
- printf "%s\n" ""Bad output from ls -t: \"`ls -t conftest.ts[12]`\""" >&5
- { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ printf '%s\n' ""Bad output from ls -t: \"`ls -t conftest.ts[12]`\""" >&5
+ { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error $? "ls -t produces unexpected output.
Make sure there is not a broken ls alias in your environment.
See 'config.log' for more details" "$LINENO" 5; }
@@ -5258,12 +5383,12 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_filesystem_timestamp_resolution" >&5
-printf "%s\n" "$am_cv_filesystem_timestamp_resolution" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_filesystem_timestamp_resolution" >&5
+printf '%s\n' "$am_cv_filesystem_timestamp_resolution" >&6; }
# This check should not be cached, as it may vary across builds of
# different projects.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
printf %s "checking whether build environment is sane... " >&6; }
# Reject unsafe characters in $srcdir or the absolute working directory
# name. Accept space and tab only in the latter.
@@ -5271,10 +5396,14 @@
'
case `pwd` in
*[\\\"\#\$\&\'\`$am_lf]*)
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
esac
case $srcdir in
*[\\\"\#\$\&\'\`$am_lf\ \ ]*)
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
esac
@@ -5304,8 +5433,8 @@
am_has_slept=yes
done
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_build_env_is_sane" >&5
-printf "%s\n" "$am_build_env_is_sane" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_build_env_is_sane" >&5
+printf '%s\n' "$am_build_env_is_sane" >&6; }
if test "$am_build_env_is_sane" = no; then
as_fn_error $? "newly created file is older than distributed files!
Check your system clock" "$LINENO" 5
@@ -5334,7 +5463,7 @@
# Double any \ or $.
# By default was 's,x,x', remove it if useless.
ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
-program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"`
+program_transform_name=`printf '%s\n' "$program_transform_name" | sed "$ac_script"`
# Expand $ac_aux_dir to an absolute path.
@@ -5349,8 +5478,8 @@
am_missing_run="$MISSING "
else
am_missing_run=
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
-printf "%s\n" "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
+printf '%s\n' "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
fi
if test x"${install_sh+set}" != xset; then
@@ -5370,7 +5499,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_STRIP+y}
then :
@@ -5391,7 +5520,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_STRIP="${ac_tool_prefix}strip"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -5403,11 +5532,11 @@
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-printf "%s\n" "$STRIP" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+printf '%s\n' "$STRIP" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -5416,7 +5545,7 @@
ac_ct_STRIP=$STRIP
# Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_STRIP+y}
then :
@@ -5437,7 +5566,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_STRIP="strip"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -5449,11 +5578,11 @@
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
-printf "%s\n" "$ac_ct_STRIP" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+printf '%s\n' "$ac_ct_STRIP" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_STRIP" = x; then
@@ -5461,8 +5590,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
STRIP=$ac_ct_STRIP
@@ -5475,7 +5604,7 @@
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a race-free mkdir -p" >&5
printf %s "checking for a race-free mkdir -p... " >&6; }
if test -z "$MKDIR_P"; then
if test ${ac_cv_path_mkdir+y}
@@ -5518,14 +5647,14 @@
MKDIR_P='mkdir -p'
fi
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
-printf "%s\n" "$MKDIR_P" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
+printf '%s\n' "$MKDIR_P" >&6; }
-for ac_prog in gawk mawk nawk awk
+for ac_prog in gawk mawk nawk awk 'busybox awk'
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_AWK+y}
then :
@@ -5546,7 +5675,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_AWK="$ac_prog"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -5558,21 +5687,21 @@
fi
AWK=$ac_cv_prog_AWK
if test -n "$AWK"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
-printf "%s\n" "$AWK" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+printf '%s\n' "$AWK" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
test -n "$AWK" && break
done
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
printf %s "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
set x ${MAKE-make}
-ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
+ac_make=`printf '%s\n' "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
if eval test \${ac_cv_prog_make_${ac_make}_set+y}
then :
printf %s "(cached) " >&6
@@ -5580,7 +5709,7 @@
e) cat >conftest.make <<\_ACEOF
SHELL = /bin/sh
all:
- @echo '@@@%%%=$(MAKE)=@@@%%%'
+ @printf '%s\n' '@@@%%%=$(MAKE)=@@@%%%'
_ACEOF
# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
case `${MAKE-make} -f conftest.make 2>/dev/null` in
@@ -5593,12 +5722,12 @@
esac
fi
if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
SET_MAKE=
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
SET_MAKE="MAKE=${MAKE-make}"
fi
@@ -5619,13 +5748,13 @@
fi
am_make=${MAKE-make}
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
printf %s "checking whether $am_make supports nested variables... " >&6; }
if test ${am_cv_make_support_nested_variables+y}
then :
printf %s "(cached) " >&6
else case e in #(
- e) if printf "%s\n" 'TRUE=$(BAR$(V))
+ e) if printf '%s\n' 'TRUE=$(BAR$(V))
BAR0=false
BAR1=true
V=1
@@ -5638,8 +5767,8 @@
fi ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
-printf "%s\n" "$am_cv_make_support_nested_variables" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
+printf '%s\n' "$am_cv_make_support_nested_variables" >&6; }
AM_BACKSLASH='\'
am__rm_f_notfound=
@@ -5652,7 +5781,7 @@
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking xargs -n works" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking xargs -n works" >&5
printf %s "checking xargs -n works... " >&6; }
if test ${am_cv_xargs_n_works+y}
then :
@@ -5668,8 +5797,8 @@
fi ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_xargs_n_works" >&5
-printf "%s\n" "$am_cv_xargs_n_works" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_xargs_n_works" >&5
+printf '%s\n' "$am_cv_xargs_n_works" >&6; }
if test "$am_cv_xargs_n_works" = yes
then :
am__xargs_n='xargs -n'
@@ -5701,13 +5830,13 @@
# Define the identity of the package.
PACKAGE='xz'
- VERSION='5.8.1'
+ VERSION='5.8.3'
-printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h
+printf '%s\n' "#define PACKAGE \"$PACKAGE\"" >>confdefs.h
-printf "%s\n" "#define VERSION \"$VERSION\"" >>confdefs.h
+printf '%s\n' "#define VERSION \"$VERSION\"" >>confdefs.h
# Some tools Automake needs.
@@ -5766,15 +5895,15 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
printf %s "checking whether ln -s works... " >&6; }
LN_S=$as_ln_s
if test "$LN_S" = "ln -s"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
-printf "%s\n" "no, using $LN_S" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
+printf '%s\n' "no, using $LN_S" >&6; }
fi
@@ -5787,11 +5916,14 @@
+
+
+
DEPDIR="${am__leading_dot}deps"
ac_config_commands="$ac_config_commands depfiles"
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
printf %s "checking whether ${MAKE-make} supports the include directive... " >&6; }
cat > confinc.mk << 'END'
am__doit:
@@ -5828,8 +5960,8 @@
fi
done
rm -f confinc.* confmf.*
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
-printf "%s\n" "${_am_result}" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
+printf '%s\n' "${_am_result}" >&6; }
# Check whether --enable-dependency-tracking was given.
if test ${enable_dependency_tracking+y}
@@ -5859,7 +5991,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
set dummy ${ac_tool_prefix}gcc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
@@ -5880,7 +6012,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}gcc"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -5892,11 +6024,11 @@
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf '%s\n' "$CC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -5905,7 +6037,7 @@
ac_ct_CC=$CC
# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_CC+y}
then :
@@ -5926,7 +6058,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="gcc"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -5938,11 +6070,11 @@
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-printf "%s\n" "$ac_ct_CC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+printf '%s\n' "$ac_ct_CC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_CC" = x; then
@@ -5950,8 +6082,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
@@ -5964,7 +6096,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
set dummy ${ac_tool_prefix}cc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
@@ -5985,7 +6117,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}cc"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -5997,11 +6129,11 @@
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf '%s\n' "$CC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -6010,7 +6142,7 @@
if test -z "$CC"; then
# Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
@@ -6036,7 +6168,7 @@
continue
fi
ac_cv_prog_CC="cc"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -6060,11 +6192,11 @@
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf '%s\n' "$CC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -6075,7 +6207,7 @@
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
@@ -6096,7 +6228,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -6108,11 +6240,11 @@
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf '%s\n' "$CC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -6125,7 +6257,7 @@
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_CC+y}
then :
@@ -6146,7 +6278,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="$ac_prog"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -6158,11 +6290,11 @@
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-printf "%s\n" "$ac_ct_CC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+printf '%s\n' "$ac_ct_CC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -6174,8 +6306,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
@@ -6187,7 +6319,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}clang", so it can be a program name with args.
set dummy ${ac_tool_prefix}clang; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_CC+y}
then :
@@ -6208,7 +6340,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}clang"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -6220,11 +6352,11 @@
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-printf "%s\n" "$CC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+printf '%s\n' "$CC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -6233,7 +6365,7 @@
ac_ct_CC=$CC
# Extract the first word of "clang", so it can be a program name with args.
set dummy clang; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_CC+y}
then :
@@ -6254,7 +6386,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="clang"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -6266,11 +6398,11 @@
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-printf "%s\n" "$ac_ct_CC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+printf '%s\n' "$ac_ct_CC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_CC" = x; then
@@ -6278,8 +6410,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
@@ -6291,13 +6423,13 @@
fi
-test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+test -z "$CC" && { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error $? "no acceptable C compiler found in \$PATH
See 'config.log' for more details" "$LINENO" 5; }
# Provide some information about the compiler.
-printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion -version; do
@@ -6307,7 +6439,7 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_compiler $ac_option >&5") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
@@ -6317,7 +6449,7 @@
cat conftest.er1 >&5
fi
rm -f conftest.er1 conftest.err
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
done
@@ -6337,9 +6469,9 @@
# Try to create an executable without -o first, disregard a.out.
# It will help us diagnose broken compilers, and finding out an intuition
# of exeext.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
printf %s "checking whether the C compiler works... " >&6; }
-ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+ac_link_default=`printf '%s\n' "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
# The possible output files:
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
@@ -6360,10 +6492,10 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_link_default") 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
then :
# Autoconf-2.13 could set the ac_cv_exeext variable to 'no'.
@@ -6404,29 +6536,29 @@
fi
if test -z "$ac_file"
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
-printf "%s\n" "$as_me: failed program was:" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
+printf '%s\n' "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
-{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+{ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error 77 "C compiler cannot create executables
See 'config.log' for more details" "$LINENO" 5; }
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; } ;;
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; } ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
printf %s "checking for C compiler default output file name... " >&6; }
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
-printf "%s\n" "$ac_file" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+printf '%s\n' "$ac_file" >&6; }
ac_exeext=$ac_cv_exeext
rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
ac_clean_files=$ac_clean_files_save
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
printf %s "checking for suffix of executables... " >&6; }
if { { ac_try="$ac_link"
case "(($ac_try" in
@@ -6434,10 +6566,10 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
then :
# If both 'conftest.exe' and 'conftest' are 'present' (well, observable)
@@ -6454,15 +6586,15 @@
esac
done
else case e in #(
- e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ e) { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of executables: cannot compile and link
See 'config.log' for more details" "$LINENO" 5; } ;;
esac
fi
rm -f conftest conftest$ac_cv_exeext
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
-printf "%s\n" "$ac_cv_exeext" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+printf '%s\n' "$ac_cv_exeext" >&6; }
rm -f conftest.$ac_ext
EXEEXT=$ac_cv_exeext
@@ -6485,7 +6617,7 @@
ac_clean_files="$ac_clean_files conftest.out"
# Check that the compiler produces executables we can run. If not, either
# the compiler is broken, or we cross compile.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
printf %s "checking whether we are cross compiling... " >&6; }
if test "$cross_compiling" != yes; then
{ { ac_try="$ac_link"
@@ -6494,10 +6626,10 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
if { ac_try='./conftest$ac_cv_exeext'
{ { case "(($ac_try" in
@@ -6505,31 +6637,31 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; }; then
cross_compiling=no
else
if test "$cross_compiling" = maybe; then
cross_compiling=yes
else
- { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error 77 "cannot run C compiled programs.
If you meant to cross compile, use '--host'.
See 'config.log' for more details" "$LINENO" 5; }
fi
fi
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
-printf "%s\n" "$cross_compiling" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+printf '%s\n' "$cross_compiling" >&6; }
rm -f conftest.$ac_ext conftest$ac_cv_exeext \
conftest.o conftest.obj conftest.out
ac_clean_files=$ac_clean_files_save
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
printf %s "checking for suffix of object files... " >&6; }
if test ${ac_cv_objext+y}
then :
@@ -6553,10 +6685,10 @@
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-printf "%s\n" "$ac_try_echo"; } >&5
+printf '%s\n' "$ac_try_echo"; } >&5
(eval "$ac_compile") 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
then :
for ac_file in conftest.o conftest.obj conftest.*; do
@@ -6568,11 +6700,11 @@
esac
done
else case e in #(
- e) printf "%s\n" "$as_me: failed program was:" >&5
+ e) printf '%s\n' "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
-{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+{ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of object files: cannot compile
See 'config.log' for more details" "$LINENO" 5; } ;;
esac
@@ -6580,11 +6712,11 @@
rm -f conftest.$ac_cv_objext conftest.$ac_ext ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
-printf "%s\n" "$ac_cv_objext" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+printf '%s\n' "$ac_cv_objext" >&6; }
OBJEXT=$ac_cv_objext
ac_objext=$OBJEXT
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5
printf %s "checking whether the compiler supports GNU C... " >&6; }
if test ${ac_cv_c_compiler_gnu+y}
then :
@@ -6616,8 +6748,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
-printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+printf '%s\n' "$ac_cv_c_compiler_gnu" >&6; }
ac_compiler_gnu=$ac_cv_c_compiler_gnu
if test $ac_compiler_gnu = yes; then
@@ -6627,7 +6759,7 @@
fi
ac_test_CFLAGS=${CFLAGS+y}
ac_save_CFLAGS=$CFLAGS
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
printf %s "checking whether $CC accepts -g... " >&6; }
if test ${ac_cv_prog_cc_g+y}
then :
@@ -6695,8 +6827,8 @@
ac_c_werror_flag=$ac_save_c_werror_flag ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
-printf "%s\n" "$ac_cv_prog_cc_g" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+printf '%s\n' "$ac_cv_prog_cc_g" >&6; }
if test $ac_test_CFLAGS; then
CFLAGS=$ac_save_CFLAGS
elif test $ac_cv_prog_cc_g = yes; then
@@ -6715,7 +6847,56 @@
ac_prog_cc_stdc=no
if test x$ac_prog_cc_stdc = xno
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C23 features" >&5
+printf %s "checking for $CC option to enable C23 features... " >&6; }
+if test ${ac_cv_prog_cc_c23+y}
+then :
+ printf %s "(cached) " >&6
+else case e in #(
+ e) ac_cv_prog_cc_c23=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+$ac_c_conftest_c23_program
+_ACEOF
+for ac_arg in '' -std=gnu23
+do
+ CC="$ac_save_CC $ac_arg"
+ if ac_fn_c_try_compile "$LINENO"
+then :
+ ac_cv_prog_cc_c23=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam
+ test "x$ac_cv_prog_cc_c23" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC ;;
+esac
+fi
+
+if test "x$ac_cv_prog_cc_c23" = xno
+then :
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+printf '%s\n' "unsupported" >&6; }
+else case e in #(
+ e) if test "x$ac_cv_prog_cc_c23" = x
+then :
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+printf '%s\n' "none needed" >&6; }
+else case e in #(
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c23" >&5
+printf '%s\n' "$ac_cv_prog_cc_c23" >&6; }
+ CC="$CC $ac_cv_prog_cc_c23" ;;
+esac
+fi
+ ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c23
+ ac_prog_cc_stdc=c23 ;;
+esac
+fi
+fi
+if test x$ac_prog_cc_stdc = xno
+then :
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5
printf %s "checking for $CC option to enable C11 features... " >&6; }
if test ${ac_cv_prog_cc_c11+y}
then :
@@ -6727,7 +6908,7 @@
/* end confdefs.h. */
$ac_c_conftest_c11_program
_ACEOF
-for ac_arg in '' -std=gnu11
+for ac_arg in '' -std=gnu11 -std:c11
do
CC="$ac_save_CC $ac_arg"
if ac_fn_c_try_compile "$LINENO"
@@ -6744,16 +6925,16 @@
if test "x$ac_cv_prog_cc_c11" = xno
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+printf '%s\n' "unsupported" >&6; }
else case e in #(
e) if test "x$ac_cv_prog_cc_c11" = x
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+printf '%s\n' "none needed" >&6; }
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
-printf "%s\n" "$ac_cv_prog_cc_c11" >&6; }
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
+printf '%s\n' "$ac_cv_prog_cc_c11" >&6; }
CC="$CC $ac_cv_prog_cc_c11" ;;
esac
fi
@@ -6764,7 +6945,7 @@
fi
if test x$ac_prog_cc_stdc = xno
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5
printf %s "checking for $CC option to enable C99 features... " >&6; }
if test ${ac_cv_prog_cc_c99+y}
then :
@@ -6793,16 +6974,16 @@
if test "x$ac_cv_prog_cc_c99" = xno
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+printf '%s\n' "unsupported" >&6; }
else case e in #(
e) if test "x$ac_cv_prog_cc_c99" = x
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+printf '%s\n' "none needed" >&6; }
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
-printf "%s\n" "$ac_cv_prog_cc_c99" >&6; }
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
+printf '%s\n' "$ac_cv_prog_cc_c99" >&6; }
CC="$CC $ac_cv_prog_cc_c99" ;;
esac
fi
@@ -6813,7 +6994,7 @@
fi
if test x$ac_prog_cc_stdc = xno
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5
printf %s "checking for $CC option to enable C89 features... " >&6; }
if test ${ac_cv_prog_cc_c89+y}
then :
@@ -6842,16 +7023,16 @@
if test "x$ac_cv_prog_cc_c89" = xno
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-printf "%s\n" "unsupported" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+printf '%s\n' "unsupported" >&6; }
else case e in #(
e) if test "x$ac_cv_prog_cc_c89" = x
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-printf "%s\n" "none needed" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+printf '%s\n' "none needed" >&6; }
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
-printf "%s\n" "$ac_cv_prog_cc_c89" >&6; }
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+printf '%s\n' "$ac_cv_prog_cc_c89" >&6; }
CC="$CC $ac_cv_prog_cc_c89" ;;
esac
fi
@@ -6873,7 +7054,7 @@
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
printf %s "checking whether $CC understands -c and -o together... " >&6; }
if test ${am_cv_prog_cc_c_o+y}
then :
@@ -6908,12 +7089,15 @@
break
fi
done
- rm -f core conftest*
+ # aligned with autoconf, so not including core; see bug#72225.
+ rm -f -r a.out a.exe b.out conftest.$ac_ext conftest.$ac_objext \
+ conftest.dSYM conftest1.$ac_ext conftest1.$ac_objext conftest1.dSYM \
+ conftest2.$ac_ext conftest2.$ac_objext conftest2.dSYM
unset am_i ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
-printf "%s\n" "$am_cv_prog_cc_c_o" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
+printf '%s\n' "$am_cv_prog_cc_c_o" >&6; }
if test "$am_cv_prog_cc_c_o" != yes; then
# Losing compiler, so override with the script.
# FIXME: It is wrong to rewrite CC.
@@ -6931,7 +7115,7 @@
depcc="$CC" am_compiler_list=
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
printf %s "checking dependency style of $depcc... " >&6; }
if test ${am_cv_CC_dependencies_compiler_type+y}
then :
@@ -7044,8 +7228,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
-printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
+printf '%s\n' "$am_cv_CC_dependencies_compiler_type" >&6; }
CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
if
@@ -7074,7 +7258,7 @@
depcc="$CCAS" am_compiler_list=
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
printf %s "checking dependency style of $depcc... " >&6; }
if test ${am_cv_CCAS_dependencies_compiler_type+y}
then :
@@ -7185,8 +7369,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CCAS_dependencies_compiler_type" >&5
-printf "%s\n" "$am_cv_CCAS_dependencies_compiler_type" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_CCAS_dependencies_compiler_type" >&5
+printf '%s\n' "$am_cv_CCAS_dependencies_compiler_type" >&6; }
CCASDEPMODE=depmode=$am_cv_CCAS_dependencies_compiler_type
if
@@ -7207,7 +7391,7 @@
if test $ac_cache; then
ac_fn_c_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default"
if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then
- printf "%s\n" "#define $ac_item 1" >> confdefs.h
+ printf '%s\n' "#define $ac_item 1" >> confdefs.h
fi
ac_header= ac_cache=
elif test $ac_header; then
@@ -7227,7 +7411,7 @@
if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes
then :
-printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h
+printf '%s\n' "#define STDC_HEADERS 1" >>confdefs.h
fi
@@ -7236,7 +7420,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether it is safe to define __EXTENSIONS__" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether it is safe to define __EXTENSIONS__" >&5
printf %s "checking whether it is safe to define __EXTENSIONS__... " >&6; }
if test ${ac_cv_safe_to_define___extensions__+y}
then :
@@ -7265,10 +7449,10 @@
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_safe_to_define___extensions__" >&5
-printf "%s\n" "$ac_cv_safe_to_define___extensions__" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_safe_to_define___extensions__" >&5
+printf '%s\n' "$ac_cv_safe_to_define___extensions__" >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether _XOPEN_SOURCE should be defined" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether _XOPEN_SOURCE should be defined" >&5
printf %s "checking whether _XOPEN_SOURCE should be defined... " >&6; }
if test ${ac_cv_should_define__xopen_source+y}
then :
@@ -7319,49 +7503,51 @@
fi ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_should_define__xopen_source" >&5
-printf "%s\n" "$ac_cv_should_define__xopen_source" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_should_define__xopen_source" >&5
+printf '%s\n' "$ac_cv_should_define__xopen_source" >&6; }
- printf "%s\n" "#define _ALL_SOURCE 1" >>confdefs.h
+ printf '%s\n' "#define _ALL_SOURCE 1" >>confdefs.h
- printf "%s\n" "#define _DARWIN_C_SOURCE 1" >>confdefs.h
+ printf '%s\n' "#define _COSMO_SOURCE 1" >>confdefs.h
- printf "%s\n" "#define _GNU_SOURCE 1" >>confdefs.h
+ printf '%s\n' "#define _DARWIN_C_SOURCE 1" >>confdefs.h
- printf "%s\n" "#define _HPUX_ALT_XOPEN_SOCKET_API 1" >>confdefs.h
+ printf '%s\n' "#define _GNU_SOURCE 1" >>confdefs.h
- printf "%s\n" "#define _NETBSD_SOURCE 1" >>confdefs.h
+ printf '%s\n' "#define _HPUX_ALT_XOPEN_SOCKET_API 1" >>confdefs.h
- printf "%s\n" "#define _OPENBSD_SOURCE 1" >>confdefs.h
+ printf '%s\n' "#define _NETBSD_SOURCE 1" >>confdefs.h
- printf "%s\n" "#define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h
+ printf '%s\n' "#define _OPENBSD_SOURCE 1" >>confdefs.h
- printf "%s\n" "#define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1" >>confdefs.h
+ printf '%s\n' "#define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h
- printf "%s\n" "#define __STDC_WANT_IEC_60559_BFP_EXT__ 1" >>confdefs.h
+ printf '%s\n' "#define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1" >>confdefs.h
- printf "%s\n" "#define __STDC_WANT_IEC_60559_DFP_EXT__ 1" >>confdefs.h
+ printf '%s\n' "#define __STDC_WANT_IEC_60559_BFP_EXT__ 1" >>confdefs.h
- printf "%s\n" "#define __STDC_WANT_IEC_60559_EXT__ 1" >>confdefs.h
+ printf '%s\n' "#define __STDC_WANT_IEC_60559_DFP_EXT__ 1" >>confdefs.h
- printf "%s\n" "#define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1" >>confdefs.h
+ printf '%s\n' "#define __STDC_WANT_IEC_60559_EXT__ 1" >>confdefs.h
- printf "%s\n" "#define __STDC_WANT_IEC_60559_TYPES_EXT__ 1" >>confdefs.h
+ printf '%s\n' "#define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1" >>confdefs.h
- printf "%s\n" "#define __STDC_WANT_LIB_EXT2__ 1" >>confdefs.h
+ printf '%s\n' "#define __STDC_WANT_IEC_60559_TYPES_EXT__ 1" >>confdefs.h
- printf "%s\n" "#define __STDC_WANT_MATH_SPEC_FUNCS__ 1" >>confdefs.h
+ printf '%s\n' "#define __STDC_WANT_LIB_EXT2__ 1" >>confdefs.h
- printf "%s\n" "#define _TANDEM_SOURCE 1" >>confdefs.h
+ printf '%s\n' "#define __STDC_WANT_MATH_SPEC_FUNCS__ 1" >>confdefs.h
+
+ printf '%s\n' "#define _TANDEM_SOURCE 1" >>confdefs.h
if test $ac_cv_header_minix_config_h = yes
then :
MINIX=yes
- printf "%s\n" "#define _MINIX 1" >>confdefs.h
+ printf '%s\n' "#define _MINIX 1" >>confdefs.h
- printf "%s\n" "#define _POSIX_SOURCE 1" >>confdefs.h
+ printf '%s\n' "#define _POSIX_SOURCE 1" >>confdefs.h
- printf "%s\n" "#define _POSIX_1_SOURCE 2" >>confdefs.h
+ printf '%s\n' "#define _POSIX_1_SOURCE 2" >>confdefs.h
else case e in #(
e) MINIX= ;;
@@ -7369,12 +7555,12 @@
fi
if test $ac_cv_safe_to_define___extensions__ = yes
then :
- printf "%s\n" "#define __EXTENSIONS__ 1" >>confdefs.h
+ printf '%s\n' "#define __EXTENSIONS__ 1" >>confdefs.h
fi
if test $ac_cv_should_define__xopen_source = yes
then :
- printf "%s\n" "#define _XOPEN_SOURCE 500" >>confdefs.h
+ printf '%s\n' "#define _XOPEN_SOURCE 500" >>confdefs.h
fi
@@ -7384,7 +7570,7 @@
# the above check for system extensions. It adds macros that can trigger,
# for example, -Wunused-macros.
if test "$GCC" = yes && test "x$SKIP_WERROR_CHECK" != xyes ; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the -Werror option is usable" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if the -Werror option is usable" >&5
printf %s "checking if the -Werror option is usable... " >&6; }
OLD_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS -Werror"
@@ -7395,13 +7581,13 @@
if ac_fn_c_try_compile "$LINENO"
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
e)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
as_fn_error $? "
CFLAGS contains something that makes -Werror complain (see config.log).
This would break certain checks in 'configure'. It is strongly
@@ -7419,7 +7605,7 @@
CFLAGS=$OLD_CFLAGS
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
printf %s "checking for a sed that does not truncate output... " >&6; }
if test ${ac_cv_path_SED+y}
then :
@@ -7462,7 +7648,7 @@
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
- printf "%s\n" '' >> "conftest.nl"
+ printf '%s\n' '' >> "conftest.nl"
"$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
@@ -7491,8 +7677,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
-printf "%s\n" "$ac_cv_path_SED" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+printf '%s\n' "$ac_cv_path_SED" >&6; }
SED="$ac_cv_path_SED"
rm -f conftest.sed
@@ -7501,7 +7687,7 @@
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
printf %s "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
@@ -7572,8 +7758,8 @@
else
ac_cv_prog_CPP=$CPP
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
-printf "%s\n" "$CPP" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+printf '%s\n' "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
@@ -7621,8 +7807,8 @@
then :
else case e in #(
- e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ e) { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
See 'config.log' for more details" "$LINENO" 5; } ;;
esac
@@ -7635,7 +7821,7 @@
ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep -e" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for egrep -e" >&5
printf %s "checking for egrep -e... " >&6; }
if test ${ac_cv_path_EGREP_TRADITIONAL+y}
then :
@@ -7672,7 +7858,7 @@
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
- printf "%s\n" 'EGREP_TRADITIONAL' >> "conftest.nl"
+ printf '%s\n' 'EGREP_TRADITIONAL' >> "conftest.nl"
"$ac_path_EGREP_TRADITIONAL" -E 'EGR(EP|AC)_TRADITIONAL$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
@@ -7734,7 +7920,7 @@
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
- printf "%s\n" 'EGREP_TRADITIONAL' >> "conftest.nl"
+ printf '%s\n' 'EGREP_TRADITIONAL' >> "conftest.nl"
"$ac_path_EGREP_TRADITIONAL" 'EGR(EP|AC)_TRADITIONAL$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
@@ -7765,8 +7951,8 @@
fi ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP_TRADITIONAL" >&5
-printf "%s\n" "$ac_cv_path_EGREP_TRADITIONAL" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP_TRADITIONAL" >&5
+printf '%s\n' "$ac_cv_path_EGREP_TRADITIONAL" >&6; }
EGREP_TRADITIONAL=$ac_cv_path_EGREP_TRADITIONAL
case $enable_threads in #(
@@ -7807,7 +7993,7 @@
fi
CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
LIBS="$PTHREAD_LIBS $LIBS"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS" >&5
printf %s "checking for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
@@ -7836,8 +8022,8 @@
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_pthread_ok" >&5
-printf "%s\n" "$ax_pthread_ok" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ax_pthread_ok" >&5
+printf '%s\n' "$ax_pthread_ok" >&6; }
if test "x$ax_pthread_ok" = "xno"; then
PTHREAD_LIBS=""
PTHREAD_CFLAGS=""
@@ -7917,8 +8103,8 @@
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP_TRADITIONAL "AX_PTHREAD_ZOS_MISSING" >/dev/null 2>&1
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support." >&5
-printf "%s\n" "$as_me: WARNING: IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support." >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support." >&5
+printf '%s\n' "$as_me: WARNING: IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support." >&2;}
fi
rm -rf conftest*
@@ -7940,7 +8126,7 @@
# Are we compiling with Clang?
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC is Clang" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether $CC is Clang" >&5
printf %s "checking whether $CC is Clang... " >&6; }
if test ${ax_cv_PTHREAD_CLANG+y}
then :
@@ -7968,8 +8154,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_CLANG" >&5
-printf "%s\n" "$ax_cv_PTHREAD_CLANG" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_CLANG" >&5
+printf '%s\n' "$ax_cv_PTHREAD_CLANG" >&6; }
ax_pthread_clang="$ax_cv_PTHREAD_CLANG"
@@ -8027,19 +8213,19 @@
case $ax_pthread_try_flag in
none)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether pthreads work without any flags" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether pthreads work without any flags" >&5
printf %s "checking whether pthreads work without any flags... " >&6; }
;;
*,*)
PTHREAD_CFLAGS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\1/"`
PTHREAD_LIBS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\2/"`
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether pthreads work with \"$PTHREAD_CFLAGS\" and \"$PTHREAD_LIBS\"" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether pthreads work with \"$PTHREAD_CFLAGS\" and \"$PTHREAD_LIBS\"" >&5
printf %s "checking whether pthreads work with \"$PTHREAD_CFLAGS\" and \"$PTHREAD_LIBS\"... " >&6; }
;;
-*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether pthreads work with $ax_pthread_try_flag" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether pthreads work with $ax_pthread_try_flag" >&5
printf %s "checking whether pthreads work with $ax_pthread_try_flag... " >&6; }
PTHREAD_CFLAGS="$ax_pthread_try_flag"
;;
@@ -8047,7 +8233,7 @@
pthread-config)
# Extract the first word of "pthread-config", so it can be a program name with args.
set dummy pthread-config; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ax_pthread_config+y}
then :
@@ -8068,7 +8254,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ax_pthread_config="yes"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -8081,11 +8267,11 @@
fi
ax_pthread_config=$ac_cv_prog_ax_pthread_config
if test -n "$ax_pthread_config"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_pthread_config" >&5
-printf "%s\n" "$ax_pthread_config" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ax_pthread_config" >&5
+printf '%s\n' "$ax_pthread_config" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -8098,7 +8284,7 @@
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for the pthreads library -l$ax_pthread_try_flag" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for the pthreads library -l$ax_pthread_try_flag" >&5
printf %s "checking for the pthreads library -l$ax_pthread_try_flag... " >&6; }
PTHREAD_LIBS="-l$ax_pthread_try_flag"
;;
@@ -8156,8 +8342,8 @@
CFLAGS="$ax_pthread_save_CFLAGS"
LIBS="$ax_pthread_save_LIBS"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_pthread_ok" >&5
-printf "%s\n" "$ax_pthread_ok" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ax_pthread_ok" >&5
+printf '%s\n' "$ax_pthread_ok" >&6; }
if test "x$ax_pthread_ok" = "xyes"
then :
break
@@ -8205,7 +8391,7 @@
# that build with -Werror. So if the active version of Clang has
# this misfeature, we search for an option to squash it.
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether Clang needs flag to prevent \"argument unused\" warning when linking with -pthread" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether Clang needs flag to prevent \"argument unused\" warning when linking with -pthread" >&5
printf %s "checking whether Clang needs flag to prevent \"argument unused\" warning when linking with -pthread... " >&6; }
if test ${ax_cv_PTHREAD_CLANG_NO_WARN_FLAG+y}
then :
@@ -8218,7 +8404,7 @@
# step
ax_pthread_save_ac_link="$ac_link"
ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g'
- ax_pthread_link_step=`printf "%s\n" "$ac_link" | sed "$ax_pthread_sed"`
+ ax_pthread_link_step=`printf '%s\n' "$ac_link" | sed "$ax_pthread_sed"`
ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)"
ax_pthread_save_CFLAGS="$CFLAGS"
for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do
@@ -8260,8 +8446,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" >&5
-printf "%s\n" "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" >&5
+printf '%s\n' "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" >&6; }
case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in
no | unknown) ;;
@@ -8280,7 +8466,7 @@
LIBS="$PTHREAD_LIBS $LIBS"
# Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for joinable pthread attribute" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for joinable pthread attribute" >&5
printf %s "checking for joinable pthread attribute... " >&6; }
if test ${ax_cv_PTHREAD_JOINABLE_ATTR+y}
then :
@@ -8309,20 +8495,20 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_JOINABLE_ATTR" >&5
-printf "%s\n" "$ax_cv_PTHREAD_JOINABLE_ATTR" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_JOINABLE_ATTR" >&5
+printf '%s\n' "$ax_cv_PTHREAD_JOINABLE_ATTR" >&6; }
if test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \
test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \
test "x$ax_pthread_joinable_attr_defined" != "xyes"
then :
-printf "%s\n" "#define PTHREAD_CREATE_JOINABLE $ax_cv_PTHREAD_JOINABLE_ATTR" >>confdefs.h
+printf '%s\n' "#define PTHREAD_CREATE_JOINABLE $ax_cv_PTHREAD_JOINABLE_ATTR" >>confdefs.h
ax_pthread_joinable_attr_defined=yes
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether more special flags are required for pthreads" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether more special flags are required for pthreads" >&5
printf %s "checking whether more special flags are required for pthreads... " >&6; }
if test ${ax_cv_PTHREAD_SPECIAL_FLAGS+y}
then :
@@ -8337,8 +8523,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_SPECIAL_FLAGS" >&5
-printf "%s\n" "$ax_cv_PTHREAD_SPECIAL_FLAGS" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_SPECIAL_FLAGS" >&5
+printf '%s\n' "$ax_cv_PTHREAD_SPECIAL_FLAGS" >&6; }
if test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \
test "x$ax_pthread_special_flags_added" != "xyes"
then :
@@ -8346,7 +8532,7 @@
ax_pthread_special_flags_added=yes
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for PTHREAD_PRIO_INHERIT" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for PTHREAD_PRIO_INHERIT" >&5
printf %s "checking for PTHREAD_PRIO_INHERIT... " >&6; }
if test ${ax_cv_PTHREAD_PRIO_INHERIT+y}
then :
@@ -8376,13 +8562,13 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_PRIO_INHERIT" >&5
-printf "%s\n" "$ax_cv_PTHREAD_PRIO_INHERIT" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ax_cv_PTHREAD_PRIO_INHERIT" >&5
+printf '%s\n' "$ax_cv_PTHREAD_PRIO_INHERIT" >&6; }
if test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \
test "x$ax_pthread_prio_inherit_defined" != "xyes"
then :
-printf "%s\n" "#define HAVE_PTHREAD_PRIO_INHERIT 1" >>confdefs.h
+printf '%s\n' "#define HAVE_PTHREAD_PRIO_INHERIT 1" >>confdefs.h
ax_pthread_prio_inherit_defined=yes
@@ -8419,7 +8605,7 @@
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_PTHREAD_CC+y}
then :
@@ -8440,7 +8626,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_PTHREAD_CC="$ac_prog"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -8452,11 +8638,11 @@
fi
PTHREAD_CC=$ac_cv_prog_PTHREAD_CC
if test -n "$PTHREAD_CC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PTHREAD_CC" >&5
-printf "%s\n" "$PTHREAD_CC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $PTHREAD_CC" >&5
+printf '%s\n' "$PTHREAD_CC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -8470,7 +8656,7 @@
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_PTHREAD_CXX+y}
then :
@@ -8491,7 +8677,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_PTHREAD_CXX="$ac_prog"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -8503,11 +8689,11 @@
fi
PTHREAD_CXX=$ac_cv_prog_PTHREAD_CXX
if test -n "$PTHREAD_CXX"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PTHREAD_CXX" >&5
-printf "%s\n" "$PTHREAD_CXX" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $PTHREAD_CXX" >&5
+printf '%s\n' "$PTHREAD_CXX" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -8555,7 +8741,7 @@
-printf "%s\n" "#define MYTHREAD_POSIX 1" >>confdefs.h
+printf '%s\n' "#define MYTHREAD_POSIX 1" >>confdefs.h
# This is nice to have but not mandatory.
@@ -8564,7 +8750,7 @@
ac_fn_c_check_func "$LINENO" "pthread_condattr_setclock" "ac_cv_func_pthread_condattr_setclock"
if test "x$ac_cv_func_pthread_condattr_setclock" = xyes
then :
- printf "%s\n" "#define HAVE_PTHREAD_CONDATTR_SETCLOCK 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_PTHREAD_CONDATTR_SETCLOCK 1" >>confdefs.h
fi
@@ -8573,13 +8759,13 @@
win95) :
-printf "%s\n" "#define MYTHREAD_WIN95 1" >>confdefs.h
+printf '%s\n' "#define MYTHREAD_WIN95 1" >>confdefs.h
;; #(
vista) :
-printf "%s\n" "#define MYTHREAD_VISTA 1" >>confdefs.h
+printf '%s\n' "#define MYTHREAD_VISTA 1" >>confdefs.h
;; #(
@@ -8600,14 +8786,14 @@
case `pwd` in
*\ * | *\ *)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
-printf "%s\n" "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
+printf '%s\n' "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
esac
-macro_version='2.5.4.1-baa1-dirty'
-macro_revision='2.5.4.1'
+macro_version='2.6.0'
+macro_revision='2.6.0'
@@ -8645,7 +8831,7 @@
ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
printf %s "checking how to print strings... " >&6; }
# Test print first, because it will be a builtin if present.
if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
@@ -8672,12 +8858,12 @@
}
case $ECHO in
- printf*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: printf" >&5
-printf "%s\n" "printf" >&6; } ;;
- print*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
-printf "%s\n" "print -r" >&6; } ;;
- *) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: cat" >&5
-printf "%s\n" "cat" >&6; } ;;
+ printf*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: printf" >&5
+printf '%s\n' "printf" >&6; } ;;
+ print*) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
+printf '%s\n' "print -r" >&6; } ;;
+ *) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: cat" >&5
+printf '%s\n' "cat" >&6; } ;;
esac
@@ -8693,7 +8879,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
printf %s "checking for a sed that does not truncate output... " >&6; }
if test ${ac_cv_path_SED+y}
then :
@@ -8736,7 +8922,7 @@
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
- printf "%s\n" '' >> "conftest.nl"
+ printf '%s\n' '' >> "conftest.nl"
"$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
@@ -8765,8 +8951,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
-printf "%s\n" "$ac_cv_path_SED" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+printf '%s\n' "$ac_cv_path_SED" >&6; }
SED="$ac_cv_path_SED"
rm -f conftest.sed
@@ -8783,7 +8969,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
printf %s "checking for grep that handles long lines and -e... " >&6; }
if test ${ac_cv_path_GREP+y}
then :
@@ -8820,7 +9006,7 @@
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
- printf "%s\n" 'GREP' >> "conftest.nl"
+ printf '%s\n' 'GREP' >> "conftest.nl"
"$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
@@ -8849,12 +9035,12 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
-printf "%s\n" "$ac_cv_path_GREP" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+printf '%s\n' "$ac_cv_path_GREP" >&6; }
GREP="$ac_cv_path_GREP"
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
printf %s "checking for egrep... " >&6; }
if test ${ac_cv_path_EGREP+y}
then :
@@ -8894,7 +9080,7 @@
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
- printf "%s\n" 'EGREP' >> "conftest.nl"
+ printf '%s\n' 'EGREP' >> "conftest.nl"
"$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
@@ -8924,14 +9110,14 @@
fi ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
-printf "%s\n" "$ac_cv_path_EGREP" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+printf '%s\n' "$ac_cv_path_EGREP" >&6; }
EGREP="$ac_cv_path_EGREP"
EGREP_TRADITIONAL=$EGREP
ac_cv_path_EGREP_TRADITIONAL=$EGREP
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
printf %s "checking for fgrep... " >&6; }
if test ${ac_cv_path_FGREP+y}
then :
@@ -8971,7 +9157,7 @@
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
- printf "%s\n" 'FGREP' >> "conftest.nl"
+ printf '%s\n' 'FGREP' >> "conftest.nl"
"$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
@@ -9001,8 +9187,8 @@
fi ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
-printf "%s\n" "$ac_cv_path_FGREP" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
+printf '%s\n' "$ac_cv_path_FGREP" >&6; }
FGREP="$ac_cv_path_FGREP"
@@ -9038,7 +9224,7 @@
ac_prog=ld
if test yes = "$GCC"; then
# Check if gcc -print-prog-name=ld gives a path.
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
printf %s "checking for ld used by $CC... " >&6; }
case $host in
*-*-mingw* | *-*-windows*)
@@ -9068,10 +9254,10 @@
;;
esac
elif test yes = "$with_gnu_ld"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
printf %s "checking for GNU ld... " >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
printf %s "checking for non-GNU ld... " >&6; }
fi
if test ${lt_cv_path_LD+y}
@@ -9107,14 +9293,14 @@
LD=$lt_cv_path_LD
if test -n "$LD"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
-printf "%s\n" "$LD" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+printf '%s\n' "$LD" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
if test ${lt_cv_prog_gnu_ld+y}
then :
@@ -9131,8 +9317,8 @@
esac ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
-printf "%s\n" "$lt_cv_prog_gnu_ld" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+printf '%s\n' "$lt_cv_prog_gnu_ld" >&6; }
with_gnu_ld=$lt_cv_prog_gnu_ld
@@ -9143,7 +9329,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
printf %s "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
if test ${lt_cv_path_NM+y}
then :
@@ -9199,8 +9385,8 @@
fi ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
-printf "%s\n" "$lt_cv_path_NM" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
+printf '%s\n' "$lt_cv_path_NM" >&6; }
if test no != "$lt_cv_path_NM"; then
NM=$lt_cv_path_NM
else
@@ -9213,7 +9399,7 @@
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_DUMPBIN+y}
then :
@@ -9234,7 +9420,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -9246,11 +9432,11 @@
fi
DUMPBIN=$ac_cv_prog_DUMPBIN
if test -n "$DUMPBIN"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
-printf "%s\n" "$DUMPBIN" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
+printf '%s\n' "$DUMPBIN" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -9263,7 +9449,7 @@
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_DUMPBIN+y}
then :
@@ -9284,7 +9470,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -9296,11 +9482,11 @@
fi
ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
if test -n "$ac_ct_DUMPBIN"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
-printf "%s\n" "$ac_ct_DUMPBIN" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
+printf '%s\n' "$ac_ct_DUMPBIN" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -9312,8 +9498,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
DUMPBIN=$ac_ct_DUMPBIN
@@ -9341,7 +9527,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
printf %s "checking the name lister ($NM) interface... " >&6; }
if test ${lt_cv_nm_interface+y}
then :
@@ -9363,11 +9549,11 @@
rm -f conftest* ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
-printf "%s\n" "$lt_cv_nm_interface" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
+printf '%s\n' "$lt_cv_nm_interface" >&6; }
# find the maximum length of command line arguments
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
printf %s "checking the maximum length of command line arguments... " >&6; }
if test ${lt_cv_sys_max_cmd_len+y}
then :
@@ -9500,11 +9686,11 @@
fi
if test -n "$lt_cv_sys_max_cmd_len"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
-printf "%s\n" "$lt_cv_sys_max_cmd_len" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
+printf '%s\n' "$lt_cv_sys_max_cmd_len" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none" >&5
-printf "%s\n" "none" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: none" >&5
+printf '%s\n' "none" >&6; }
fi
max_cmd_len=$lt_cv_sys_max_cmd_len
@@ -9548,7 +9734,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
printf %s "checking how to convert $build file names to $host format... " >&6; }
if test ${lt_cv_to_host_file_cmd+y}
then :
@@ -9590,14 +9776,14 @@
fi
to_host_file_cmd=$lt_cv_to_host_file_cmd
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
-printf "%s\n" "$lt_cv_to_host_file_cmd" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
+printf '%s\n' "$lt_cv_to_host_file_cmd" >&6; }
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
printf %s "checking how to convert $build file names to toolchain format... " >&6; }
if test ${lt_cv_to_tool_file_cmd+y}
then :
@@ -9619,14 +9805,85 @@
fi
to_tool_file_cmd=$lt_cv_to_tool_file_cmd
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
-printf "%s\n" "$lt_cv_to_tool_file_cmd" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
+printf '%s\n' "$lt_cv_to_tool_file_cmd" >&6; }
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
+case $host in #(
+ *-*-mingw* | *-*-windows* | *-*-cygwin*) :
+ case $build in #(
+ *-*-mingw* | *-*-windows* | *-*-cygwin*) :
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether cygpath is installed" >&5
+printf %s "checking whether cygpath is installed... " >&6; }
+ if test ${lt_cv_cygpath_installed+y}
+then :
+ printf %s "(cached) " >&6
+else case e in #(
+ e) lt_cv_cygpath_installed=ignoring
+ cygpath --help &> /dev/null
+ _lt_result=$?
+ if test 0 = "$_lt_result"
+then :
+ lt_cv_cygpath_installed=yes
+else case e in #(
+ e) lt_cv_cygpath_installed=no ;;
+esac
+fi
+ ;;
+esac
+fi
+
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cygpath_installed" >&5
+printf '%s\n' "$lt_cv_cygpath_installed" >&6; }
+
+
+
+
+ if test "xyes" != "x$lt_cv_cygpath_installed"
+then :
+
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to use cmd with one slash or two slashes" >&5
+printf %s "checking whether to use cmd with one slash or two slashes... " >&6; }
+ if test ${lt_cv_cmd_slashes+y}
+then :
+ printf %s "(cached) " >&6
+else case e in #(
+ e)
+ _lt_result=`cmd /c echo one-slash works. Not checked //c echo two-slashes 2>/dev/null`
+ if test 0 != $?
+then :
+ as_fn_error $? "Do not know how to convert paths" "$LINENO" 5
+fi
+ case $_lt_result in #(
+ one-slash*) :
+ lt_cv_cmd_slashes="one" ;; #(
+ two-slashes*) :
+ lt_cv_cmd_slashes="two" ;; #(
+ *) :
+ as_fn_error $? "Do not know how to convert paths" "$LINENO" 5
+ ;;
+esac
+ ;;
+esac
+fi
+
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cmd_slashes" >&5
+printf '%s\n' "$lt_cv_cmd_slashes" >&6; }
+
+fi
+ ;; #(
+ *) :
+ ;;
+esac
+
+ ;; #(
+ *) :
+ ;;
+esac
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
printf %s "checking for $LD option to reload object files... " >&6; }
if test ${lt_cv_ld_reload_flag+y}
then :
@@ -9635,8 +9892,8 @@
e) lt_cv_ld_reload_flag='-r' ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
-printf "%s\n" "$lt_cv_ld_reload_flag" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
+printf '%s\n' "$lt_cv_ld_reload_flag" >&6; }
reload_flag=$lt_cv_ld_reload_flag
case $reload_flag in
"" | " "*) ;;
@@ -9651,7 +9908,7 @@
;;
darwin*)
if test yes = "$GCC"; then
- reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
+ reload_cmds='$LTCC $LTCFLAGS $stdlibflag $wl-r -o $output$reload_objs'
else
reload_cmds='$LD$reload_flag -o $output$reload_objs'
fi
@@ -9668,7 +9925,7 @@
# Extract the first word of "file", so it can be a program name with args.
set dummy file; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_FILECMD+y}
then :
@@ -9689,7 +9946,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_FILECMD="file"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -9702,11 +9959,11 @@
fi
FILECMD=$ac_cv_prog_FILECMD
if test -n "$FILECMD"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FILECMD" >&5
-printf "%s\n" "$FILECMD" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $FILECMD" >&5
+printf '%s\n' "$FILECMD" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -9719,7 +9976,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
set dummy ${ac_tool_prefix}objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_OBJDUMP+y}
then :
@@ -9740,7 +9997,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -9752,11 +10009,11 @@
fi
OBJDUMP=$ac_cv_prog_OBJDUMP
if test -n "$OBJDUMP"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
-printf "%s\n" "$OBJDUMP" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+printf '%s\n' "$OBJDUMP" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -9765,7 +10022,7 @@
ac_ct_OBJDUMP=$OBJDUMP
# Extract the first word of "objdump", so it can be a program name with args.
set dummy objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
then :
@@ -9786,7 +10043,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_OBJDUMP="objdump"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -9798,11 +10055,11 @@
fi
ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
if test -n "$ac_ct_OBJDUMP"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
-printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+printf '%s\n' "$ac_ct_OBJDUMP" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_OBJDUMP" = x; then
@@ -9810,8 +10067,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
OBJDUMP=$ac_ct_OBJDUMP
@@ -9827,7 +10084,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
printf %s "checking how to recognize dependent libraries... " >&6; }
if test ${lt_cv_deplibs_check_method+y}
then :
@@ -9944,12 +10201,12 @@
lt_cv_deplibs_check_method=pass_all
;;
-# This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+*-mlibc)
lt_cv_deplibs_check_method=pass_all
;;
-*-mlibc)
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
lt_cv_deplibs_check_method=pass_all
;;
@@ -10036,8 +10293,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
-printf "%s\n" "$lt_cv_deplibs_check_method" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
+printf '%s\n' "$lt_cv_deplibs_check_method" >&6; }
file_magic_glob=
want_nocaseglob=no
@@ -10081,7 +10338,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
set dummy ${ac_tool_prefix}dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_DLLTOOL+y}
then :
@@ -10102,7 +10359,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -10114,11 +10371,11 @@
fi
DLLTOOL=$ac_cv_prog_DLLTOOL
if test -n "$DLLTOOL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
-printf "%s\n" "$DLLTOOL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
+printf '%s\n' "$DLLTOOL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -10127,7 +10384,7 @@
ac_ct_DLLTOOL=$DLLTOOL
# Extract the first word of "dlltool", so it can be a program name with args.
set dummy dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
then :
@@ -10148,7 +10405,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_DLLTOOL="dlltool"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -10160,11 +10417,11 @@
fi
ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
if test -n "$ac_ct_DLLTOOL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
-printf "%s\n" "$ac_ct_DLLTOOL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
+printf '%s\n' "$ac_ct_DLLTOOL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_DLLTOOL" = x; then
@@ -10172,8 +10429,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
DLLTOOL=$ac_ct_DLLTOOL
@@ -10190,7 +10447,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5
printf %s "checking how to associate runtime and link libraries... " >&6; }
if test ${lt_cv_sharedlib_from_linklib_cmd+y}
then :
@@ -10219,8 +10476,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
-printf "%s\n" "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
+printf '%s\n' "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
@@ -10233,7 +10490,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_RANLIB+y}
then :
@@ -10254,7 +10511,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -10266,11 +10523,11 @@
fi
RANLIB=$ac_cv_prog_RANLIB
if test -n "$RANLIB"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
-printf "%s\n" "$RANLIB" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
+printf '%s\n' "$RANLIB" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -10279,7 +10536,7 @@
ac_ct_RANLIB=$RANLIB
# Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_RANLIB+y}
then :
@@ -10300,7 +10557,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_RANLIB="ranlib"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -10312,11 +10569,11 @@
fi
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
if test -n "$ac_ct_RANLIB"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
-printf "%s\n" "$ac_ct_RANLIB" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
+printf '%s\n' "$ac_ct_RANLIB" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_RANLIB" = x; then
@@ -10324,8 +10581,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
RANLIB=$ac_ct_RANLIB
@@ -10339,7 +10596,7 @@
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_AR+y}
then :
@@ -10360,7 +10617,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -10372,11 +10629,11 @@
fi
AR=$ac_cv_prog_AR
if test -n "$AR"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
-printf "%s\n" "$AR" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+printf '%s\n' "$AR" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -10389,7 +10646,7 @@
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_AR+y}
then :
@@ -10410,7 +10667,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_AR="$ac_prog"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -10422,11 +10679,11 @@
fi
ac_ct_AR=$ac_cv_prog_ac_ct_AR
if test -n "$ac_ct_AR"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
-printf "%s\n" "$ac_ct_AR" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
+printf '%s\n' "$ac_ct_AR" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -10438,8 +10695,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
AR=$ac_ct_AR
@@ -10475,7 +10732,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5
printf %s "checking for archiver @FILE support... " >&6; }
if test ${lt_cv_ar_at_file+y}
then :
@@ -10500,7 +10757,7 @@
{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
(eval $lt_ar_try) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
if test 0 -eq "$ac_status"; then
# Ensure the archiver fails upon bogus file names.
@@ -10508,7 +10765,7 @@
{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
(eval $lt_ar_try) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
if test 0 -ne "$ac_status"; then
lt_cv_ar_at_file=@
@@ -10521,8 +10778,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
-printf "%s\n" "$lt_cv_ar_at_file" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
+printf '%s\n' "$lt_cv_ar_at_file" >&6; }
if test no = "$lt_cv_ar_at_file"; then
archiver_list_spec=
@@ -10539,7 +10796,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_STRIP+y}
then :
@@ -10560,7 +10817,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_STRIP="${ac_tool_prefix}strip"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -10572,11 +10829,11 @@
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-printf "%s\n" "$STRIP" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+printf '%s\n' "$STRIP" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -10585,7 +10842,7 @@
ac_ct_STRIP=$STRIP
# Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_STRIP+y}
then :
@@ -10606,7 +10863,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_STRIP="strip"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -10618,11 +10875,11 @@
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
-printf "%s\n" "$ac_ct_STRIP" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+printf '%s\n' "$ac_ct_STRIP" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_STRIP" = x; then
@@ -10630,8 +10887,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
STRIP=$ac_ct_STRIP
@@ -10721,7 +10978,7 @@
# Check for command to grab the raw symbol name followed by C symbol from nm.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
printf %s "checking command to parse $NM output from $compiler object... " >&6; }
if test ${lt_cv_sys_global_symbol_pipe+y}
then :
@@ -10781,13 +11038,13 @@
if test "$lt_cv_nm_interface" = "MS dumpbin"; then
# Gets list of data symbols to import.
- lt_cv_sys_global_symbol_to_import="$SED -n -e 's/^I .* \(.*\)$/\1/p'"
+ lt_cv_sys_global_symbol_to_import="$SED -n -e 's/^I .* \([a-zA-Z_][a-zA-Z0-9_]*\)$/\1/p'"
# Adjust the below global symbol transforms to fixup imported variables.
- lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
- lt_c_name_hook=" -e 's/^I .* \(.*\)$/ {\"\1\", (void *) 0},/p'"
+ lt_cdecl_hook=" -e 's/^I .* \([a-zA-Z_][a-zA-Z0-9_]*\)$/extern __declspec(dllimport) char \1;/p'"
+ lt_c_name_hook=" -e 's/^I .* \([a-zA-Z_][a-zA-Z0-9_]*\)$/ {\"\1\", (void *) 0},/p'"
lt_c_name_lib_hook="\
- -e 's/^I .* \(lib.*\)$/ {\"\1\", (void *) 0},/p'\
- -e 's/^I .* \(.*\)$/ {\"lib\1\", (void *) 0},/p'"
+ -e 's/^I .* \(lib[a-zA-Z_][a-zA-Z0-9_]*\)$/ {\"\1\", (void *) 0},/p'\
+ -e 's/^I .* \([a-zA-Z_][a-zA-Z0-9_]*\)$/ {\"lib\1\", (void *) 0},/p'"
else
# Disable hooks by default.
lt_cv_sys_global_symbol_to_import=
@@ -10801,22 +11058,22 @@
# so use this general approach.
lt_cv_sys_global_symbol_to_cdecl="$SED -n"\
$lt_cdecl_hook\
-" -e 's/^T .* \(.*\)$/extern int \1();/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
+" -e 's/^T .* \([a-zA-Z_][a-zA-Z0-9_]*\)$/extern int \1();/p'"\
+" -e 's/^$symcode$symcode* .* \([a-zA-Z_][a-zA-Z0-9_]*\)$/extern char \1;/p'"
# Transform an extracted symbol line into symbol name and symbol address
lt_cv_sys_global_symbol_to_c_name_address="$SED -n"\
$lt_c_name_hook\
" -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/p'"
+" -e 's/^$symcode$symcode* .* \([a-zA-Z_][a-zA-Z0-9_]*\)$/ {\"\1\", (void *) \&\1},/p'"
# Transform an extracted symbol line into symbol name with lib prefix and
# symbol address.
lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="$SED -n"\
$lt_c_name_lib_hook\
" -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\
-" -e 's/^$symcode$symcode* .* \(lib.*\)$/ {\"\1\", (void *) \&\1},/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/ {\"lib\1\", (void *) \&\1},/p'"
+" -e 's/^$symcode$symcode* .* \(lib[a-zA-Z_][a-zA-Z0-9_]*\)$/ {\"\1\", (void *) \&\1},/p'"\
+" -e 's/^$symcode$symcode* .* \([a-zA-Z_][a-zA-Z0-9_]*\)$/ {\"lib\1\", (void *) \&\1},/p'"
# Handle CRLF in mingw tool chain
opt_cr=
@@ -10837,8 +11094,10 @@
# Fake it for dumpbin and say T for any non-static function,
# D for any global variable and I for any imported variable.
# Also find C++ and __fastcall symbols from MSVC++ or ICC,
- # which start with @ or ?.
+ # which start with @ or ?. And Cygwin gawk-4.1.4-3 and newer
+ # treats input as binary, have to drop carriage return first.
lt_cv_sys_global_symbol_pipe="$AWK '"\
+" {sub(/\\r\$/,\"\")};"\
" {last_section=section; section=\$ 3};"\
" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
@@ -10878,7 +11137,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
# Now try to grab the symbols.
nlist=conftest.nm
@@ -10951,7 +11210,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
(eval $ac_link) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && test -s conftest$ac_exeext; then
pipe_works=yes
fi
@@ -10987,11 +11246,11 @@
lt_cv_sys_global_symbol_to_cdecl=
fi
if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: failed" >&5
-printf "%s\n" "failed" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: failed" >&5
+printf '%s\n' "failed" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-printf "%s\n" "ok" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+printf '%s\n' "ok" >&6; }
fi
# Response file support.
@@ -11037,7 +11296,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
printf %s "checking for sysroot... " >&6; }
# Check whether --with-sysroot was given.
@@ -11065,20 +11324,20 @@
no|'')
;; #(
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5
-printf "%s\n" "$with_sysroot" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5
+printf '%s\n' "$with_sysroot" >&6; }
as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
;;
esac
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5
-printf "%s\n" "${lt_sysroot:-no}" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5
+printf '%s\n' "${lt_sysroot:-no}" >&6; }
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
printf %s "checking for a working dd... " >&6; }
if test ${ac_cv_path_lt_DD+y}
then :
@@ -11123,11 +11382,11 @@
rm -f conftest.i conftest2.i conftest.out ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
-printf "%s\n" "$ac_cv_path_lt_DD" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
+printf '%s\n' "$ac_cv_path_lt_DD" >&6; }
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
printf %s "checking how to truncate binary pipes... " >&6; }
if test ${lt_cv_truncate_bin+y}
then :
@@ -11144,8 +11403,8 @@
test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q" ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
-printf "%s\n" "$lt_cv_truncate_bin" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
+printf '%s\n' "$lt_cv_truncate_bin" >&6; }
@@ -11185,7 +11444,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
case `$FILECMD conftest.$ac_objext` in
*ELF-32*)
@@ -11205,7 +11464,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
if test yes = "$lt_cv_prog_gnu_ld"; then
case `$FILECMD conftest.$ac_objext` in
@@ -11243,7 +11502,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
emul=elf
case `$FILECMD conftest.$ac_objext` in
@@ -11284,7 +11543,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
case `$FILECMD conftest.o` in
*32-bit*)
@@ -11347,7 +11606,7 @@
# On SCO OpenServer 5, we need -belf to get full-featured binaries.
SAVE_CFLAGS=$CFLAGS
CFLAGS="$CFLAGS -belf"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
printf %s "checking whether the C compiler needs -belf... " >&6; }
if test ${lt_cv_cc_needs_belf+y}
then :
@@ -11387,8 +11646,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
-printf "%s\n" "$lt_cv_cc_needs_belf" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
+printf '%s\n' "$lt_cv_cc_needs_belf" >&6; }
if test yes != "$lt_cv_cc_needs_belf"; then
# this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
CFLAGS=$SAVE_CFLAGS
@@ -11401,7 +11660,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
case `$FILECMD conftest.o` in
*64-bit*)
@@ -11438,7 +11697,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.
set dummy ${ac_tool_prefix}mt; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_MANIFEST_TOOL+y}
then :
@@ -11459,7 +11718,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11471,11 +11730,11 @@
fi
MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL
if test -n "$MANIFEST_TOOL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5
-printf "%s\n" "$MANIFEST_TOOL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5
+printf '%s\n' "$MANIFEST_TOOL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -11484,7 +11743,7 @@
ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL
# Extract the first word of "mt", so it can be a program name with args.
set dummy mt; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_MANIFEST_TOOL+y}
then :
@@ -11505,7 +11764,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_MANIFEST_TOOL="mt"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11517,11 +11776,11 @@
fi
ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL
if test -n "$ac_ct_MANIFEST_TOOL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5
-printf "%s\n" "$ac_ct_MANIFEST_TOOL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5
+printf '%s\n' "$ac_ct_MANIFEST_TOOL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_MANIFEST_TOOL" = x; then
@@ -11529,8 +11788,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL
@@ -11540,7 +11799,7 @@
fi
test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5
printf %s "checking if $MANIFEST_TOOL is a manifest tool... " >&6; }
if test ${lt_cv_path_manifest_tool+y}
then :
@@ -11556,8 +11815,8 @@
rm -f conftest* ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_manifest_tool" >&5
-printf "%s\n" "$lt_cv_path_manifest_tool" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_manifest_tool" >&5
+printf '%s\n' "$lt_cv_path_manifest_tool" >&6; }
if test yes != "$lt_cv_path_manifest_tool"; then
MANIFEST_TOOL=:
fi
@@ -11572,7 +11831,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_DSYMUTIL+y}
then :
@@ -11593,7 +11852,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11605,11 +11864,11 @@
fi
DSYMUTIL=$ac_cv_prog_DSYMUTIL
if test -n "$DSYMUTIL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
-printf "%s\n" "$DSYMUTIL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
+printf '%s\n' "$DSYMUTIL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -11618,7 +11877,7 @@
ac_ct_DSYMUTIL=$DSYMUTIL
# Extract the first word of "dsymutil", so it can be a program name with args.
set dummy dsymutil; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_DSYMUTIL+y}
then :
@@ -11639,7 +11898,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11651,11 +11910,11 @@
fi
ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
if test -n "$ac_ct_DSYMUTIL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
-printf "%s\n" "$ac_ct_DSYMUTIL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
+printf '%s\n' "$ac_ct_DSYMUTIL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_DSYMUTIL" = x; then
@@ -11663,8 +11922,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
DSYMUTIL=$ac_ct_DSYMUTIL
@@ -11676,7 +11935,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
set dummy ${ac_tool_prefix}nmedit; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_NMEDIT+y}
then :
@@ -11697,7 +11956,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11709,11 +11968,11 @@
fi
NMEDIT=$ac_cv_prog_NMEDIT
if test -n "$NMEDIT"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
-printf "%s\n" "$NMEDIT" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
+printf '%s\n' "$NMEDIT" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -11722,7 +11981,7 @@
ac_ct_NMEDIT=$NMEDIT
# Extract the first word of "nmedit", so it can be a program name with args.
set dummy nmedit; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_NMEDIT+y}
then :
@@ -11743,7 +12002,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_NMEDIT="nmedit"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11755,11 +12014,11 @@
fi
ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
if test -n "$ac_ct_NMEDIT"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
-printf "%s\n" "$ac_ct_NMEDIT" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
+printf '%s\n' "$ac_ct_NMEDIT" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_NMEDIT" = x; then
@@ -11767,8 +12026,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
NMEDIT=$ac_ct_NMEDIT
@@ -11780,7 +12039,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
set dummy ${ac_tool_prefix}lipo; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_LIPO+y}
then :
@@ -11801,7 +12060,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11813,11 +12072,11 @@
fi
LIPO=$ac_cv_prog_LIPO
if test -n "$LIPO"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
-printf "%s\n" "$LIPO" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
+printf '%s\n' "$LIPO" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -11826,7 +12085,7 @@
ac_ct_LIPO=$LIPO
# Extract the first word of "lipo", so it can be a program name with args.
set dummy lipo; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_LIPO+y}
then :
@@ -11847,7 +12106,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_LIPO="lipo"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11859,11 +12118,11 @@
fi
ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
if test -n "$ac_ct_LIPO"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
-printf "%s\n" "$ac_ct_LIPO" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
+printf '%s\n' "$ac_ct_LIPO" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_LIPO" = x; then
@@ -11871,8 +12130,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
LIPO=$ac_ct_LIPO
@@ -11884,7 +12143,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
set dummy ${ac_tool_prefix}otool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_OTOOL+y}
then :
@@ -11905,7 +12164,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11917,11 +12176,11 @@
fi
OTOOL=$ac_cv_prog_OTOOL
if test -n "$OTOOL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
-printf "%s\n" "$OTOOL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
+printf '%s\n' "$OTOOL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -11930,7 +12189,7 @@
ac_ct_OTOOL=$OTOOL
# Extract the first word of "otool", so it can be a program name with args.
set dummy otool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_OTOOL+y}
then :
@@ -11951,7 +12210,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_OTOOL="otool"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -11963,11 +12222,11 @@
fi
ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
if test -n "$ac_ct_OTOOL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
-printf "%s\n" "$ac_ct_OTOOL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
+printf '%s\n' "$ac_ct_OTOOL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_OTOOL" = x; then
@@ -11975,8 +12234,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
OTOOL=$ac_ct_OTOOL
@@ -11988,7 +12247,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
set dummy ${ac_tool_prefix}otool64; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_OTOOL64+y}
then :
@@ -12009,7 +12268,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -12021,11 +12280,11 @@
fi
OTOOL64=$ac_cv_prog_OTOOL64
if test -n "$OTOOL64"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
-printf "%s\n" "$OTOOL64" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
+printf '%s\n' "$OTOOL64" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -12034,7 +12293,7 @@
ac_ct_OTOOL64=$OTOOL64
# Extract the first word of "otool64", so it can be a program name with args.
set dummy otool64; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_OTOOL64+y}
then :
@@ -12055,7 +12314,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_OTOOL64="otool64"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -12067,11 +12326,11 @@
fi
ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
if test -n "$ac_ct_OTOOL64"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
-printf "%s\n" "$ac_ct_OTOOL64" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
+printf '%s\n' "$ac_ct_OTOOL64" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_OTOOL64" = x; then
@@ -12079,8 +12338,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
OTOOL64=$ac_ct_OTOOL64
@@ -12115,7 +12374,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
printf %s "checking for -single_module linker flag... " >&6; }
if test ${lt_cv_apple_cc_single_mod+y}
then :
@@ -12150,12 +12409,12 @@
fi ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
-printf "%s\n" "$lt_cv_apple_cc_single_mod" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
+printf '%s\n' "$lt_cv_apple_cc_single_mod" >&6; }
# Feature test to disable chained fixups since it is not
# compatible with '-undefined dynamic_lookup'
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -no_fixup_chains linker flag" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -no_fixup_chains linker flag" >&5
printf %s "checking for -no_fixup_chains linker flag... " >&6; }
if test ${lt_cv_support_no_fixup_chains+y}
then :
@@ -12189,10 +12448,10 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_support_no_fixup_chains" >&5
-printf "%s\n" "$lt_cv_support_no_fixup_chains" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_support_no_fixup_chains" >&5
+printf '%s\n' "$lt_cv_support_no_fixup_chains" >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
printf %s "checking for -exported_symbols_list linker flag... " >&6; }
if test ${lt_cv_ld_exported_symbols_list+y}
then :
@@ -12226,10 +12485,10 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
-printf "%s\n" "$lt_cv_ld_exported_symbols_list" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
+printf '%s\n' "$lt_cv_ld_exported_symbols_list" >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
printf %s "checking for -force_load linker flag... " >&6; }
if test ${lt_cv_ld_force_load+y}
then :
@@ -12263,8 +12522,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
-printf "%s\n" "$lt_cv_ld_force_load" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
+printf '%s\n' "$lt_cv_ld_force_load" >&6; }
case $host_os in
rhapsody* | darwin1.[012])
_lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
@@ -12353,7 +12612,7 @@
"
if test "x$ac_cv_header_dlfcn_h" = xyes
then :
- printf "%s\n" "#define HAVE_DLFCN_H 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_DLFCN_H 1" >>confdefs.h
fi
@@ -12369,7 +12628,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}as", so it can be a program name with args.
set dummy ${ac_tool_prefix}as; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_AS+y}
then :
@@ -12390,7 +12649,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_AS="${ac_tool_prefix}as"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -12402,11 +12661,11 @@
fi
AS=$ac_cv_prog_AS
if test -n "$AS"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
-printf "%s\n" "$AS" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
+printf '%s\n' "$AS" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -12415,7 +12674,7 @@
ac_ct_AS=$AS
# Extract the first word of "as", so it can be a program name with args.
set dummy as; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_AS+y}
then :
@@ -12436,7 +12695,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_AS="as"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -12448,11 +12707,11 @@
fi
ac_ct_AS=$ac_cv_prog_ac_ct_AS
if test -n "$ac_ct_AS"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5
-printf "%s\n" "$ac_ct_AS" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AS" >&5
+printf '%s\n' "$ac_ct_AS" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_AS" = x; then
@@ -12460,8 +12719,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
AS=$ac_ct_AS
@@ -12473,7 +12732,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
set dummy ${ac_tool_prefix}dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_DLLTOOL+y}
then :
@@ -12494,7 +12753,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -12506,11 +12765,11 @@
fi
DLLTOOL=$ac_cv_prog_DLLTOOL
if test -n "$DLLTOOL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
-printf "%s\n" "$DLLTOOL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
+printf '%s\n' "$DLLTOOL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -12519,7 +12778,7 @@
ac_ct_DLLTOOL=$DLLTOOL
# Extract the first word of "dlltool", so it can be a program name with args.
set dummy dlltool; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_DLLTOOL+y}
then :
@@ -12540,7 +12799,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_DLLTOOL="dlltool"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -12552,11 +12811,11 @@
fi
ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
if test -n "$ac_ct_DLLTOOL"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
-printf "%s\n" "$ac_ct_DLLTOOL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
+printf '%s\n' "$ac_ct_DLLTOOL" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_DLLTOOL" = x; then
@@ -12564,8 +12823,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
DLLTOOL=$ac_ct_DLLTOOL
@@ -12577,7 +12836,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
set dummy ${ac_tool_prefix}objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_OBJDUMP+y}
then :
@@ -12598,7 +12857,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -12610,11 +12869,11 @@
fi
OBJDUMP=$ac_cv_prog_OBJDUMP
if test -n "$OBJDUMP"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
-printf "%s\n" "$OBJDUMP" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+printf '%s\n' "$OBJDUMP" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -12623,7 +12882,7 @@
ac_ct_OBJDUMP=$OBJDUMP
# Extract the first word of "objdump", so it can be a program name with args.
set dummy objdump; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
then :
@@ -12644,7 +12903,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_OBJDUMP="objdump"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -12656,11 +12915,11 @@
fi
ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
if test -n "$ac_ct_OBJDUMP"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
-printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+printf '%s\n' "$ac_ct_OBJDUMP" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_OBJDUMP" = x; then
@@ -12668,8 +12927,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
OBJDUMP=$ac_ct_OBJDUMP
@@ -12826,6 +13085,47 @@
+ stdlibflag=-nostdlib
+# Check whether --enable-cxx-stdlib was given.
+if test ${enable_cxx_stdlib+y}
+then :
+ enableval=$enable_cxx_stdlib; p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_cxx_stdlib=yes ;;
+ no) enable_cxx_stdlib=no ;;
+ *)
+ enable_cxx_stdlib=no
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+ for pkg in $enableval; do
+ IFS=$lt_save_ifs
+ if test "X$pkg" = "X$p"; then
+ enable_cxx_stdlib=yes
+ fi
+ done
+ IFS=$lt_save_ifs
+ ;;
+ esac
+else case e in #(
+ e) enable_cxx_stdlib=no ;;
+esac
+fi
+
+
+if test yes = "$enable_cxx_stdlib"; then
+ stdlibflag=
+fi
+
+
+
+
+
+
+
+
+
+
+
# Check whether --enable-fast-install was given.
if test ${enable_fast_install+y}
then :
@@ -12861,7 +13161,7 @@
shared_archive_member_spec=
case $host,$enable_shared in
power*-*-aix[5-9]*,yes)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
printf %s "checking which variant of shared library versioning to provide... " >&6; }
# Check whether --enable-aix-soname was given.
if test ${enable_aix_soname+y}
@@ -12903,8 +13203,8 @@
fi
with_aix_soname=$enable_aix_soname
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
-printf "%s\n" "$with_aix_soname" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
+printf '%s\n' "$with_aix_soname" >&6; }
if test aix != "$with_aix_soname"; then
# For the AIX way of multilib, we name the shared archive member
# based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
@@ -12918,8 +13218,21 @@
fi
fi
;;
+power*-*-aix[5-9]*,'')
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: for $host, specify if building shared libraries for versioning (svr4|both)" >&5
+printf '%s\n' "$as_me: WARNING: for $host, specify if building shared libraries for versioning (svr4|both)" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
+printf %s "checking which variant of shared library versioning to provide... " >&6; }
+ with_aix_soname=aix
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: (default) $with_aix_soname" >&5
+printf '%s\n' "(default) $with_aix_soname" >&6; }
+ ;;
*)
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
+printf %s "checking which variant of shared library versioning to provide... " >&6; }
with_aix_soname=aix
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: (default) $with_aix_soname" >&5
+printf '%s\n' "(default) $with_aix_soname" >&6; }
;;
esac
@@ -12986,7 +13299,7 @@
setopt NO_GLOB_SUBST
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
printf %s "checking for objdir... " >&6; }
if test ${lt_cv_objdir+y}
then :
@@ -13003,15 +13316,15 @@
rmdir .libs 2>/dev/null ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
-printf "%s\n" "$lt_cv_objdir" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
+printf '%s\n' "$lt_cv_objdir" >&6; }
objdir=$lt_cv_objdir
-printf "%s\n" "#define LT_OBJDIR \"$lt_cv_objdir/\"" >>confdefs.h
+printf '%s\n' "#define LT_OBJDIR \"$lt_cv_objdir/\"" >>confdefs.h
@@ -13057,7 +13370,7 @@
case $deplibs_check_method in
file_magic*)
if test "$file_magic_cmd" = '$MAGIC_CMD'; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
printf %s "checking for ${ac_tool_prefix}file... " >&6; }
if test ${lt_cv_path_MAGIC_CMD+y}
then :
@@ -13112,11 +13425,11 @@
MAGIC_CMD=$lt_cv_path_MAGIC_CMD
if test -n "$MAGIC_CMD"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
-printf "%s\n" "$MAGIC_CMD" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+printf '%s\n' "$MAGIC_CMD" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -13125,7 +13438,7 @@
if test -z "$lt_cv_path_MAGIC_CMD"; then
if test -n "$ac_tool_prefix"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for file" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for file" >&5
printf %s "checking for file... " >&6; }
if test ${lt_cv_path_MAGIC_CMD+y}
then :
@@ -13180,11 +13493,11 @@
MAGIC_CMD=$lt_cv_path_MAGIC_CMD
if test -n "$MAGIC_CMD"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
-printf "%s\n" "$MAGIC_CMD" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+printf '%s\n' "$MAGIC_CMD" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -13269,7 +13582,7 @@
lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;;
esac
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
printf %s "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
if test ${lt_cv_prog_compiler_rtti_exceptions+y}
then :
@@ -13296,9 +13609,9 @@
if (exit $ac_status) && test -s "$ac_outfile"; then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings other than the usual output.
- $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.expsym
$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
- if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+ if test ! -s conftest.er2 || diff conftest.expsym conftest.er2 >/dev/null; then
lt_cv_prog_compiler_rtti_exceptions=yes
fi
fi
@@ -13306,8 +13619,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
-printf "%s\n" "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
+printf '%s\n' "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
if test yes = "$lt_cv_prog_compiler_rtti_exceptions"; then
lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
@@ -13445,7 +13758,7 @@
# AIX 5 now supports IA64 processor
lt_prog_compiler_static='-Bstatic'
else
- lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
+ lt_prog_compiler_static='-bnso -bI:/lib/syscalls.expsym'
fi
;;
@@ -13496,7 +13809,13 @@
lt_prog_compiler_static='-non_shared'
;;
- linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ *-mlibc)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-fPIC'
+ lt_prog_compiler_static='-static'
+ ;;
+
+ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu* | freebsd*)
case $cc_basename in
# old Intel for x86_64, which still supported -KPIC.
ecc*)
@@ -13512,7 +13831,7 @@
;;
# icc used to be incompatible with GCC.
# ICC 10 doesn't accept -KPIC any more.
- icc* | ifort*)
+ icc* | ifort* | icx* | ifx*)
lt_prog_compiler_wl='-Wl,'
lt_prog_compiler_pic='-fPIC'
lt_prog_compiler_static='-static'
@@ -13592,12 +13911,6 @@
lt_prog_compiler_static='-Bstatic'
;;
- *-mlibc)
- lt_prog_compiler_wl='-Wl,'
- lt_prog_compiler_pic='-fPIC'
- lt_prog_compiler_static='-static'
- ;;
-
*nto* | *qnx*)
# QNX uses GNU C++, but need to define -shared option too, otherwise
# it will coredump.
@@ -13679,7 +13992,7 @@
;;
esac
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
printf %s "checking for $compiler option to produce PIC... " >&6; }
if test ${lt_cv_prog_compiler_pic+y}
then :
@@ -13688,15 +14001,15 @@
e) lt_cv_prog_compiler_pic=$lt_prog_compiler_pic ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
-printf "%s\n" "$lt_cv_prog_compiler_pic" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
+printf '%s\n' "$lt_cv_prog_compiler_pic" >&6; }
lt_prog_compiler_pic=$lt_cv_prog_compiler_pic
#
# Check to make sure the PIC flag actually works.
#
if test -n "$lt_prog_compiler_pic"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
if test ${lt_cv_prog_compiler_pic_works+y}
then :
@@ -13723,9 +14036,9 @@
if (exit $ac_status) && test -s "$ac_outfile"; then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings other than the usual output.
- $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.expsym
$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
- if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+ if test ! -s conftest.er2 || diff conftest.expsym conftest.er2 >/dev/null; then
lt_cv_prog_compiler_pic_works=yes
fi
fi
@@ -13733,8 +14046,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
-printf "%s\n" "$lt_cv_prog_compiler_pic_works" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
+printf '%s\n' "$lt_cv_prog_compiler_pic_works" >&6; }
if test yes = "$lt_cv_prog_compiler_pic_works"; then
case $lt_prog_compiler_pic in
@@ -13762,7 +14075,7 @@
# Check to make sure the static flag actually works.
#
wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
if test ${lt_cv_prog_compiler_static_works+y}
then :
@@ -13778,9 +14091,9 @@
if test -s conftest.err; then
# Append any errors to the config.log.
cat conftest.err 1>&5
- $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+ $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.expsym
$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
- if diff conftest.exp conftest.er2 >/dev/null; then
+ if diff conftest.expsym conftest.er2 >/dev/null; then
lt_cv_prog_compiler_static_works=yes
fi
else
@@ -13792,8 +14105,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
-printf "%s\n" "$lt_cv_prog_compiler_static_works" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
+printf '%s\n' "$lt_cv_prog_compiler_static_works" >&6; }
if test yes = "$lt_cv_prog_compiler_static_works"; then
:
@@ -13807,7 +14120,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
if test ${lt_cv_prog_compiler_c_o+y}
then :
@@ -13838,9 +14151,9 @@
then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings
- $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.expsym
$SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
- if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+ if test ! -s out/conftest.er2 || diff out/conftest.expsym out/conftest.er2 >/dev/null; then
lt_cv_prog_compiler_c_o=yes
fi
fi
@@ -13856,15 +14169,15 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
-printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+printf '%s\n' "$lt_cv_prog_compiler_c_o" >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
if test ${lt_cv_prog_compiler_c_o+y}
then :
@@ -13895,9 +14208,9 @@
then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings
- $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.expsym
$SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
- if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+ if test ! -s out/conftest.er2 || diff out/conftest.expsym out/conftest.er2 >/dev/null; then
lt_cv_prog_compiler_c_o=yes
fi
fi
@@ -13913,8 +14226,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
-printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+printf '%s\n' "$lt_cv_prog_compiler_c_o" >&6; }
@@ -13922,7 +14235,7 @@
hard_links=nottested
if test no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; then
# do not overwrite the value of need_locks provided by the user
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
printf %s "checking if we can lock with hard links... " >&6; }
hard_links=yes
$RM conftest*
@@ -13930,11 +14243,11 @@
touch conftest.a
ln conftest.a conftest.b 2>&5 || hard_links=no
ln conftest.a conftest.b 2>/dev/null && hard_links=no
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
-printf "%s\n" "$hard_links" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
+printf '%s\n' "$hard_links" >&6; }
if test no = "$hard_links"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
-printf "%s\n" "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
+printf '%s\n' "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
need_locks=warn
fi
else
@@ -13946,7 +14259,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
printf %s "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
runpath_var=
@@ -14179,6 +14492,11 @@
archive_expsym_cmds='$SED "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
;;
+ *-mlibc)
+ archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+ archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+ ;;
+
gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
tmp_diet=no
if test linux-dietlibc = "$host_os"; then
@@ -14204,7 +14522,7 @@
tmp_addflag=' -i_dynamic' ;;
efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64
tmp_addflag=' -i_dynamic -nofor_main' ;;
- ifc* | ifort*) # Intel Fortran compiler
+ ifc* | ifort* | ifx*) # Intel Fortran compiler
tmp_addflag=' -nofor_main' ;;
lf95*) # Lahey Fortran 8.1
whole_archive_flag_spec=
@@ -14259,11 +14577,6 @@
fi
;;
- *-mlibc)
- archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
- archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
- ;;
-
netbsd* | netbsdelf*-gnu)
if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
@@ -14662,8 +14975,8 @@
# hardcode_libdir_flag_spec is actually meaningless, as there is
# no search path for DLLs.
case $cc_basename in
- cl* | icl*)
- # Native MSVC or ICC
+ cl* | icl* | icx* | icpx*)
+ # Native MSVC and Intel compilers
hardcode_libdir_flag_spec=' '
allow_undefined_flag=unsupported
always_export_symbols=yes
@@ -14673,14 +14986,20 @@
# Tell ltmain to make .dll files, not .so files.
shrext_cmds=.dll
# FIXME: Setting linknames here is a bad hack.
+ # A check exists to verify if there are linker flags, which will use
+ # different commands when linking.
archive_cmds='$CC -Fe$output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
archive_expsym_cmds='if test DEF = "`$SED -n -e '\''s/^[ ]*//'\'' -e '\''/^\(;.*\)*$/d'\'' -e '\''s/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p'\'' -e q $export_symbols`" ; then
cp "$export_symbols" "$output_objdir/$soname.def";
- echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+ echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.expsym";
else
- $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+ $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.expsym;
+ fi~
+ if test -z "$linker_flags"; then
+ $CC -Fe$tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.expsym" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib";
+ else
+ $CC -Fe$tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.expsym" -Wl,$linker_flags-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib";
fi~
- $CC -Fe$tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
linknames='
# The linker will not automatically build a static lib if we build a DLL.
# _LT_TAGVAR(old_archive_from_new_cmds, )='true'
@@ -14712,7 +15031,7 @@
# Tell ltmain to make .dll files, not .so files.
shrext_cmds=.dll
# FIXME: Setting linknames here is a bad hack.
- archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
+ archive_cmds='$CC -Fe$lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
# The linker will automatically build a .lib file if we build a DLL.
old_archive_from_new_cmds='true'
# FIXME: Should let the user specify the lib program.
@@ -14846,7 +15165,7 @@
# Older versions of the 11.00 compiler do not understand -b yet
# (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5
printf %s "checking if $CC understands -b... " >&6; }
if test ${lt_cv_prog_compiler__b+y}
then :
@@ -14862,9 +15181,9 @@
if test -s conftest.err; then
# Append any errors to the config.log.
cat conftest.err 1>&5
- $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+ $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.expsym
$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
- if diff conftest.exp conftest.er2 >/dev/null; then
+ if diff conftest.expsym conftest.er2 >/dev/null; then
lt_cv_prog_compiler__b=yes
fi
else
@@ -14876,8 +15195,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
-printf "%s\n" "$lt_cv_prog_compiler__b" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
+printf '%s\n' "$lt_cv_prog_compiler__b" >&6; }
if test yes = "$lt_cv_prog_compiler__b"; then
archive_cmds='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
@@ -14917,7 +15236,7 @@
# work, assume that -exports_file does not work either and
# implicitly export all symbols.
# This should be the same for all languages, so no per-tag cache variable.
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5
printf %s "checking whether the $host_os linker accepts -exported_symbol... " >&6; }
if test ${lt_cv_irix_exported_symbol+y}
then :
@@ -14941,8 +15260,8 @@
LDFLAGS=$save_LDFLAGS ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
-printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
+printf '%s\n' "$lt_cv_irix_exported_symbol" >&6; }
if test yes = "$lt_cv_irix_exported_symbol"; then
archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
fi
@@ -14957,6 +15276,9 @@
link_all_deplibs=yes
;;
+ *-mlibc)
+ ;;
+
linux*)
case $cc_basename in
tcc*)
@@ -14968,9 +15290,6 @@
esac
;;
- *-mlibc)
- ;;
-
netbsd* | netbsdelf*-gnu)
if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out
@@ -15062,8 +15381,8 @@
else
allow_undefined_flag=' -expect_unresolved \*'
archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
- archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
- $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
+ archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.expsym; done; printf "%s\\n" "-hidden">> $lib.expsym~
+ $CC -shared$allow_undefined_flag $wl-input $wl$lib.expsym $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.expsym'
# Both c and cxx compiler support -rpath directly
hardcode_libdir_flag_spec='-rpath $libdir'
@@ -15080,21 +15399,21 @@
if test yes = "$GCC"; then
wlarc='$wl'
archive_cmds='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
- archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
- $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+ archive_expsym_cmds='echo "{ global:" > $lib.expsym~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.expsym~echo "local: *; };" >> $lib.expsym~
+ $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.expsym $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.expsym'
else
case `$CC -V 2>&1` in
*"Compilers 5.0"*)
wlarc=''
archive_cmds='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
- archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
- $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+ archive_expsym_cmds='echo "{ global:" > $lib.expsym~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.expsym~echo "local: *; };" >> $lib.expsym~
+ $LD -G$allow_undefined_flag -M $lib.expsym -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.expsym'
;;
*)
wlarc='$wl'
archive_cmds='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
- archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
- $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+ archive_expsym_cmds='echo "{ global:" > $lib.expsym~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.expsym~echo "local: *; };" >> $lib.expsym~
+ $CC -G$allow_undefined_flag -M $lib.expsym -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.expsym'
;;
esac
fi
@@ -15230,8 +15549,8 @@
fi
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
-printf "%s\n" "$ld_shlibs" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
+printf '%s\n' "$ld_shlibs" >&6; }
test no = "$ld_shlibs" && can_build_shared=no
with_gnu_ld=$with_gnu_ld
@@ -15267,7 +15586,7 @@
# Test whether the compiler implicitly links with -lc since on some
# systems, -lgcc has to come before -lc. If gcc already passes -lc
# to ld, don't add -lc before -lgcc.
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
printf %s "checking whether -lc should be explicitly linked in... " >&6; }
if test ${lt_cv_archive_cmds_need_lc+y}
then :
@@ -15279,7 +15598,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } 2>conftest.err; then
soname=conftest
lib=conftest
@@ -15297,7 +15616,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
(eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
then
lt_cv_archive_cmds_need_lc=no
@@ -15312,8 +15631,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
-printf "%s\n" "$lt_cv_archive_cmds_need_lc" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
+printf '%s\n' "$lt_cv_archive_cmds_need_lc" >&6; }
archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc
;;
esac
@@ -15472,7 +15791,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
printf %s "checking dynamic linker characteristics... " >&6; }
if test yes = "$GCC"; then
@@ -15765,8 +16084,8 @@
dynamic_linker='Win32 ld.exe'
;;
- *,cl* | *,icl*)
- # Native MSVC or ICC
+ *,cl* | *,icl* | *,icx*)
+ # Native MSVC and Intel compilers
libname_spec='$name'
soname_spec='$libname`echo $release | $SED -e 's/[.]/-/g'`$versuffix$shared_ext'
library_names_spec='$libname.dll.lib'
@@ -16033,6 +16352,18 @@
hardcode_into_libs=yes
;;
+*-mlibc)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+ soname_spec='$libname$release$shared_ext$major'
+ dynamic_linker='mlibc ld.so'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+
# No shared lib support for Linux oldld, aout, or coff.
linux*oldld* | linux*aout* | linux*coff*)
dynamic_linker=no
@@ -16143,6 +16474,8 @@
shlibpath_overrides_runpath=no
hardcode_into_libs=yes
dynamic_linker='NetBSD ld.elf_so'
+ enable_cxx_stdlib=yes
+ stdlibflag=
;;
netbsd*)
@@ -16161,18 +16494,8 @@
shlibpath_var=LD_LIBRARY_PATH
shlibpath_overrides_runpath=yes
hardcode_into_libs=yes
- ;;
-
-*-mlibc)
- version_type=linux # correct to gnu/linux during the next big refactor
- need_lib_prefix=no
- need_version=no
- library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
- soname_spec='$libname$release$shared_ext$major'
- dynamic_linker='mlibc ld.so'
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=no
- hardcode_into_libs=yes
+ enable_cxx_stdlib=yes
+ stdlibflag=
;;
newsos6)
@@ -16493,7 +16816,7 @@
# AIX 5 now supports IA64 processor
lt_prog_compiler_static='-Bstatic'
else
- lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
+ lt_prog_compiler_static='-bnso -bI:/lib/syscalls.expsym'
fi
;;
@@ -16544,7 +16867,13 @@
lt_prog_compiler_static='-non_shared'
;;
- linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ *-mlibc)
+ lt_prog_compiler_wl='-Wl,'
+ lt_prog_compiler_pic='-fPIC'
+ lt_prog_compiler_static='-static'
+ ;;
+
+ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu* | freebsd*)
case $cc_basename in
# old Intel for x86_64, which still supported -KPIC.
ecc*)
@@ -16560,7 +16889,7 @@
;;
# icc used to be incompatible with GCC.
# ICC 10 doesn't accept -KPIC any more.
- icc* | ifort*)
+ icc* | ifort* | icx* | ifx*)
lt_prog_compiler_wl='-Wl,'
lt_prog_compiler_pic='-fPIC'
lt_prog_compiler_static='-static'
@@ -16640,12 +16969,6 @@
lt_prog_compiler_static='-Bstatic'
;;
- *-mlibc)
- lt_prog_compiler_wl='-Wl,'
- lt_prog_compiler_pic='-fPIC'
- lt_prog_compiler_static='-static'
- ;;
-
*nto* | *qnx*)
# QNX uses GNU C++, but need to define -shared option too, otherwise
# it will coredump.
@@ -16727,7 +17050,7 @@
;;
esac
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
printf %s "checking for $compiler option to produce PIC... " >&6; }
if test ${lt_cv_prog_compiler_pic+y}
then :
@@ -16736,15 +17059,15 @@
e) lt_cv_prog_compiler_pic=$lt_prog_compiler_pic ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
-printf "%s\n" "$lt_cv_prog_compiler_pic" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
+printf '%s\n' "$lt_cv_prog_compiler_pic" >&6; }
lt_prog_compiler_pic=$lt_cv_prog_compiler_pic
#
# Check to make sure the PIC flag actually works.
#
if test -n "$lt_prog_compiler_pic"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
if test ${lt_cv_prog_compiler_pic_works+y}
then :
@@ -16771,9 +17094,9 @@
if (exit $ac_status) && test -s "$ac_outfile"; then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings other than the usual output.
- $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.expsym
$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
- if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+ if test ! -s conftest.er2 || diff conftest.expsym conftest.er2 >/dev/null; then
lt_cv_prog_compiler_pic_works=yes
fi
fi
@@ -16781,8 +17104,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
-printf "%s\n" "$lt_cv_prog_compiler_pic_works" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
+printf '%s\n' "$lt_cv_prog_compiler_pic_works" >&6; }
if test yes = "$lt_cv_prog_compiler_pic_works"; then
case $lt_prog_compiler_pic in
@@ -16804,7 +17127,7 @@
# Check to make sure the static flag actually works.
#
wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
if test ${lt_cv_prog_compiler_static_works+y}
then :
@@ -16820,9 +17143,9 @@
if test -s conftest.err; then
# Append any errors to the config.log.
cat conftest.err 1>&5
- $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+ $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.expsym
$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
- if diff conftest.exp conftest.er2 >/dev/null; then
+ if diff conftest.expsym conftest.er2 >/dev/null; then
lt_cv_prog_compiler_static_works=yes
fi
else
@@ -16834,8 +17157,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
-printf "%s\n" "$lt_cv_prog_compiler_static_works" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
+printf '%s\n' "$lt_cv_prog_compiler_static_works" >&6; }
if test yes = "$lt_cv_prog_compiler_static_works"; then
:
@@ -16856,8 +17179,8 @@
dynamic_linker=no
;;
esac
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
-printf "%s\n" "$dynamic_linker" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
+printf '%s\n' "$dynamic_linker" >&6; }
test no = "$dynamic_linker" && can_build_shared=no
variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
@@ -16978,7 +17301,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
printf %s "checking how to hardcode library paths into programs... " >&6; }
hardcode_action=
if test -n "$hardcode_libdir_flag_spec" ||
@@ -17003,8 +17326,8 @@
# directories.
hardcode_action=unsupported
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
-printf "%s\n" "$hardcode_action" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
+printf '%s\n' "$hardcode_action" >&6; }
if test relink = "$hardcode_action" ||
test yes = "$inherit_rpath"; then
@@ -17048,7 +17371,7 @@
darwin*)
# if libdl is installed we need to link against it
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
printf %s "checking for dlopen in -ldl... " >&6; }
if test ${ac_cv_lib_dl_dlopen+y}
then :
@@ -17089,8 +17412,8 @@
LIBS=$ac_check_lib_save_LIBS ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
-printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+printf '%s\n' "$ac_cv_lib_dl_dlopen" >&6; }
if test "x$ac_cv_lib_dl_dlopen" = xyes
then :
lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
@@ -17119,7 +17442,7 @@
then :
lt_cv_dlopen=shl_load
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
printf %s "checking for shl_load in -ldld... " >&6; }
if test ${ac_cv_lib_dld_shl_load+y}
then :
@@ -17160,8 +17483,8 @@
LIBS=$ac_check_lib_save_LIBS ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
-printf "%s\n" "$ac_cv_lib_dld_shl_load" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
+printf '%s\n' "$ac_cv_lib_dld_shl_load" >&6; }
if test "x$ac_cv_lib_dld_shl_load" = xyes
then :
lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld
@@ -17171,7 +17494,7 @@
then :
lt_cv_dlopen=dlopen
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
printf %s "checking for dlopen in -ldl... " >&6; }
if test ${ac_cv_lib_dl_dlopen+y}
then :
@@ -17212,13 +17535,13 @@
LIBS=$ac_check_lib_save_LIBS ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
-printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+printf '%s\n' "$ac_cv_lib_dl_dlopen" >&6; }
if test "x$ac_cv_lib_dl_dlopen" = xyes
then :
lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
printf %s "checking for dlopen in -lsvld... " >&6; }
if test ${ac_cv_lib_svld_dlopen+y}
then :
@@ -17259,13 +17582,13 @@
LIBS=$ac_check_lib_save_LIBS ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
-printf "%s\n" "$ac_cv_lib_svld_dlopen" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
+printf '%s\n' "$ac_cv_lib_svld_dlopen" >&6; }
if test "x$ac_cv_lib_svld_dlopen" = xyes
then :
lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
printf %s "checking for dld_link in -ldld... " >&6; }
if test ${ac_cv_lib_dld_dld_link+y}
then :
@@ -17306,8 +17629,8 @@
LIBS=$ac_check_lib_save_LIBS ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
-printf "%s\n" "$ac_cv_lib_dld_dld_link" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
+printf '%s\n' "$ac_cv_lib_dld_dld_link" >&6; }
if test "x$ac_cv_lib_dld_dld_link" = xyes
then :
lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld
@@ -17353,7 +17676,7 @@
save_LIBS=$LIBS
LIBS="$lt_cv_dlopen_libs $LIBS"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
printf %s "checking whether a program can dlopen itself... " >&6; }
if test ${lt_cv_dlopen_self+y}
then :
@@ -17437,7 +17760,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
(eval $ac_link) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
(./conftest; exit; ) >&5 2>/dev/null
lt_status=$?
@@ -17456,12 +17779,12 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
-printf "%s\n" "$lt_cv_dlopen_self" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
+printf '%s\n' "$lt_cv_dlopen_self" >&6; }
if test yes = "$lt_cv_dlopen_self"; then
wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
printf %s "checking whether a statically linked program can dlopen itself... " >&6; }
if test ${lt_cv_dlopen_self_static+y}
then :
@@ -17545,7 +17868,7 @@
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
(eval $ac_link) 2>&5
ac_status=$?
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
(./conftest; exit; ) >&5 2>/dev/null
lt_status=$?
@@ -17564,8 +17887,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
-printf "%s\n" "$lt_cv_dlopen_self_static" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
+printf '%s\n' "$lt_cv_dlopen_self_static" >&6; }
fi
CPPFLAGS=$save_CPPFLAGS
@@ -17603,40 +17926,40 @@
striplib=
old_striplib=
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
printf %s "checking whether stripping libraries is possible... " >&6; }
if test -z "$STRIP"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
else
if $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
old_striplib="$STRIP --strip-debug"
striplib="$STRIP --strip-unneeded"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else
case $host_os in
darwin*)
# FIXME - insert some real tests, host_os isn't really good enough
striplib="$STRIP -x"
old_striplib="$STRIP -S"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
;;
freebsd*)
if $STRIP -V 2>&1 | $GREP "elftoolchain" >/dev/null; then
old_striplib="$STRIP --strip-debug"
striplib="$STRIP --strip-unneeded"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
;;
esac
fi
@@ -17654,12 +17977,12 @@
# Report what library types will actually be built
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
printf %s "checking if libtool supports shared libraries... " >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
-printf "%s\n" "$can_build_shared" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
+printf '%s\n' "$can_build_shared" >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
printf %s "checking whether to build shared libraries... " >&6; }
test no = "$can_build_shared" && enable_shared=no
@@ -17684,15 +18007,15 @@
fi
;;
esac
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
-printf "%s\n" "$enable_shared" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
+printf '%s\n' "$enable_shared" >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
printf %s "checking whether to build static libraries... " >&6; }
# Make sure either enable_shared or enable_static is yes.
test yes = "$enable_shared" || enable_static=yes
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
-printf "%s\n" "$enable_static" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
+printf '%s\n' "$enable_static" >&6; }
@@ -17720,6 +18043,13 @@
+
+
+
+
+
+
+
ac_config_commands="$ac_config_commands libtool"
@@ -17731,7 +18061,7 @@
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}windres", so it can be a program name with args.
set dummy ${ac_tool_prefix}windres; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_RC+y}
then :
@@ -17752,7 +18082,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_RC="${ac_tool_prefix}windres"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -17764,11 +18094,11 @@
fi
RC=$ac_cv_prog_RC
if test -n "$RC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RC" >&5
-printf "%s\n" "$RC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $RC" >&5
+printf '%s\n' "$RC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -17777,7 +18107,7 @@
ac_ct_RC=$RC
# Extract the first word of "windres", so it can be a program name with args.
set dummy windres; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_prog_ac_ct_RC+y}
then :
@@ -17798,7 +18128,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_RC="windres"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -17810,11 +18140,11 @@
fi
ac_ct_RC=$ac_cv_prog_ac_ct_RC
if test -n "$ac_ct_RC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RC" >&5
-printf "%s\n" "$ac_ct_RC" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RC" >&5
+printf '%s\n' "$ac_ct_RC" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
if test "x$ac_ct_RC" = x; then
@@ -17822,8 +18152,8 @@
else
case $cross_compiling:$ac_tool_warned in
yes:)
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
RC=$ac_ct_RC
@@ -17931,7 +18261,7 @@
# NOTE: This checks if we are building shared or static library
# and if --with-pic or --without-pic was used. Thus this check
# must be after Libtool initialization.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if library symbol versioning should be used" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if library symbol versioning should be used" >&5
printf %s "checking if library symbol versioning should be used... " >&6; }
# Check whether --enable-symbol-versions was given.
if test ${enable_symbol_versions+y}
@@ -17972,19 +18302,20 @@
# --with-pic and --without-pic though. As long as neither --with-pic nor
# --without-pic is used then we can use #ifdef PIC to detect if the file is
# being built for a shared library.
+LINKER_FLAG_UNDEFINED_VERSION=
if test "x$enable_symbol_versions" = xno
then :
enable_symbol_versions=no
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
elif test "x$enable_shared" = xno
then :
enable_symbol_versions=no
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no (not building a shared library)" >&5
-printf "%s\n" "no (not building a shared library)" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no (not building a shared library)" >&5
+printf '%s\n' "no (not building a shared library)" >&6; }
else case e in #(
e)
@@ -18040,8 +18371,8 @@
have_symbol_versions_linux=1
;;
*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "
On GNU/Linux, building both shared and static library at the same time
is not supported if --with-pic or --without-pic is used.
@@ -18051,15 +18382,51 @@
;;
esac
-printf "%s\n" "#define HAVE_SYMBOL_VERSIONS_LINUX $have_symbol_versions_linux" >>confdefs.h
+printf '%s\n' "#define HAVE_SYMBOL_VERSIONS_LINUX $have_symbol_versions_linux" >>confdefs.h
elif test "x$enable_symbol_versions" != xgeneric ; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: " >&5
-printf "%s\n" "" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: " >&5
+printf '%s\n' "" >&6; }
as_fn_error $? "unknown symbol versioning variant '$enable_symbol_versions'" "$LINENO" 5
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes ($enable_symbol_versions)" >&5
-printf "%s\n" "yes ($enable_symbol_versions)" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes ($enable_symbol_versions)" >&5
+printf '%s\n' "yes ($enable_symbol_versions)" >&6; }
+
+ # If features are disabled in liblzma, some symbols may be missing.
+ # LLVM's lld defaults to --no-undefined-version and the build breaks
+ # if not all symbols in the version script exist. That is good for
+ # catching errors like typos, but in our case the downside is too big.
+ # Avoid the problem by using --undefined-version if the linker
+ # supports it.
+ #
+ # GNU ld has had --no-undefined-version for a long time but it's not
+ # the default. The opposite option --undefined-version was only added
+ # in 2022, thus we must use --undefined-version conditionally.
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if linker supports --undefined-version" >&5
+printf %s "checking if linker supports --undefined-version... " >&6; }
+ OLD_LDFLAGS=$LDFLAGS
+ LDFLAGS="$LDFLAGS -Wl,--undefined-version"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+int main(void) { return 0; }
+_ACEOF
+if ac_fn_c_try_link "$LINENO"
+then :
+
+ LINKER_FLAG_UNDEFINED_VERSION=-Wl,--undefined-version
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
+
+else case e in #(
+ e)
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
+ ;;
+esac
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam \
+ conftest$ac_exeext conftest.$ac_ext
+ LDFLAGS=$OLD_LDFLAGS
;;
esac
fi
@@ -18082,6 +18449,7 @@
+
###############################################################################
# Checks for libraries.
###############################################################################
@@ -18091,7 +18459,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether NLS is requested" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether NLS is requested" >&5
printf %s "checking whether NLS is requested... " >&6; }
# Check whether --enable-nls was given.
if test ${enable_nls+y}
@@ -18102,8 +18470,8 @@
esac
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_NLS" >&5
-printf "%s\n" "$USE_NLS" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $USE_NLS" >&5
+printf '%s\n' "$USE_NLS" >&6; }
@@ -18142,7 +18510,7 @@
# Extract the first word of "msgfmt", so it can be a program name with args.
set dummy msgfmt; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_path_MSGFMT+y}
then :
@@ -18176,16 +18544,16 @@
fi
MSGFMT="$ac_cv_path_MSGFMT"
if test "$MSGFMT" != ":"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSGFMT" >&5
-printf "%s\n" "$MSGFMT" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MSGFMT" >&5
+printf '%s\n' "$MSGFMT" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
# Extract the first word of "gmsgfmt", so it can be a program name with args.
set dummy gmsgfmt; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_path_GMSGFMT+y}
then :
@@ -18208,7 +18576,7 @@
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
ac_cv_path_GMSGFMT="$as_dir$ac_word$ac_exec_ext"
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
break 2
fi
done
@@ -18222,11 +18590,11 @@
fi
GMSGFMT=$ac_cv_path_GMSGFMT
if test -n "$GMSGFMT"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GMSGFMT" >&5
-printf "%s\n" "$GMSGFMT" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $GMSGFMT" >&5
+printf '%s\n' "$GMSGFMT" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -18267,7 +18635,7 @@
# Extract the first word of "xgettext", so it can be a program name with args.
set dummy xgettext; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_path_XGETTEXT+y}
then :
@@ -18301,11 +18669,11 @@
fi
XGETTEXT="$ac_cv_path_XGETTEXT"
if test "$XGETTEXT" != ":"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XGETTEXT" >&5
-printf "%s\n" "$XGETTEXT" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $XGETTEXT" >&5
+printf '%s\n' "$XGETTEXT" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
rm -f messages.po
@@ -18346,7 +18714,7 @@
# Extract the first word of "msgmerge", so it can be a program name with args.
set dummy msgmerge; ac_word=$2
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
printf %s "checking for $ac_word... " >&6; }
if test ${ac_cv_path_MSGMERGE+y}
then :
@@ -18379,11 +18747,11 @@
fi
MSGMERGE="$ac_cv_path_MSGMERGE"
if test "$MSGMERGE" != ":"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSGMERGE" >&5
-printf "%s\n" "$MSGMERGE" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $MSGMERGE" >&5
+printf '%s\n' "$MSGMERGE" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
@@ -18445,16 +18813,16 @@
fi
if test -n "$LD"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ld" >&5
printf %s "checking for ld... " >&6; }
elif test "$GCC" = yes; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
printf %s "checking for ld used by $CC... " >&6; }
elif test "$with_gnu_ld" = yes; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
printf %s "checking for GNU ld... " >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
printf %s "checking for non-GNU ld... " >&6; }
fi
if test -n "$LD"; then
@@ -18578,14 +18946,14 @@
LD="$acl_cv_path_LD"
fi
if test -n "$LD"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
-printf "%s\n" "$LD" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+printf '%s\n' "$LD" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
printf %s "checking if the linker ($LD) is GNU ld... " >&6; }
if test ${acl_cv_prog_gnu_ld+y}
then :
@@ -18602,15 +18970,15 @@
esac ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_prog_gnu_ld" >&5
-printf "%s\n" "$acl_cv_prog_gnu_ld" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $acl_cv_prog_gnu_ld" >&5
+printf '%s\n' "$acl_cv_prog_gnu_ld" >&6; }
with_gnu_ld=$acl_cv_prog_gnu_ld
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shared library run path origin" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for shared library run path origin" >&5
printf %s "checking for shared library run path origin... " >&6; }
if test ${acl_cv_rpath+y}
then :
@@ -18625,8 +18993,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_rpath" >&5
-printf "%s\n" "$acl_cv_rpath" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $acl_cv_rpath" >&5
+printf '%s\n' "$acl_cv_rpath" >&6; }
wl="$acl_cv_wl"
acl_libext="$acl_cv_libext"
acl_shlibext="$acl_cv_shlibext"
@@ -18648,7 +19016,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking 32-bit host C ABI" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking 32-bit host C ABI" >&5
printf %s "checking 32-bit host C ABI... " >&6; }
if test ${gl_cv_host_cpu_c_abi_32bit+y}
then :
@@ -18715,8 +19083,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_host_cpu_c_abi_32bit" >&5
-printf "%s\n" "$gl_cv_host_cpu_c_abi_32bit" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_host_cpu_c_abi_32bit" >&5
+printf '%s\n' "$gl_cv_host_cpu_c_abi_32bit" >&6; }
HOST_CPU_C_ABI_32BIT="$gl_cv_host_cpu_c_abi_32bit"
@@ -18724,7 +19092,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ELF binary format" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for ELF binary format" >&5
printf %s "checking for ELF binary format... " >&6; }
if test ${gl_cv_elf+y}
then :
@@ -18750,8 +19118,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_elf" >&5
-printf "%s\n" "$gl_cv_elf" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_elf" >&5
+printf '%s\n' "$gl_cv_elf" >&6; }
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
@@ -18802,7 +19170,7 @@
}
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for the common suffixes of directories in the library search path" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for the common suffixes of directories in the library search path" >&5
printf %s "checking for the common suffixes of directories in the library search path... " >&6; }
if test ${acl_cv_libdirstems+y}
then :
@@ -18879,8 +19247,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $acl_cv_libdirstems" >&5
-printf "%s\n" "$acl_cv_libdirstems" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $acl_cv_libdirstems" >&5
+printf '%s\n' "$acl_cv_libdirstems" >&6; }
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/,.*//'`
@@ -19450,7 +19818,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CFPreferencesCopyAppValue" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for CFPreferencesCopyAppValue" >&5
printf %s "checking for CFPreferencesCopyAppValue... " >&6; }
if test ${gt_cv_func_CFPreferencesCopyAppValue+y}
then :
@@ -19481,14 +19849,14 @@
LIBS="$gt_saved_LIBS" ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_CFPreferencesCopyAppValue" >&5
-printf "%s\n" "$gt_cv_func_CFPreferencesCopyAppValue" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_CFPreferencesCopyAppValue" >&5
+printf '%s\n' "$gt_cv_func_CFPreferencesCopyAppValue" >&6; }
if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then
-printf "%s\n" "#define HAVE_CFPREFERENCESCOPYAPPVALUE 1" >>confdefs.h
+printf '%s\n' "#define HAVE_CFPREFERENCESCOPYAPPVALUE 1" >>confdefs.h
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CFLocaleCopyPreferredLanguages" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for CFLocaleCopyPreferredLanguages" >&5
printf %s "checking for CFLocaleCopyPreferredLanguages... " >&6; }
if test ${gt_cv_func_CFLocaleCopyPreferredLanguages+y}
then :
@@ -19519,11 +19887,11 @@
LIBS="$gt_saved_LIBS" ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_CFLocaleCopyPreferredLanguages" >&5
-printf "%s\n" "$gt_cv_func_CFLocaleCopyPreferredLanguages" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_cv_func_CFLocaleCopyPreferredLanguages" >&5
+printf '%s\n' "$gt_cv_func_CFLocaleCopyPreferredLanguages" >&6; }
if test $gt_cv_func_CFLocaleCopyPreferredLanguages = yes; then
-printf "%s\n" "#define HAVE_CFLOCALECOPYPREFERREDLANGUAGES 1" >>confdefs.h
+printf '%s\n' "#define HAVE_CFLOCALECOPYPREFERREDLANGUAGES 1" >>confdefs.h
fi
INTL_MACOSX_LIBS=
@@ -19569,7 +19937,7 @@
gt_expression_test_code=
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU gettext in libc" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU gettext in libc" >&5
printf %s "checking for GNU gettext in libc... " >&6; }
if eval test \${$gt_func_gnugettext_libc+y}
then :
@@ -19611,8 +19979,8 @@
esac
fi
eval ac_res=\$$gt_func_gnugettext_libc
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf '%s\n' "$ac_res" >&6; }
if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then
@@ -19645,7 +20013,7 @@
done
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for iconv" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for iconv" >&5
printf %s "checking for iconv... " >&6; }
if test ${am_cv_func_iconv+y}
then :
@@ -19707,10 +20075,10 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_func_iconv" >&5
-printf "%s\n" "$am_cv_func_iconv" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_func_iconv" >&5
+printf '%s\n' "$am_cv_func_iconv" >&6; }
if test "$am_cv_func_iconv" = yes; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for working iconv" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for working iconv" >&5
printf %s "checking for working iconv... " >&6; }
if test ${am_cv_func_iconv_works+y}
then :
@@ -19898,8 +20266,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_func_iconv_works" >&5
-printf "%s\n" "$am_cv_func_iconv_works" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $am_cv_func_iconv_works" >&5
+printf '%s\n' "$am_cv_func_iconv_works" >&6; }
case "$am_cv_func_iconv_works" in
*no) am_func_iconv=no am_cv_lib_iconv=no ;;
*) am_func_iconv=yes ;;
@@ -19909,14 +20277,14 @@
fi
if test "$am_func_iconv" = yes; then
-printf "%s\n" "#define HAVE_ICONV 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ICONV 1" >>confdefs.h
fi
if test "$am_cv_lib_iconv" = yes; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libiconv" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to link with libiconv" >&5
printf %s "checking how to link with libiconv... " >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBICONV" >&5
-printf "%s\n" "$LIBICONV" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LIBICONV" >&5
+printf '%s\n' "$LIBICONV" >&6; }
else
CPPFLAGS="$gl_saved_CPPFLAGS"
LIBICONV=
@@ -20417,7 +20785,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNU gettext in libintl" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for GNU gettext in libintl" >&5
printf %s "checking for GNU gettext in libintl... " >&6; }
if eval test \${$gt_func_gnugettext_libintl+y}
then :
@@ -20515,8 +20883,8 @@
esac
fi
eval ac_res=\$$gt_func_gnugettext_libintl
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-printf "%s\n" "$ac_res" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+printf '%s\n' "$ac_res" >&6; }
fi
if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" = "yes"; } \
@@ -20544,19 +20912,19 @@
if test "$gt_use_preinstalled_gnugettext" = "yes" \
|| test "$nls_cv_use_gnu_gettext" = "yes"; then
-printf "%s\n" "#define ENABLE_NLS 1" >>confdefs.h
+printf '%s\n' "#define ENABLE_NLS 1" >>confdefs.h
else
USE_NLS=no
fi
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use NLS" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether to use NLS" >&5
printf %s "checking whether to use NLS... " >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_NLS" >&5
-printf "%s\n" "$USE_NLS" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $USE_NLS" >&5
+printf '%s\n' "$USE_NLS" >&6; }
if test "$USE_NLS" = "yes"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking where the gettext function comes from" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking where the gettext function comes from" >&5
printf %s "checking where the gettext function comes from... " >&6; }
if test "$gt_use_preinstalled_gnugettext" = "yes"; then
if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then
@@ -20567,18 +20935,18 @@
else
gt_source="included intl directory"
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gt_source" >&5
-printf "%s\n" "$gt_source" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gt_source" >&5
+printf '%s\n' "$gt_source" >&6; }
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
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libintl" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to link with libintl" >&5
printf %s "checking how to link with libintl... " >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIBINTL" >&5
-printf "%s\n" "$LIBINTL" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $LIBINTL" >&5
+printf '%s\n' "$LIBINTL" >&6; }
for element in $INCINTL; do
haveit=
@@ -20605,10 +20973,10 @@
fi
-printf "%s\n" "#define HAVE_GETTEXT 1" >>confdefs.h
+printf '%s\n' "#define HAVE_GETTEXT 1" >>confdefs.h
-printf "%s\n" "#define HAVE_DCGETTEXT 1" >>confdefs.h
+printf '%s\n' "#define HAVE_DCGETTEXT 1" >>confdefs.h
fi
@@ -20634,7 +21002,7 @@
case $USE_NLS-$host_os in #(
yes-mingw*) :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for UCRT and gettext-runtime >= 0.23.1" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for UCRT and gettext-runtime >= 0.23.1" >&5
printf %s "checking for UCRT and gettext-runtime >= 0.23.1... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
@@ -20655,13 +21023,13 @@
if ac_fn_c_try_cpp "$LINENO"
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
e)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
as_fn_error $? "
Translation support (--enable-nls) on native Windows requires
UCRT and gettext-runtime >= 0.23.1. Use --disable-nls to build
@@ -20689,13 +21057,13 @@
ac_fn_c_check_header_compile "$LINENO" "immintrin.h" "ac_cv_header_immintrin_h" "$ac_includes_default"
if test "x$ac_cv_header_immintrin_h" = xyes
then :
- printf "%s\n" "#define HAVE_IMMINTRIN_H 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_IMMINTRIN_H 1" >>confdefs.h
fi
ac_fn_c_check_header_compile "$LINENO" "cpuid.h" "ac_cv_header_cpuid_h" "$ac_includes_default"
if test "x$ac_cv_header_cpuid_h" = xyes
then :
- printf "%s\n" "#define HAVE_CPUID_H 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_CPUID_H 1" >>confdefs.h
fi
@@ -20709,12 +21077,12 @@
if test "x$ac_cv_type__Bool" = xyes
then :
-printf "%s\n" "#define HAVE__BOOL 1" >>confdefs.h
+printf '%s\n' "#define HAVE__BOOL 1" >>confdefs.h
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99 or later" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99 or later" >&5
printf %s "checking for stdbool.h that conforms to C99 or later... " >&6; }
if test ${ac_cv_header_stdbool_h+y}
then :
@@ -20799,12 +21167,12 @@
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
-printf "%s\n" "$ac_cv_header_stdbool_h" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
+printf '%s\n' "$ac_cv_header_stdbool_h" >&6; }
if test $ac_cv_header_stdbool_h = yes; then
-printf "%s\n" "#define HAVE_STDBOOL_H 1" >>confdefs.h
+printf '%s\n' "#define HAVE_STDBOOL_H 1" >>confdefs.h
fi
@@ -20814,10 +21182,10 @@
no|yes) ;; #(
*)
-printf "%s\n" "#define _UINT8_T 1" >>confdefs.h
+printf '%s\n' "#define _UINT8_T 1" >>confdefs.h
-printf "%s\n" "#define uint8_t $ac_cv_c_uint8_t" >>confdefs.h
+printf '%s\n' "#define uint8_t $ac_cv_c_uint8_t" >>confdefs.h
;;
esac
@@ -20827,7 +21195,7 @@
*)
-printf "%s\n" "#define uint16_t $ac_cv_c_uint16_t" >>confdefs.h
+printf '%s\n' "#define uint16_t $ac_cv_c_uint16_t" >>confdefs.h
;;
esac
@@ -20836,7 +21204,7 @@
no|yes) ;; #(
*)
-printf "%s\n" "#define int32_t $ac_cv_c_int32_t" >>confdefs.h
+printf '%s\n' "#define int32_t $ac_cv_c_int32_t" >>confdefs.h
;;
esac
@@ -20845,10 +21213,10 @@
no|yes) ;; #(
*)
-printf "%s\n" "#define _UINT32_T 1" >>confdefs.h
+printf '%s\n' "#define _UINT32_T 1" >>confdefs.h
-printf "%s\n" "#define uint32_t $ac_cv_c_uint32_t" >>confdefs.h
+printf '%s\n' "#define uint32_t $ac_cv_c_uint32_t" >>confdefs.h
;;
esac
@@ -20857,7 +21225,7 @@
no|yes) ;; #(
*)
-printf "%s\n" "#define int64_t $ac_cv_c_int64_t" >>confdefs.h
+printf '%s\n' "#define int64_t $ac_cv_c_int64_t" >>confdefs.h
;;
esac
@@ -20866,10 +21234,10 @@
no|yes) ;; #(
*)
-printf "%s\n" "#define _UINT64_T 1" >>confdefs.h
+printf '%s\n' "#define _UINT64_T 1" >>confdefs.h
-printf "%s\n" "#define uint64_t $ac_cv_c_uint64_t" >>confdefs.h
+printf '%s\n' "#define uint64_t $ac_cv_c_uint64_t" >>confdefs.h
;;
esac
@@ -20878,7 +21246,7 @@
if test "x$ac_cv_type_uintptr_t" = xyes
then :
-printf "%s\n" "#define HAVE_UINTPTR_T 1" >>confdefs.h
+printf '%s\n' "#define HAVE_UINTPTR_T 1" >>confdefs.h
else case e in #(
e) for ac_type in 'unsigned int' 'unsigned long int' \
@@ -20900,7 +21268,7 @@
if ac_fn_c_try_compile "$LINENO"
then :
-printf "%s\n" "#define uintptr_t $ac_type" >>confdefs.h
+printf '%s\n' "#define uintptr_t $ac_type" >>confdefs.h
ac_type=
fi
@@ -20916,7 +21284,7 @@
# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
# declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'.
# This bug is HP SR number 8606223364.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of size_t" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking size of size_t" >&5
printf %s "checking size of size_t... " >&6; }
if test ${ac_cv_sizeof_size_t+y}
then :
@@ -20926,25 +21294,18 @@
then :
else case e in #(
- e) if test "$ac_cv_type_size_t" = yes; then
- { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
-as_fn_error 77 "cannot compute sizeof (size_t)
-See 'config.log' for more details" "$LINENO" 5; }
- else
- ac_cv_sizeof_size_t=0
- fi ;;
+ e) ac_cv_sizeof_size_t=0 ;;
esac
fi
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_size_t" >&5
-printf "%s\n" "$ac_cv_sizeof_size_t" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_size_t" >&5
+printf '%s\n' "$ac_cv_sizeof_size_t" >&6; }
-printf "%s\n" "#define SIZEOF_SIZE_T $ac_cv_sizeof_size_t" >>confdefs.h
+printf '%s\n' "#define SIZEOF_SIZE_T $ac_cv_sizeof_size_t" >>confdefs.h
@@ -20955,7 +21316,7 @@
if test "x$ac_cv_member_struct_stat_st_atim_tv_nsec" = xyes
then :
-printf "%s\n" "#define HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC 1" >>confdefs.h
fi
@@ -20963,7 +21324,7 @@
if test "x$ac_cv_member_struct_stat_st_atimespec_tv_nsec" = xyes
then :
-printf "%s\n" "#define HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC 1" >>confdefs.h
fi
@@ -20971,7 +21332,7 @@
if test "x$ac_cv_member_struct_stat_st_atimensec" = xyes
then :
-printf "%s\n" "#define HAVE_STRUCT_STAT_ST_ATIMENSEC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_STRUCT_STAT_ST_ATIMENSEC 1" >>confdefs.h
fi
@@ -20979,7 +21340,7 @@
if test "x$ac_cv_member_struct_stat_st_uatime" = xyes
then :
-printf "%s\n" "#define HAVE_STRUCT_STAT_ST_UATIME 1" >>confdefs.h
+printf '%s\n' "#define HAVE_STRUCT_STAT_ST_UATIME 1" >>confdefs.h
fi
@@ -20987,7 +21348,7 @@
if test "x$ac_cv_member_struct_stat_st_atim_st__tim_tv_nsec" = xyes
then :
-printf "%s\n" "#define HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC 1" >>confdefs.h
fi
@@ -21000,18 +21361,18 @@
fi
if test "$enable_largefile,$enable_year2038" != no,no
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable large file support" >&5
-printf %s "checking for $CC option to enable large file support... " >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to support large files" >&5
+printf %s "checking for $CC option to support large files... " >&6; }
if test ${ac_cv_sys_largefile_opts+y}
then :
printf %s "(cached) " >&6
else case e in #(
- e) ac_save_CC="$CC"
+ e) ac_save_CPPFLAGS=$CPPFLAGS
ac_opt_found=no
- for ac_opt in "none needed" "-D_FILE_OFFSET_BITS=64" "-D_LARGE_FILES=1" "-n32"; do
+ for ac_opt in "none needed" "-D_FILE_OFFSET_BITS=64" "-D_LARGE_FILES=1"; do
if test x"$ac_opt" != x"none needed"
then :
- CC="$ac_save_CC $ac_opt"
+ CPPFLAGS="$ac_save_CPPFLAGS $ac_opt"
fi
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
@@ -21040,12 +21401,12 @@
if test x"$ac_opt" = x"none needed"
then :
# GNU/Linux s390x and alpha need _FILE_OFFSET_BITS=64 for wide ino_t.
- CC="$CC -DFTYPE=ino_t"
+ CPPFLAGS="$CPPFLAGS -DFTYPE=ino_t"
if ac_fn_c_try_compile "$LINENO"
then :
else case e in #(
- e) CC="$CC -D_FILE_OFFSET_BITS=64"
+ e) CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64"
if ac_fn_c_try_compile "$LINENO"
then :
ac_opt='-D_FILE_OFFSET_BITS=64'
@@ -21061,13 +21422,13 @@
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
test $ac_opt_found = no || break
done
- CC="$ac_save_CC"
+ CPPFLAGS=$ac_save_CPPFLAGS
test $ac_opt_found = yes || ac_cv_sys_largefile_opts="support not detected" ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_opts" >&5
-printf "%s\n" "$ac_cv_sys_largefile_opts" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_largefile_opts" >&5
+printf '%s\n' "$ac_cv_sys_largefile_opts" >&6; }
ac_have_largefile=yes
case $ac_cv_sys_largefile_opts in #(
@@ -21079,22 +21440,20 @@
ac_have_largefile=no ;; #(
"-D_FILE_OFFSET_BITS=64") :
-printf "%s\n" "#define _FILE_OFFSET_BITS 64" >>confdefs.h
+printf '%s\n' "#define _FILE_OFFSET_BITS 64" >>confdefs.h
;; #(
"-D_LARGE_FILES=1") :
-printf "%s\n" "#define _LARGE_FILES 1" >>confdefs.h
+printf '%s\n' "#define _LARGE_FILES 1" >>confdefs.h
;; #(
- "-n32") :
- CC="$CC -n32" ;; #(
*) :
as_fn_error $? "internal error: bad value for \$ac_cv_sys_largefile_opts" "$LINENO" 5 ;;
esac
if test "$enable_year2038" != no
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option for timestamps after 2038" >&5
-printf %s "checking for $CC option for timestamps after 2038... " >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC option to support timestamps after 2038" >&5
+printf %s "checking for $CC option to support timestamps after 2038... " >&6; }
if test ${ac_cv_sys_year2038_opts+y}
then :
printf %s "(cached) " >&6
@@ -21137,8 +21496,8 @@
test $ac_opt_found = yes || ac_cv_sys_year2038_opts="support not detected" ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_year2038_opts" >&5
-printf "%s\n" "$ac_cv_sys_year2038_opts" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_year2038_opts" >&5
+printf '%s\n' "$ac_cv_sys_year2038_opts" >&6; }
ac_have_year2038=yes
case $ac_cv_sys_year2038_opts in #(
@@ -21148,15 +21507,15 @@
ac_have_year2038=no ;; #(
"-D_TIME_BITS=64") :
-printf "%s\n" "#define _TIME_BITS 64" >>confdefs.h
+printf '%s\n' "#define _TIME_BITS 64" >>confdefs.h
;; #(
"-D__MINGW_USE_VC2005_COMPAT") :
-printf "%s\n" "#define __MINGW_USE_VC2005_COMPAT 1" >>confdefs.h
+printf '%s\n' "#define __MINGW_USE_VC2005_COMPAT 1" >>confdefs.h
;; #(
"-U_USE_32_BIT_TIME_T"*) :
- { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error $? "the 'time_t' type is currently forced to be 32-bit. It
will stop working after mid-January 2038. Remove
_USE_32BIT_TIME_T from the compiler flags.
@@ -21168,7 +21527,7 @@
fi
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
printf %s "checking whether byte ordering is bigendian... " >&6; }
if test ${ac_cv_c_bigendian+y}
then :
@@ -21390,17 +21749,17 @@
fi ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
-printf "%s\n" "$ac_cv_c_bigendian" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
+printf '%s\n' "$ac_cv_c_bigendian" >&6; }
case $ac_cv_c_bigendian in #(
yes)
- printf "%s\n" "#define WORDS_BIGENDIAN 1" >>confdefs.h
+ printf '%s\n' "#define WORDS_BIGENDIAN 1" >>confdefs.h
;; #(
no)
;; #(
universal)
-printf "%s\n" "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
+printf '%s\n' "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h
;; #(
*)
@@ -21412,7 +21771,7 @@
# __attribute__((__constructor__)) can be used for one-time initializations.
# Use -Werror because some compilers accept unknown attributes and just
# give a warning.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if __attribute__((__constructor__)) can be used" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if __attribute__((__constructor__)) can be used" >&5
printf %s "checking if __attribute__((__constructor__)) can be used... " >&6; }
have_func_attribute_constructor=no
OLD_CFLAGS="$CFLAGS"
@@ -21428,16 +21787,16 @@
then :
-printf "%s\n" "#define HAVE_FUNC_ATTRIBUTE_CONSTRUCTOR 1" >>confdefs.h
+printf '%s\n' "#define HAVE_FUNC_ATTRIBUTE_CONSTRUCTOR 1" >>confdefs.h
have_func_attribute_constructor=yes
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
e)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
;;
esac
fi
@@ -21464,8 +21823,8 @@
###############################################################################
# Gnulib replacements as needed
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC options needed to detect all undeclared functions" >&5
-printf %s "checking for $CC options needed to detect all undeclared functions... " >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC options to detect undeclared functions" >&5
+printf %s "checking for $CC options to detect undeclared functions... " >&6; }
if test ${ac_cv_c_undeclared_builtin_options+y}
then :
printf %s "(cached) " >&6
@@ -21533,12 +21892,12 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5
-printf "%s\n" "$ac_cv_c_undeclared_builtin_options" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_undeclared_builtin_options" >&5
+printf '%s\n' "$ac_cv_c_undeclared_builtin_options" >&6; }
case $ac_cv_c_undeclared_builtin_options in #(
'cannot detect') :
- { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error $? "cannot make $CC report undeclared builtins
See 'config.log' for more details" "$LINENO" 5; } ;; #(
'none needed') :
@@ -21547,6 +21906,49 @@
ac_c_undeclared_builtin_options=$ac_cv_c_undeclared_builtin_options ;;
esac
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $CC options to ignore future-version functions" >&5
+printf %s "checking for $CC options to ignore future-version functions... " >&6; }
+if test ${ac_cv_c_future_darwin_options+y}
+then :
+ printf %s "(cached) " >&6
+else case e in #(
+ e) ac_compile_saved="$ac_compile"
+ ac_compile="$ac_compile -Werror=unguarded-availability-new"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+#if ! (defined __APPLE__ && defined __MACH__)
+ #error "-Werror=unguarded-availability-new not needed here"
+ #endif
+
+int
+main (void)
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+ ac_cv_c_future_darwin_options='-Werror=unguarded-availability-new'
+else case e in #(
+ e) ac_cv_c_future_darwin_options='none needed' ;;
+esac
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ ac_compile="$ac_compile_saved"
+ ;;
+esac
+fi
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_future_darwin_options" >&5
+printf '%s\n' "$ac_cv_c_future_darwin_options" >&6; }
+ case $ac_cv_c_future_darwin_options in #(
+ 'none needed') :
+ ac_c_future_darwin_options='' ;; #(
+ *) :
+ ac_c_future_darwin_options=$ac_cv_c_future_darwin_options ;;
+esac
+
if test -z "$gl_replace_getopt"; then
for ac_header in getopt.h
@@ -21554,7 +21956,7 @@
ac_fn_c_check_header_compile "$LINENO" "getopt.h" "ac_cv_header_getopt_h" "$ac_includes_default"
if test "x$ac_cv_header_getopt_h" = xyes
then :
- printf "%s\n" "#define HAVE_GETOPT_H 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_GETOPT_H 1" >>confdefs.h
else case e in #(
e) gl_replace_getopt=yes ;;
@@ -21571,7 +21973,7 @@
ac_fn_c_check_func "$LINENO" "getopt_long" "ac_cv_func_getopt_long"
if test "x$ac_cv_func_getopt_long" = xyes
then :
- printf "%s\n" "#define HAVE_GETOPT_LONG 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_GETOPT_LONG 1" >>confdefs.h
else case e in #(
e) gl_replace_getopt=yes ;;
@@ -21583,11 +21985,11 @@
if test -z "$gl_replace_getopt"; then
ac_fn_check_decl "$LINENO" "optreset" "ac_cv_have_decl_optreset" "#include
-" "$ac_c_undeclared_builtin_options" "CFLAGS"
+" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS"
if test "x$ac_cv_have_decl_optreset" = xyes
then :
-printf "%s\n" "#define HAVE_OPTRESET 1" >>confdefs.h
+printf '%s\n' "#define HAVE_OPTRESET 1" >>confdefs.h
fi
fi
@@ -21617,7 +22019,7 @@
-printf "%s\n" "#define __GETOPT_PREFIX rpl_" >>confdefs.h
+printf '%s\n' "#define __GETOPT_PREFIX rpl_" >>confdefs.h
GETOPT_H=getopt.h
@@ -21636,7 +22038,7 @@
# The above reasoning is thoroughly obsolete: On GNU/Linux, librt hasn't
# been needed for clock_gettime() since glibc 2.17 (2012-12-25).
# Solaris 10 needs librt but Solaris 11 doesn't anymore.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing clock_gettime" >&5
printf %s "checking for library containing clock_gettime... " >&6; }
if test ${ac_cv_search_clock_gettime+y}
then :
@@ -21694,8 +22096,8 @@
LIBS=$ac_func_search_save_LIBS ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_clock_gettime" >&5
-printf "%s\n" "$ac_cv_search_clock_gettime" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_clock_gettime" >&5
+printf '%s\n' "$ac_cv_search_clock_gettime" >&6; }
ac_res=$ac_cv_search_clock_gettime
if test "$ac_res" != no
then :
@@ -21706,16 +22108,16 @@
ac_fn_c_check_func "$LINENO" "clock_gettime" "ac_cv_func_clock_gettime"
if test "x$ac_cv_func_clock_gettime" = xyes
then :
- printf "%s\n" "#define HAVE_CLOCK_GETTIME 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_CLOCK_GETTIME 1" >>confdefs.h
fi
ac_fn_check_decl "$LINENO" "CLOCK_MONOTONIC" "ac_cv_have_decl_CLOCK_MONOTONIC" "#include
-" "$ac_c_undeclared_builtin_options" "CFLAGS"
+" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS"
if test "x$ac_cv_have_decl_CLOCK_MONOTONIC" = xyes
then :
-printf "%s\n" "#define HAVE_CLOCK_MONOTONIC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_CLOCK_MONOTONIC 1" >>confdefs.h
fi
@@ -21723,23 +22125,29 @@
for ac_func in futimens futimes futimesat utimes _futime utime
do :
- as_ac_var=`printf "%s\n" "ac_cv_func_$ac_func" | sed "$as_sed_sh"`
+ as_ac_var=`printf '%s\n' "ac_cv_func_$ac_func" | sed "$as_sed_sh"`
ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
if eval test \"x\$"$as_ac_var"\" = x"yes"
then :
cat >>confdefs.h <<_ACEOF
-#define `printf "%s\n" "HAVE_$ac_func" | sed "$as_sed_cpp"` 1
+#define `printf '%s\n' "HAVE_$ac_func" | sed "$as_sed_cpp"` 1
_ACEOF
break
fi
done
-# This is nice to have but not mandatory.
+# These are nice to have but not mandatory.
+ac_fn_c_check_func "$LINENO" "getrlimit" "ac_cv_func_getrlimit"
+if test "x$ac_cv_func_getrlimit" = xyes
+then :
+ printf '%s\n' "#define HAVE_GETRLIMIT 1" >>confdefs.h
+
+fi
ac_fn_c_check_func "$LINENO" "posix_fadvise" "ac_cv_func_posix_fadvise"
if test "x$ac_cv_func_posix_fadvise" = xyes
then :
- printf "%s\n" "#define HAVE_POSIX_FADVISE 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_POSIX_FADVISE 1" >>confdefs.h
fi
@@ -21752,11 +22160,11 @@
ac_fn_check_decl "$LINENO" "program_invocation_name" "ac_cv_have_decl_program_invocation_name" "#include
-" "$ac_c_undeclared_builtin_options" "CFLAGS"
+" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS"
if test "x$ac_cv_have_decl_program_invocation_name" = xyes
then :
-printf "%s\n" "#define HAVE_PROGRAM_INVOCATION_NAME 1" >>confdefs.h
+printf '%s\n' "#define HAVE_PROGRAM_INVOCATION_NAME 1" >>confdefs.h
fi
@@ -21764,7 +22172,7 @@
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if __builtin_bswap16/32/64 are supported" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if __builtin_bswap16/32/64 are supported" >&5
printf %s "checking if __builtin_bswap16/32/64 are supported... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
@@ -21783,25 +22191,25 @@
then :
-printf "%s\n" "#define HAVE___BUILTIN_BSWAPXX 1" >>confdefs.h
+printf '%s\n' "#define HAVE___BUILTIN_BSWAPXX 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
e)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
# Look for other byteswapping methods.
for ac_header in byteswap.h sys/endian.h sys/byteorder.h
do :
- as_ac_Header=`printf "%s\n" "ac_cv_header_$ac_header" | sed "$as_sed_sh"`
+ as_ac_Header=`printf '%s\n' "ac_cv_header_$ac_header" | sed "$as_sed_sh"`
ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
if eval test \"x\$"$as_ac_Header"\" = x"yes"
then :
cat >>confdefs.h <<_ACEOF
-#define `printf "%s\n" "HAVE_$ac_header" | sed "$as_sed_cpp"` 1
+#define `printf '%s\n' "HAVE_$ac_header" | sed "$as_sed_cpp"` 1
_ACEOF
break
fi
@@ -21811,7 +22219,7 @@
# Even if we have byteswap.h we may lack the specific macros/functions.
if test x$ac_cv_header_byteswap_h = xyes ; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if bswap_16 is available" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if bswap_16 is available" >&5
printf %s "checking if bswap_16 is available... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
@@ -21829,21 +22237,21 @@
then :
-printf "%s\n" "#define HAVE_BSWAP_16 1" >>confdefs.h
+printf '%s\n' "#define HAVE_BSWAP_16 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; } ;;
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; } ;;
esac
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if bswap_32 is available" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if bswap_32 is available" >&5
printf %s "checking if bswap_32 is available... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
@@ -21861,21 +22269,21 @@
then :
-printf "%s\n" "#define HAVE_BSWAP_32 1" >>confdefs.h
+printf '%s\n' "#define HAVE_BSWAP_32 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; } ;;
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; } ;;
esac
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if bswap_64 is available" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if bswap_64 is available" >&5
printf %s "checking if bswap_64 is available... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
@@ -21893,14 +22301,14 @@
then :
-printf "%s\n" "#define HAVE_BSWAP_64 1" >>confdefs.h
+printf '%s\n' "#define HAVE_BSWAP_64 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
- e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; } ;;
+ e) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; } ;;
esac
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
@@ -21913,7 +22321,170 @@
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if unaligned memory access should be used" >&5
+# On archs that we use tuklib_integer_strict_align() (see below), we need
+# objdump to detect support for unaligned access. (Libtool needs objdump
+# too, so Libtool does this same tool check as well.)
+if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_OBJDUMP+y}
+then :
+ printf %s "(cached) " >&6
+else case e in #(
+ e) if test -n "$OBJDUMP"; then
+ ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ case $as_dir in #(((
+ '') as_dir=./ ;;
+ */) ;;
+ *) as_dir=$as_dir/ ;;
+ esac
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+ ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi ;;
+esac
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+printf '%s\n' "$OBJDUMP" >&6; }
+else
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+ ac_ct_OBJDUMP=$OBJDUMP
+ # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+printf %s "checking for $ac_word... " >&6; }
+if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
+then :
+ printf %s "(cached) " >&6
+else case e in #(
+ e) if test -n "$ac_ct_OBJDUMP"; then
+ ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ case $as_dir in #(((
+ '') as_dir=./ ;;
+ */) ;;
+ *) as_dir=$as_dir/ ;;
+ esac
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_OBJDUMP="objdump"
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi ;;
+esac
+fi
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+printf '%s\n' "$ac_ct_OBJDUMP" >&6; }
+else
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
+fi
+
+ if test "x$ac_ct_OBJDUMP" = x; then
+ OBJDUMP="false"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+printf '%s\n' "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ OBJDUMP=$ac_ct_OBJDUMP
+ fi
+else
+ OBJDUMP="$ac_cv_prog_OBJDUMP"
+fi
+
+
+# An internal helper that attempts to detect if -mstrict-align or
+# -mno-strict-align is in effect. This sets enable_unaligned_access=yes
+# if compilation succeeds and the regex passed as an argument does *not*
+# match the objdump output of a check program. Otherwise this sets
+# enable_unaligned_access=no.
+tuklib_integer_strict_align ()
+{
+ # First guess no.
+ enable_unaligned_access=no
+
+ # Force -O2 because without optimizations the memcpy()
+ # won't be optimized out.
+ tuklib_integer_saved_CFLAGS=$CFLAGS
+ CFLAGS="$CFLAGS -O2"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+ #include
+ unsigned int check_strict_align(const void *p)
+ {
+ unsigned int i;
+ memcpy(&i, p, sizeof(i));
+ return i;
+ }
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+
+ # Disassemble the test function from the object file.
+ if $OBJDUMP -d conftest.$ac_objext > conftest.s ; then
+ # This function should be passed a regex that
+ # matches if there are instructions that load
+ # unsigned bytes. Such instructions indicate
+ # that -mstrict-align is in effect.
+ #
+ # NOTE: Use braces to avoid M4 parameter
+ # expansion.
+ if grep -- "${1}" conftest.s > /dev/null ; then
+ :
+ else
+ # No single-byte unsigned load
+ # instructions were found,
+ # so it seems that -mno-strict-align
+ # is in effect.
+ # Override our earlier guess.
+ enable_unaligned_access=yes
+ fi
+ fi
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ CFLAGS=$tuklib_integer_saved_CFLAGS
+}
+
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if unaligned memory access should be used" >&5
printf %s "checking if unaligned memory access should be used... " >&6; }
# Check whether --enable-unaligned-access was given.
if test ${enable_unaligned_access+y}
@@ -21931,35 +22502,28 @@
i?86|x86_64|powerpc|powerpc64|powerpc64le)
enable_unaligned_access=yes
;;
- arm*|aarch64*|riscv*)
- # On 32-bit and 64-bit ARM, GCC and Clang
- # #define __ARM_FEATURE_UNALIGNED if
- # unaligned access is supported.
- #
- # Exception: GCC at least up to 13.2.0
- # defines it even when using -mstrict-align
- # so in that case this autodetection goes wrong.
- # Most of the time -mstrict-align isn't used so it
- # shouldn't be a common problem in practice. See:
- # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111555
+ arm*|riscv*)
+ # On 32-bit ARM, GCC and Clang
+ # #define __ARM_FEATURE_UNALIGNED
+ # if and only if unaligned access is supported.
#
# RISC-V C API Specification says that if
# __riscv_misaligned_fast is defined then
# unaligned access is known to be fast.
#
# MSVC is handled as a special case: We assume that
- # 32/64-bit ARM supports fast unaligned access.
+ # 32-bit ARM supports fast unaligned access.
# If MSVC gets RISC-V support then this will assume
# fast unaligned access on RISC-V too.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
-#if !defined(__ARM_FEATURE_UNALIGNED) \
- && !defined(__riscv_misaligned_fast) \
- && !defined(_MSC_VER)
-compile error
-#endif
-int main(void) { return 0; }
+ #if !defined(__ARM_FEATURE_UNALIGNED) \
+ && !defined(__riscv_misaligned_fast) \
+ && !defined(_MSC_VER)
+ compile error
+ #endif
+ int main(void) { return 0; }
_ACEOF
if ac_fn_c_try_compile "$LINENO"
@@ -21971,6 +22535,83 @@
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
;;
+ aarch64*)
+ # On ARM64, Clang defines __ARM_FEATURE_UNALIGNED
+ # if and only if unaligned access is supported.
+ # However, GCC (at least up to 15.2.0) defines it
+ # even when using -mstrict-align, so autodetection
+ # with this macro doesn't work with GCC on ARM64.
+ # (It does work on 32-bit ARM.) See:
+ #
+ # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111555
+ #
+ # We need three checks:
+ #
+ # 1. If __ARM_FEATURE_UNALIGNED is defined and the
+ # compiler isn't GCC, unaligned access is enabled.
+ # If the compiler is MSVC, unaligned access is
+ # enabled even without __ARM_FEATURE_UNALIGNED.
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+ #if defined(__ARM_FEATURE_UNALIGNED) \
+ && (!defined(__GNUC__) \
+ || defined(__clang__))
+ #elif defined(_MSC_VER)
+ #else
+ compile error
+ #endif
+ int main(void) { return 0; }
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+ enable_unaligned_access=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+
+ # 2. If __ARM_FEATURE_UNALIGNED is not defined,
+ # unaligned access is disabled.
+ if test "x$enable_unaligned_access" = xauto ; then
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+ #ifdef __ARM_FEATURE_UNALIGNED
+ compile error
+ #endif
+ int main(void) { return 0; }
+
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"
+then :
+ enable_unaligned_access=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ fi
+
+ # 3. Use heuristics to detect if -mstrict-align is
+ # in effect when building with GCC.
+ if test "x$enable_unaligned_access" = xauto ; then
+ tuklib_integer_strict_align \
+ '[[:blank:]]ldrb[[:blank:]]'
+ fi
+ ;;
+ loongarch*)
+ # See sections 7.4, 8.1, and 8.2:
+ # https://github.com/loongson/la-softdev-convention/blob/v0.2/la-softdev-convention.adoc
+ #
+ # That is, desktop and server processors likely support
+ # unaligned access in hardware but embedded processors
+ # might not. GCC defaults to -mno-strict-align and so
+ # do majority of GNU/Linux distributions. As of
+ # GCC 15.2, there is no predefined macro to detect
+ # if -mstrict-align or -mno-strict-align is in effect.
+ # Use heuristics based on compiler output.
+
+ tuklib_integer_strict_align \
+ '[[:blank:]]ld\.bu[[:blank:]]'
+
+ ;;
*)
enable_unaligned_access=no
;;
@@ -21978,16 +22619,16 @@
fi
if test "x$enable_unaligned_access" = xyes ; then
-printf "%s\n" "#define TUKLIB_FAST_UNALIGNED_ACCESS 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_FAST_UNALIGNED_ACCESS 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if unsafe type punning should be used" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if unsafe type punning should be used" >&5
printf %s "checking if unsafe type punning should be used... " >&6; }
# Check whether --enable-unsafe-type-punning was given.
if test ${enable_unsafe_type_punning+y}
@@ -22000,16 +22641,16 @@
if test "x$enable_unsafe_type_punning" = xyes ; then
-printf "%s\n" "#define TUKLIB_USE_UNSAFE_TYPE_PUNNING 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_USE_UNSAFE_TYPE_PUNNING 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if __builtin_assume_aligned is supported" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if __builtin_assume_aligned is supported" >&5
printf %s "checking if __builtin_assume_aligned is supported... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
@@ -22026,15 +22667,15 @@
then :
-printf "%s\n" "#define HAVE___BUILTIN_ASSUME_ALIGNED 1" >>confdefs.h
+printf '%s\n' "#define HAVE___BUILTIN_ASSUME_ALIGNED 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
e)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
;;
esac
fi
@@ -22048,12 +22689,12 @@
ac_fn_c_check_header_compile "$LINENO" "sys/param.h" "ac_cv_header_sys_param_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_param_h" = xyes
then :
- printf "%s\n" "#define HAVE_SYS_PARAM_H 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_SYS_PARAM_H 1" >>confdefs.h
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to detect the amount of physical memory" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to detect the amount of physical memory" >&5
printf %s "checking how to detect the amount of physical memory... " >&6; }
if test ${tuklib_cv_physmem_method+y}
then :
@@ -22285,43 +22926,43 @@
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tuklib_cv_physmem_method" >&5
-printf "%s\n" "$tuklib_cv_physmem_method" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $tuklib_cv_physmem_method" >&5
+printf '%s\n' "$tuklib_cv_physmem_method" >&6; }
case $tuklib_cv_physmem_method in
aix)
-printf "%s\n" "#define TUKLIB_PHYSMEM_AIX 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_PHYSMEM_AIX 1" >>confdefs.h
;;
sysconf)
-printf "%s\n" "#define TUKLIB_PHYSMEM_SYSCONF 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_PHYSMEM_SYSCONF 1" >>confdefs.h
;;
sysctl)
-printf "%s\n" "#define TUKLIB_PHYSMEM_SYSCTL 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_PHYSMEM_SYSCTL 1" >>confdefs.h
;;
getsysinfo)
-printf "%s\n" "#define TUKLIB_PHYSMEM_GETSYSINFO 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_PHYSMEM_GETSYSINFO 1" >>confdefs.h
;;
pstat_getstatic)
-printf "%s\n" "#define TUKLIB_PHYSMEM_PSTAT_GETSTATIC 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_PHYSMEM_PSTAT_GETSTATIC 1" >>confdefs.h
;;
getinvent_r)
-printf "%s\n" "#define TUKLIB_PHYSMEM_GETINVENT_R 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_PHYSMEM_GETINVENT_R 1" >>confdefs.h
;;
sysinfo)
-printf "%s\n" "#define TUKLIB_PHYSMEM_SYSINFO 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_PHYSMEM_SYSINFO 1" >>confdefs.h
;;
esac
@@ -22333,12 +22974,12 @@
ac_fn_c_check_header_compile "$LINENO" "sys/param.h" "ac_cv_header_sys_param_h" "$ac_includes_default"
if test "x$ac_cv_header_sys_param_h" = xyes
then :
- printf "%s\n" "#define HAVE_SYS_PARAM_H 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_SYS_PARAM_H 1" >>confdefs.h
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to detect the number of available CPU cores" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking how to detect the number of available CPU cores" >&5
printf %s "checking how to detect the number of available CPU cores... " >&6; }
if test ${tuklib_cv_cpucores_method+y}
then :
@@ -22533,33 +23174,33 @@
rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tuklib_cv_cpucores_method" >&5
-printf "%s\n" "$tuklib_cv_cpucores_method" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $tuklib_cv_cpucores_method" >&5
+printf '%s\n' "$tuklib_cv_cpucores_method" >&6; }
case $tuklib_cv_cpucores_method in
sched_getaffinity)
-printf "%s\n" "#define TUKLIB_CPUCORES_SCHED_GETAFFINITY 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_CPUCORES_SCHED_GETAFFINITY 1" >>confdefs.h
;;
cpuset)
-printf "%s\n" "#define TUKLIB_CPUCORES_CPUSET 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_CPUCORES_CPUSET 1" >>confdefs.h
;;
sysctl)
-printf "%s\n" "#define TUKLIB_CPUCORES_SYSCTL 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_CPUCORES_SYSCTL 1" >>confdefs.h
;;
sysconf)
-printf "%s\n" "#define TUKLIB_CPUCORES_SYSCONF 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_CPUCORES_SYSCONF 1" >>confdefs.h
;;
pstat_getdynamic)
-printf "%s\n" "#define TUKLIB_CPUCORES_PSTAT_GETDYNAMIC 1" >>confdefs.h
+printf '%s\n' "#define TUKLIB_CPUCORES_PSTAT_GETDYNAMIC 1" >>confdefs.h
;;
esac
@@ -22567,7 +23208,7 @@
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc and mbstate_t are properly declared" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether mbrtowc and mbstate_t are properly declared" >&5
printf %s "checking whether mbrtowc and mbstate_t are properly declared... " >&6; }
if test ${ac_cv_func_mbrtowc+y}
then :
@@ -22599,24 +23240,24 @@
conftest$ac_exeext conftest.$ac_ext ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mbrtowc" >&5
-printf "%s\n" "$ac_cv_func_mbrtowc" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_mbrtowc" >&5
+printf '%s\n' "$ac_cv_func_mbrtowc" >&6; }
if test $ac_cv_func_mbrtowc = yes; then
-printf "%s\n" "#define HAVE_MBRTOWC 1" >>confdefs.h
+printf '%s\n' "#define HAVE_MBRTOWC 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "wcwidth" "ac_cv_func_wcwidth"
if test "x$ac_cv_func_wcwidth" = xyes
then :
- printf "%s\n" "#define HAVE_WCWIDTH 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_WCWIDTH 1" >>confdefs.h
fi
ac_fn_c_check_func "$LINENO" "vasprintf" "ac_cv_func_vasprintf"
if test "x$ac_cv_func_vasprintf" = xyes
then :
- printf "%s\n" "#define HAVE_VASPRINTF 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_VASPRINTF 1" >>confdefs.h
fi
@@ -22648,12 +23289,12 @@
# succeed.
for ac_header in CommonCrypto/CommonDigest.h sha256.h sha2.h
do :
- as_ac_Header=`printf "%s\n" "ac_cv_header_$ac_header" | sed "$as_sed_sh"`
+ as_ac_Header=`printf '%s\n' "ac_cv_header_$ac_header" | sed "$as_sed_sh"`
ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
if eval test \"x\$"$as_ac_Header"\" = x"yes"
then :
cat >>confdefs.h <<_ACEOF
-#define `printf "%s\n" "HAVE_$ac_header" | sed "$as_sed_cpp"` 1
+#define `printf '%s\n' "HAVE_$ac_header" | sed "$as_sed_cpp"` 1
_ACEOF
sha256_header_found=yes ; break
fi
@@ -22676,7 +23317,7 @@
if test "x$ac_cv_type_CC_SHA256_CTX" = xyes
then :
-printf "%s\n" "#define HAVE_CC_SHA256_CTX 1" >>confdefs.h
+printf '%s\n' "#define HAVE_CC_SHA256_CTX 1" >>confdefs.h
sha256_type_found=yes
fi
@@ -22696,7 +23337,7 @@
if test "x$ac_cv_type_SHA256_CTX" = xyes
then :
-printf "%s\n" "#define HAVE_SHA256_CTX 1" >>confdefs.h
+printf '%s\n' "#define HAVE_SHA256_CTX 1" >>confdefs.h
sha256_type_found=yes
fi
@@ -22716,13 +23357,13 @@
if test "x$ac_cv_type_SHA2_CTX" = xyes
then :
-printf "%s\n" "#define HAVE_SHA2_CTX 1" >>confdefs.h
+printf '%s\n' "#define HAVE_SHA2_CTX 1" >>confdefs.h
sha256_type_found=yes
fi
if test "x$sha256_type_found" = xyes ; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing SHA256Init" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing SHA256Init" >&5
printf %s "checking for library containing SHA256Init... " >&6; }
if test ${ac_cv_search_SHA256Init+y}
then :
@@ -22780,8 +23421,8 @@
LIBS=$ac_func_search_save_LIBS ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_SHA256Init" >&5
-printf "%s\n" "$ac_cv_search_SHA256Init" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_SHA256Init" >&5
+printf '%s\n' "$ac_cv_search_SHA256Init" >&6; }
ac_res=$ac_cv_search_SHA256Init
if test "$ac_res" != no
then :
@@ -22789,7 +23430,7 @@
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for library containing SHA256_Init" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for library containing SHA256_Init" >&5
printf %s "checking for library containing SHA256_Init... " >&6; }
if test ${ac_cv_search_SHA256_Init+y}
then :
@@ -22847,8 +23488,8 @@
LIBS=$ac_func_search_save_LIBS ;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_SHA256_Init" >&5
-printf "%s\n" "$ac_cv_search_SHA256_Init" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_SHA256_Init" >&5
+printf '%s\n' "$ac_cv_search_SHA256_Init" >&6; }
ac_res=$ac_cv_search_SHA256_Init
if test "$ac_res" != no
then :
@@ -22859,12 +23500,12 @@
for ac_func in CC_SHA256_Init SHA256Init SHA256_Init
do :
- as_ac_var=`printf "%s\n" "ac_cv_func_$ac_func" | sed "$as_sed_sh"`
+ as_ac_var=`printf '%s\n' "ac_cv_func_$ac_func" | sed "$as_sed_sh"`
ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
if eval test \"x\$"$as_ac_var"\" = x"yes"
then :
cat >>confdefs.h <<_ACEOF
-#define `printf "%s\n" "HAVE_$ac_func" | sed "$as_sed_cpp"` 1
+#define `printf '%s\n' "HAVE_$ac_func" | sed "$as_sed_cpp"` 1
_ACEOF
sha256_func_found=yes ; break
fi
@@ -22893,11 +23534,11 @@
ac_fn_check_decl "$LINENO" "_mm_movemask_epi8" "ac_cv_have_decl__mm_movemask_epi8" "#ifdef HAVE_IMMINTRIN_H
#include
#endif
-" "$ac_c_undeclared_builtin_options" "CFLAGS"
+" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS"
if test "x$ac_cv_have_decl__mm_movemask_epi8" = xyes
then :
-printf "%s\n" "#define HAVE__MM_MOVEMASK_EPI8 1" >>confdefs.h
+printf '%s\n' "#define HAVE__MM_MOVEMASK_EPI8 1" >>confdefs.h
fi
@@ -22919,13 +23560,13 @@
# NOTE: Use a check that links and not merely compiles to ensure that
# missing intrinsics don't get accepted with compilers that allow
# implicit function declarations.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if _mm_clmulepi64_si128 is usable" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if _mm_clmulepi64_si128 is usable" >&5
printf %s "checking if _mm_clmulepi64_si128 is usable... " >&6; }
if test "x$enable_clmul_crc" = xno
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, --disable-clmul-crc was used" >&5
-printf "%s\n" "no, --disable-clmul-crc was used" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no, --disable-clmul-crc was used" >&5
+printf '%s\n' "no, --disable-clmul-crc was used" >&6; }
else case e in #(
e)
@@ -22957,7 +23598,7 @@
then :
-printf "%s\n" "#define HAVE_USABLE_CLMUL 1" >>confdefs.h
+printf '%s\n' "#define HAVE_USABLE_CLMUL 1" >>confdefs.h
enable_clmul_crc=yes
@@ -22969,8 +23610,8 @@
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_clmul_crc" >&5
-printf "%s\n" "$enable_clmul_crc" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_clmul_crc" >&5
+printf '%s\n' "$enable_clmul_crc" >&6; }
;;
esac
fi
@@ -22979,13 +23620,13 @@
# These are supported by at least GCC and Clang which both need
# __attribute__((__target__("+crc"))), unless the needed compiler flags
# are used to support the CRC instruction.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ARM64 CRC32 instruction is usable" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if ARM64 CRC32 instruction is usable" >&5
printf %s "checking if ARM64 CRC32 instruction is usable... " >&6; }
if test "x$enable_arm64_crc32" = xno
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, --disable-arm64-crc32 was used" >&5
-printf "%s\n" "no, --disable-arm64-crc32 was used" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no, --disable-arm64-crc32 was used" >&5
+printf '%s\n' "no, --disable-arm64-crc32 was used" >&6; }
else case e in #(
e)
@@ -23008,7 +23649,7 @@
then :
-printf "%s\n" "#define HAVE_ARM64_CRC32 1" >>confdefs.h
+printf '%s\n' "#define HAVE_ARM64_CRC32 1" >>confdefs.h
enable_arm64_crc32=yes
@@ -23020,15 +23661,16 @@
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_arm64_crc32" >&5
-printf "%s\n" "$enable_arm64_crc32" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_arm64_crc32" >&5
+printf '%s\n' "$enable_arm64_crc32" >&6; }
;;
esac
fi
# Check for ARM64 CRC32 instruction runtime detection.
#
-# - getauxval() is supported on Linux.
+# - getauxval() is supported on Linux. We also need HWCAP_CRC32 which was
+# added in glibc 2.24.
#
# - elf_aux_info() is supported on FreeBSD and OpenBSD >= 7.6.
#
@@ -23044,17 +23686,25 @@
for ac_func in getauxval elf_aux_info sysctlbyname
do :
- as_ac_var=`printf "%s\n" "ac_cv_func_$ac_func" | sed "$as_sed_sh"`
+ as_ac_var=`printf '%s\n' "ac_cv_func_$ac_func" | sed "$as_sed_sh"`
ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
if eval test \"x\$"$as_ac_var"\" = x"yes"
then :
cat >>confdefs.h <<_ACEOF
-#define `printf "%s\n" "HAVE_$ac_func" | sed "$as_sed_cpp"` 1
+#define `printf '%s\n' "HAVE_$ac_func" | sed "$as_sed_cpp"` 1
_ACEOF
break
fi
done
+ ac_fn_check_decl "$LINENO" "HWCAP_CRC32" "ac_cv_have_decl_HWCAP_CRC32" "#include
+" "$ac_c_undeclared_builtin_options$ac_c_future_darwin_options" "CFLAGS"
+if test "x$ac_cv_have_decl_HWCAP_CRC32" = xyes
+then :
+
+printf '%s\n' "#define HAVE_HWCAP_CRC32 1" >>confdefs.h
+
+fi
fi
@@ -23064,13 +23714,13 @@
#
# Only 64-bit LoongArch is currently supported.
# It doesn't need runtime detection.
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if LoongArch CRC32 instructions are usable" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if LoongArch CRC32 instructions are usable" >&5
printf %s "checking if LoongArch CRC32 instructions are usable... " >&6; }
if test "x$enable_loongarch_crc32" = xno
then :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, --disable-loongarch-crc32 was used" >&5
-printf "%s\n" "no, --disable-loongarch-crc32 was used" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no, --disable-loongarch-crc32 was used" >&5
+printf '%s\n' "no, --disable-loongarch-crc32 was used" >&6; }
else case e in #(
e)
@@ -23092,7 +23742,7 @@
then :
-printf "%s\n" "#define HAVE_LOONGARCH_CRC32 1" >>confdefs.h
+printf '%s\n' "#define HAVE_LOONGARCH_CRC32 1" >>confdefs.h
enable_loongarch_crc32=yes
@@ -23104,8 +23754,8 @@
fi
rm -f core conftest.err conftest.$ac_objext conftest.beam \
conftest$ac_exeext conftest.$ac_ext
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $enable_loongarch_crc32" >&5
-printf "%s\n" "$enable_loongarch_crc32" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $enable_loongarch_crc32" >&5
+printf '%s\n' "$enable_loongarch_crc32" >&6; }
;;
esac
fi
@@ -23132,7 +23782,7 @@
ac_fn_c_check_func "$LINENO" "cap_rights_limit" "ac_cv_func_cap_rights_limit"
if test "x$ac_cv_func_cap_rights_limit" = xyes
then :
- printf "%s\n" "#define HAVE_CAP_RIGHTS_LIMIT 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_CAP_RIGHTS_LIMIT 1" >>confdefs.h
enable_sandbox=found
fi
@@ -23151,7 +23801,7 @@
ac_fn_c_check_func "$LINENO" "pledge" "ac_cv_func_pledge"
if test "x$ac_cv_func_pledge" = xyes
then :
- printf "%s\n" "#define HAVE_PLEDGE 1" >>confdefs.h
+ printf '%s\n' "#define HAVE_PLEDGE 1" >>confdefs.h
enable_sandbox=found
fi
@@ -23164,7 +23814,7 @@
case $enable_sandbox in #(
auto | landlock) :
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if Linux Landlock is usable" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if Linux Landlock is usable" >&5
printf %s "checking if Linux Landlock is usable... " >&6; }
# A compile check is done here because some systems have
@@ -23202,15 +23852,15 @@
esac
-printf "%s\n" "#define HAVE_LINUX_LANDLOCK 1" >>confdefs.h
+printf '%s\n' "#define HAVE_LINUX_LANDLOCK 1" >>confdefs.h
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
e)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
;;
esac
fi
@@ -23249,7 +23899,7 @@
CFLAG_VISIBILITY=
HAVE_VISIBILITY=0
if test -n "$GCC"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the -Werror option is usable" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking whether the -Werror option is usable" >&5
printf %s "checking whether the -Werror option is usable... " >&6; }
if test ${gl_cv_cc_vis_werror+y}
then :
@@ -23280,9 +23930,9 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_vis_werror" >&5
-printf "%s\n" "$gl_cv_cc_vis_werror" >&6; }
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for simple visibility declarations" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_vis_werror" >&5
+printf '%s\n' "$gl_cv_cc_vis_werror" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking for simple visibility declarations" >&5
printf %s "checking for simple visibility declarations... " >&6; }
if test ${gl_cv_cc_visibility+y}
then :
@@ -23326,8 +23976,8 @@
;;
esac
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_visibility" >&5
-printf "%s\n" "$gl_cv_cc_visibility" >&6; }
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: $gl_cv_cc_visibility" >&5
+printf '%s\n' "$gl_cv_cc_visibility" >&6; }
if test $gl_cv_cc_visibility = yes; then
CFLAG_VISIBILITY="-fvisibility=hidden"
HAVE_VISIBILITY=1
@@ -23336,7 +23986,7 @@
-printf "%s\n" "#define HAVE_VISIBILITY $HAVE_VISIBILITY" >>confdefs.h
+printf '%s\n' "#define HAVE_VISIBILITY $HAVE_VISIBILITY" >>confdefs.h
if test -n "$CFLAG_VISIBILITY" && test "$is_w32" = no; then
@@ -23394,20 +24044,20 @@
-Wc11-extensions \
-Wc2x-compat \
-Wc2x-extensions \
- -Wpre-c2x-compat \
-Warray-bounds-pointer-arithmetic \
-Wassign-enum \
-Wconditional-uninitialized \
-Wdocumentation \
-Wduplicate-enum \
-Wempty-translation-unit \
+ -Wextra-semi-stmt \
-Wflexible-array-extensions \
-Wmissing-variable-declarations \
-Wnewline-eof \
-Wshift-sign-overflow \
-Wstring-conversion
do
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $CC accepts $NEW_FLAG" >&5
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking if $CC accepts $NEW_FLAG" >&5
printf %s "checking if $CC accepts $NEW_FLAG... " >&6; }
OLD_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $NEW_FLAG -Werror"
@@ -23419,13 +24069,13 @@
then :
AM_CFLAGS="$AM_CFLAGS $NEW_FLAG"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-printf "%s\n" "yes" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf '%s\n' "yes" >&6; }
else case e in #(
e)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-printf "%s\n" "no" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf '%s\n' "no" >&6; }
;;
esac
fi
@@ -23500,44 +24150,7 @@
_ACEOF
-# The following way of writing the cache mishandles newlines in values,
-# but we know of no workaround that is simple, portable, and efficient.
-# So, we kill variables containing newlines.
-# Ultrix sh set writes to stderr and can't be redirected directly,
-# and sets the high bit in the cache file unless we assign to the vars.
-(
- for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
- eval ac_val=\$$ac_var
- case $ac_val in #(
- *${as_nl}*)
- case $ac_var in #(
- *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
- esac
- case $ac_var in #(
- _ | IFS | as_nl) ;; #(
- BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
- *) { eval $ac_var=; unset $ac_var;} ;;
- esac ;;
- esac
- done
-
- (set) 2>&1 |
- case $as_nl`(ac_space=' '; set) 2>&1` in #(
- *${as_nl}ac_space=\ *)
- # 'set' does not quote correctly, so add quotes: double-quote
- # substitution turns \\\\ into \\, and sed turns \\ into \.
- sed -n \
- "s/'/'\\\\''/g;
- s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
- ;; #(
- *)
- # 'set' quotes correctly as required by POSIX, so do not add quotes.
- sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
- ;;
- esac |
- sort
-) |
+ac_cache_dump |
sed '
/^ac_cv_env_/b end
t clear
@@ -23549,8 +24162,8 @@
if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
if test -w "$cache_file"; then
if test "x$cache_file" != "x/dev/null"; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
-printf "%s\n" "$as_me: updating cache $cache_file" >&6;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+printf '%s\n' "$as_me: updating cache $cache_file" >&6;}
if test ! -f "$cache_file" || test -h "$cache_file"; then
cat confcache >"$cache_file"
else
@@ -23564,8 +24177,8 @@
fi
fi
else
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
-printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+printf '%s\n' "$as_me: not updating unwritable cache $cache_file" >&6;}
fi
fi
rm -f confcache
@@ -23582,7 +24195,7 @@
for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
# 1. Remove the extension, and $U if already installed.
ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
- ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"`
+ ac_i=`printf '%s\n' "$ac_i" | sed "$ac_script"`
# 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR
# will be set to the directory where LIBOBJS objects are built.
as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
@@ -23821,14 +24434,14 @@
as_fn_error $? "conditional \"COND_DOXYGEN\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
printf %s "checking that generated files are newer than configure... " >&6; }
if test -n "$am_sleep_pid"; then
# Hide warnings about reused PIDs.
wait $am_sleep_pid 2>/dev/null
fi
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: done" >&5
-printf "%s\n" "done" >&6; }
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: result: done" >&5
+printf '%s\n' "done" >&6; }
case $enable_silent_rules in # (((
yes) AM_DEFAULT_VERBOSITY=0;;
no) AM_DEFAULT_VERBOSITY=1;;
@@ -23894,13 +24507,21 @@
fi
: "${CONFIG_STATUS=./config.status}"
+case $CONFIG_STATUS in #(
+ -*) :
+ CONFIG_STATUS=./$CONFIG_STATUS ;; #(
+ */*) :
+ ;; #(
+ *) :
+ CONFIG_STATUS=./$CONFIG_STATUS ;;
+esac
+
ac_write_fail=0
-ac_clean_files_save=$ac_clean_files
-ac_clean_files="$ac_clean_files $CONFIG_STATUS"
-{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
-printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;}
+ac_clean_CONFIG_STATUS='"$CONFIG_STATUS"'
+{ printf '%s\n' "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+printf '%s\n' "$as_me: creating $CONFIG_STATUS" >&6;}
as_write_fail=0
-cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+cat >"$CONFIG_STATUS" <<_ASEOF || as_write_fail=1
#! $SHELL
# Generated by $as_me.
# Run this file to recreate the current configuration.
@@ -23914,7 +24535,7 @@
SHELL=\${CONFIG_SHELL-$SHELL}
export SHELL
_ASEOF
-cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ASEOF || as_write_fail=1
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##
@@ -23926,7 +24547,7 @@
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
- # is contrary to our usage. Disable this feature.
+ # contradicts POSIX and common usage. Disable this.
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else case e in #(
@@ -24013,7 +24634,7 @@
as_myself=$0
fi
if test ! -f "$as_myself"; then
- printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+ printf '%s\n' "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
exit 1
fi
@@ -24029,9 +24650,9 @@
as_status=$1; test $as_status -eq 0 && as_status=1
if test "$4"; then
as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
- printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+ printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
fi
- printf "%s\n" "$as_me: error: $2" >&2
+ printf '%s\n' "$as_me: error: $2" >&2
as_fn_exit $as_status
} # as_fn_error
@@ -24126,7 +24747,7 @@
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
X"$0" : 'X\(//\)$' \| \
X"$0" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X/"$0" |
+printf '%s\n' X/"$0" |
sed '/^.*\/\([^/][^/]*\)\/*$/{
s//\1/
q
@@ -24148,29 +24769,6 @@
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits
-
-# Determine whether it's possible to make 'echo' print without a newline.
-# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
-# for compatibility with existing Makefiles.
-ECHO_C= ECHO_N= ECHO_T=
-case `echo -n x` in #(((((
--n*)
- case `echo 'xy\c'` in
- *c*) ECHO_T=' ';; # ECHO_T is single tab character.
- xy) ECHO_C='\c';;
- *) echo `echo ksh88 bug on AIX 6.1` > /dev/null
- ECHO_T=' ';;
- esac;;
-*)
- ECHO_N='-n';;
-esac
-
-# For backward compatibility with old third-party macros, we provide
-# the shell variables $as_echo and $as_echo_n. New code should use
-# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
-as_echo='printf %s\n'
-as_echo_n='printf %s'
-
rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
rm -f conf$$.dir/conf$$.file
@@ -24212,7 +24810,7 @@
as_dirs=
while :; do
case $as_dir in #(
- *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+ *\'*) as_qdir=`printf '%s\n' "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
*) as_qdir=$as_dir;;
esac
as_dirs="'$as_qdir' $as_dirs"
@@ -24221,7 +24819,7 @@
X"$as_dir" : 'X\(//\)[^/]' \| \
X"$as_dir" : 'X\(//\)$' \| \
X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$as_dir" |
+printf '%s\n' X"$as_dir" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
@@ -24274,19 +24872,19 @@
exec 6>&1
-## ----------------------------------- ##
-## Main body of $CONFIG_STATUS script. ##
-## ----------------------------------- ##
+## ------------------------------------- ##
+## Main body of "$CONFIG_STATUS" script. ##
+## ------------------------------------- ##
_ASEOF
-test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+test $as_write_fail = 0 && chmod +x "$CONFIG_STATUS" || ac_write_fail=1
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
# Save the log message, to keep $0 and so on meaningful, and to
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
-This file was extended by XZ Utils $as_me 5.8.1, which was
-generated by GNU Autoconf 2.72. Invocation command line was
+This file was extended by XZ Utils $as_me 5.8.3, which was
+generated by GNU Autoconf 2.73. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
CONFIG_HEADERS = $CONFIG_HEADERS
@@ -24308,7 +24906,7 @@
esac
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1
# Files that config.status was made for.
config_files="$ac_config_files"
config_headers="$ac_config_headers"
@@ -24316,7 +24914,7 @@
_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
ac_cs_usage="\
'$as_me' instantiates files and other configuration actions
from templates according to the current configuration. Unless the files
@@ -24349,16 +24947,16 @@
XZ Utils home page: ."
_ACEOF
-ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"`
-ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"`
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config=`printf '%s\n' "$ac_configure_args" | sed "$ac_safe_unquote"`
+ac_cs_config_escaped=`printf '%s\n' "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"`
+cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1
ac_cs_config='$ac_cs_config_escaped'
ac_cs_version="\\
-XZ Utils config.status 5.8.1
-configured by $0, generated by GNU Autoconf 2.72,
+XZ Utils config.status 5.8.3
+configured by $0, generated by GNU Autoconf 2.73,
with options \\"\$ac_cs_config\\"
-Copyright (C) 2023 Free Software Foundation, Inc.
+Copyright (C) 2026 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."
@@ -24367,10 +24965,14 @@
INSTALL='$INSTALL'
MKDIR_P='$MKDIR_P'
AWK='$AWK'
-test -n "\$AWK" || AWK=awk
+test -n "\$AWK" || {
+ awk '' >$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
# The default lists apply if the user does not specify any file.
ac_need_defaults=:
while test $# != 0
@@ -24398,15 +25000,15 @@
-recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
ac_cs_recheck=: ;;
--version | --versio | --versi | --vers | --ver | --ve | --v | -V )
- printf "%s\n" "$ac_cs_version"; exit ;;
+ printf '%s\n' "$ac_cs_version"; exit ;;
--config | --confi | --conf | --con | --co | --c )
- printf "%s\n" "$ac_cs_config"; exit ;;
+ printf '%s\n' "$ac_cs_config"; exit ;;
--debug | --debu | --deb | --de | --d | -d )
debug=: ;;
--file | --fil | --fi | --f )
$ac_shift
case $ac_optarg in
- *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+ *\'*) ac_optarg=`printf '%s\n' "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
'') as_fn_error $? "missing file argument" ;;
esac
as_fn_append CONFIG_FILES " '$ac_optarg'"
@@ -24414,7 +25016,7 @@
--header | --heade | --head | --hea )
$ac_shift
case $ac_optarg in
- *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+ *\'*) ac_optarg=`printf '%s\n' "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
as_fn_append CONFIG_HEADERS " '$ac_optarg'"
ac_need_defaults=false;;
@@ -24423,7 +25025,7 @@
as_fn_error $? "ambiguous option: '$1'
Try '$0 --help' for more information.";;
--help | --hel | -h )
- printf "%s\n" "$ac_cs_usage"; exit ;;
+ printf '%s\n' "$ac_cs_usage"; exit ;;
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
| -silent | --silent | --silen | --sile | --sil | --si | --s)
ac_cs_silent=: ;;
@@ -24447,29 +25049,29 @@
fi
_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1
if \$ac_cs_recheck; then
set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
shift
- \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6
+ \printf '%s\n' "running CONFIG_SHELL=$SHELL \$*" >&6
CONFIG_SHELL='$SHELL'
export CONFIG_SHELL
exec "\$@"
fi
_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
exec 5>>config.log
{
echo
sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
## Running $as_me. ##
_ASBOX
- printf "%s\n" "$ac_log"
+ printf '%s\n' "$ac_log"
} >&5
_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1
#
# INIT-COMMANDS
#
@@ -24491,6 +25093,8 @@
enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
+enable_cxx_stdlib='`$ECHO "$enable_cxx_stdlib" | $SED "$delay_single_quote_subst"`'
+stdlibflag='`$ECHO "$stdlibflag" | $SED "$delay_single_quote_subst"`'
enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`'
SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
@@ -24518,6 +25122,7 @@
lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`'
lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`'
lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`'
+lt_cv_cygpath_installed='`$ECHO "$lt_cv_cygpath_installed" | $SED "$delay_single_quote_subst"`'
reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`'
reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`'
FILECMD='`$ECHO "$FILECMD" | $SED "$delay_single_quote_subst"`'
@@ -24700,6 +25305,7 @@
want_nocaseglob \
sharedlib_from_linklib_cmd \
AR \
+lt_ar_flags \
archiver_list_spec \
STRIP \
RANLIB \
@@ -24844,7 +25450,7 @@
_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
# Handling of arguments.
for ac_config_target in $ac_config_targets
@@ -24943,13 +25549,13 @@
echo "_ACEOF"
} >conf$$subs.sh ||
as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim_num=`echo "$ac_subst_vars" | sed -n '$='`
ac_delim='%!_!# '
for ac_last_try in false false false false false :; do
. ./conf$$subs.sh ||
as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
- ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+ ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | sed -n '$='`
if test $ac_delim_n = $ac_delim_num; then
break
elif $ac_last_try; then
@@ -24960,7 +25566,7 @@
done
rm -f conf$$subs.sh
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1
cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
_ACEOF
sed -n '
@@ -25005,9 +25611,9 @@
N
s/\n//
}
-' >>$CONFIG_STATUS || ac_write_fail=1
+' >>"$CONFIG_STATUS" || ac_write_fail=1
rm -f conf$$subs.awk
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1
_ACAWK
cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
for (key in S) S_is_set[key] = 1
@@ -25036,7 +25642,7 @@
_ACAWK
_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
else
@@ -25068,7 +25674,7 @@
}'
fi
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
fi # test -n "$CONFIG_FILES"
# Set up the scripts for CONFIG_HEADERS section.
@@ -25139,9 +25745,9 @@
b cont
' >$CONFIG_STATUS || ac_write_fail=1
+"/g' >>"$CONFIG_STATUS" || ac_write_fail=1
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1
for (key in D) D_is_set[key] = 1
FS = ""
}
@@ -25159,8 +25765,12 @@
macro = mac2[1]
prefix = substr(line, 1, index(line, defundef) - 1)
if (D_is_set[macro]) {
+ suffix = P[macro] D[macro]
+ while (suffix ~ /[\t ]$/) {
+ suffix = substr(suffix, 1, length(suffix) - 1)
+ }
# Preserve the white space surrounding the "#".
- print prefix "define", macro P[macro] D[macro]
+ print prefix "define", macro suffix
next
} else {
# Replace #undef with comments. This is necessary, for example,
@@ -25175,7 +25785,7 @@
{ print }
_ACAWK
_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
fi # test -n "$CONFIG_HEADERS"
@@ -25219,7 +25829,7 @@
esac ||
as_fn_error 1 "cannot find input file: '$ac_f'" "$LINENO" 5;;
esac
- case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+ case $ac_f in *\'*) ac_f=`printf '%s\n' "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
as_fn_append ac_file_inputs " '$ac_f'"
done
@@ -25227,17 +25837,17 @@
# use $as_me), people would be surprised to read:
# /* config.h. Generated by config.status. */
configure_input='Generated from '`
- printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+ printf '%s\n' "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
`' by configure.'
if test x"$ac_file" != x-; then
configure_input="$ac_file. $configure_input"
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
-printf "%s\n" "$as_me: creating $ac_file" >&6;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+printf '%s\n' "$as_me: creating $ac_file" >&6;}
fi
# Neutralize special characters interpreted by sed in replacement strings.
case $configure_input in #(
*\&* | *\|* | *\\* )
- ac_sed_conf_input=`printf "%s\n" "$configure_input" |
+ ac_sed_conf_input=`printf '%s\n' "$configure_input" |
sed 's/[\\\\&|]/\\\\&/g'`;; #(
*) ac_sed_conf_input=$configure_input;;
esac
@@ -25254,7 +25864,7 @@
X"$ac_file" : 'X\(//\)[^/]' \| \
X"$ac_file" : 'X\(//\)$' \| \
X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$ac_file" |
+printf '%s\n' X"$ac_file" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
@@ -25278,9 +25888,9 @@
case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
- ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
+ ac_dir_suffix=/`printf '%s\n' "$ac_dir" | sed 's|^\.[\\/]||'`
# A ".." for each directory in $ac_dir_suffix.
- ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+ ac_top_builddir_sub=`printf '%s\n' "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
case $ac_top_builddir_sub in
"") ac_top_builddir_sub=. ac_top_build_prefix= ;;
*) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
@@ -25325,7 +25935,7 @@
esac
_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
# If the template does not know about datarootdir, expand it.
# FIXME: This hack should be removed a few years after 2.60.
ac_datarootdir_hack=; ac_datarootdir_seen=
@@ -25342,10 +25952,10 @@
case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
*datarootdir*) ac_datarootdir_seen=yes;;
*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
-printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+printf '%s\n' "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
_ACEOF
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1
ac_datarootdir_hack='
s&@datadir@&$datadir&g
s&@docdir@&$docdir&g
@@ -25359,11 +25969,11 @@
# Neutralize VPATH when '$srcdir' = '.'.
# Shell code in configure.ac might set extrasub.
# FIXME: do we really want to maintain this feature?
-cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<_ACEOF || ac_write_fail=1
ac_sed_extra="$ac_vpsub
$extrasub
_ACEOF
-cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+cat >>"$CONFIG_STATUS" <<\_ACEOF || ac_write_fail=1
:t
/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
s|@configure_input@|$ac_sed_conf_input|;t t
@@ -25387,9 +25997,9 @@
{ ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
{ ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \
"$ac_tmp/out"`; test -z "$ac_out"; } &&
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir'
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir'
which seems to be undefined. Please make sure it is defined" >&5
-printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir'
+printf '%s\n' "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir'
which seems to be undefined. Please make sure it is defined" >&2;}
rm -f "$ac_tmp/stdin"
@@ -25405,20 +26015,20 @@
#
if test x"$ac_file" != x-; then
{
- printf "%s\n" "/* $configure_input */" >&1 \
+ printf '%s\n' "/* $configure_input */" >&1 \
&& eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
} >"$ac_tmp/config.h" \
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
-printf "%s\n" "$as_me: $ac_file is unchanged" >&6;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+printf '%s\n' "$as_me: $ac_file is unchanged" >&6;}
else
rm -f "$ac_file"
mv "$ac_tmp/config.h" "$ac_file" \
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
fi
else
- printf "%s\n" "/* $configure_input */" >&1 \
+ printf '%s\n' "/* $configure_input */" >&1 \
&& eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
|| as_fn_error $? "could not create -" "$LINENO" 5
fi
@@ -25438,7 +26048,7 @@
X"$_am_arg" : 'X\(//\)[^/]' \| \
X"$_am_arg" : 'X\(//\)$' \| \
X"$_am_arg" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$_am_arg" |
+printf '%s\n' X"$_am_arg" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
@@ -25458,8 +26068,8 @@
s/.*/./; q'`/stamp-h$_am_stamp_count
;;
- :C) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
-printf "%s\n" "$as_me: executing $ac_file commands" >&6;}
+ :C) { printf '%s\n' "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
+printf '%s\n' "$as_me: executing $ac_file commands" >&6;}
;;
esac
@@ -25485,7 +26095,7 @@
for am_mf
do
# Strip MF so we end up with the name of the file.
- am_mf=`printf "%s\n" "$am_mf" | sed -e 's/:.*$//'`
+ am_mf=`printf '%s\n' "$am_mf" | sed -e 's/:.*$//'`
# Check whether this is an Automake generated Makefile which includes
# dependency-tracking related rules and includes.
# Grep'ing the whole file directly is not great: AIX grep has a line
@@ -25497,7 +26107,7 @@
X"$am_mf" : 'X\(//\)[^/]' \| \
X"$am_mf" : 'X\(//\)$' \| \
X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X"$am_mf" |
+printf '%s\n' X"$am_mf" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
@@ -25519,7 +26129,7 @@
$as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
X"$am_mf" : 'X\(//\)$' \| \
X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
-printf "%s\n" X/"$am_mf" |
+printf '%s\n' X/"$am_mf" |
sed '/^.*\/\([^/][^/]*\)\/*$/{
s//\1/
q
@@ -25544,8 +26154,8 @@
(exit $ac_status); } || am_rc=$?
done
if test $am_rc -ne 0; then
- { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ { { printf '%s\n' "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
+printf '%s\n' "$as_me: error: in '$ac_pwd':" >&2;}
as_fn_error $? "Something went wrong bootstrapping makefile fragments
for automatic dependency tracking. If GNU make was not used, consider
re-running the configure script with MAKE=\"gmake\" (or whatever is
@@ -25581,7 +26191,7 @@
# Provide generalized library-building support services.
# Written by Gordon Matzigkeit, 1996
-# Copyright (C) 2024 Free Software Foundation, Inc.
+# Copyright (C) 2025 Free Software Foundation, Inc.
# This is free software; see the source for copying conditions. There is NO
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
@@ -25634,6 +26244,12 @@
# What type of objects to build.
pic_mode=$pic_mode
+# Whether to let the compiler frontend decide what standard libraries to link when building C++ shared libraries and modules.
+enable_cxx_stdlib=$enable_cxx_stdlib
+
+# Flag used for specifying not to link standard libraries.
+stdlibflag=$stdlibflag
+
# Whether or not to optimize for fast installation.
fast_install=$enable_fast_install
@@ -25704,6 +26320,9 @@
# convert \$build files to toolchain format.
to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+# whether cygpath is installed.
+cygpath_installed=$lt_cv_cygpath_installed
+
# A file(cmd) program that detects file types.
FILECMD=$lt_FILECMD
@@ -25726,7 +26345,7 @@
AR=$lt_AR
# Flags to create an archive (by configure).
-lt_ar_flags=$lt_ar_flags
+lt_ar_flags=$lt_lt_ar_flags
# Flags to create an archive.
AR_FLAGS=\${ARFLAGS-"\$lt_ar_flags"}
@@ -26376,7 +26995,7 @@
as_fn_exit 0
_ACEOF
-ac_clean_files=$ac_clean_files_save
+ac_clean_CONFIG_STATUS=
test $ac_write_fail = 0 ||
as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
@@ -26392,19 +27011,26 @@
# need to make the FD available again.
if test "$no_create" != yes; then
ac_cs_success=:
+ case $CONFIG_STATUS in #(
+ -*) :
+ ac_no_opts=-- ;; #(
+ *) :
+ ac_no_opts= ;;
+esac
ac_config_status_args=
test "$silent" = yes &&
ac_config_status_args="$ac_config_status_args --quiet"
exec 5>/dev/null
- $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+ $SHELL $ac_no_opts "$CONFIG_STATUS" $ac_config_status_args ||
+ ac_cs_success=false
exec 5>>config.log
# Use ||, not &&, to avoid exiting from the if with $? = 1, which
# would make configure fail if this is the last instruction.
$ac_cs_success || as_fn_exit 1
fi
if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
- { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
-printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+ { printf '%s\n' "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+printf '%s\n' "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
fi
diff -Nru xz-utils-5.8.1/configure.ac xz-utils-5.8.3/configure.ac
--- xz-utils-5.8.1/configure.ac 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/configure.ac 2026-03-31 15:27:00.000000000 +0000
@@ -350,7 +350,7 @@
case $host_os in
# Darwin should work too but only if not creating universal
# binaries. Solaris x86 could work too but I cannot test.
- linux* | *bsd* | mingw* | cygwin | msys | *djgpp*)
+ linux* | gnu* | *bsd* | mingw* | cygwin | msys | *djgpp*)
case $host_cpu in
i?86) enable_assembler=x86 ;;
esac
@@ -758,6 +758,7 @@
# --with-pic and --without-pic though. As long as neither --with-pic nor
# --without-pic is used then we can use #ifdef PIC to detect if the file is
# being built for a shared library.
+LINKER_FLAG_UNDEFINED_VERSION=
AS_IF([test "x$enable_symbol_versions" = xno], [
enable_symbol_versions=no
AC_MSG_RESULT([no])
@@ -831,12 +832,34 @@
AC_MSG_ERROR([unknown symbol versioning variant '$enable_symbol_versions'])
fi
AC_MSG_RESULT([yes ($enable_symbol_versions)])
+
+ # If features are disabled in liblzma, some symbols may be missing.
+ # LLVM's lld defaults to --no-undefined-version and the build breaks
+ # if not all symbols in the version script exist. That is good for
+ # catching errors like typos, but in our case the downside is too big.
+ # Avoid the problem by using --undefined-version if the linker
+ # supports it.
+ #
+ # GNU ld has had --no-undefined-version for a long time but it's not
+ # the default. The opposite option --undefined-version was only added
+ # in 2022, thus we must use --undefined-version conditionally.
+ AC_MSG_CHECKING([if linker supports --undefined-version])
+ OLD_LDFLAGS=$LDFLAGS
+ LDFLAGS="$LDFLAGS -Wl,--undefined-version"
+ AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void) { return 0; }]])], [
+ LINKER_FLAG_UNDEFINED_VERSION=-Wl,--undefined-version
+ AC_MSG_RESULT([yes])
+ ], [
+ AC_MSG_RESULT([no])
+ ])
+ LDFLAGS=$OLD_LDFLAGS
])
AM_CONDITIONAL([COND_SYMVERS_LINUX],
[test "x$enable_symbol_versions" = xlinux])
AM_CONDITIONAL([COND_SYMVERS_GENERIC],
[test "x$enable_symbol_versions" = xgeneric])
+AC_SUBST([LINKER_FLAG_UNDEFINED_VERSION])
###############################################################################
@@ -985,8 +1008,8 @@
# Find the best function to set timestamps.
AC_CHECK_FUNCS([futimens futimes futimesat utimes _futime utime], [break])
-# This is nice to have but not mandatory.
-AC_CHECK_FUNCS([posix_fadvise])
+# These are nice to have but not mandatory.
+AC_CHECK_FUNCS([getrlimit posix_fadvise])
TUKLIB_PROGNAME
TUKLIB_INTEGER
@@ -1145,7 +1168,8 @@
# Check for ARM64 CRC32 instruction runtime detection.
#
-# - getauxval() is supported on Linux.
+# - getauxval() is supported on Linux. We also need HWCAP_CRC32 which was
+# added in glibc 2.24.
#
# - elf_aux_info() is supported on FreeBSD and OpenBSD >= 7.6.
#
@@ -1157,6 +1181,9 @@
#
AS_IF([test "x$enable_arm64_crc32" = xyes], [
AC_CHECK_FUNCS([getauxval elf_aux_info sysctlbyname], [break])
+ AC_CHECK_DECL([HWCAP_CRC32], [AC_DEFINE([HAVE_HWCAP_CRC32], [1],
+ [Define to 1 if 'HWCAP_CRC32' is declared in .])],
+ [], [[#include ]])
])
@@ -1326,13 +1353,13 @@
-Wc11-extensions \
-Wc2x-compat \
-Wc2x-extensions \
- -Wpre-c2x-compat \
-Warray-bounds-pointer-arithmetic \
-Wassign-enum \
-Wconditional-uninitialized \
-Wdocumentation \
-Wduplicate-enum \
-Wempty-translation-unit \
+ -Wextra-semi-stmt \
-Wflexible-array-extensions \
-Wmissing-variable-declarations \
-Wnewline-eof \
diff -Nru xz-utils-5.8.1/debian/changelog xz-utils-5.8.3/debian/changelog
--- xz-utils-5.8.1/debian/changelog 2025-04-03 21:02:58.000000000 +0000
+++ xz-utils-5.8.3/debian/changelog 2026-06-26 13:13:13.000000000 +0000
@@ -1,3 +1,16 @@
+xz-utils (5.8.3-0+deb13u1) trixie; urgency=medium
+
+ * Import 5.8.3
+ - CVE-2026-34743 ("Buffer overflow in lzma_index_append()")
+ (Closes: #1132497)
+ - Soname updated from liblzma.so.5.8.1 -> liblzma.so.5.8.3 as in all new
+ versions, but ABI remains compatible with the 5.8 series
+ - New man pages in Arabic and Swedish and minor updates to other languages
+ * Add myself as uploader and prepare gbp.conf and salsa-ci.yml for easier
+ maintenance of this package in Trixie (and later potentially in LTS)
+
+ -- Otto Kekäläinen Fri, 26 Jun 2026 13:13:13 +0000
+
xz-utils (5.8.1-1) unstable; urgency=medium
* Import 5.8.1
diff -Nru xz-utils-5.8.1/debian/control xz-utils-5.8.3/debian/control
--- xz-utils-5.8.1/debian/control 2025-04-03 20:58:15.000000000 +0000
+++ xz-utils-5.8.3/debian/control 2026-06-26 13:13:13.000000000 +0000
@@ -2,7 +2,7 @@
Section: utils
Priority: optional
Maintainer: Sebastian Andrzej Siewior
-Uploaders: Jonathan Nieder
+Uploaders: Jonathan Nieder , Otto Kekäläinen
Build-Depends: debhelper-compat (= 13), dpkg-dev (>= 1.16.2),
autoconf (>= 2.64~), automake, libtool (>= 2.2),
gettext, autopoint | gettext (<< 0.18-1), autopoint | cvs, po4a
diff -Nru xz-utils-5.8.1/debian/gbp.conf xz-utils-5.8.3/debian/gbp.conf
--- xz-utils-5.8.1/debian/gbp.conf 2025-04-03 20:58:15.000000000 +0000
+++ xz-utils-5.8.3/debian/gbp.conf 2026-06-26 13:13:13.000000000 +0000
@@ -1,6 +1,47 @@
[DEFAULT]
-debian-branch=debian/unstable
-upstream-branch=upstream/v5.8
+# DEP-14 format. Other naming convention are available,
+# see DEP-14 for more details.
+debian-branch = debian/13-trixie
+upstream-branch = upstream/latest
-[pq]
-patch-numbers = False
+# Enable pristine-tar to exactly reproduce orig tarballs
+#
+# The xz upstream tarballs have such a large delta to the git tag contents that
+# pristine-tar will not be able to reproduce it.
+#pristine-tar = True
+
+# Lax requirement to use branch name 'debian/latest' so that git-buildpackage
+# will always build using the currently checked out branch as the Debian branch.
+# This makes it easier for contributors to work with feature and bugfix
+# branches.
+ignore-branch = True
+
+# The Debian packaging git repository may also host actual upstream tags and
+# branches, typically named 'main' or 'master'. Configure the upstream tag
+# format below, so that 'gbp import-orig' will run correctly, and link tarball
+# import branch ('upstream/latest') with the equivalent upstream release tag,
+# showing a complete audit trail of what upstream released and what was imported
+# into Debian.
+#
+# The xz upstream uses release tags of format 'v5.2.5'.
+upstream-vcs-tag = v%(version%~%.)s
+
+# If upstream publishes tarball signatures, git-buildpackage will by default
+# import and use the them. Change this to 'on' to make 'gbp import-orig' abort
+# if the signature is not found or is not valid.
+upstream-signatures = on
+
+# Ensure the Debian maintainer signs git tags automatically.
+sign-tags = True
+
+# Automatically open a new changelog entry about the new upstream release, but
+# do not commit it, as the 'gbp dch' still needs to run and list all commits
+# based on when the debian/changelog last was updated in a git commit.
+postimport = dch -v %(version)s "New upstream release"
+
+# Ensure a human always reviews all the debian/changelog entries.
+spawn-editor = always
+
+# No need to confirm package name or version at any time, git-buildpackage
+# always gets it right.
+interactive = False
diff -Nru xz-utils-5.8.1/debian/salsa-ci.yml xz-utils-5.8.3/debian/salsa-ci.yml
--- xz-utils-5.8.1/debian/salsa-ci.yml 1970-01-01 00:00:00.000000000 +0000
+++ xz-utils-5.8.3/debian/salsa-ci.yml 2026-06-26 13:13:13.000000000 +0000
@@ -0,0 +1,22 @@
+# This is a template from
+# https://salsa.debian.org/salsa-ci-team/pipeline/-/raw/master/recipes/salsa-ci.yml
+#
+# If this pipeline is not running at after committing and pushing this file,
+# ensure that https://salsa.debian.org/%{project_path}/-/settings/ci_cd has in
+# field "CI/CD configuration file" filename "debian/salsa-ci.yml", the filename
+# is the same as of this file, and duplicate files with similar contents but
+# different filenames have been cleaned away.
+#
+# Feel free disable and enable tests to find a good balance between extensive
+# coverage and having a consistently green pipeline where failures are rare
+# enough that they are always investigated and addressed. For documentation
+# please read https://salsa.debian.org/salsa-ci-team/pipeline
+---
+include:
+ - https://salsa.debian.org/salsa-ci-team/pipeline/raw/master/recipes/debian.yml
+
+variables:
+ RELEASE: trixie
+ # Broken and unmaintained watch file in past Debian release not worth fixing
+ # as we scanning for new upstream version is only relevant in Debian unstable
+ SALSA_CI_DISABLE_USCAN: 1
diff -Nru xz-utils-5.8.1/debug/Makefile.in xz-utils-5.8.3/debug/Makefile.in
--- xz-utils-5.8.1/debug/Makefile.in 2025-04-03 11:35:21.000000000 +0000
+++ xz-utils-5.8.3/debug/Makefile.in 2026-03-31 15:27:10.000000000 +0000
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.17 from Makefile.am.
+# Makefile.in generated by automake 1.18.1 from Makefile.am.
# @configure_input@
-# Copyright (C) 1994-2024 Free Software Foundation, Inc.
+# Copyright (C) 1994-2025 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -290,6 +290,7 @@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
+LINKER_FLAG_UNDEFINED_VERSION = @LINKER_FLAG_UNDEFINED_VERSION@
LIPO = @LIPO@
LN_EXEEXT = @LN_EXEEXT@
LN_S = @LN_S@
@@ -573,6 +574,7 @@
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
distdir: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) distdir-am
diff -Nru xz-utils-5.8.1/doc/man/txt/lzmainfo.txt xz-utils-5.8.3/doc/man/txt/lzmainfo.txt
--- xz-utils-5.8.1/doc/man/txt/lzmainfo.txt 2025-04-03 11:36:55.000000000 +0000
+++ xz-utils-5.8.3/doc/man/txt/lzmainfo.txt 2026-03-31 15:27:26.000000000 +0000
@@ -1,36 +1,35 @@
-LZMAINFO(1) XZ Utils LZMAINFO(1)
+LZMAINFO(1) XZ Utils LZMAINFO(1)
NAME
- lzmainfo - show information stored in the .lzma file header
+ lzmainfo - show information stored in the .lzma file header
SYNOPSIS
- lzmainfo [--help] [--version] [file...]
+ lzmainfo [--help] [--version] [file...]
DESCRIPTION
- lzmainfo shows information stored in the .lzma file header. It reads
- the first 13 bytes from the specified file, decodes the header, and
- prints it to standard output in human readable format. If no files are
- given or file is -, standard input is read.
-
- Usually the most interesting information is the uncompressed size and
- the dictionary size. Uncompressed size can be shown only if the file
- is in the non-streamed .lzma format variant. The amount of memory re-
- quired to decompress the file is a few dozen kilobytes plus the dictio-
- nary size.
+ lzmainfo shows information stored in the .lzma file header. It reads the
+ first 13 bytes from the specified file, decodes the header, and prints it
+ to standard output in human readable format. If no files are given or file
+ is -, standard input is read.
+
+ Usually the most interesting information is the uncompressed size and the
+ dictionary size. Uncompressed size can be shown only if the file is in the
+ non-streamed .lzma format variant. The amount of memory required to decom-
+ press the file is a few dozen kilobytes plus the dictionary size.
- lzmainfo is included in XZ Utils primarily for backward compatibility
- with LZMA Utils.
+ lzmainfo is included in XZ Utils primarily for backward compatibility with
+ LZMA Utils.
EXIT STATUS
- 0 All is good.
+ 0 All is good.
- 1 An error occurred.
+ 1 An error occurred.
BUGS
- lzmainfo uses MB while the correct suffix would be MiB (2^20 bytes).
- This is to keep the output compatible with LZMA Utils.
+ lzmainfo uses MB while the correct suffix would be MiB (2^20 bytes). This
+ is to keep the output compatible with LZMA Utils.
SEE ALSO
- xz(1)
+ xz(1)
-Tukaani 2013-06-30 LZMAINFO(1)
+Tukaani 2013-06-30 LZMAINFO(1)
diff -Nru xz-utils-5.8.1/doc/man/txt/xz.txt xz-utils-5.8.3/doc/man/txt/xz.txt
--- xz-utils-5.8.1/doc/man/txt/xz.txt 2025-04-03 11:36:55.000000000 +0000
+++ xz-utils-5.8.3/doc/man/txt/xz.txt 2026-03-31 15:27:26.000000000 +0000
@@ -1,1708 +1,1651 @@
-XZ(1) XZ Utils XZ(1)
+XZ(1) XZ Utils XZ(1)
NAME
- xz, unxz, xzcat, lzma, unlzma, lzcat - Compress or decompress .xz and
- .lzma files
+ xz, unxz, xzcat, lzma, unlzma, lzcat - Compress or decompress .xz and .lzma
+ files
SYNOPSIS
- xz [option...] [file...]
+ xz [option...] [file...]
COMMAND ALIASES
- unxz is equivalent to xz --decompress.
- xzcat is equivalent to xz --decompress --stdout.
- lzma is equivalent to xz --format=lzma.
- unlzma is equivalent to xz --format=lzma --decompress.
- lzcat is equivalent to xz --format=lzma --decompress --stdout.
-
- When writing scripts that need to decompress files, it is recommended
- to always use the name xz with appropriate arguments (xz -d or xz -dc)
- instead of the names unxz and xzcat.
+ unxz is equivalent to xz --decompress.
+ xzcat is equivalent to xz --decompress --stdout.
+ lzma is equivalent to xz --format=lzma.
+ unlzma is equivalent to xz --format=lzma --decompress.
+ lzcat is equivalent to xz --format=lzma --decompress --stdout.
+
+ When writing scripts that need to decompress files, it is recommended to
+ always use the name xz with appropriate arguments (xz -d or xz -dc) instead
+ of the names unxz and xzcat.
DESCRIPTION
- xz is a general-purpose data compression tool with command line syntax
- similar to gzip(1) and bzip2(1). The native file format is the .xz
- format, but the legacy .lzma format used by LZMA Utils and raw com-
- pressed streams with no container format headers are also supported.
- In addition, decompression of the .lz format used by lzip is supported.
-
- xz compresses or decompresses each file according to the selected oper-
- ation mode. If no files are given or file is -, xz reads from standard
- input and writes the processed data to standard output. xz will refuse
- (display an error and skip the file) to write compressed data to stan-
- dard output if it is a terminal. Similarly, xz will refuse to read
- compressed data from standard input if it is a terminal.
-
- Unless --stdout is specified, files other than - are written to a new
- file whose name is derived from the source file name:
-
- o When compressing, the suffix of the target file format (.xz or
- .lzma) is appended to the source filename to get the target file-
- name.
-
- o When decompressing, the .xz, .lzma, or .lz suffix is removed from
- the filename to get the target filename. xz also recognizes the
- suffixes .txz and .tlz, and replaces them with the .tar suffix.
-
- If the target file already exists, an error is displayed and the file
- is skipped.
-
- Unless writing to standard output, xz will display a warning and skip
- the file if any of the following applies:
-
- o File is not a regular file. Symbolic links are not followed, and
- thus they are not considered to be regular files.
-
- o File has more than one hard link.
-
- o File has setuid, setgid, or sticky bit set.
-
- o The operation mode is set to compress and the file already has a
- suffix of the target file format (.xz or .txz when compressing to
- the .xz format, and .lzma or .tlz when compressing to the .lzma for-
- mat).
-
- o The operation mode is set to decompress and the file doesn't have a
- suffix of any of the supported file formats (.xz, .txz, .lzma, .tlz,
- or .lz).
-
- After successfully compressing or decompressing the file, xz copies the
- owner, group, permissions, access time, and modification time from the
- source file to the target file. If copying the group fails, the per-
- missions are modified so that the target file doesn't become accessible
- to users who didn't have permission to access the source file. xz
- doesn't support copying other metadata like access control lists or ex-
- tended attributes yet.
-
- Once the target file has been successfully closed, the source file is
- removed unless --keep was specified. The source file is never removed
- if the output is written to standard output or if an error occurs.
-
- Sending SIGINFO or SIGUSR1 to the xz process makes it print progress
- information to standard error. This has only limited use since when
- standard error is a terminal, using --verbose will display an automati-
- cally updating progress indicator.
+ xz is a general-purpose data compression tool with command line syntax sim-
+ ilar to gzip(1) and bzip2(1). The native file format is the .xz format,
+ but the legacy .lzma format used by LZMA Utils and raw compressed streams
+ with no container format headers are also supported. In addition, decom-
+ pression of the .lz format used by lzip is supported.
+
+ xz compresses or decompresses each file according to the selected operation
+ mode. If no files are given or file is -, xz reads from standard input and
+ writes the processed data to standard output. xz will refuse (display an
+ error and skip the file) to write compressed data to standard output if it
+ is a terminal. Similarly, xz will refuse to read compressed data from
+ standard input if it is a terminal.
+
+ Unless --stdout is specified, files other than - are written to a new file
+ whose name is derived from the source file name:
+
+ * When compressing, the suffix of the target file format (.xz or .lzma) is
+ appended to the source filename to get the target filename.
+
+ * When decompressing, the .xz, .lzma, or .lz suffix is removed from the
+ filename to get the target filename. xz also recognizes the suffixes
+ .txz and .tlz, and replaces them with the .tar suffix.
+
+ If the target file already exists, an error is displayed and the file is
+ skipped.
+
+ Unless writing to standard output, xz will display a warning and skip the
+ file if any of the following applies:
+
+ * File is not a regular file. Symbolic links are not followed, and thus
+ they are not considered to be regular files.
+
+ * File has more than one hard link.
+
+ * File has setuid, setgid, or sticky bit set.
+
+ * The operation mode is set to compress and the file already has a suffix
+ of the target file format (.xz or .txz when compressing to the .xz for-
+ mat, and .lzma or .tlz when compressing to the .lzma format).
+
+ * The operation mode is set to decompress and the file doesn't have a suf-
+ fix of any of the supported file formats (.xz, .txz, .lzma, .tlz, or
+ .lz).
+
+ After successfully compressing or decompressing the file, xz copies the
+ owner, group, permissions, access time, and modification time from the
+ source file to the target file. If copying the group fails, the permis-
+ sions are modified so that the target file doesn't become accessible to
+ users who didn't have permission to access the source file. xz doesn't
+ support copying other metadata like access control lists or extended at-
+ tributes yet.
+
+ Once the target file has been successfully closed, the source file is re-
+ moved unless --keep was specified. The source file is never removed if the
+ output is written to standard output or if an error occurs.
+
+ Sending SIGINFO or SIGUSR1 to the xz process makes it print progress infor-
+ mation to standard error. This has only limited use since when standard
+ error is a terminal, using --verbose will display an automatically updating
+ progress indicator.
Memory usage
- The memory usage of xz varies from a few hundred kilobytes to several
- gigabytes depending on the compression settings. The settings used
- when compressing a file determine the memory requirements of the decom-
- pressor. Typically the decompressor needs 5 % to 20 % of the amount of
- memory that the compressor needed when creating the file. For example,
- decompressing a file created with xz -9 currently requires 65 MiB of
- memory. Still, it is possible to have .xz files that require several
- gigabytes of memory to decompress.
-
- Especially users of older systems may find the possibility of very
- large memory usage annoying. To prevent uncomfortable surprises, xz
- has a built-in memory usage limiter, which is disabled by default.
- While some operating systems provide ways to limit the memory usage of
- processes, relying on it wasn't deemed to be flexible enough (for exam-
- ple, using ulimit(1) to limit virtual memory tends to cripple mmap(2)).
-
- The memory usage limiter can be enabled with the command line option
- --memlimit=limit. Often it is more convenient to enable the limiter by
- default by setting the environment variable XZ_DEFAULTS, for example,
- XZ_DEFAULTS=--memlimit=150MiB. It is possible to set the limits sepa-
- rately for compression and decompression by using --memlimit-com-
- press=limit and --memlimit-decompress=limit. Using these two options
- outside XZ_DEFAULTS is rarely useful because a single run of xz cannot
- do both compression and decompression and --memlimit=limit (or -M
- limit) is shorter to type on the command line.
-
- If the specified memory usage limit is exceeded when decompressing, xz
- will display an error and decompressing the file will fail. If the
- limit is exceeded when compressing, xz will try to scale the settings
- down so that the limit is no longer exceeded (except when using --for-
- mat=raw or --no-adjust). This way the operation won't fail unless the
- limit is very small. The scaling of the settings is done in steps that
- don't match the compression level presets, for example, if the limit is
- only slightly less than the amount required for xz -9, the settings
- will be scaled down only a little, not all the way down to xz -8.
+ The memory usage of xz varies from a few hundred kilobytes to several giga-
+ bytes depending on the compression settings. The settings used when com-
+ pressing a file determine the memory requirements of the decompressor.
+ Typically the decompressor needs 5 % to 20 % of the amount of memory that
+ the compressor needed when creating the file. For example, decompressing a
+ file created with xz -9 currently requires 65 MiB of memory. Still, it is
+ possible to have .xz files that require several gigabytes of memory to de-
+ compress.
+
+ Especially users of older systems may find the possibility of very large
+ memory usage annoying. To prevent uncomfortable surprises, xz has a built-
+ in memory usage limiter, which is disabled by default. While some operat-
+ ing systems provide ways to limit the memory usage of processes, relying on
+ it wasn't deemed to be flexible enough (for example, using ulimit(1) to
+ limit virtual memory tends to cripple mmap(2)).
+
+ The memory usage limiter can be enabled with the command line option --mem-
+ limit=limit. Often it is more convenient to enable the limiter by default
+ by setting the environment variable XZ_DEFAULTS, for example, XZ_DE-
+ FAULTS=--memlimit=150MiB. It is possible to set the limits separately for
+ compression and decompression by using --memlimit-compress=limit and --mem-
+ limit-decompress=limit. Using these two options outside XZ_DEFAULTS is
+ rarely useful because a single run of xz cannot do both compression and de-
+ compression and --memlimit=limit (or -M limit) is shorter to type on the
+ command line.
+
+ If the specified memory usage limit is exceeded when decompressing, xz will
+ display an error and decompressing the file will fail. If the limit is ex-
+ ceeded when compressing, xz will try to scale the settings down so that the
+ limit is no longer exceeded (except when using --format=raw or --no-ad-
+ just). This way the operation won't fail unless the limit is very small.
+ The scaling of the settings is done in steps that don't match the compres-
+ sion level presets, for example, if the limit is only slightly less than
+ the amount required for xz -9, the settings will be scaled down only a lit-
+ tle, not all the way down to xz -8.
Concatenation and padding with .xz files
- It is possible to concatenate .xz files as is. xz will decompress such
- files as if they were a single .xz file.
+ It is possible to concatenate .xz files as is. xz will decompress such
+ files as if they were a single .xz file.
- It is possible to insert padding between the concatenated parts or af-
- ter the last part. The padding must consist of null bytes and the size
- of the padding must be a multiple of four bytes. This can be useful,
- for example, if the .xz file is stored on a medium that measures file
- sizes in 512-byte blocks.
+ It is possible to insert padding between the concatenated parts or after
+ the last part. The padding must consist of null bytes and the size of the
+ padding must be a multiple of four bytes. This can be useful, for example,
+ if the .xz file is stored on a medium that measures file sizes in 512-byte
+ blocks.
- Concatenation and padding are not allowed with .lzma files or raw
- streams.
+ Concatenation and padding are not allowed with .lzma files or raw streams.
OPTIONS
Integer suffixes and special values
- In most places where an integer argument is expected, an optional suf-
- fix is supported to easily indicate large integers. There must be no
- space between the integer and the suffix.
+ In most places where an integer argument is expected, an optional suffix is
+ supported to easily indicate large integers. There must be no space be-
+ tween the integer and the suffix.
- KiB Multiply the integer by 1,024 (2^10). Ki, k, kB, K, and KB are
- accepted as synonyms for KiB.
+ KiB Multiply the integer by 1,024 (2^10). Ki, k, kB, K, and KB are ac-
+ cepted as synonyms for KiB.
- MiB Multiply the integer by 1,048,576 (2^20). Mi, m, M, and MB are
- accepted as synonyms for MiB.
+ MiB Multiply the integer by 1,048,576 (2^20). Mi, m, M, and MB are ac-
+ cepted as synonyms for MiB.
- GiB Multiply the integer by 1,073,741,824 (2^30). Gi, g, G, and GB
- are accepted as synonyms for GiB.
+ GiB Multiply the integer by 1,073,741,824 (2^30). Gi, g, G, and GB are
+ accepted as synonyms for GiB.
- The special value max can be used to indicate the maximum integer value
- supported by the option.
+ The special value max can be used to indicate the maximum integer value
+ supported by the option.
Operation mode
- If multiple operation mode options are given, the last one takes ef-
- fect.
+ If multiple operation mode options are given, the last one takes effect.
- -z, --compress
- Compress. This is the default operation mode when no operation
- mode option is specified and no other operation mode is implied
- from the command name (for example, unxz implies --decompress).
-
- After successful compression, the source file is removed unless
- writing to standard output or --keep was specified.
-
- -d, --decompress, --uncompress
- Decompress. After successful decompression, the source file is
- removed unless writing to standard output or --keep was speci-
- fied.
-
- -t, --test
- Test the integrity of compressed files. This option is equiva-
- lent to --decompress --stdout except that the decompressed data
- is discarded instead of being written to standard output. No
- files are created or removed.
-
- -l, --list
- Print information about compressed files. No uncompressed out-
- put is produced, and no files are created or removed. In list
- mode, the program cannot read the compressed data from standard
- input or from other unseekable sources.
-
- The default listing shows basic information about files, one
- file per line. To get more detailed information, use also the
- --verbose option. For even more information, use --verbose
- twice, but note that this may be slow, because getting all the
- extra information requires many seeks. The width of verbose
- output exceeds 80 characters, so piping the output to, for exam-
- ple, less -S may be convenient if the terminal isn't wide
- enough.
-
- The exact output may vary between xz versions and different lo-
- cales. For machine-readable output, --robot --list should be
- used.
+ -z, --compress
+ Compress. This is the default operation mode when no operation mode
+ option is specified and no other operation mode is implied from the
+ command name (for example, unxz implies --decompress).
+
+ After successful compression, the source file is removed unless
+ writing to standard output or --keep was specified.
+
+ -d, --decompress, --uncompress
+ Decompress. After successful decompression, the source file is re-
+ moved unless writing to standard output or --keep was specified.
+
+ -t, --test
+ Test the integrity of compressed files. This option is equivalent
+ to --decompress --stdout except that the decompressed data is dis-
+ carded instead of being written to standard output. No files are
+ created or removed.
+
+ -l, --list
+ Print information about compressed files. No uncompressed output is
+ produced, and no files are created or removed. In list mode, the
+ program cannot read the compressed data from standard input or from
+ other unseekable sources.
+
+ The default listing shows basic information about files, one file
+ per line. To get more detailed information, use also the --verbose
+ option. For even more information, use --verbose twice, but note
+ that this may be slow, because getting all the extra information re-
+ quires many seeks. The width of verbose output exceeds 80 charac-
+ ters, so piping the output to, for example, less -S may be conve-
+ nient if the terminal isn't wide enough.
+
+ The exact output may vary between xz versions and different locales.
+ For machine-readable output, --robot --list should be used.
Operation modifiers
- -k, --keep
- Don't delete the input files.
+ -k, --keep
+ Don't delete the input files.
- Since xz 5.2.6, this option also makes xz compress or decompress
- even if the input is a symbolic link to a regular file, has more
- than one hard link, or has the setuid, setgid, or sticky bit
- set. The setuid, setgid, and sticky bits are not copied to the
- target file. In earlier versions this was only done with
- --force.
-
- -f, --force
- This option has several effects:
-
- o If the target file already exists, delete it before compress-
- ing or decompressing.
-
- o Compress or decompress even if the input is a symbolic link
- to a regular file, has more than one hard link, or has the
- setuid, setgid, or sticky bit set. The setuid, setgid, and
- sticky bits are not copied to the target file.
-
- o When used with --decompress --stdout and xz cannot recognize
- the type of the source file, copy the source file as is to
- standard output. This allows xzcat --force to be used like
- cat(1) for files that have not been compressed with xz. Note
- that in future, xz might support new compressed file formats,
- which may make xz decompress more types of files instead of
- copying them as is to standard output. --format=format can
- be used to restrict xz to decompress only a single file for-
- mat.
-
- -c, --stdout, --to-stdout
- Write the compressed or decompressed data to standard output in-
- stead of a file. This implies --keep.
-
- --single-stream
- Decompress only the first .xz stream, and silently ignore possi-
- ble remaining input data following the stream. Normally such
- trailing garbage makes xz display an error.
-
- xz never decompresses more than one stream from .lzma files or
- raw streams, but this option still makes xz ignore the possible
- trailing data after the .lzma file or raw stream.
-
- This option has no effect if the operation mode is not --decom-
- press or --test.
-
- Since xz 5.7.1alpha, --single-stream implies --keep.
-
- --no-sparse
- Disable creation of sparse files. By default, if decompressing
- into a regular file, xz tries to make the file sparse if the de-
- compressed data contains long sequences of binary zeros. It
- also works when writing to standard output as long as standard
- output is connected to a regular file and certain additional
- conditions are met to make it safe. Creating sparse files may
- save disk space and speed up the decompression by reducing the
- amount of disk I/O.
-
- -S .suf, --suffix=.suf
- When compressing, use .suf as the suffix for the target file in-
- stead of .xz or .lzma. If not writing to standard output and
- the source file already has the suffix .suf, a warning is dis-
- played and the file is skipped.
-
- When decompressing, recognize files with the suffix .suf in ad-
- dition to files with the .xz, .txz, .lzma, .tlz, or .lz suffix.
- If the source file has the suffix .suf, the suffix is removed to
- get the target filename.
-
- When compressing or decompressing raw streams (--format=raw),
- the suffix must always be specified unless writing to standard
- output, because there is no default suffix for raw streams.
-
- --files[=file]
- Read the filenames to process from file; if file is omitted,
- filenames are read from standard input. Filenames must be ter-
- minated with the newline character. A dash (-) is taken as a
- regular filename; it doesn't mean standard input. If filenames
- are given also as command line arguments, they are processed be-
- fore the filenames read from file.
-
- --files0[=file]
- This is identical to --files[=file] except that each filename
- must be terminated with the null character.
+ Since xz 5.2.6, this option also makes xz compress or decompress
+ even if the input is a symbolic link to a regular file, has more
+ than one hard link, or has the setuid, setgid, or sticky bit set.
+ The setuid, setgid, and sticky bits are not copied to the target
+ file. In earlier versions this was only done with --force.
+
+ -f, --force
+ This option has several effects:
+
+ * If the target file already exists, delete it before compressing
+ or decompressing.
+
+ * Compress or decompress even if the input is a symbolic link to a
+ regular file, has more than one hard link, or has the setuid,
+ setgid, or sticky bit set. The setuid, setgid, and sticky bits
+ are not copied to the target file.
+
+ * When used with --decompress --stdout and xz cannot recognize the
+ type of the source file, copy the source file as is to standard
+ output. This allows xzcat --force to be used like cat(1) for
+ files that have not been compressed with xz. Note that in fu-
+ ture, xz might support new compressed file formats, which may
+ make xz decompress more types of files instead of copying them as
+ is to standard output. --format=format can be used to restrict
+ xz to decompress only a single file format.
+
+ -c, --stdout, --to-stdout
+ Write the compressed or decompressed data to standard output instead
+ of a file. This implies --keep.
+
+ --single-stream
+ Decompress only the first .xz stream, and silently ignore possible
+ remaining input data following the stream. Normally such trailing
+ garbage makes xz display an error.
+
+ xz never decompresses more than one stream from .lzma files or raw
+ streams, but this option still makes xz ignore the possible trailing
+ data after the .lzma file or raw stream.
+
+ This option has no effect if the operation mode is not --decompress
+ or --test.
+
+ Since xz 5.7.1alpha, --single-stream implies --keep.
+
+ --no-sparse
+ Disable creation of sparse files. By default, if decompressing into
+ a regular file, xz tries to make the file sparse if the decompressed
+ data contains long sequences of binary zeros. It also works when
+ writing to standard output as long as standard output is connected
+ to a regular file and certain additional conditions are met to make
+ it safe. Creating sparse files may save disk space and speed up the
+ decompression by reducing the amount of disk I/O.
+
+ -S .suf, --suffix=.suf
+ When compressing, use .suf as the suffix for the target file instead
+ of .xz or .lzma. If not writing to standard output and the source
+ file already has the suffix .suf, a warning is displayed and the
+ file is skipped.
+
+ When decompressing, recognize files with the suffix .suf in addition
+ to files with the .xz, .txz, .lzma, .tlz, or .lz suffix. If the
+ source file has the suffix .suf, the suffix is removed to get the
+ target filename.
+
+ When compressing or decompressing raw streams (--format=raw), the
+ suffix must always be specified unless writing to standard output,
+ because there is no default suffix for raw streams.
+
+ --files[=file]
+ Read the filenames to process from file; if file is omitted, file-
+ names are read from standard input. Filenames must be terminated
+ with the newline character. A dash (-) is taken as a regular file-
+ name; it doesn't mean standard input. If filenames are given also
+ as command line arguments, they are processed before the filenames
+ read from file.
+
+ --files0[=file]
+ This is identical to --files[=file] except that each filename must
+ be terminated with the null character.
Basic file format and compression options
- -F format, --format=format
- Specify the file format to compress or decompress:
+ -F format, --format=format
+ Specify the file format to compress or decompress:
- auto This is the default. When compressing, auto is equiva-
- lent to xz. When decompressing, the format of the input
- file is automatically detected. Note that raw streams
- (created with --format=raw) cannot be auto-detected.
-
- xz Compress to the .xz file format, or accept only .xz files
- when decompressing.
-
- lzma, alone
- Compress to the legacy .lzma file format, or accept only
- .lzma files when decompressing. The alternative name
- alone is provided for backwards compatibility with LZMA
- Utils.
-
- lzip Accept only .lz files when decompressing. Compression is
- not supported.
-
- The .lz format version 0 and the unextended version 1 are
- supported. Version 0 files were produced by lzip 1.3 and
- older. Such files aren't common but may be found from
- file archives as a few source packages were released in
- this format. People might have old personal files in
- this format too. Decompression support for the format
- version 0 was removed in lzip 1.18.
-
- lzip 1.4 and later create files in the format version 1.
- The sync flush marker extension to the format version 1
- was added in lzip 1.6. This extension is rarely used and
- isn't supported by xz (diagnosed as corrupt input).
-
- raw Compress or uncompress a raw stream (no headers). This
- is meant for advanced users only. To decode raw streams,
- you need use --format=raw and explicitly specify the fil-
- ter chain, which normally would have been stored in the
- container headers.
-
- -C check, --check=check
- Specify the type of the integrity check. The check is calcu-
- lated from the uncompressed data and stored in the .xz file.
- This option has an effect only when compressing into the .xz
- format; the .lzma format doesn't support integrity checks. The
- integrity check (if any) is verified when the .xz file is decom-
- pressed.
-
- Supported check types:
-
- none Don't calculate an integrity check at all. This is usu-
- ally a bad idea. This can be useful when integrity of
- the data is verified by other means anyway.
-
- crc32 Calculate CRC32 using the polynomial from IEEE-802.3
- (Ethernet).
-
- crc64 Calculate CRC64 using the polynomial from ECMA-182. This
- is the default, since it is slightly better than CRC32 at
- detecting damaged files and the speed difference is neg-
- ligible.
-
- sha256 Calculate SHA-256. This is somewhat slower than CRC32
- and CRC64.
-
- Integrity of the .xz headers is always verified with CRC32. It
- is not possible to change or disable it.
-
- --ignore-check
- Don't verify the integrity check of the compressed data when de-
- compressing. The CRC32 values in the .xz headers will still be
- verified normally.
-
- Do not use this option unless you know what you are doing. Pos-
- sible reasons to use this option:
-
- o Trying to recover data from a corrupt .xz file.
-
- o Speeding up decompression. This matters mostly with SHA-256
- or with files that have compressed extremely well. It's rec-
- ommended to not use this option for this purpose unless the
- file integrity is verified externally in some other way.
-
- -0 ... -9
- Select a compression preset level. The default is -6. If mul-
- tiple preset levels are specified, the last one takes effect.
- If a custom filter chain was already specified, setting a com-
- pression preset level clears the custom filter chain.
-
- The differences between the presets are more significant than
- with gzip(1) and bzip2(1). The selected compression settings
- determine the memory requirements of the decompressor, thus us-
- ing a too high preset level might make it painful to decompress
- the file on an old system with little RAM. Specifically, it's
- not a good idea to blindly use -9 for everything like it often
- is with gzip(1) and bzip2(1).
-
- -0 ... -3
- These are somewhat fast presets. -0 is sometimes faster
- than gzip -9 while compressing much better. The higher
- ones often have speed comparable to bzip2(1) with compa-
- rable or better compression ratio, although the results
- depend a lot on the type of data being compressed.
-
- -4 ... -6
- Good to very good compression while keeping decompressor
- memory usage reasonable even for old systems. -6 is the
- default, which is usually a good choice for distributing
- files that need to be decompressible even on systems with
- only 16 MiB RAM. (-5e or -6e may be worth considering
- too. See --extreme.)
-
- -7 ... -9
- These are like -6 but with higher compressor and decom-
- pressor memory requirements. These are useful only when
- compressing files bigger than 8 MiB, 16 MiB, and 32 MiB,
- respectively.
-
- On the same hardware, the decompression speed is approximately a
- constant number of bytes of compressed data per second. In
- other words, the better the compression, the faster the decom-
- pression will usually be. This also means that the amount of
- uncompressed output produced per second can vary a lot.
-
- The following table summarises the features of the presets:
-
- Preset DictSize CompCPU CompMem DecMem
- -0 256 KiB 0 3 MiB 1 MiB
- -1 1 MiB 1 9 MiB 2 MiB
- -2 2 MiB 2 17 MiB 3 MiB
- -3 4 MiB 3 32 MiB 5 MiB
- -4 4 MiB 4 48 MiB 5 MiB
- -5 8 MiB 5 94 MiB 9 MiB
- -6 8 MiB 6 94 MiB 9 MiB
- -7 16 MiB 6 186 MiB 17 MiB
- -8 32 MiB 6 370 MiB 33 MiB
- -9 64 MiB 6 674 MiB 65 MiB
-
- Column descriptions:
-
- o DictSize is the LZMA2 dictionary size. It is waste of memory
- to use a dictionary bigger than the size of the uncompressed
- file. This is why it is good to avoid using the presets -7
- ... -9 when there's no real need for them. At -6 and lower,
- the amount of memory wasted is usually low enough to not mat-
- ter.
-
- o CompCPU is a simplified representation of the LZMA2 settings
- that affect compression speed. The dictionary size affects
- speed too, so while CompCPU is the same for levels -6 ... -9,
- higher levels still tend to be a little slower. To get even
- slower and thus possibly better compression, see --extreme.
-
- o CompMem contains the compressor memory requirements in the
- single-threaded mode. It may vary slightly between xz ver-
- sions.
-
- o DecMem contains the decompressor memory requirements. That
- is, the compression settings determine the memory require-
- ments of the decompressor. The exact decompressor memory us-
- age is slightly more than the LZMA2 dictionary size, but the
- values in the table have been rounded up to the next full
- MiB.
-
- Memory requirements of the multi-threaded mode are significantly
- higher than that of the single-threaded mode. With the default
- value of --block-size, each thread needs 3*3*DictSize plus Comp-
- Mem or DecMem. For example, four threads with preset -6 needs
- 660-670 MiB of memory.
-
- -e, --extreme
- Use a slower variant of the selected compression preset level
- (-0 ... -9) to hopefully get a little bit better compression ra-
- tio, but with bad luck this can also make it worse. Decompres-
- sor memory usage is not affected, but compressor memory usage
- increases a little at preset levels -0 ... -3.
-
- Since there are two presets with dictionary sizes 4 MiB and
- 8 MiB, the presets -3e and -5e use slightly faster settings
- (lower CompCPU) than -4e and -6e, respectively. That way no two
- presets are identical.
-
- Preset DictSize CompCPU CompMem DecMem
- -0e 256 KiB 8 4 MiB 1 MiB
- -1e 1 MiB 8 13 MiB 2 MiB
- -2e 2 MiB 8 25 MiB 3 MiB
- -3e 4 MiB 7 48 MiB 5 MiB
- -4e 4 MiB 8 48 MiB 5 MiB
- -5e 8 MiB 7 94 MiB 9 MiB
- -6e 8 MiB 8 94 MiB 9 MiB
- -7e 16 MiB 8 186 MiB 17 MiB
- -8e 32 MiB 8 370 MiB 33 MiB
- -9e 64 MiB 8 674 MiB 65 MiB
-
- For example, there are a total of four presets that use 8 MiB
- dictionary, whose order from the fastest to the slowest is -5,
- -6, -5e, and -6e.
-
- --fast
- --best These are somewhat misleading aliases for -0 and -9, respec-
- tively. These are provided only for backwards compatibility
- with LZMA Utils. Avoid using these options.
-
- --block-size=size
- When compressing to the .xz format, split the input data into
- blocks of size bytes. The blocks are compressed independently
- from each other, which helps with multi-threading and makes lim-
- ited random-access decompression possible. This option is typi-
- cally used to override the default block size in multi-threaded
- mode, but this option can be used in single-threaded mode too.
-
- In multi-threaded mode about three times size bytes will be al-
- located in each thread for buffering input and output. The de-
- fault size is three times the LZMA2 dictionary size or 1 MiB,
- whichever is more. Typically a good value is 2-4 times the size
- of the LZMA2 dictionary or at least 1 MiB. Using size less than
- the LZMA2 dictionary size is waste of RAM because then the LZMA2
- dictionary buffer will never get fully used. In multi-threaded
- mode, the sizes of the blocks are stored in the block headers.
- This size information is required for multi-threaded decompres-
- sion.
-
- In single-threaded mode no block splitting is done by default.
- Setting this option doesn't affect memory usage. No size infor-
- mation is stored in block headers, thus files created in single-
- threaded mode won't be identical to files created in multi-
- threaded mode. The lack of size information also means that xz
- won't be able decompress the files in multi-threaded mode.
-
- --block-list=items
- When compressing to the .xz format, start a new block with an
- optional custom filter chain after the given intervals of uncom-
- pressed data.
-
- The items are a comma-separated list. Each item consists of an
- optional filter chain number between 0 and 9 followed by a colon
- (:) and a required size of uncompressed data. Omitting an item
- (two or more consecutive commas) is a shorthand to use the size
- and filters of the previous item.
-
- If the input file is bigger than the sum of the sizes in items,
- the last item is repeated until the end of the file. A special
- value of 0 may be used as the last size to indicate that the
- rest of the file should be encoded as a single block.
-
- An alternative filter chain for each block can be specified in
- combination with the --filters1=filters ... --filters9=filters
- options. These options define filter chains with an identifier
- between 1-9. Filter chain 0 can be used to refer to the default
- filter chain, which is the same as not specifying a filter
- chain. The filter chain identifier can be used before the un-
- compressed size, followed by a colon (:). For example, if one
- specifies --block-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB then
- blocks will be created using:
-
- o The filter chain specified by --filters1 and 2 MiB input
-
- o The filter chain specified by --filters3 and 2 MiB input
-
- o The filter chain specified by --filters2 and 4 MiB input
-
- o The filter chain specified by --filters2 and 4 MiB input
-
- o The default filter chain and 2 MiB input
-
- o The default filter chain and 4 MiB input for every block un-
- til end of input.
-
- If one specifies a size that exceeds the encoder's block size
- (either the default value in threaded mode or the value speci-
- fied with --block-size=size), the encoder will create additional
- blocks while keeping the boundaries specified in items. For ex-
- ample, if one specifies --block-size=10MiB
- --block-list=5MiB,10MiB,8MiB,12MiB,24MiB and the input file is
- 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, 10,
- 10, and 1 MiB.
-
- In multi-threaded mode the sizes of the blocks are stored in the
- block headers. This isn't done in single-threaded mode, so the
- encoded output won't be identical to that of the multi-threaded
- mode.
-
- --flush-timeout=timeout
- When compressing, if more than timeout milliseconds (a positive
- integer) has passed since the previous flush and reading more
- input would block, all the pending input data is flushed from
- the encoder and made available in the output stream. This can
- be useful if xz is used to compress data that is streamed over a
- network. Small timeout values make the data available at the
- receiving end with a small delay, but large timeout values give
- better compression ratio.
-
- This feature is disabled by default. If this option is speci-
- fied more than once, the last one takes effect. The special
- timeout value of 0 can be used to explicitly disable this fea-
- ture.
-
- This feature is not available on non-POSIX systems.
-
- This feature is still experimental. Currently xz is unsuitable
- for decompressing the stream in real time due to how xz does
- buffering.
-
- --no-sync
- Do not synchronize the target file and its directory to the
- storage device before removing the source file. This can im-
- prove performance if compressing or decompressing many small
- files. However, if the system crashes soon after the deletion,
- it is possible that the target file was not written to the stor-
- age device but the delete operation was. In that case neither
- the original source file nor the target file is available.
-
- This option has an effect only when xz is going to remove the
- source file. In other cases synchronization is never done.
-
- The synchronization and --no-sync were added in xz 5.7.1alpha.
-
- --memlimit-compress=limit
- Set a memory usage limit for compression. If this option is
- specified multiple times, the last one takes effect.
-
- If the compression settings exceed the limit, xz will attempt to
- adjust the settings downwards so that the limit is no longer ex-
- ceeded and display a notice that automatic adjustment was done.
- The adjustments are done in this order: reducing the number of
- threads, switching to single-threaded mode if even one thread in
- multi-threaded mode exceeds the limit, and finally reducing the
- LZMA2 dictionary size.
-
- When compressing with --format=raw or if --no-adjust has been
- specified, only the number of threads may be reduced since it
- can be done without affecting the compressed output.
-
- If the limit cannot be met even with the adjustments described
- above, an error is displayed and xz will exit with exit status
- 1.
-
- The limit can be specified in multiple ways:
-
- o The limit can be an absolute value in bytes. Using an inte-
- ger suffix like MiB can be useful. Example: --memlimit-com-
- press=80MiB
-
- o The limit can be specified as a percentage of total physical
- memory (RAM). This can be useful especially when setting the
- XZ_DEFAULTS environment variable in a shell initialization
- script that is shared between different computers. That way
- the limit is automatically bigger on systems with more mem-
- ory. Example: --memlimit-compress=70%
-
- o The limit can be reset back to its default value by setting
- it to 0. This is currently equivalent to setting the limit
- to max (no memory usage limit).
-
- For 32-bit xz there is a special case: if the limit would be
- over 4020 MiB, the limit is set to 4020 MiB. On MIPS32 2000 MiB
- is used instead. (The values 0 and max aren't affected by this.
- A similar feature doesn't exist for decompression.) This can be
- helpful when a 32-bit executable has access to 4 GiB address
- space (2 GiB on MIPS32) while hopefully doing no harm in other
- situations.
-
- See also the section Memory usage.
-
- --memlimit-decompress=limit
- Set a memory usage limit for decompression. This also affects
- the --list mode. If the operation is not possible without ex-
- ceeding the limit, xz will display an error and decompressing
- the file will fail. See --memlimit-compress=limit for possible
- ways to specify the limit.
-
- --memlimit-mt-decompress=limit
- Set a memory usage limit for multi-threaded decompression. This
- can only affect the number of threads; this will never make xz
- refuse to decompress a file. If limit is too low to allow any
- multi-threading, the limit is ignored and xz will continue in
- single-threaded mode. Note that if also --memlimit-decompress
- is used, it will always apply to both single-threaded and multi-
- threaded modes, and so the effective limit for multi-threading
- will never be higher than the limit set with --memlimit-decom-
- press.
-
- In contrast to the other memory usage limit options, --mem-
- limit-mt-decompress=limit has a system-specific default limit.
- xz --info-memory can be used to see the current value.
-
- This option and its default value exist because without any
- limit the threaded decompressor could end up allocating an in-
- sane amount of memory with some input files. If the default
- limit is too low on your system, feel free to increase the limit
- but never set it to a value larger than the amount of usable RAM
- as with appropriate input files xz will attempt to use that
- amount of memory even with a low number of threads. Running out
- of memory or swapping will not improve decompression perfor-
- mance.
-
- See --memlimit-compress=limit for possible ways to specify the
- limit. Setting limit to 0 resets the limit to the default sys-
- tem-specific value.
-
- -M limit, --memlimit=limit, --memory=limit
- This is equivalent to specifying --memlimit-compress=limit
- --memlimit-decompress=limit --memlimit-mt-decompress=limit.
-
- --no-adjust
- Display an error and exit if the memory usage limit cannot be
- met without adjusting settings that affect the compressed out-
- put. That is, this prevents xz from switching the encoder from
- multi-threaded mode to single-threaded mode and from reducing
- the LZMA2 dictionary size. Even when this option is used the
- number of threads may be reduced to meet the memory usage limit
- as that won't affect the compressed output.
-
- Automatic adjusting is always disabled when creating raw streams
- (--format=raw).
-
- -T threads, --threads=threads
- Specify the number of worker threads to use. Setting threads to
- a special value 0 makes xz use up to as many threads as the
- processor(s) on the system support. The actual number of
- threads can be fewer than threads if the input file is not big
- enough for threading with the given settings or if using more
- threads would exceed the memory usage limit.
-
- The single-threaded and multi-threaded compressors produce dif-
- ferent output. Single-threaded compressor will give the small-
- est file size but only the output from the multi-threaded com-
- pressor can be decompressed using multiple threads. Setting
- threads to 1 will use the single-threaded mode. Setting threads
- to any other value, including 0, will use the multi-threaded
- compressor even if the system supports only one hardware thread.
- (xz 5.2.x used single-threaded mode in this situation.)
-
- To use multi-threaded mode with only one thread, set threads to
- +1. The + prefix has no effect with values other than 1. A
- memory usage limit can still make xz switch to single-threaded
- mode unless --no-adjust is used. Support for the + prefix was
- added in xz 5.4.0.
-
- If an automatic number of threads has been requested and no mem-
- ory usage limit has been specified, then a system-specific de-
- fault soft limit will be used to possibly limit the number of
- threads. It is a soft limit in sense that it is ignored if the
- number of threads becomes one, thus a soft limit will never stop
- xz from compressing or decompressing. This default soft limit
- will not make xz switch from multi-threaded mode to single-
- threaded mode. The active limits can be seen with xz
- --info-memory.
-
- Currently the only threading method is to split the input into
- blocks and compress them independently from each other. The de-
- fault block size depends on the compression level and can be
- overridden with the --block-size=size option.
-
- Threaded decompression only works on files that contain multiple
- blocks with size information in block headers. All large enough
- files compressed in multi-threaded mode meet this condition, but
- files compressed in single-threaded mode don't even if
- --block-size=size has been used.
+ auto This is the default. When compressing, auto is equivalent to
+ xz. When decompressing, the format of the input file is au-
+ tomatically detected. Note that raw streams (created with
+ --format=raw) cannot be auto-detected.
+
+ xz Compress to the .xz file format, or accept only .xz files
+ when decompressing.
+
+ lzma, alone
+ Compress to the legacy .lzma file format, or accept only
+ .lzma files when decompressing. The alternative name alone
+ is provided for backwards compatibility with LZMA Utils.
+
+ lzip Accept only .lz files when decompressing. Compression is not
+ supported.
+
+ The .lz format versions 0 and 1 are supported. Version 0
+ files were produced by lzip 1.3 and older. Such files aren't
+ common but may be found from file archives as a few source
+ packages were released in this format. People might have old
+ personal files in this format too. Decompression support for
+ the format version 0 was removed in lzip 1.18. lzip 1.4 and
+ later create files in the format version 1.
+
+ raw Compress or uncompress a raw stream (no headers). This is
+ meant for advanced users only. To decode raw streams, you
+ need use --format=raw and explicitly specify the filter
+ chain, which normally would have been stored in the container
+ headers.
+
+ -C check, --check=check
+ Specify the type of the integrity check. The check is calculated
+ from the uncompressed data and stored in the .xz file. This option
+ has an effect only when compressing into the .xz format; the .lzma
+ format doesn't support integrity checks. The integrity check (if
+ any) is verified when the .xz file is decompressed.
+
+ Supported check types:
+
+ none Don't calculate an integrity check at all. This is usually a
+ bad idea. This can be useful when integrity of the data is
+ verified by other means anyway.
+
+ crc32 Calculate CRC32 using the polynomial from IEEE-802.3 (Ether-
+ net).
+
+ crc64 Calculate CRC64 using the polynomial from ECMA-182. This is
+ the default, since it is slightly better than CRC32 at de-
+ tecting damaged files and the speed difference is negligible.
+
+ sha256
+ Calculate SHA-256. This is somewhat slower than CRC32 and
+ CRC64.
+
+ Integrity of the .xz headers is always verified with CRC32. It is
+ not possible to change or disable it.
+
+ --ignore-check
+ Don't verify the integrity check of the compressed data when decom-
+ pressing. The CRC32 values in the .xz headers will still be veri-
+ fied normally.
+
+ Do not use this option unless you know what you are doing. Possible
+ reasons to use this option:
+
+ * Trying to recover data from a corrupt .xz file.
+
+ * Speeding up decompression. This matters mostly with SHA-256 or
+ with files that have compressed extremely well. It's recommended
+ to not use this option for this purpose unless the file integrity
+ is verified externally in some other way.
+
+ -0 ... -9
+ Select a compression preset level. The default is -6. If multiple
+ preset levels are specified, the last one takes effect. If a custom
+ filter chain was already specified, setting a compression preset
+ level clears the custom filter chain.
+
+ The differences between the presets are more significant than with
+ gzip(1) and bzip2(1). The selected compression settings determine
+ the memory requirements of the decompressor, thus using a too high
+ preset level might make it painful to decompress the file on an old
+ system with little RAM. Specifically, it's not a good idea to
+ blindly use -9 for everything like it often is with gzip(1) and
+ bzip2(1).
+
+ -0 ... -3
+ These are somewhat fast presets. -0 is sometimes faster than
+ gzip -9 while compressing much better. The higher ones often
+ have speed comparable to bzip2(1) with comparable or better
+ compression ratio, although the results depend a lot on the
+ type of data being compressed.
+
+ -4 ... -6
+ Good to very good compression while keeping decompressor mem-
+ ory usage reasonable even for old systems. -6 is the de-
+ fault, which is usually a good choice for distributing files
+ that need to be decompressible even on systems with only
+ 16 MiB RAM. (-5e or -6e may be worth considering too. See
+ --extreme.)
+
+ -7 ... -9
+ These are like -6 but with higher compressor and decompressor
+ memory requirements. These are useful only when compressing
+ files bigger than 8 MiB, 16 MiB, and 32 MiB, respectively.
+
+ On the same hardware, the decompression speed is approximately a
+ constant number of bytes of compressed data per second. In other
+ words, the better the compression, the faster the decompression will
+ usually be. This also means that the amount of uncompressed output
+ produced per second can vary a lot.
+
+ The following table summarises the features of the presets:
+
+ Preset DictSize CompCPU CompMem DecMem
+ -0 256 KiB 0 3 MiB 1 MiB
+ -1 1 MiB 1 9 MiB 2 MiB
+ -2 2 MiB 2 17 MiB 3 MiB
+ -3 4 MiB 3 32 MiB 5 MiB
+ -4 4 MiB 4 48 MiB 5 MiB
+ -5 8 MiB 5 94 MiB 9 MiB
+ -6 8 MiB 6 94 MiB 9 MiB
+ -7 16 MiB 6 186 MiB 17 MiB
+ -8 32 MiB 6 370 MiB 33 MiB
+ -9 64 MiB 6 674 MiB 65 MiB
+
+ Column descriptions:
+
+ * DictSize is the LZMA2 dictionary size. It is waste of memory to
+ use a dictionary bigger than the size of the uncompressed file.
+ This is why it is good to avoid using the presets -7 ... -9 when
+ there's no real need for them. At -6 and lower, the amount of
+ memory wasted is usually low enough to not matter.
+
+ * CompCPU is a simplified representation of the LZMA2 settings that
+ affect compression speed. The dictionary size affects speed too,
+ so while CompCPU is the same for levels -6 ... -9, higher levels
+ still tend to be a little slower. To get even slower and thus
+ possibly better compression, see --extreme.
+
+ * CompMem contains the compressor memory requirements in the sin-
+ gle-threaded mode. It may vary slightly between xz versions.
+
+ * DecMem contains the decompressor memory requirements. That is,
+ the compression settings determine the memory requirements of the
+ decompressor. The exact decompressor memory usage is slightly
+ more than the LZMA2 dictionary size, but the values in the table
+ have been rounded up to the next full MiB.
+
+ Memory requirements of the multi-threaded mode are significantly
+ higher than that of the single-threaded mode. With the default
+ value of --block-size, each thread needs 3*3*DictSize plus CompMem
+ or DecMem. For example, four threads with preset -6 needs
+ 660-670 MiB of memory.
+
+ -e, --extreme
+ Use a slower variant of the selected compression preset level (-0
+ ... -9) to hopefully get a little bit better compression ratio, but
+ with bad luck this can also make it worse. Decompressor memory us-
+ age is not affected, but compressor memory usage increases a little
+ at preset levels -0 ... -3.
+
+ Since there are two presets with dictionary sizes 4 MiB and 8 MiB,
+ the presets -3e and -5e use slightly faster settings (lower CompCPU)
+ than -4e and -6e, respectively. That way no two presets are identi-
+ cal.
+
+ Preset DictSize CompCPU CompMem DecMem
+ -0e 256 KiB 8 4 MiB 1 MiB
+ -1e 1 MiB 8 13 MiB 2 MiB
+ -2e 2 MiB 8 25 MiB 3 MiB
+ -3e 4 MiB 7 48 MiB 5 MiB
+ -4e 4 MiB 8 48 MiB 5 MiB
+ -5e 8 MiB 7 94 MiB 9 MiB
+ -6e 8 MiB 8 94 MiB 9 MiB
+ -7e 16 MiB 8 186 MiB 17 MiB
+ -8e 32 MiB 8 370 MiB 33 MiB
+ -9e 64 MiB 8 674 MiB 65 MiB
+
+ For example, there are a total of four presets that use 8 MiB dic-
+ tionary, whose order from the fastest to the slowest is -5, -6, -5e,
+ and -6e.
+
+ --fast
+ --best
+ These are somewhat misleading aliases for -0 and -9, respectively.
+ These are provided only for backwards compatibility with LZMA Utils.
+ Avoid using these options.
+
+ --block-size=size
+ When compressing to the .xz format, split the input data into blocks
+ of size bytes. The blocks are compressed independently from each
+ other, which helps with multi-threading and makes limited random-ac-
+ cess decompression possible. This option is typically used to over-
+ ride the default block size in multi-threaded mode, but this option
+ can be used in single-threaded mode too.
+
+ In multi-threaded mode about three times size bytes will be allo-
+ cated in each thread for buffering input and output. The default
+ size is three times the LZMA2 dictionary size or 1 MiB, whichever is
+ more. Typically a good value is 2-4 times the size of the LZMA2
+ dictionary or at least 1 MiB. Using size less than the LZMA2 dic-
+ tionary size is waste of RAM because then the LZMA2 dictionary
+ buffer will never get fully used. In multi-threaded mode, the sizes
+ of the blocks are stored in the block headers. This size informa-
+ tion is required for multi-threaded decompression.
+
+ In single-threaded mode no block splitting is done by default. Set-
+ ting this option doesn't affect memory usage. No size information
+ is stored in block headers, thus files created in single-threaded
+ mode won't be identical to files created in multi-threaded mode.
+ The lack of size information also means that xz won't be able decom-
+ press the files in multi-threaded mode.
+
+ --block-list=items
+ When compressing to the .xz format, start a new block with an op-
+ tional custom filter chain after the given intervals of uncompressed
+ data.
+
+ The items are a comma-separated list. Each item consists of an op-
+ tional filter chain number between 0 and 9 followed by a colon (:)
+ and a required size of uncompressed data. Omitting an item (two or
+ more consecutive commas) is a shorthand to use the size and filters
+ of the previous item.
+
+ If the input file is bigger than the sum of the sizes in items, the
+ last item is repeated until the end of the file. A special value of
+ 0 may be used as the last size to indicate that the rest of the file
+ should be encoded as a single block.
+
+ An alternative filter chain for each block can be specified in com-
+ bination with the --filters1=filters ... --filters9=filters options.
+ These options define filter chains with an identifier between 1-9.
+ Filter chain 0 can be used to refer to the default filter chain,
+ which is the same as not specifying a filter chain. The filter
+ chain identifier can be used before the uncompressed size, followed
+ by a colon (:). For example, if one specifies
+ --block-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB then blocks will be
+ created using:
+
+ * The filter chain specified by --filters1 and 2 MiB input
+
+ * The filter chain specified by --filters3 and 2 MiB input
+
+ * The filter chain specified by --filters2 and 4 MiB input
+
+ * The filter chain specified by --filters2 and 4 MiB input
+
+ * The default filter chain and 2 MiB input
+
+ * The default filter chain and 4 MiB input for every block until
+ end of input.
+
+ If one specifies a size that exceeds the encoder's block size (ei-
+ ther the default value in threaded mode or the value specified with
+ --block-size=size), the encoder will create additional blocks while
+ keeping the boundaries specified in items. For example, if one
+ specifies --block-size=10MiB
+ --block-list=5MiB,10MiB,8MiB,12MiB,24MiB and the input file is 80
+ MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and
+ 1 MiB.
+
+ In multi-threaded mode the sizes of the blocks are stored in the
+ block headers. This isn't done in single-threaded mode, so the en-
+ coded output won't be identical to that of the multi-threaded mode.
+
+ --flush-timeout=timeout
+ When compressing, if more than timeout milliseconds (a positive in-
+ teger) has passed since the previous flush and reading more input
+ would block, all the pending input data is flushed from the encoder
+ and made available in the output stream. This can be useful if xz
+ is used to compress data that is streamed over a network. Small
+ timeout values make the data available at the receiving end with a
+ small delay, but large timeout values give better compression ratio.
+
+ This feature is disabled by default. If this option is specified
+ more than once, the last one takes effect. The special timeout
+ value of 0 can be used to explicitly disable this feature.
+
+ This feature is not available on non-POSIX systems.
+
+ This feature is still experimental. Currently xz is unsuitable for
+ decompressing the stream in real time due to how xz does buffering.
+
+ --no-sync
+ Do not synchronize the target file and its directory to the storage
+ device before removing the source file. This can improve perfor-
+ mance if compressing or decompressing many small files. However, if
+ the system crashes soon after the deletion, it is possible that the
+ target file was not written to the storage device but the delete op-
+ eration was. In that case neither the original source file nor the
+ target file is available.
+
+ This option has an effect only when xz is going to remove the source
+ file. In other cases synchronization is never done.
+
+ The synchronization and --no-sync were added in xz 5.7.1alpha.
+
+ --memlimit-compress=limit
+ Set a memory usage limit for compression. If this option is speci-
+ fied multiple times, the last one takes effect.
+
+ If the compression settings exceed the limit, xz will attempt to ad-
+ just the settings downwards so that the limit is no longer exceeded
+ and display a notice that automatic adjustment was done. The ad-
+ justments are done in this order: reducing the number of threads,
+ switching to single-threaded mode if even one thread in multi-
+ threaded mode exceeds the limit, and finally reducing the LZMA2 dic-
+ tionary size.
+
+ When compressing with --format=raw or if --no-adjust has been speci-
+ fied, only the number of threads may be reduced since it can be done
+ without affecting the compressed output.
+
+ If the limit cannot be met even with the adjustments described
+ above, an error is displayed and xz will exit with exit status 1.
+
+ The limit can be specified in multiple ways:
+
+ * The limit can be an absolute value in bytes. Using an integer
+ suffix like MiB can be useful. Example: --memlimit-com-
+ press=80MiB
+
+ * The limit can be specified as a percentage of total physical mem-
+ ory (RAM). This can be useful especially when setting the XZ_DE-
+ FAULTS environment variable in a shell initialization script that
+ is shared between different computers. That way the limit is au-
+ tomatically bigger on systems with more memory. Example: --mem-
+ limit-compress=70%
+
+ * The limit can be reset back to its default value by setting it to
+ 0. This is currently equivalent to setting the limit to max (no
+ memory usage limit).
+
+ For 32-bit xz there is a special case: if the limit would be over
+ 4020 MiB, the limit is set to 4020 MiB. On MIPS32 2000 MiB is used
+ instead. (The values 0 and max aren't affected by this. A similar
+ feature doesn't exist for decompression.) This can be helpful when
+ a 32-bit executable has access to 4 GiB address space (2 GiB on
+ MIPS32) while hopefully doing no harm in other situations.
+
+ See also the section Memory usage.
+
+ --memlimit-decompress=limit
+ Set a memory usage limit for decompression. This also affects the
+ --list mode. If the operation is not possible without exceeding the
+ limit, xz will display an error and decompressing the file will
+ fail. See --memlimit-compress=limit for possible ways to specify
+ the limit.
+
+ --memlimit-mt-decompress=limit
+ Set a memory usage limit for multi-threaded decompression. This can
+ only affect the number of threads; this will never make xz refuse to
+ decompress a file. If limit is too low to allow any multi-thread-
+ ing, the limit is ignored and xz will continue in single-threaded
+ mode. Note that if also --memlimit-decompress is used, it will al-
+ ways apply to both single-threaded and multi-threaded modes, and so
+ the effective limit for multi-threading will never be higher than
+ the limit set with --memlimit-decompress.
+
+ In contrast to the other memory usage limit options, --mem-
+ limit-mt-decompress=limit has a system-specific default limit. xz
+ --info-memory can be used to see the current value.
+
+ This option and its default value exist because without any limit
+ the threaded decompressor could end up allocating an insane amount
+ of memory with some input files. If the default limit is too low on
+ your system, feel free to increase the limit but never set it to a
+ value larger than the amount of usable RAM as with appropriate input
+ files xz will attempt to use that amount of memory even with a low
+ number of threads. Running out of memory or swapping will not im-
+ prove decompression performance.
+
+ See --memlimit-compress=limit for possible ways to specify the
+ limit. Setting limit to 0 resets the limit to the default system-
+ specific value.
+
+ -M limit, --memlimit=limit, --memory=limit
+ This is equivalent to specifying --memlimit-compress=limit --mem-
+ limit-decompress=limit --memlimit-mt-decompress=limit.
+
+ --no-adjust
+ Display an error and exit if the memory usage limit cannot be met
+ without adjusting settings that affect the compressed output. That
+ is, this prevents xz from switching the encoder from multi-threaded
+ mode to single-threaded mode and from reducing the LZMA2 dictionary
+ size. Even when this option is used the number of threads may be
+ reduced to meet the memory usage limit as that won't affect the com-
+ pressed output.
+
+ Automatic adjusting is always disabled when creating raw streams
+ (--format=raw).
+
+ -T threads, --threads=threads
+ Specify the number of worker threads to use. Setting threads to a
+ special value 0 makes xz use up to as many threads as the proces-
+ sor(s) on the system support. The actual number of threads can be
+ fewer than threads if the input file is not big enough for threading
+ with the given settings or if using more threads would exceed the
+ memory usage limit.
+
+ The single-threaded and multi-threaded compressors produce different
+ output. Single-threaded compressor will give the smallest file size
+ but only the output from the multi-threaded compressor can be decom-
+ pressed using multiple threads. Setting threads to 1 will use the
+ single-threaded mode. Setting threads to any other value, including
+ 0, will use the multi-threaded compressor even if the system sup-
+ ports only one hardware thread. (xz 5.2.x used single-threaded mode
+ in this situation.)
+
+ To use multi-threaded mode with only one thread, set threads to +1.
+ The + prefix has no effect with values other than 1. A memory usage
+ limit can still make xz switch to single-threaded mode unless
+ --no-adjust is used. Support for the + prefix was added in xz
+ 5.4.0.
+
+ If an automatic number of threads has been requested and no memory
+ usage limit has been specified, then a system-specific default soft
+ limit will be used to possibly limit the number of threads. It is a
+ soft limit in sense that it is ignored if the number of threads be-
+ comes one, thus a soft limit will never stop xz from compressing or
+ decompressing. This default soft limit will not make xz switch from
+ multi-threaded mode to single-threaded mode. The active limits can
+ be seen with xz --info-memory.
+
+ Currently the only threading method is to split the input into
+ blocks and compress them independently from each other. The default
+ block size depends on the compression level and can be overridden
+ with the --block-size=size option.
+
+ Threaded decompression only works on files that contain multiple
+ blocks with size information in block headers. All large enough
+ files compressed in multi-threaded mode meet this condition, but
+ files compressed in single-threaded mode don't even if
+ --block-size=size has been used.
- The default value for threads is 0. In xz 5.4.x and older the
- default is 1.
+ The default value for threads is 0. In xz 5.4.x and older the de-
+ fault is 1.
Custom compressor filter chains
- A custom filter chain allows specifying the compression settings in de-
- tail instead of relying on the settings associated to the presets.
- When a custom filter chain is specified, preset options (-0 ... -9 and
- --extreme) earlier on the command line are forgotten. If a preset op-
- tion is specified after one or more custom filter chain options, the
- new preset takes effect and the custom filter chain options specified
- earlier are forgotten.
-
- A filter chain is comparable to piping on the command line. When com-
- pressing, the uncompressed input goes to the first filter, whose output
- goes to the next filter (if any). The output of the last filter gets
- written to the compressed file. The maximum number of filters in the
- chain is four, but typically a filter chain has only one or two fil-
- ters.
-
- Many filters have limitations on where they can be in the filter chain:
- some filters can work only as the last filter in the chain, some only
- as a non-last filter, and some work in any position in the chain. De-
- pending on the filter, this limitation is either inherent to the filter
- design or exists to prevent security issues.
-
- A custom filter chain can be specified in two different ways. The op-
- tions --filters=filters and --filters1=filters ... --filters9=filters
- allow specifying an entire filter chain in one option using the liblzma
- filter string syntax. Alternatively, a filter chain can be specified
- by using one or more individual filter options in the order they are
- wanted in the filter chain. That is, the order of the individual fil-
- ter options is significant! When decoding raw streams (--format=raw),
- the filter chain must be specified in the same order as it was speci-
- fied when compressing. Any individual filter or preset options speci-
- fied before the full chain option (--filters=filters) will be forgot-
- ten. Individual filters specified after the full chain option will re-
- set the filter chain.
-
- Both the full and individual filter options take filter-specific op-
- tions as a comma-separated list. Extra commas in options are ignored.
- Every option has a default value, so specify those you want to change.
-
- To see the whole filter chain and options, use xz -vv (that is, use
- --verbose twice). This works also for viewing the filter chain options
- used by presets.
-
- --filters=filters
- Specify the full filter chain or a preset in a single option.
- Each filter can be separated by spaces or two dashes (--). fil-
- ters may need to be quoted on the shell command line so it is
- parsed as a single option. To denote options, use : or =. A
- preset can be prefixed with a - and followed with zero or more
- flags. The only supported flag is e to apply the same options
- as --extreme.
-
- --filters1=filters ... --filters9=filters
- Specify up to nine additional filter chains that can be used
- with --block-list.
-
- For example, when compressing an archive with executable files
- followed by text files, the executable part could use a filter
- chain with a BCJ filter and the text part only the LZMA2 filter.
-
- --filters-help
- Display a help message describing how to specify presets and
- custom filter chains in the --filters and --filters1=filters ...
- --filters9=filters options, and exit successfully.
-
- --lzma1[=options]
- --lzma2[=options]
- Add LZMA1 or LZMA2 filter to the filter chain. These filters
- can be used only as the last filter in the chain.
-
- LZMA1 is a legacy filter, which is supported almost solely due
- to the legacy .lzma file format, which supports only LZMA1.
- LZMA2 is an updated version of LZMA1 to fix some practical is-
- sues of LZMA1. The .xz format uses LZMA2 and doesn't support
- LZMA1 at all. Compression speed and ratios of LZMA1 and LZMA2
- are practically the same.
-
- LZMA1 and LZMA2 share the same set of options:
-
- preset=preset
- Reset all LZMA1 or LZMA2 options to preset. Preset con-
- sist of an integer, which may be followed by single-let-
- ter preset modifiers. The integer can be from 0 to 9,
- matching the command line options -0 ... -9. The only
- supported modifier is currently e, which matches --ex-
- treme. If no preset is specified, the default values of
- LZMA1 or LZMA2 options are taken from the preset 6.
-
- dict=size
- Dictionary (history buffer) size indicates how many bytes
- of the recently processed uncompressed data is kept in
- memory. The algorithm tries to find repeating byte se-
- quences (matches) in the uncompressed data, and replace
- them with references to the data currently in the dictio-
- nary. The bigger the dictionary, the higher is the
- chance to find a match. Thus, increasing dictionary size
- usually improves compression ratio, but a dictionary big-
- ger than the uncompressed file is waste of memory.
-
- Typical dictionary size is from 64 KiB to 64 MiB. The
- minimum is 4 KiB. The maximum for compression is cur-
- rently 1.5 GiB (1536 MiB). The decompressor already sup-
- ports dictionaries up to one byte less than 4 GiB, which
- is the maximum for the LZMA1 and LZMA2 stream formats.
-
- Dictionary size and match finder (mf) together determine
- the memory usage of the LZMA1 or LZMA2 encoder. The same
- (or bigger) dictionary size is required for decompressing
- that was used when compressing, thus the memory usage of
- the decoder is determined by the dictionary size used
- when compressing. The .xz headers store the dictionary
- size either as 2^n or 2^n + 2^(n-1), so these sizes are
- somewhat preferred for compression. Other sizes will get
- rounded up when stored in the .xz headers.
-
- lc=lc Specify the number of literal context bits. The minimum
- is 0 and the maximum is 4; the default is 3. In addi-
- tion, the sum of lc and lp must not exceed 4.
-
- All bytes that cannot be encoded as matches are encoded
- as literals. That is, literals are simply 8-bit bytes
- that are encoded one at a time.
-
- The literal coding makes an assumption that the highest
- lc bits of the previous uncompressed byte correlate with
- the next byte. For example, in typical English text, an
- upper-case letter is often followed by a lower-case let-
- ter, and a lower-case letter is usually followed by an-
- other lower-case letter. In the US-ASCII character set,
- the highest three bits are 010 for upper-case letters and
- 011 for lower-case letters. When lc is at least 3, the
- literal coding can take advantage of this property in the
- uncompressed data.
-
- The default value (3) is usually good. If you want maxi-
- mum compression, test lc=4. Sometimes it helps a little,
- and sometimes it makes compression worse. If it makes it
- worse, test lc=2 too.
-
- lp=lp Specify the number of literal position bits. The minimum
- is 0 and the maximum is 4; the default is 0.
-
- Lp affects what kind of alignment in the uncompressed
- data is assumed when encoding literals. See pb below for
- more information about alignment.
-
- pb=pb Specify the number of position bits. The minimum is 0
- and the maximum is 4; the default is 2.
-
- Pb affects what kind of alignment in the uncompressed
- data is assumed in general. The default means four-byte
- alignment (2^pb=2^2=4), which is often a good choice when
- there's no better guess.
-
- When the alignment is known, setting pb accordingly may
- reduce the file size a little. For example, with text
- files having one-byte alignment (US-ASCII, ISO-8859-*,
- UTF-8), setting pb=0 can improve compression slightly.
- For UTF-16 text, pb=1 is a good choice. If the alignment
- is an odd number like 3 bytes, pb=0 might be the best
- choice.
-
- Even though the assumed alignment can be adjusted with pb
- and lp, LZMA1 and LZMA2 still slightly favor 16-byte
- alignment. It might be worth taking into account when
- designing file formats that are likely to be often com-
- pressed with LZMA1 or LZMA2.
-
- mf=mf Match finder has a major effect on encoder speed, memory
- usage, and compression ratio. Usually Hash Chain match
- finders are faster than Binary Tree match finders. The
- default depends on the preset: 0 uses hc3, 1-3 use hc4,
- and the rest use bt4.
-
- The following match finders are supported. The memory
- usage formulas below are rough approximations, which are
- closest to the reality when dict is a power of two.
-
- hc3 Hash Chain with 2- and 3-byte hashing
- Minimum value for nice: 3
- Memory usage:
- dict * 7.5 (if dict <= 16 MiB);
- dict * 5.5 + 64 MiB (if dict > 16 MiB)
-
- hc4 Hash Chain with 2-, 3-, and 4-byte hashing
- Minimum value for nice: 4
- Memory usage:
- dict * 7.5 (if dict <= 32 MiB);
- dict * 6.5 (if dict > 32 MiB)
-
- bt2 Binary Tree with 2-byte hashing
- Minimum value for nice: 2
- Memory usage: dict * 9.5
-
- bt3 Binary Tree with 2- and 3-byte hashing
- Minimum value for nice: 3
- Memory usage:
- dict * 11.5 (if dict <= 16 MiB);
- dict * 9.5 + 64 MiB (if dict > 16 MiB)
-
- bt4 Binary Tree with 2-, 3-, and 4-byte hashing
- Minimum value for nice: 4
- Memory usage:
- dict * 11.5 (if dict <= 32 MiB);
- dict * 10.5 (if dict > 32 MiB)
-
- mode=mode
- Compression mode specifies the method to analyze the data
- produced by the match finder. Supported modes are fast
- and normal. The default is fast for presets 0-3 and nor-
- mal for presets 4-9.
-
- Usually fast is used with Hash Chain match finders and
- normal with Binary Tree match finders. This is also what
- the presets do.
-
- nice=nice
- Specify what is considered to be a nice length for a
- match. Once a match of at least nice bytes is found, the
- algorithm stops looking for possibly better matches.
-
- Nice can be 2-273 bytes. Higher values tend to give bet-
- ter compression ratio at the expense of speed. The de-
- fault depends on the preset.
-
- depth=depth
- Specify the maximum search depth in the match finder.
- The default is the special value of 0, which makes the
- compressor determine a reasonable depth from mf and nice.
-
- Reasonable depth for Hash Chains is 4-100 and 16-1000 for
- Binary Trees. Using very high values for depth can make
- the encoder extremely slow with some files. Avoid set-
- ting the depth over 1000 unless you are prepared to in-
- terrupt the compression in case it is taking far too
- long.
-
- When decoding raw streams (--format=raw), LZMA2 needs only the
- dictionary size. LZMA1 needs also lc, lp, and pb.
-
- --x86[=options]
- --arm[=options]
- --armthumb[=options]
- --arm64[=options]
- --powerpc[=options]
- --ia64[=options]
- --sparc[=options]
- --riscv[=options]
- Add a branch/call/jump (BCJ) filter to the filter chain. These
- filters can be used only as a non-last filter in the filter
- chain.
-
- A BCJ filter converts relative addresses in the machine code to
- their absolute counterparts. This doesn't change the size of
- the data but it increases redundancy, which can help LZMA2 to
- produce 0-15 % smaller .xz file. The BCJ filters are always re-
- versible, so using a BCJ filter for wrong type of data doesn't
- cause any data loss, although it may make the compression ratio
- slightly worse. The BCJ filters are very fast and use an in-
- significant amount of memory.
-
- These BCJ filters have known problems related to the compression
- ratio:
-
- o Some types of files containing executable code (for example,
- object files, static libraries, and Linux kernel modules)
- have the addresses in the instructions filled with filler
- values. These BCJ filters will still do the address conver-
- sion, which will make the compression worse with these files.
-
- o If a BCJ filter is applied on an archive, it is possible that
- it makes the compression ratio worse than not using a BCJ
- filter. For example, if there are similar or even identical
- executables then filtering will likely make the files less
- similar and thus compression is worse. The contents of non-
- executable files in the same archive can matter too. In
- practice one has to try with and without a BCJ filter to see
- which is better in each situation.
-
- Different instruction sets have different alignment: the exe-
- cutable file must be aligned to a multiple of this value in the
- input data to make the filter work.
-
- Filter Alignment Notes
- x86 1 32-bit or 64-bit x86
- ARM 4
- ARM-Thumb 2
- ARM64 4 4096-byte alignment is best
- PowerPC 4 Big endian only
- IA-64 16 Itanium
- SPARC 4
- RISC-V 2
-
- Since the BCJ-filtered data is usually compressed with LZMA2,
- the compression ratio may be improved slightly if the LZMA2 op-
- tions are set to match the alignment of the selected BCJ filter.
- Examples:
-
- o IA-64 filter has 16-byte alignment so pb=4,lp=4,lc=0 is good
- with LZMA2 (2^4=16).
-
- o RISC-V code has 2-byte or 4-byte alignment depending on
- whether the file contains 16-bit compressed instructions (the
- C extension). When 16-bit instructions are used,
- pb=2,lp=1,lc=3 or pb=1,lp=1,lc=3 is good. When 16-bit in-
- structions aren't present, pb=2,lp=2,lc=2 is the best. read-
- elf -h can be used to check if "RVC" appears on the "Flags"
- line.
-
- o ARM64 is always 4-byte aligned so pb=2,lp=2,lc=2 is the best.
-
- o The x86 filter is an exception. It's usually good to stick
- to LZMA2's defaults (pb=2,lp=0,lc=3) when compressing x86 ex-
- ecutables.
-
- All BCJ filters support the same options:
-
- start=offset
- Specify the start offset that is used when converting be-
- tween relative and absolute addresses. The offset must
- be a multiple of the alignment of the filter (see the ta-
- ble above). The default is zero. In practice, the de-
- fault is good; specifying a custom offset is almost never
- useful.
-
- --delta[=options]
- Add the Delta filter to the filter chain. The Delta filter can
- be only used as a non-last filter in the filter chain.
-
- Currently only simple byte-wise delta calculation is supported.
- It can be useful when compressing, for example, uncompressed
- bitmap images or uncompressed PCM audio. However, special pur-
- pose algorithms may give significantly better results than Delta
- + LZMA2. This is true especially with audio, which compresses
- faster and better, for example, with flac(1).
-
- Supported options:
-
- dist=distance
- Specify the distance of the delta calculation in bytes.
- distance must be 1-256. The default is 1.
+ A custom filter chain allows specifying the compression settings in detail
+ instead of relying on the settings associated to the presets. When a cus-
+ tom filter chain is specified, preset options (-0 ... -9 and --extreme)
+ earlier on the command line are forgotten. If a preset option is specified
+ after one or more custom filter chain options, the new preset takes effect
+ and the custom filter chain options specified earlier are forgotten.
+
+ A filter chain is comparable to piping on the command line. When compress-
+ ing, the uncompressed input goes to the first filter, whose output goes to
+ the next filter (if any). The output of the last filter gets written to
+ the compressed file. The maximum number of filters in the chain is four,
+ but typically a filter chain has only one or two filters.
+
+ Many filters have limitations on where they can be in the filter chain:
+ some filters can work only as the last filter in the chain, some only as a
+ non-last filter, and some work in any position in the chain. Depending on
+ the filter, this limitation is either inherent to the filter design or ex-
+ ists to prevent security issues.
+
+ A custom filter chain can be specified in two different ways. The options
+ --filters=filters and --filters1=filters ... --filters9=filters allow spec-
+ ifying an entire filter chain in one option using the liblzma filter string
+ syntax. Alternatively, a filter chain can be specified by using one or
+ more individual filter options in the order they are wanted in the filter
+ chain. That is, the order of the individual filter options is significant!
+ When decoding raw streams (--format=raw), the filter chain must be speci-
+ fied in the same order as it was specified when compressing. Any individ-
+ ual filter or preset options specified before the full chain option (--fil-
+ ters=filters) will be forgotten. Individual filters specified after the
+ full chain option will reset the filter chain.
+
+ Both the full and individual filter options take filter-specific options as
+ a comma-separated list. Extra commas in options are ignored. Every option
+ has a default value, so specify those you want to change.
+
+ To see the whole filter chain and options, use xz -vv (that is, use --ver-
+ bose twice). This works also for viewing the filter chain options used by
+ presets.
+
+ --filters=filters
+ Specify the full filter chain or a preset in a single option. Each
+ filter can be separated by spaces or two dashes (--). filters may
+ need to be quoted on the shell command line so it is parsed as a
+ single option. To denote options, use : or =. A preset can be pre-
+ fixed with a - and followed with zero or more flags. The only sup-
+ ported flag is e to apply the same options as --extreme.
+
+ --filters1=filters ... --filters9=filters
+ Specify up to nine additional filter chains that can be used with
+ --block-list.
+
+ For example, when compressing an archive with executable files fol-
+ lowed by text files, the executable part could use a filter chain
+ with a BCJ filter and the text part only the LZMA2 filter.
+
+ --filters-help
+ Display a help message describing how to specify presets and custom
+ filter chains in the --filters and --filters1=filters ... --fil-
+ ters9=filters options, and exit successfully.
+
+ --lzma1[=options]
+ --lzma2[=options]
+ Add LZMA1 or LZMA2 filter to the filter chain. These filters can be
+ used only as the last filter in the chain.
+
+ LZMA1 is a legacy filter, which is supported almost solely due to
+ the legacy .lzma file format, which supports only LZMA1. LZMA2 is
+ an updated version of LZMA1 to fix some practical issues of LZMA1.
+ The .xz format uses LZMA2 and doesn't support LZMA1 at all. Com-
+ pression speed and ratios of LZMA1 and LZMA2 are practically the
+ same.
+
+ LZMA1 and LZMA2 share the same set of options:
+
+ preset=preset
+ Reset all LZMA1 or LZMA2 options to preset. Preset consist
+ of an integer, which may be followed by single-letter preset
+ modifiers. The integer can be from 0 to 9, matching the com-
+ mand line options -0 ... -9. The only supported modifier is
+ currently e, which matches --extreme. If no preset is speci-
+ fied, the default values of LZMA1 or LZMA2 options are taken
+ from the preset 6.
+
+ dict=size
+ Dictionary (history buffer) size indicates how many bytes of
+ the recently processed uncompressed data is kept in memory.
+ The algorithm tries to find repeating byte sequences
+ (matches) in the uncompressed data, and replace them with
+ references to the data currently in the dictionary. The big-
+ ger the dictionary, the higher is the chance to find a match.
+ Thus, increasing dictionary size usually improves compression
+ ratio, but a dictionary bigger than the uncompressed file is
+ waste of memory.
+
+ Typical dictionary size is from 64 KiB to 64 MiB. The mini-
+ mum is 4 KiB. The maximum for compression is currently
+ 1.5 GiB (1536 MiB). The decompressor already supports dic-
+ tionaries up to one byte less than 4 GiB, which is the maxi-
+ mum for the LZMA1 and LZMA2 stream formats.
+
+ Dictionary size and match finder (mf) together determine the
+ memory usage of the LZMA1 or LZMA2 encoder. The same (or
+ bigger) dictionary size is required for decompressing that
+ was used when compressing, thus the memory usage of the de-
+ coder is determined by the dictionary size used when com-
+ pressing. The .xz headers store the dictionary size either
+ as 2^n or 2^n + 2^(n-1), so these sizes are somewhat pre-
+ ferred for compression. Other sizes will get rounded up when
+ stored in the .xz headers.
+
+ lc=lc Specify the number of literal context bits. The minimum is 0
+ and the maximum is 4; the default is 3. In addition, the sum
+ of lc and lp must not exceed 4.
+
+ All bytes that cannot be encoded as matches are encoded as
+ literals. That is, literals are simply 8-bit bytes that are
+ encoded one at a time.
+
+ The literal coding makes an assumption that the highest lc
+ bits of the previous uncompressed byte correlate with the
+ next byte. For example, in typical English text, an upper-
+ case letter is often followed by a lower-case letter, and a
+ lower-case letter is usually followed by another lower-case
+ letter. In the US-ASCII character set, the highest three
+ bits are 010 for upper-case letters and 011 for lower-case
+ letters. When lc is at least 3, the literal coding can take
+ advantage of this property in the uncompressed data.
+
+ The default value (3) is usually good. If you want maximum
+ compression, test lc=4. Sometimes it helps a little, and
+ sometimes it makes compression worse. If it makes it worse,
+ test lc=2 too.
+
+ lp=lp Specify the number of literal position bits. The minimum is
+ 0 and the maximum is 4; the default is 0.
+
+ Lp affects what kind of alignment in the uncompressed data is
+ assumed when encoding literals. See pb below for more infor-
+ mation about alignment.
+
+ pb=pb Specify the number of position bits. The minimum is 0 and
+ the maximum is 4; the default is 2.
+
+ Pb affects what kind of alignment in the uncompressed data is
+ assumed in general. The default means four-byte alignment
+ (2^pb=2^2=4), which is often a good choice when there's no
+ better guess.
+
+ When the alignment is known, setting pb accordingly may re-
+ duce the file size a little. For example, with text files
+ having one-byte alignment (US-ASCII, ISO-8859-*, UTF-8), set-
+ ting pb=0 can improve compression slightly. For UTF-16 text,
+ pb=1 is a good choice. If the alignment is an odd number
+ like 3 bytes, pb=0 might be the best choice.
+
+ Even though the assumed alignment can be adjusted with pb and
+ lp, LZMA1 and LZMA2 still slightly favor 16-byte alignment.
+ It might be worth taking into account when designing file
+ formats that are likely to be often compressed with LZMA1 or
+ LZMA2.
+
+ mf=mf Match finder has a major effect on encoder speed, memory us-
+ age, and compression ratio. Usually Hash Chain match finders
+ are faster than Binary Tree match finders. The default de-
+ pends on the preset: 0 uses hc3, 1-3 use hc4, and the rest
+ use bt4.
+
+ The following match finders are supported. The memory usage
+ formulas below are rough approximations, which are closest to
+ the reality when dict is a power of two.
+
+ hc3 Hash Chain with 2- and 3-byte hashing
+ Minimum value for nice: 3
+ Memory usage:
+ dict * 7.5 (if dict <= 16 MiB);
+ dict * 5.5 + 64 MiB (if dict > 16 MiB)
+
+ hc4 Hash Chain with 2-, 3-, and 4-byte hashing
+ Minimum value for nice: 4
+ Memory usage:
+ dict * 7.5 (if dict <= 32 MiB);
+ dict * 6.5 (if dict > 32 MiB)
+
+ bt2 Binary Tree with 2-byte hashing
+ Minimum value for nice: 2
+ Memory usage: dict * 9.5
+
+ bt3 Binary Tree with 2- and 3-byte hashing
+ Minimum value for nice: 3
+ Memory usage:
+ dict * 11.5 (if dict <= 16 MiB);
+ dict * 9.5 + 64 MiB (if dict > 16 MiB)
+
+ bt4 Binary Tree with 2-, 3-, and 4-byte hashing
+ Minimum value for nice: 4
+ Memory usage:
+ dict * 11.5 (if dict <= 32 MiB);
+ dict * 10.5 (if dict > 32 MiB)
+
+ mode=mode
+ Compression mode specifies the method to analyze the data
+ produced by the match finder. Supported modes are fast and
+ normal. The default is fast for presets 0-3 and normal for
+ presets 4-9.
+
+ Usually fast is used with Hash Chain match finders and normal
+ with Binary Tree match finders. This is also what the pre-
+ sets do.
+
+ nice=nice
+ Specify what is considered to be a nice length for a match.
+ Once a match of at least nice bytes is found, the algorithm
+ stops looking for possibly better matches.
+
+ Nice can be 2-273 bytes. Higher values tend to give better
+ compression ratio at the expense of speed. The default de-
+ pends on the preset.
+
+ depth=depth
+ Specify the maximum search depth in the match finder. The
+ default is the special value of 0, which makes the compressor
+ determine a reasonable depth from mf and nice.
+
+ Reasonable depth for Hash Chains is 4-100 and 16-1000 for Bi-
+ nary Trees. Using very high values for depth can make the
+ encoder extremely slow with some files. Avoid setting the
+ depth over 1000 unless you are prepared to interrupt the com-
+ pression in case it is taking far too long.
+
+ When decoding raw streams (--format=raw), LZMA2 needs only the dic-
+ tionary size. LZMA1 needs also lc, lp, and pb.
+
+ --x86[=options]
+ --arm[=options]
+ --armthumb[=options]
+ --arm64[=options]
+ --powerpc[=options]
+ --ia64[=options]
+ --sparc[=options]
+ --riscv[=options]
+ Add a branch/call/jump (BCJ) filter to the filter chain. These fil-
+ ters can be used only as a non-last filter in the filter chain.
+
+ A BCJ filter converts relative addresses in the machine code to
+ their absolute counterparts. This doesn't change the size of the
+ data but it increases redundancy, which can help LZMA2 to produce
+ 0-15 % smaller .xz file. The BCJ filters are always reversible, so
+ using a BCJ filter for wrong type of data doesn't cause any data
+ loss, although it may make the compression ratio slightly worse.
+ The BCJ filters are very fast and use an insignificant amount of
+ memory.
+
+ These BCJ filters have known problems related to the compression ra-
+ tio:
+
+ * Some types of files containing executable code (for example, ob-
+ ject files, static libraries, and Linux kernel modules) have the
+ addresses in the instructions filled with filler values. These
+ BCJ filters will still do the address conversion, which will make
+ the compression worse with these files.
+
+ * If a BCJ filter is applied on an archive, it is possible that it
+ makes the compression ratio worse than not using a BCJ filter.
+ For example, if there are similar or even identical executables
+ then filtering will likely make the files less similar and thus
+ compression is worse. The contents of non-executable files in
+ the same archive can matter too. In practice one has to try with
+ and without a BCJ filter to see which is better in each situa-
+ tion.
+
+ Different instruction sets have different alignment: the executable
+ file must be aligned to a multiple of this value in the input data
+ to make the filter work.
+
+ Filter Alignment Notes
+ x86 1 32-bit or 64-bit x86
+ ARM 4
+ ARM-Thumb 2
+ ARM64 4 4096-byte alignment is best
+ PowerPC 4 Big endian only
+ IA-64 16 Itanium
+ SPARC 4
+ RISC-V 2
+
+ Since the BCJ-filtered data is usually compressed with LZMA2, the
+ compression ratio may be improved slightly if the LZMA2 options are
+ set to match the alignment of the selected BCJ filter. Examples:
+
+ * IA-64 filter has 16-byte alignment so pb=4,lp=4,lc=0 is good with
+ LZMA2 (2^4=16).
+
+ * RISC-V code has 2-byte or 4-byte alignment depending on whether
+ the file contains 16-bit compressed instructions (the C exten-
+ sion). When 16-bit instructions are used, pb=2,lp=1,lc=3 or
+ pb=1,lp=1,lc=3 is good. When 16-bit instructions aren't present,
+ pb=2,lp=2,lc=2 is the best. readelf -h can be used to check if
+ "RVC" appears on the "Flags" line.
+
+ * ARM64 is always 4-byte aligned so pb=2,lp=2,lc=2 is the best.
+
+ * The x86 filter is an exception. It's usually good to stick to
+ LZMA2's defaults (pb=2,lp=0,lc=3) when compressing x86 executa-
+ bles.
+
+ All BCJ filters support the same options:
+
+ start=offset
+ Specify the start offset that is used when converting between
+ relative and absolute addresses. The offset must be a multi-
+ ple of the alignment of the filter (see the table above).
+ The default is zero. In practice, the default is good; spec-
+ ifying a custom offset is almost never useful.
+
+ --delta[=options]
+ Add the Delta filter to the filter chain. The Delta filter can be
+ only used as a non-last filter in the filter chain.
+
+ Currently only simple byte-wise delta calculation is supported. It
+ can be useful when compressing, for example, uncompressed bitmap im-
+ ages or uncompressed PCM audio. However, special purpose algorithms
+ may give significantly better results than Delta + LZMA2. This is
+ true especially with audio, which compresses faster and better, for
+ example, with flac(1).
+
+ Supported options:
+
+ dist=distance
+ Specify the distance of the delta calculation in bytes. dis-
+ tance must be 1-256. The default is 1.
- For example, with dist=2 and eight-byte input A1 B1 A2 B3
- A3 B5 A4 B7, the output will be A1 B1 01 02 01 02 01 02.
+ For example, with dist=2 and eight-byte input A1 B1 A2 B3 A3
+ B5 A4 B7, the output will be A1 B1 01 02 01 02 01 02.
Other options
- -q, --quiet
- Suppress warnings and notices. Specify this twice to suppress
- errors too. This option has no effect on the exit status. That
- is, even if a warning was suppressed, the exit status to indi-
- cate a warning is still used.
-
- -v, --verbose
- Be verbose. If standard error is connected to a terminal, xz
- will display a progress indicator. Specifying --verbose twice
- will give even more verbose output.
-
- The progress indicator shows the following information:
-
- o Completion percentage is shown if the size of the input file
- is known. That is, the percentage cannot be shown in pipes.
-
- o Amount of compressed data produced (compressing) or consumed
- (decompressing).
-
- o Amount of uncompressed data consumed (compressing) or pro-
- duced (decompressing).
-
- o Compression ratio, which is calculated by dividing the amount
- of compressed data processed so far by the amount of uncom-
- pressed data processed so far.
-
- o Compression or decompression speed. This is measured as the
- amount of uncompressed data consumed (compression) or pro-
- duced (decompression) per second. It is shown after a few
- seconds have passed since xz started processing the file.
-
- o Elapsed time in the format M:SS or H:MM:SS.
-
- o Estimated remaining time is shown only when the size of the
- input file is known and a couple of seconds have already
- passed since xz started processing the file. The time is
- shown in a less precise format which never has any colons,
- for example, 2 min 30 s.
-
- When standard error is not a terminal, --verbose will make xz
- print the filename, compressed size, uncompressed size, compres-
- sion ratio, and possibly also the speed and elapsed time on a
- single line to standard error after compressing or decompressing
- the file. The speed and elapsed time are included only when the
- operation took at least a few seconds. If the operation didn't
- finish, for example, due to user interruption, also the comple-
- tion percentage is printed if the size of the input file is
- known.
-
- -Q, --no-warn
- Don't set the exit status to 2 even if a condition worth a warn-
- ing was detected. This option doesn't affect the verbosity
- level, thus both --quiet and --no-warn have to be used to not
- display warnings and to not alter the exit status.
-
- --robot
- Print messages in a machine-parsable format. This is intended
- to ease writing frontends that want to use xz instead of li-
- blzma, which may be the case with various scripts. The output
- with this option enabled is meant to be stable across xz re-
- leases. See the section ROBOT MODE for details.
-
- --info-memory
- Display, in human-readable format, how much physical memory
- (RAM) and how many processor threads xz thinks the system has
- and the memory usage limits for compression and decompression,
- and exit successfully.
-
- -h, --help
- Display a help message describing the most commonly used op-
- tions, and exit successfully.
-
- -H, --long-help
- Display a help message describing all features of xz, and exit
- successfully
-
- -V, --version
- Display the version number of xz and liblzma in human readable
- format. To get machine-parsable output, specify --robot before
- --version.
+ -q, --quiet
+ Suppress warnings and notices. Specify this twice to suppress er-
+ rors too. This option has no effect on the exit status. That is,
+ even if a warning was suppressed, the exit status to indicate a
+ warning is still used.
+
+ -v, --verbose
+ Be verbose. If standard error is connected to a terminal, xz will
+ display a progress indicator. Specifying --verbose twice will give
+ even more verbose output.
+
+ The progress indicator shows the following information:
+
+ * Completion percentage is shown if the size of the input file is
+ known. That is, the percentage cannot be shown in pipes.
+
+ * Amount of compressed data produced (compressing) or consumed (de-
+ compressing).
+
+ * Amount of uncompressed data consumed (compressing) or produced
+ (decompressing).
+
+ * Compression ratio, which is calculated by dividing the amount of
+ compressed data processed so far by the amount of uncompressed
+ data processed so far.
+
+ * Compression or decompression speed. This is measured as the
+ amount of uncompressed data consumed (compression) or produced
+ (decompression) per second. It is shown after a few seconds have
+ passed since xz started processing the file.
+
+ * Elapsed time in the format M:SS or H:MM:SS.
+
+ * Estimated remaining time is shown only when the size of the input
+ file is known and a couple of seconds have already passed since
+ xz started processing the file. The time is shown in a less pre-
+ cise format which never has any colons, for example, 2 min 30 s.
+
+ When standard error is not a terminal, --verbose will make xz print
+ the filename, compressed size, uncompressed size, compression ratio,
+ and possibly also the speed and elapsed time on a single line to
+ standard error after compressing or decompressing the file. The
+ speed and elapsed time are included only when the operation took at
+ least a few seconds. If the operation didn't finish, for example,
+ due to user interruption, also the completion percentage is printed
+ if the size of the input file is known.
+
+ -Q, --no-warn
+ Don't set the exit status to 2 even if a condition worth a warning
+ was detected. This option doesn't affect the verbosity level, thus
+ both --quiet and --no-warn have to be used to not display warnings
+ and to not alter the exit status.
+
+ --robot
+ Print messages in a machine-parsable format. This is intended to
+ ease writing frontends that want to use xz instead of liblzma, which
+ may be the case with various scripts. The output with this option
+ enabled is meant to be stable across xz releases. See the section
+ ROBOT MODE for details.
+
+ --info-memory
+ Display, in human-readable format, how much physical memory (RAM)
+ and how many processor threads xz thinks the system has and the mem-
+ ory usage limits for compression and decompression, and exit suc-
+ cessfully.
+
+ -h, --help
+ Display a help message describing the most commonly used options,
+ and exit successfully.
+
+ -H, --long-help
+ Display a help message describing all features of xz, and exit suc-
+ cessfully
+
+ -V, --version
+ Display the version number of xz and liblzma in human readable for-
+ mat. To get machine-parsable output, specify --robot before --ver-
+ sion.
ROBOT MODE
- The robot mode is activated with the --robot option. It makes the out-
- put of xz easier to parse by other programs. Currently --robot is sup-
- ported only together with --list, --filters-help, --info-memory, and
- --version. It will be supported for compression and decompression in
- the future.
+ The robot mode is activated with the --robot option. It makes the output
+ of xz easier to parse by other programs. Currently --robot is supported
+ only together with --list, --filters-help, --info-memory, and --version.
+ It will be supported for compression and decompression in the future.
List mode
- xz --robot --list uses tab-separated output. The first column of every
- line has a string that indicates the type of the information found on
- that line:
-
- name This is always the first line when starting to list a file. The
- second column on the line is the filename.
-
- file This line contains overall information about the .xz file. This
- line is always printed after the name line.
-
- stream This line type is used only when --verbose was specified. There
- are as many stream lines as there are streams in the .xz file.
-
- block This line type is used only when --verbose was specified. There
- are as many block lines as there are blocks in the .xz file.
- The block lines are shown after all the stream lines; different
- line types are not interleaved.
-
- summary
- This line type is used only when --verbose was specified twice.
- This line is printed after all block lines. Like the file line,
- the summary line contains overall information about the .xz
- file.
-
- totals This line is always the very last line of the list output. It
- shows the total counts and sizes.
-
- The columns of the file lines:
- 2. Number of streams in the file
- 3. Total number of blocks in the stream(s)
- 4. Compressed size of the file
- 5. Uncompressed size of the file
- 6. Compression ratio, for example, 0.123. If ratio is over
- 9.999, three dashes (---) are displayed instead of the ra-
- tio.
- 7. Comma-separated list of integrity check names. The follow-
- ing strings are used for the known check types: None, CRC32,
- CRC64, and SHA-256. For unknown check types, Unknown-N is
- used, where N is the Check ID as a decimal number (one or
- two digits).
- 8. Total size of stream padding in the file
-
- The columns of the stream lines:
- 2. Stream number (the first stream is 1)
- 3. Number of blocks in the stream
- 4. Compressed start offset
- 5. Uncompressed start offset
- 6. Compressed size (does not include stream padding)
- 7. Uncompressed size
- 8. Compression ratio
- 9. Name of the integrity check
- 10. Size of stream padding
-
- The columns of the block lines:
- 2. Number of the stream containing this block
- 3. Block number relative to the beginning of the stream (the
- first block is 1)
- 4. Block number relative to the beginning of the file
- 5. Compressed start offset relative to the beginning of the
- file
- 6. Uncompressed start offset relative to the beginning of the
- file
- 7. Total compressed size of the block (includes headers)
- 8. Uncompressed size
- 9. Compression ratio
- 10. Name of the integrity check
-
- If --verbose was specified twice, additional columns are included on
- the block lines. These are not displayed with a single --verbose, be-
- cause getting this information requires many seeks and can thus be
- slow:
- 11. Value of the integrity check in hexadecimal
- 12. Block header size
- 13. Block flags: c indicates that compressed size is present,
- and u indicates that uncompressed size is present. If the
- flag is not set, a dash (-) is shown instead to keep the
- string length fixed. New flags may be added to the end of
- the string in the future.
- 14. Size of the actual compressed data in the block (this ex-
- cludes the block header, block padding, and check fields)
- 15. Amount of memory (in bytes) required to decompress this
- block with this xz version
- 16. Filter chain. Note that most of the options used at com-
- pression time cannot be known, because only the options that
- are needed for decompression are stored in the .xz headers.
-
- The columns of the summary lines:
- 2. Amount of memory (in bytes) required to decompress this file
- with this xz version
- 3. yes or no indicating if all block headers have both com-
- pressed size and uncompressed size stored in them
- Since xz 5.1.2alpha:
- 4. Minimum xz version required to decompress the file
-
- The columns of the totals line:
- 2. Number of streams
- 3. Number of blocks
- 4. Compressed size
- 5. Uncompressed size
- 6. Average compression ratio
- 7. Comma-separated list of integrity check names that were
- present in the files
- 8. Stream padding size
- 9. Number of files. This is here to keep the order of the ear-
- lier columns the same as on file lines.
-
- If --verbose was specified twice, additional columns are included on
- the totals line:
- 10. Maximum amount of memory (in bytes) required to decompress
- the files with this xz version
- 11. yes or no indicating if all block headers have both com-
- pressed size and uncompressed size stored in them
- Since xz 5.1.2alpha:
- 12. Minimum xz version required to decompress the file
+ xz --robot --list uses tab-separated output. The first column of every
+ line has a string that indicates the type of the information found on that
+ line:
+
+ name This is always the first line when starting to list a file. The
+ second column on the line is the filename.
+
+ file This line contains overall information about the .xz file. This
+ line is always printed after the name line.
+
+ stream
+ This line type is used only when --verbose was specified. There are
+ as many stream lines as there are streams in the .xz file.
+
+ block This line type is used only when --verbose was specified. There are
+ as many block lines as there are blocks in the .xz file. The block
+ lines are shown after all the stream lines; different line types are
+ not interleaved.
+
+ summary
+ This line type is used only when --verbose was specified twice.
+ This line is printed after all block lines. Like the file line, the
+ summary line contains overall information about the .xz file.
+
+ totals
+ This line is always the very last line of the list output. It shows
+ the total counts and sizes.
+
+ The columns of the file lines:
+ 2. Number of streams in the file
+ 3. Total number of blocks in the stream(s)
+ 4. Compressed size of the file
+ 5. Uncompressed size of the file
+ 6. Compression ratio, for example, 0.123. If ratio is over 9.999,
+ three dashes (---) are displayed instead of the ratio.
+ 7. Comma-separated list of integrity check names. The following
+ strings are used for the known check types: None, CRC32, CRC64,
+ and SHA-256. For unknown check types, Unknown-N is used, where
+ N is the Check ID as a decimal number (one or two digits).
+ 8. Total size of stream padding in the file
+
+ The columns of the stream lines:
+ 2. Stream number (the first stream is 1)
+ 3. Number of blocks in the stream
+ 4. Compressed start offset
+ 5. Uncompressed start offset
+ 6. Compressed size (does not include stream padding)
+ 7. Uncompressed size
+ 8. Compression ratio
+ 9. Name of the integrity check
+ 10. Size of stream padding
+
+ The columns of the block lines:
+ 2. Number of the stream containing this block
+ 3. Block number relative to the beginning of the stream (the first
+ block is 1)
+ 4. Block number relative to the beginning of the file
+ 5. Compressed start offset relative to the beginning of the file
+ 6. Uncompressed start offset relative to the beginning of the file
+ 7. Total compressed size of the block (includes headers)
+ 8. Uncompressed size
+ 9. Compression ratio
+ 10. Name of the integrity check
+
+ If --verbose was specified twice, additional columns are included on the
+ block lines. These are not displayed with a single --verbose, because get-
+ ting this information requires many seeks and can thus be slow:
+ 11. Value of the integrity check in hexadecimal
+ 12. Block header size
+ 13. Block flags: c indicates that compressed size is present, and u
+ indicates that uncompressed size is present. If the flag is not
+ set, a dash (-) is shown instead to keep the string length
+ fixed. New flags may be added to the end of the string in the
+ future.
+ 14. Size of the actual compressed data in the block (this excludes
+ the block header, block padding, and check fields)
+ 15. Amount of memory (in bytes) required to decompress this block
+ with this xz version
+ 16. Filter chain. Note that most of the options used at compression
+ time cannot be known, because only the options that are needed
+ for decompression are stored in the .xz headers.
+
+ The columns of the summary lines:
+ 2. Amount of memory (in bytes) required to decompress this file
+ with this xz version
+ 3. yes or no indicating if all block headers have both compressed
+ size and uncompressed size stored in them
+ Since xz 5.1.2alpha:
+ 4. Minimum xz version required to decompress the file
+
+ The columns of the totals line:
+ 2. Number of streams
+ 3. Number of blocks
+ 4. Compressed size
+ 5. Uncompressed size
+ 6. Average compression ratio
+ 7. Comma-separated list of integrity check names that were present
+ in the files
+ 8. Stream padding size
+ 9. Number of files. This is here to keep the order of the earlier
+ columns the same as on file lines.
+
+ If --verbose was specified twice, additional columns are included on the
+ totals line:
+ 10. Maximum amount of memory (in bytes) required to decompress the
+ files with this xz version
+ 11. yes or no indicating if all block headers have both compressed
+ size and uncompressed size stored in them
+ Since xz 5.1.2alpha:
+ 12. Minimum xz version required to decompress the file
- Future versions may add new line types and new columns can be added to
- the existing line types, but the existing columns won't be changed.
+ Future versions may add new line types and new columns can be added to the
+ existing line types, but the existing columns won't be changed.
Filters help
- xz --robot --filters-help prints the supported filters in the following
- format:
+ xz --robot --filters-help prints the supported filters in the following
+ format:
- filter:option=,option=...
+ filter:option=,option=...
- filter Name of the filter
+ filter
+ Name of the filter
- option Name of a filter specific option
+ option
+ Name of a filter specific option
- value Numeric value ranges appear as . String value choices
- are shown within < > and separated by a | character.
+ value Numeric value ranges appear as . String value choices are
+ shown within < > and separated by a | character.
- Each filter is printed on its own line.
+ Each filter is printed on its own line.
Memory limit information
- xz --robot --info-memory prints a single line with multiple tab-sepa-
- rated columns:
+ xz --robot --info-memory prints a single line with multiple tab-separated
+ columns:
- 1. Total amount of physical memory (RAM) in bytes.
+ 1. Total amount of physical memory (RAM) in bytes.
- 2. Memory usage limit for compression in bytes (--memlimit-compress).
- A special value of 0 indicates the default setting which for sin-
- gle-threaded mode is the same as no limit.
-
- 3. Memory usage limit for decompression in bytes (--memlimit-decom-
- press). A special value of 0 indicates the default setting which
- for single-threaded mode is the same as no limit.
-
- 4. Since xz 5.3.4alpha: Memory usage for multi-threaded decompression
- in bytes (--memlimit-mt-decompress). This is never zero because a
- system-specific default value shown in the column 5 is used if no
- limit has been specified explicitly. This is also never greater
- than the value in the column 3 even if a larger value has been
- specified with --memlimit-mt-decompress.
-
- 5. Since xz 5.3.4alpha: A system-specific default memory usage limit
- that is used to limit the number of threads when compressing with
- an automatic number of threads (--threads=0) and no memory usage
- limit has been specified (--memlimit-compress). This is also used
- as the default value for --memlimit-mt-decompress.
+ 2. Memory usage limit for compression in bytes (--memlimit-compress). A
+ special value of 0 indicates the default setting which for single-
+ threaded mode is the same as no limit.
+
+ 3. Memory usage limit for decompression in bytes (--memlimit-decompress).
+ A special value of 0 indicates the default setting which for single-
+ threaded mode is the same as no limit.
+
+ 4. Since xz 5.3.4alpha: Memory usage for multi-threaded decompression in
+ bytes (--memlimit-mt-decompress). This is never zero because a system-
+ specific default value shown in the column 5 is used if no limit has
+ been specified explicitly. This is also never greater than the value
+ in the column 3 even if a larger value has been specified with --mem-
+ limit-mt-decompress.
+
+ 5. Since xz 5.3.4alpha: A system-specific default memory usage limit that
+ is used to limit the number of threads when compressing with an auto-
+ matic number of threads (--threads=0) and no memory usage limit has
+ been specified (--memlimit-compress). This is also used as the default
+ value for --memlimit-mt-decompress.
- 6. Since xz 5.3.4alpha: Number of available processor threads.
+ 6. Since xz 5.3.4alpha: Number of available processor threads.
- In the future, the output of xz --robot --info-memory may have more
- columns, but never more than a single line.
+ In the future, the output of xz --robot --info-memory may have more
+ columns, but never more than a single line.
Version
- xz --robot --version prints the version number of xz and liblzma in the
- following format:
+ xz --robot --version prints the version number of xz and liblzma in the
+ following format:
- XZ_VERSION=XYYYZZZS
- LIBLZMA_VERSION=XYYYZZZS
+ XZ_VERSION=XYYYZZZS
+ LIBLZMA_VERSION=XYYYZZZS
- X Major version.
+ X Major version.
- YYY Minor version. Even numbers are stable. Odd numbers are alpha
- or beta versions.
+ YYY Minor version. Even numbers are stable. Odd numbers are alpha or
+ beta versions.
- ZZZ Patch level for stable releases or just a counter for develop-
- ment releases.
+ ZZZ Patch level for stable releases or just a counter for development
+ releases.
- S Stability. 0 is alpha, 1 is beta, and 2 is stable. S should be
- always 2 when YYY is even.
+ S Stability. 0 is alpha, 1 is beta, and 2 is stable. S should be al-
+ ways 2 when YYY is even.
- XYYYZZZS are the same on both lines if xz and liblzma are from the same
- XZ Utils release.
+ XYYYZZZS are the same on both lines if xz and liblzma are from the same XZ
+ Utils release.
- Examples: 4.999.9beta is 49990091 and 5.0.0 is 50000002.
+ Examples: 4.999.9beta is 49990091 and 5.0.0 is 50000002.
EXIT STATUS
- 0 All is good.
+ 0 All is good.
- 1 An error occurred.
+ 1 An error occurred.
- 2 Something worth a warning occurred, but no actual errors oc-
- curred.
+ 2 Something worth a warning occurred, but no actual errors occurred.
- Notices (not warnings or errors) printed on standard error don't affect
- the exit status.
+ Notices (not warnings or errors) printed on standard error don't affect the
+ exit status.
ENVIRONMENT
- xz parses space-separated lists of options from the environment vari-
- ables XZ_DEFAULTS and XZ_OPT, in this order, before parsing the options
- from the command line. Note that only options are parsed from the en-
- vironment variables; all non-options are silently ignored. Parsing is
- done with getopt_long(3) which is used also for the command line argu-
- ments.
-
- Warning: By setting these environment variables, one is effectively
- modifying programs and scripts that run xz. Most of the time it is
- safe to set memory usage limits, number of threads, and compression op-
- tions via the environment variables. However, some options can break
- scripts. An obvious example is --help which makes xz show the help
- text instead of compressing or decompressing a file. More subtle exam-
- ples are --quiet and --verbose. In many cases it works well to enable
- the progress indicator using --verbose, but in some situations the ex-
- tra messages create problems. The verbosity level also affects the be-
- havior of --list.
-
- XZ_DEFAULTS
- User-specific or system-wide default options. Typically this is
- set in a shell initialization script to enable xz's memory usage
- limiter by default or set the default number of threads. Ex-
- cluding shell initialization scripts and similar special cases,
- scripts should never set or unset XZ_DEFAULTS.
-
- XZ_OPT This is for passing options to xz when it is not possible to set
- the options directly on the xz command line. This is the case
- when xz is run by a script or tool, for example, GNU tar(1):
-
- XZ_OPT=-2v tar caf foo.tar.xz foo
-
- Scripts may use XZ_OPT, for example, to set script-specific de-
- fault compression options. It is still recommended to allow
- users to override XZ_OPT if that is reasonable. For example, in
- sh(1) scripts one may use something like this:
+ xz parses space-separated lists of options from the environment variables
+ XZ_DEFAULTS and XZ_OPT, in this order, before parsing the options from the
+ command line. Note that only options are parsed from the environment vari-
+ ables; all non-options are silently ignored. Parsing is done with
+ getopt_long(3) which is used also for the command line arguments.
+
+ Warning: By setting these environment variables, one is effectively modify-
+ ing programs and scripts that run xz. Most of the time it is safe to set
+ memory usage limits, number of threads, and compression options via the en-
+ vironment variables. However, some options can break scripts. An obvious
+ example is --help which makes xz show the help text instead of compressing
+ or decompressing a file. More subtle examples are --quiet and --verbose.
+ In many cases it works well to enable the progress indicator using --ver-
+ bose, but in some situations the extra messages create problems. The ver-
+ bosity level also affects the behavior of --list.
+
+ XZ_DEFAULTS
+ User-specific or system-wide default options. Typically this is set
+ in a shell initialization script to enable xz's memory usage limiter
+ by default or set the default number of threads. Excluding shell
+ initialization scripts and similar special cases, scripts should
+ never set or unset XZ_DEFAULTS.
+
+ XZ_OPT
+ This is for passing options to xz when it is not possible to set the
+ options directly on the xz command line. This is the case when xz
+ is run by a script or tool, for example, GNU tar(1):
+
+ XZ_OPT=-2v tar caf foo.tar.xz foo
+
+ Scripts may use XZ_OPT, for example, to set script-specific default
+ compression options. It is still recommended to allow users to
+ override XZ_OPT if that is reasonable. For example, in sh(1)
+ scripts one may use something like this:
- XZ_OPT=${XZ_OPT-"-7e"}
- export XZ_OPT
+ XZ_OPT=${XZ_OPT-"-7e"}
+ export XZ_OPT
LZMA UTILS COMPATIBILITY
- The command line syntax of xz is practically a superset of lzma, un-
- lzma, and lzcat as found from LZMA Utils 4.32.x. In most cases, it is
- possible to replace LZMA Utils with XZ Utils without breaking existing
- scripts. There are some incompatibilities though, which may sometimes
- cause problems.
+ The command line syntax of xz is practically a superset of lzma, unlzma,
+ and lzcat as found from LZMA Utils 4.32.x. In most cases, it is possible
+ to replace LZMA Utils with XZ Utils without breaking existing scripts.
+ There are some incompatibilities though, which may sometimes cause prob-
+ lems.
Compression preset levels
- The numbering of the compression level presets is not identical in xz
- and LZMA Utils. The most important difference is how dictionary sizes
- are mapped to different presets. Dictionary size is roughly equal to
- the decompressor memory usage.
-
- Level xz LZMA Utils
- -0 256 KiB N/A
- -1 1 MiB 64 KiB
- -2 2 MiB 1 MiB
- -3 4 MiB 512 KiB
- -4 4 MiB 1 MiB
- -5 8 MiB 2 MiB
- -6 8 MiB 4 MiB
- -7 16 MiB 8 MiB
- -8 32 MiB 16 MiB
- -9 64 MiB 32 MiB
-
- The dictionary size differences affect the compressor memory usage too,
- but there are some other differences between LZMA Utils and XZ Utils,
- which make the difference even bigger:
-
- Level xz LZMA Utils 4.32.x
- -0 3 MiB N/A
- -1 9 MiB 2 MiB
- -2 17 MiB 12 MiB
- -3 32 MiB 12 MiB
- -4 48 MiB 16 MiB
- -5 94 MiB 26 MiB
- -6 94 MiB 45 MiB
- -7 186 MiB 83 MiB
- -8 370 MiB 159 MiB
- -9 674 MiB 311 MiB
+ The numbering of the compression level presets is not identical in xz and
+ LZMA Utils. The most important difference is how dictionary sizes are
+ mapped to different presets. Dictionary size is roughly equal to the de-
+ compressor memory usage.
+
+ Level xz LZMA Utils
+ -0 256 KiB N/A
+ -1 1 MiB 64 KiB
+ -2 2 MiB 1 MiB
+ -3 4 MiB 512 KiB
+ -4 4 MiB 1 MiB
+ -5 8 MiB 2 MiB
+ -6 8 MiB 4 MiB
+ -7 16 MiB 8 MiB
+ -8 32 MiB 16 MiB
+ -9 64 MiB 32 MiB
+
+ The dictionary size differences affect the compressor memory usage too, but
+ there are some other differences between LZMA Utils and XZ Utils, which
+ make the difference even bigger:
+
+ Level xz LZMA Utils 4.32.x
+ -0 3 MiB N/A
+ -1 9 MiB 2 MiB
+ -2 17 MiB 12 MiB
+ -3 32 MiB 12 MiB
+ -4 48 MiB 16 MiB
+ -5 94 MiB 26 MiB
+ -6 94 MiB 45 MiB
+ -7 186 MiB 83 MiB
+ -8 370 MiB 159 MiB
+ -9 674 MiB 311 MiB
- The default preset level in LZMA Utils is -7 while in XZ Utils it is
- -6, so both use an 8 MiB dictionary by default.
+ The default preset level in LZMA Utils is -7 while in XZ Utils it is -6, so
+ both use an 8 MiB dictionary by default.
Streamed vs. non-streamed .lzma files
- The uncompressed size of the file can be stored in the .lzma header.
- LZMA Utils does that when compressing regular files. The alternative
- is to mark that uncompressed size is unknown and use end-of-payload
- marker to indicate where the decompressor should stop. LZMA Utils uses
- this method when uncompressed size isn't known, which is the case, for
- example, in pipes.
-
- xz supports decompressing .lzma files with or without end-of-payload
- marker, but all .lzma files created by xz will use end-of-payload
- marker and have uncompressed size marked as unknown in the .lzma
- header. This may be a problem in some uncommon situations. For exam-
- ple, a .lzma decompressor in an embedded device might work only with
- files that have known uncompressed size. If you hit this problem, you
- need to use LZMA Utils or LZMA SDK to create .lzma files with known un-
- compressed size.
+ The uncompressed size of the file can be stored in the .lzma header. LZMA
+ Utils does that when compressing regular files. The alternative is to mark
+ that uncompressed size is unknown and use end-of-payload marker to indicate
+ where the decompressor should stop. LZMA Utils uses this method when un-
+ compressed size isn't known, which is the case, for example, in pipes.
+
+ xz supports decompressing .lzma files with or without end-of-payload
+ marker, but all .lzma files created by xz will use end-of-payload marker
+ and have uncompressed size marked as unknown in the .lzma header. This may
+ be a problem in some uncommon situations. For example, a .lzma decompres-
+ sor in an embedded device might work only with files that have known uncom-
+ pressed size. If you hit this problem, you need to use LZMA Utils or LZMA
+ SDK to create .lzma files with known uncompressed size.
Unsupported .lzma files
- The .lzma format allows lc values up to 8, and lp values up to 4. LZMA
- Utils can decompress files with any lc and lp, but always creates files
- with lc=3 and lp=0. Creating files with other lc and lp is possible
- with xz and with LZMA SDK.
-
- The implementation of the LZMA1 filter in liblzma requires that the sum
- of lc and lp must not exceed 4. Thus, .lzma files, which exceed this
- limitation, cannot be decompressed with xz.
-
- LZMA Utils creates only .lzma files which have a dictionary size of 2^n
- (a power of 2) but accepts files with any dictionary size. liblzma ac-
- cepts only .lzma files which have a dictionary size of 2^n or 2^n +
- 2^(n-1). This is to decrease false positives when detecting .lzma
- files.
-
- These limitations shouldn't be a problem in practice, since practically
- all .lzma files have been compressed with settings that liblzma will
- accept.
+ The .lzma format allows lc values up to 8, and lp values up to 4. LZMA
+ Utils can decompress files with any lc and lp, but always creates files
+ with lc=3 and lp=0. Creating files with other lc and lp is possible with
+ xz and with LZMA SDK.
+
+ The implementation of the LZMA1 filter in liblzma requires that the sum of
+ lc and lp must not exceed 4. Thus, .lzma files, which exceed this limita-
+ tion, cannot be decompressed with xz.
+
+ LZMA Utils creates only .lzma files which have a dictionary size of 2^n (a
+ power of 2) but accepts files with any dictionary size. liblzma accepts
+ only .lzma files which have a dictionary size of 2^n or 2^n + 2^(n-1).
+ This is to decrease false positives when detecting .lzma files.
+
+ These limitations shouldn't be a problem in practice, since practically all
+ .lzma files have been compressed with settings that liblzma will accept.
Trailing garbage
- When decompressing, LZMA Utils silently ignore everything after the
- first .lzma stream. In most situations, this is a bug. This also
- means that LZMA Utils don't support decompressing concatenated .lzma
- files.
-
- If there is data left after the first .lzma stream, xz considers the
- file to be corrupt unless --single-stream was used. This may break ob-
- scure scripts which have assumed that trailing garbage is ignored.
+ When decompressing, LZMA Utils silently ignore everything after the first
+ .lzma stream. In most situations, this is a bug. This also means that
+ LZMA Utils don't support decompressing concatenated .lzma files.
+
+ If there is data left after the first .lzma stream, xz considers the file
+ to be corrupt unless --single-stream was used. This may break obscure
+ scripts which have assumed that trailing garbage is ignored.
NOTES
Compressed output may vary
- The exact compressed output produced from the same uncompressed input
- file may vary between XZ Utils versions even if compression options are
- identical. This is because the encoder can be improved (faster or bet-
- ter compression) without affecting the file format. The output can
- vary even between different builds of the same XZ Utils version, if
- different build options are used.
-
- The above means that once --rsyncable has been implemented, the result-
- ing files won't necessarily be rsyncable unless both old and new files
- have been compressed with the same xz version. This problem can be
- fixed if a part of the encoder implementation is frozen to keep rsynca-
- ble output stable across xz versions.
+ The exact compressed output produced from the same uncompressed input file
+ may vary between XZ Utils versions even if compression options are identi-
+ cal. This is because the encoder can be improved (faster or better com-
+ pression) without affecting the file format. The output can vary even be-
+ tween different builds of the same XZ Utils version, if different build op-
+ tions are used.
+
+ The above means that once --rsyncable has been implemented, the resulting
+ files won't necessarily be rsyncable unless both old and new files have
+ been compressed with the same xz version. This problem can be fixed if a
+ part of the encoder implementation is frozen to keep rsyncable output sta-
+ ble across xz versions.
Embedded .xz decompressors
- Embedded .xz decompressor implementations like XZ Embedded don't neces-
- sarily support files created with integrity check types other than none
- and crc32. Since the default is --check=crc64, you must use
- --check=none or --check=crc32 when creating files for embedded systems.
-
- Outside embedded systems, all .xz format decompressors support all the
- check types, or at least are able to decompress the file without veri-
- fying the integrity check if the particular check is not supported.
+ Embedded .xz decompressor implementations like XZ Embedded don't necessar-
+ ily support files created with integrity check types other than none and
+ crc32. Since the default is --check=crc64, you must use --check=none or
+ --check=crc32 when creating files for embedded systems.
+
+ Outside embedded systems, all .xz format decompressors support all the
+ check types, or at least are able to decompress the file without verifying
+ the integrity check if the particular check is not supported.
- XZ Embedded supports BCJ filters, but only with the default start off-
- set.
+ XZ Embedded supports BCJ filters, but only with the default start offset.
EXAMPLES
Basics
- Compress the file foo into foo.xz using the default compression level
- (-6), and remove foo if compression is successful:
+ Compress the file foo into foo.xz using the default compression level (-6),
+ and remove foo if compression is successful:
- xz foo
+ xz foo
- Decompress bar.xz into bar and don't remove bar.xz even if decompres-
- sion is successful:
+ Decompress bar.xz into bar and don't remove bar.xz even if decompression is
+ successful:
- xz -dk bar.xz
+ xz -dk bar.xz
- Create baz.tar.xz with the preset -4e (-4 --extreme), which is slower
- than the default -6, but needs less memory for compression and decom-
- pression (48 MiB and 5 MiB, respectively):
+ Create baz.tar.xz with the preset -4e (-4 --extreme), which is slower than
+ the default -6, but needs less memory for compression and decompression
+ (48 MiB and 5 MiB, respectively):
- tar cf - baz | xz -4e > baz.tar.xz
+ tar cf - baz | xz -4e > baz.tar.xz
- A mix of compressed and uncompressed files can be decompressed to stan-
- dard output with a single command:
+ A mix of compressed and uncompressed files can be decompressed to standard
+ output with a single command:
- xz -dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt
+ xz -dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt
Parallel compression of many files
- On GNU and *BSD, find(1) and xargs(1) can be used to parallelize com-
- pression of many files:
+ On GNU and *BSD, find(1) and xargs(1) can be used to parallelize compres-
+ sion of many files:
- find . -type f \! -name '*.xz' -print0 \
- | xargs -0r -P4 -n16 xz -T1
+ find . -type f \! -name '*.xz' -print0 \
+ | xargs -0r -P4 -n16 xz -T1
- The -P option to xargs(1) sets the number of parallel xz processes.
- The best value for the -n option depends on how many files there are to
- be compressed. If there are only a couple of files, the value should
- probably be 1; with tens of thousands of files, 100 or even more may be
- appropriate to reduce the number of xz processes that xargs(1) will
- eventually create.
+ The -P option to xargs(1) sets the number of parallel xz processes. The
+ best value for the -n option depends on how many files there are to be com-
+ pressed. If there are only a couple of files, the value should probably be
+ 1; with tens of thousands of files, 100 or even more may be appropriate to
+ reduce the number of xz processes that xargs(1) will eventually create.
- The option -T1 for xz is there to force it to single-threaded mode, be-
- cause xargs(1) is used to control the amount of parallelization.
+ The option -T1 for xz is there to force it to single-threaded mode, because
+ xargs(1) is used to control the amount of parallelization.
Robot mode
- Calculate how many bytes have been saved in total after compressing
- multiple files:
+ Calculate how many bytes have been saved in total after compressing multi-
+ ple files:
- xz --robot --list *.xz | awk '/^totals/{print $5-$4}'
+ xz --robot --list *.xz | awk '/^totals/{print $5-$4}'
- A script may want to know that it is using new enough xz. The follow-
- ing sh(1) script checks that the version number of the xz tool is at
- least 5.0.0. This method is compatible with old beta versions, which
- didn't support the --robot option:
-
- if ! eval "$(xz --robot --version 2> /dev/null)" ||
- [ "$XZ_VERSION" -lt 50000002 ]; then
- echo "Your xz is too old."
- fi
- unset XZ_VERSION LIBLZMA_VERSION
-
- Set a memory usage limit for decompression using XZ_OPT, but if a limit
- has already been set, don't increase it:
-
- NEWLIM=$((123 << 20)) # 123 MiB
- OLDLIM=$(xz --robot --info-memory | cut -f3)
- if [ $OLDLIM -eq 0 -o $OLDLIM -gt $NEWLIM ]; then
- XZ_OPT="$XZ_OPT --memlimit-decompress=$NEWLIM"
- export XZ_OPT
- fi
+ A script may want to know that it is using new enough xz. The following
+ sh(1) script checks that the version number of the xz tool is at least
+ 5.0.0. This method is compatible with old beta versions, which didn't sup-
+ port the --robot option:
+
+ if ! eval "$(xz --robot --version 2> /dev/null)" ||
+ [ "$XZ_VERSION" -lt 50000002 ]; then
+ echo "Your xz is too old."
+ fi
+ unset XZ_VERSION LIBLZMA_VERSION
+
+ Set a memory usage limit for decompression using XZ_OPT, but if a limit has
+ already been set, don't increase it:
+
+ NEWLIM=$((123 << 20)) # 123 MiB
+ OLDLIM=$(xz --robot --info-memory | cut -f3)
+ if [ $OLDLIM -eq 0 -o $OLDLIM -gt $NEWLIM ]; then
+ XZ_OPT="$XZ_OPT --memlimit-decompress=$NEWLIM"
+ export XZ_OPT
+ fi
Custom compressor filter chains
- The simplest use for custom filter chains is customizing a LZMA2 pre-
- set. This can be useful, because the presets cover only a subset of
- the potentially useful combinations of compression settings.
-
- The CompCPU columns of the tables from the descriptions of the options
- -0 ... -9 and --extreme are useful when customizing LZMA2 presets.
- Here are the relevant parts collected from those two tables:
-
- Preset CompCPU
- -0 0
- -1 1
- -2 2
- -3 3
- -4 4
- -5 5
- -6 6
- -5e 7
- -6e 8
-
- If you know that a file requires somewhat big dictionary (for example,
- 32 MiB) to compress well, but you want to compress it quicker than xz
- -8 would do, a preset with a low CompCPU value (for example, 1) can be
- modified to use a bigger dictionary:
-
- xz --lzma2=preset=1,dict=32MiB foo.tar
-
- With certain files, the above command may be faster than xz -6 while
- compressing significantly better. However, it must be emphasized that
- only some files benefit from a big dictionary while keeping the CompCPU
- value low. The most obvious situation, where a big dictionary can help
- a lot, is an archive containing very similar files of at least a few
- megabytes each. The dictionary size has to be significantly bigger
- than any individual file to allow LZMA2 to take full advantage of the
- similarities between consecutive files.
-
- If very high compressor and decompressor memory usage is fine, and the
- file being compressed is at least several hundred megabytes, it may be
- useful to use an even bigger dictionary than the 64 MiB that xz -9
- would use:
-
- xz -vv --lzma2=dict=192MiB big_foo.tar
-
- Using -vv (--verbose --verbose) like in the above example can be useful
- to see the memory requirements of the compressor and decompressor. Re-
- member that using a dictionary bigger than the size of the uncompressed
- file is waste of memory, so the above command isn't useful for small
- files.
-
- Sometimes the compression time doesn't matter, but the decompressor
- memory usage has to be kept low, for example, to make it possible to
- decompress the file on an embedded system. The following command uses
- -6e (-6 --extreme) as a base and sets the dictionary to only 64 KiB.
- The resulting file can be decompressed with XZ Embedded (that's why
- there is --check=crc32) using about 100 KiB of memory.
-
- xz --check=crc32 --lzma2=preset=6e,dict=64KiB foo
-
- If you want to squeeze out as many bytes as possible, adjusting the
- number of literal context bits (lc) and number of position bits (pb)
- can sometimes help. Adjusting the number of literal position bits (lp)
- might help too, but usually lc and pb are more important. For example,
- a source code archive contains mostly US-ASCII text, so something like
- the following might give slightly (like 0.1 %) smaller file than xz -6e
- (try also without lc=4):
-
- xz --lzma2=preset=6e,pb=0,lc=4 source_code.tar
-
- Using another filter together with LZMA2 can improve compression with
- certain file types. For example, to compress a x86-32 or x86-64 shared
- library using the x86 BCJ filter:
-
- xz --x86 --lzma2 libfoo.so
-
- Note that the order of the filter options is significant. If --x86 is
- specified after --lzma2, xz will give an error, because there cannot be
- any filter after LZMA2, and also because the x86 BCJ filter cannot be
- used as the last filter in the chain.
-
- The Delta filter together with LZMA2 can give good results with bitmap
- images. It should usually beat PNG, which has a few more advanced fil-
- ters than simple delta but uses Deflate for the actual compression.
-
- The image has to be saved in uncompressed format, for example, as un-
- compressed TIFF. The distance parameter of the Delta filter is set to
- match the number of bytes per pixel in the image. For example, 24-bit
- RGB bitmap needs dist=3, and it is also good to pass pb=0 to LZMA2 to
- accommodate the three-byte alignment:
-
- xz --delta=dist=3 --lzma2=pb=0 foo.tiff
-
- If multiple images have been put into a single archive (for example,
- .tar), the Delta filter will work on that too as long as all images
- have the same number of bytes per pixel.
+ The simplest use for custom filter chains is customizing a LZMA2 preset.
+ This can be useful, because the presets cover only a subset of the poten-
+ tially useful combinations of compression settings.
+
+ The CompCPU columns of the tables from the descriptions of the options -0
+ ... -9 and --extreme are useful when customizing LZMA2 presets. Here are
+ the relevant parts collected from those two tables:
+
+ Preset CompCPU
+ -0 0
+ -1 1
+ -2 2
+ -3 3
+ -4 4
+ -5 5
+ -6 6
+ -5e 7
+ -6e 8
+
+ If you know that a file requires somewhat big dictionary (for example,
+ 32 MiB) to compress well, but you want to compress it quicker than xz -8
+ would do, a preset with a low CompCPU value (for example, 1) can be modi-
+ fied to use a bigger dictionary:
+
+ xz --lzma2=preset=1,dict=32MiB foo.tar
+
+ With certain files, the above command may be faster than xz -6 while com-
+ pressing significantly better. However, it must be emphasized that only
+ some files benefit from a big dictionary while keeping the CompCPU value
+ low. The most obvious situation, where a big dictionary can help a lot, is
+ an archive containing very similar files of at least a few megabytes each.
+ The dictionary size has to be significantly bigger than any individual file
+ to allow LZMA2 to take full advantage of the similarities between consecu-
+ tive files.
+
+ If very high compressor and decompressor memory usage is fine, and the file
+ being compressed is at least several hundred megabytes, it may be useful to
+ use an even bigger dictionary than the 64 MiB that xz -9 would use:
+
+ xz -vv --lzma2=dict=192MiB big_foo.tar
+
+ Using -vv (--verbose --verbose) like in the above example can be useful to
+ see the memory requirements of the compressor and decompressor. Remember
+ that using a dictionary bigger than the size of the uncompressed file is
+ waste of memory, so the above command isn't useful for small files.
+
+ Sometimes the compression time doesn't matter, but the decompressor memory
+ usage has to be kept low, for example, to make it possible to decompress
+ the file on an embedded system. The following command uses -6e (-6 --ex-
+ treme) as a base and sets the dictionary to only 64 KiB. The resulting
+ file can be decompressed with XZ Embedded (that's why there is
+ --check=crc32) using about 100 KiB of memory.
+
+ xz --check=crc32 --lzma2=preset=6e,dict=64KiB foo
+
+ If you want to squeeze out as many bytes as possible, adjusting the number
+ of literal context bits (lc) and number of position bits (pb) can sometimes
+ help. Adjusting the number of literal position bits (lp) might help too,
+ but usually lc and pb are more important. For example, a source code
+ archive contains mostly US-ASCII text, so something like the following
+ might give slightly (like 0.1 %) smaller file than xz -6e (try also without
+ lc=4):
+
+ xz --lzma2=preset=6e,pb=0,lc=4 source_code.tar
+
+ Using another filter together with LZMA2 can improve compression with cer-
+ tain file types. For example, to compress a x86-32 or x86-64 shared li-
+ brary using the x86 BCJ filter:
+
+ xz --x86 --lzma2 libfoo.so
+
+ Note that the order of the filter options is significant. If --x86 is
+ specified after --lzma2, xz will give an error, because there cannot be any
+ filter after LZMA2, and also because the x86 BCJ filter cannot be used as
+ the last filter in the chain.
+
+ The Delta filter together with LZMA2 can give good results with bitmap im-
+ ages. It should usually beat PNG, which has a few more advanced filters
+ than simple delta but uses Deflate for the actual compression.
+
+ The image has to be saved in uncompressed format, for example, as uncom-
+ pressed TIFF. The distance parameter of the Delta filter is set to match
+ the number of bytes per pixel in the image. For example, 24-bit RGB bitmap
+ needs dist=3, and it is also good to pass pb=0 to LZMA2 to accommodate the
+ three-byte alignment:
+
+ xz --delta=dist=3 --lzma2=pb=0 foo.tiff
+
+ If multiple images have been put into a single archive (for example, .tar),
+ the Delta filter will work on that too as long as all images have the same
+ number of bytes per pixel.
SEE ALSO
- xzdec(1), xzdiff(1), xzgrep(1), xzless(1), xzmore(1), gzip(1),
- bzip2(1), 7z(1)
+ xzdec(1), xzdiff(1), xzgrep(1), xzless(1), xzmore(1), gzip(1), bzip2(1),
+ 7z(1)
- XZ Utils:
- XZ Embedded:
- LZMA SDK:
+ XZ Utils:
+ XZ Embedded:
+ LZMA SDK:
-Tukaani 2025-03-08 XZ(1)
+Tukaani 2025-03-08 XZ(1)
diff -Nru xz-utils-5.8.1/doc/man/txt/xzdec.txt xz-utils-5.8.3/doc/man/txt/xzdec.txt
--- xz-utils-5.8.1/doc/man/txt/xzdec.txt 2025-04-03 11:36:55.000000000 +0000
+++ xz-utils-5.8.3/doc/man/txt/xzdec.txt 2026-03-31 15:27:26.000000000 +0000
@@ -1,76 +1,74 @@
-XZDEC(1) XZ Utils XZDEC(1)
+XZDEC(1) XZ Utils XZDEC(1)
NAME
- xzdec, lzmadec - Small .xz and .lzma decompressors
+ xzdec, lzmadec - Small .xz and .lzma decompressors
SYNOPSIS
- xzdec [option...] [file...]
- lzmadec [option...] [file...]
+ xzdec [option...] [file...]
+ lzmadec [option...] [file...]
DESCRIPTION
- xzdec is a liblzma-based decompression-only tool for .xz (and only .xz)
- files. xzdec is intended to work as a drop-in replacement for xz(1) in
- the most common situations where a script has been written to use xz
- --decompress --stdout (and possibly a few other commonly used options)
- to decompress .xz files. lzmadec is identical to xzdec except that lz-
- madec supports .lzma files instead of .xz files.
-
- To reduce the size of the executable, xzdec doesn't support multi-
- threading or localization, and doesn't read options from XZ_DEFAULTS
- and XZ_OPT environment variables. xzdec doesn't support displaying in-
- termediate progress information: sending SIGINFO to xzdec does nothing,
- but sending SIGUSR1 terminates the process instead of displaying
- progress information.
+ xzdec is a liblzma-based decompression-only tool for .xz (and only .xz)
+ files. xzdec is intended to work as a drop-in replacement for xz(1) in the
+ most common situations where a script has been written to use xz --decom-
+ press --stdout (and possibly a few other commonly used options) to decom-
+ press .xz files. lzmadec is identical to xzdec except that lzmadec sup-
+ ports .lzma files instead of .xz files.
+
+ To reduce the size of the executable, xzdec doesn't support multithreading
+ or localization, and doesn't read options from XZ_DEFAULTS and XZ_OPT envi-
+ ronment variables. xzdec doesn't support displaying intermediate progress
+ information: sending SIGINFO to xzdec does nothing, but sending SIGUSR1
+ terminates the process instead of displaying progress information.
OPTIONS
- -d, --decompress, --uncompress
- Ignored for xz(1) compatibility. xzdec supports only decompres-
- sion.
-
- -k, --keep
- Ignored for xz(1) compatibility. xzdec never creates or removes
- any files.
-
- -c, --stdout, --to-stdout
- Ignored for xz(1) compatibility. xzdec always writes the decom-
- pressed data to standard output.
-
- -q, --quiet
- Specifying this once does nothing since xzdec never displays any
- warnings or notices. Specify this twice to suppress errors.
-
- -Q, --no-warn
- Ignored for xz(1) compatibility. xzdec never uses the exit sta-
- tus 2.
+ -d, --decompress, --uncompress
+ Ignored for xz(1) compatibility. xzdec supports only decompression.
- -h, --help
- Display a help message and exit successfully.
+ -k, --keep
+ Ignored for xz(1) compatibility. xzdec never creates or removes any
+ files.
+
+ -c, --stdout, --to-stdout
+ Ignored for xz(1) compatibility. xzdec always writes the decom-
+ pressed data to standard output.
+
+ -q, --quiet
+ Specifying this once does nothing since xzdec never displays any
+ warnings or notices. Specify this twice to suppress errors.
+
+ -Q, --no-warn
+ Ignored for xz(1) compatibility. xzdec never uses the exit status
+ 2.
- -V, --version
- Display the version number of xzdec and liblzma.
+ -h, --help
+ Display a help message and exit successfully.
+
+ -V, --version
+ Display the version number of xzdec and liblzma.
EXIT STATUS
- 0 All was good.
+ 0 All was good.
- 1 An error occurred.
+ 1 An error occurred.
- xzdec doesn't have any warning messages like xz(1) has, thus the exit
- status 2 is not used by xzdec.
+ xzdec doesn't have any warning messages like xz(1) has, thus the exit sta-
+ tus 2 is not used by xzdec.
NOTES
- Use xz(1) instead of xzdec or lzmadec for normal everyday use. xzdec
- or lzmadec are meant only for situations where it is important to have
- a smaller decompressor than the full-featured xz(1).
-
- xzdec and lzmadec are not really that small. The size can be reduced
- further by dropping features from liblzma at compile time, but that
- shouldn't usually be done for executables distributed in typical non-
- embedded operating system distributions. If you need a truly small .xz
- decompressor, consider using XZ Embedded.
+ Use xz(1) instead of xzdec or lzmadec for normal everyday use. xzdec or
+ lzmadec are meant only for situations where it is important to have a
+ smaller decompressor than the full-featured xz(1).
+
+ xzdec and lzmadec are not really that small. The size can be reduced fur-
+ ther by dropping features from liblzma at compile time, but that shouldn't
+ usually be done for executables distributed in typical non-embedded operat-
+ ing system distributions. If you need a truly small .xz decompressor, con-
+ sider using XZ Embedded.
SEE ALSO
- xz(1)
+ xz(1)
- XZ Embedded:
+ XZ Embedded:
-Tukaani 2024-04-08 XZDEC(1)
+Tukaani 2024-04-08 XZDEC(1)
diff -Nru xz-utils-5.8.1/doc/man/txt/xzdiff.txt xz-utils-5.8.3/doc/man/txt/xzdiff.txt
--- xz-utils-5.8.1/doc/man/txt/xzdiff.txt 2025-04-03 11:36:55.000000000 +0000
+++ xz-utils-5.8.3/doc/man/txt/xzdiff.txt 2026-03-31 15:27:26.000000000 +0000
@@ -1,39 +1,37 @@
-XZDIFF(1) XZ Utils XZDIFF(1)
+XZDIFF(1) XZ Utils XZDIFF(1)
NAME
- xzcmp, xzdiff, lzcmp, lzdiff - compare compressed files
+ xzcmp, xzdiff, lzcmp, lzdiff - compare compressed files
SYNOPSIS
- xzcmp [option...] file1 [file2]
- xzdiff ...
- lzcmp ... (DEPRECATED)
- lzdiff ... (DEPRECATED)
+ xzcmp [option...] file1 [file2]
+ xzdiff ...
+ lzcmp ... (DEPRECATED)
+ lzdiff ... (DEPRECATED)
DESCRIPTION
- xzcmp and xzdiff compare uncompressed contents of two files. Uncom-
- pressed data and options are passed to cmp(1) or diff(1) unless --help
- or --version is specified.
-
- If both file1 and file2 are specified, they can be uncompressed files
- or files in formats that xz(1), gzip(1), bzip2(1), lzop(1), zstd(1), or
- lz4(1) can decompress. The required decompression commands are deter-
- mined from the filename suffixes of file1 and file2. A file with an
- unknown suffix is assumed to be either uncompressed or in a format that
- xz(1) can decompress.
-
- If only one filename is provided, file1 must have a suffix of a sup-
- ported compression format and the name for file2 is assumed to be file1
- with the compression format suffix removed.
-
- The commands lzcmp and lzdiff are provided for backward compatibility
- with LZMA Utils. They are deprecated and will be removed in a future
- version.
+ xzcmp and xzdiff compare uncompressed contents of two files. Uncompressed
+ data and options are passed to cmp(1) or diff(1) unless --help or --version
+ is specified.
+
+ If both file1 and file2 are specified, they can be uncompressed files or
+ files in formats that xz(1), gzip(1), bzip2(1), lzop(1), zstd(1), or lz4(1)
+ can decompress. The required decompression commands are determined from
+ the filename suffixes of file1 and file2. A file with an unknown suffix is
+ assumed to be either uncompressed or in a format that xz(1) can decompress.
+
+ If only one filename is provided, file1 must have a suffix of a supported
+ compression format and the name for file2 is assumed to be file1 with the
+ compression format suffix removed.
+
+ The commands lzcmp and lzdiff are provided for backward compatibility with
+ LZMA Utils. They are deprecated and will be removed in a future version.
EXIT STATUS
- If a decompression error occurs, the exit status is 2. Otherwise the
- exit status of cmp(1) or diff(1) is used.
+ If a decompression error occurs, the exit status is 2. Otherwise the exit
+ status of cmp(1) or diff(1) is used.
SEE ALSO
- cmp(1), diff(1), xz(1), gzip(1), bzip2(1), lzop(1), zstd(1), lz4(1)
+ cmp(1), diff(1), xz(1), gzip(1), bzip2(1), lzop(1), zstd(1), lz4(1)
-Tukaani 2025-03-06 XZDIFF(1)
+Tukaani 2025-03-06 XZDIFF(1)
diff -Nru xz-utils-5.8.1/doc/man/txt/xzgrep.txt xz-utils-5.8.3/doc/man/txt/xzgrep.txt
--- xz-utils-5.8.1/doc/man/txt/xzgrep.txt 2025-04-03 11:36:55.000000000 +0000
+++ xz-utils-5.8.3/doc/man/txt/xzgrep.txt 2026-03-31 15:27:26.000000000 +0000
@@ -1,70 +1,67 @@
-XZGREP(1) XZ Utils XZGREP(1)
+XZGREP(1) XZ Utils XZGREP(1)
NAME
- xzgrep - search possibly-compressed files for patterns
+ xzgrep - search possibly-compressed files for patterns
SYNOPSIS
- xzgrep [option...] [pattern_list] [file...]
- xzegrep ...
- xzfgrep ...
- lzgrep ... (DEPRECATED)
- lzegrep ... (DEPRECATED)
- lzfgrep ... (DEPRECATED)
+ xzgrep [option...] [pattern_list] [file...]
+ xzegrep ...
+ xzfgrep ...
+ lzgrep ... (DEPRECATED)
+ lzegrep ... (DEPRECATED)
+ lzfgrep ... (DEPRECATED)
DESCRIPTION
- xzgrep invokes grep(1) on uncompressed contents of files. The formats
- of the files are determined from the filename suffixes. Any file with
- a suffix supported by xz(1), gzip(1), bzip2(1), lzop(1), zstd(1), or
- lz4(1) will be decompressed; all other files are assumed to be uncom-
- pressed.
+ xzgrep invokes grep(1) on uncompressed contents of files. The formats of
+ the files are determined from the filename suffixes. Any file with a suf-
+ fix supported by xz(1), gzip(1), bzip2(1), lzop(1), zstd(1), or lz4(1) will
+ be decompressed; all other files are assumed to be uncompressed.
- If no files are specified or file is - then standard input is read.
- When reading from standard input, only files supported by xz(1) are de-
- compressed. Other files are assumed to be in uncompressed form al-
- ready.
+ If no files are specified or file is - then standard input is read. When
+ reading from standard input, only files supported by xz(1) are decom-
+ pressed. Other files are assumed to be in uncompressed form already.
- Most options of grep(1) are supported. However, the following options
- are not supported:
+ Most options of grep(1) are supported. However, the following options are
+ not supported:
- -r, --recursive
+ -r, --recursive
- -R, --dereference-recursive
+ -R, --dereference-recursive
- -d, --directories=action
+ -d, --directories=action
- -Z, --null
+ -Z, --null
- -z, --null-data
+ -z, --null-data
- --include=glob
+ --include=glob
- --exclude=glob
+ --exclude=glob
- --exclude-from=file
+ --exclude-from=file
- --exclude-dir=glob
+ --exclude-dir=glob
- xzegrep is an alias for xzgrep -E. xzfgrep is an alias for xzgrep -F.
+ xzegrep is an alias for xzgrep -E. xzfgrep is an alias for xzgrep -F.
- The commands lzgrep, lzegrep, and lzfgrep are provided for backward
- compatibility with LZMA Utils. They are deprecated and will be removed
- in a future version.
+ The commands lzgrep, lzegrep, and lzfgrep are provided for backward compat-
+ ibility with LZMA Utils. They are deprecated and will be removed in a fu-
+ ture version.
EXIT STATUS
- 0 At least one match was found from at least one of the input
- files. No errors occurred.
+ 0 At least one match was found from at least one of the input files.
+ No errors occurred.
- 1 No matches were found from any of the input files. No errors
- occurred.
+ 1 No matches were found from any of the input files. No errors oc-
+ curred.
- >1 One or more errors occurred. It is unknown if matches were
- found.
+ >1 One or more errors occurred. It is unknown if matches were found.
ENVIRONMENT
- GREP If GREP is set to a non-empty value, it is used instead of grep,
- grep -E, or grep -F.
+ GREP If GREP is set to a non-empty value, it is used instead of grep,
+ grep -E, or grep -F.
SEE ALSO
- grep(1), xz(1), gzip(1), bzip2(1), lzop(1), zstd(1), lz4(1), zgrep(1)
+ grep(1), xz(1), gzip(1), bzip2(1), lzop(1), zstd(1), lz4(1), zgrep(1)
-Tukaani 2025-03-06 XZGREP(1)
+Tukaani 2025-03-06 XZGREP(1)
diff -Nru xz-utils-5.8.1/doc/man/txt/xzless.txt xz-utils-5.8.3/doc/man/txt/xzless.txt
--- xz-utils-5.8.1/doc/man/txt/xzless.txt 2025-04-03 11:36:55.000000000 +0000
+++ xz-utils-5.8.3/doc/man/txt/xzless.txt 2026-03-31 15:27:26.000000000 +0000
@@ -1,36 +1,36 @@
-XZLESS(1) XZ Utils XZLESS(1)
+XZLESS(1) XZ Utils XZLESS(1)
NAME
- xzless, lzless - view xz or lzma compressed (text) files
+ xzless, lzless - view xz or lzma compressed (text) files
SYNOPSIS
- xzless [file...]
- lzless [file...] (DEPRECATED)
+ xzless [file...]
+ lzless [file...] (DEPRECATED)
DESCRIPTION
- xzless is a filter that displays text from compressed files to a termi-
- nal. Files supported by xz(1) are decompressed; other files are as-
- sumed to be in uncompressed form already. If no files are given, xz-
- less reads from standard input.
-
- xzless uses less(1) to present its output. Unlike xzmore, its choice
- of pager cannot be altered by setting an environment variable. Com-
- mands are based on both more(1) and vi(1) and allow back and forth
- movement and searching. See the less(1) manual for more information.
+ xzless is a filter that displays text from compressed files to a terminal.
+ Files supported by xz(1) are decompressed; other files are assumed to be in
+ uncompressed form already. If no files are given, xzless reads from stan-
+ dard input.
+
+ xzless uses less(1) to present its output. Unlike xzmore, its choice of
+ pager cannot be altered by setting an environment variable. Commands are
+ based on both more(1) and vi(1) and allow back and forth movement and
+ searching. See the less(1) manual for more information.
- The command named lzless is provided for backward compatibility with
- LZMA Utils. It is deprecated and will be removed in a future version.
+ The command named lzless is provided for backward compatibility with LZMA
+ Utils. It is deprecated and will be removed in a future version.
ENVIRONMENT
- LESSMETACHARS
- A list of characters special to the shell. Set by xzless unless
- it is already set in the environment.
-
- LESSOPEN
- Set to a command line to invoke the xz(1) decompressor for pre-
- processing the input files to less(1).
+ LESSMETACHARS
+ A list of characters special to the shell. Set by xzless unless it
+ is already set in the environment.
+
+ LESSOPEN
+ Set to a command line to invoke the xz(1) decompressor for prepro-
+ cessing the input files to less(1).
SEE ALSO
- less(1), xz(1), xzmore(1), zless(1)
+ less(1), xz(1), xzmore(1), zless(1)
-Tukaani 2025-03-06 XZLESS(1)
+Tukaani 2025-03-06 XZLESS(1)
diff -Nru xz-utils-5.8.1/doc/man/txt/xzmore.txt xz-utils-5.8.3/doc/man/txt/xzmore.txt
--- xz-utils-5.8.1/doc/man/txt/xzmore.txt 2025-04-03 11:36:55.000000000 +0000
+++ xz-utils-5.8.3/doc/man/txt/xzmore.txt 2026-03-31 15:27:26.000000000 +0000
@@ -1,31 +1,30 @@
-XZMORE(1) XZ Utils XZMORE(1)
+XZMORE(1) XZ Utils XZMORE(1)
NAME
- xzmore, lzmore - view xz or lzma compressed (text) files
+ xzmore, lzmore - view xz or lzma compressed (text) files
SYNOPSIS
- xzmore [file...]
- lzmore [file...] (DEPRECATED)
+ xzmore [file...]
+ lzmore [file...] (DEPRECATED)
DESCRIPTION
- xzmore displays text from compressed files to a terminal using more(1).
- Files supported by xz(1) are decompressed; other files are assumed to
- be in uncompressed form already. If no files are given, xzmore reads
- from standard input. See the more(1) manual for the keyboard commands.
-
- Note that scrolling backwards might not be possible depending on the
- implementation of more(1). This is because xzmore uses a pipe to pass
- the decompressed data to more(1). xzless(1) uses less(1) which pro-
- vides more advanced features.
+ xzmore displays text from compressed files to a terminal using more(1).
+ Files supported by xz(1) are decompressed; other files are assumed to be in
+ uncompressed form already. If no files are given, xzmore reads from stan-
+ dard input. See the more(1) manual for the keyboard commands.
+
+ Note that scrolling backwards might not be possible depending on the imple-
+ mentation of more(1). This is because xzmore uses a pipe to pass the de-
+ compressed data to more(1). xzless(1) uses less(1) which provides more ad-
+ vanced features.
- The command lzmore is provided for backward compatibility with LZMA
- Utils. It is deprecated and will be removed in a future version.
+ The command lzmore is provided for backward compatibility with LZMA Utils.
+ It is deprecated and will be removed in a future version.
ENVIRONMENT
- PAGER If PAGER is set, its value is used as the pager instead of
- more(1).
+ PAGER If PAGER is set, its value is used as the pager instead of more(1).
SEE ALSO
- more(1), xz(1), xzless(1), zmore(1)
+ more(1), xz(1), xzless(1), zmore(1)
-Tukaani 2025-03-06 XZMORE(1)
+Tukaani 2025-03-06 XZMORE(1)
diff -Nru xz-utils-5.8.1/doxygen/Doxyfile xz-utils-5.8.3/doxygen/Doxyfile
--- xz-utils-5.8.1/doxygen/Doxyfile 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/doxygen/Doxyfile 2026-03-31 15:27:00.000000000 +0000
@@ -8,7 +8,7 @@
# - Instead of API docs, docs of XZ Utils internals may be built.
# - Change the output directory for out-of-tree builds.
#
-# These options were tested with Doxygen 1.10.0.
+# These options were tested with Doxygen 1.9.8 and 1.13.2.
PROJECT_NAME = "liblzma (XZ Utils)"
OUTPUT_DIRECTORY = ../doc
@@ -19,6 +19,8 @@
OPTIMIZE_OUTPUT_FOR_C = YES
EXTRACT_STATIC = YES
SORT_MEMBER_DOCS = NO
+WARN_IF_UNDOCUMENTED = NO
+WARN_AS_ERROR = FAIL_ON_WARNINGS
SOURCE_TOOLTIPS = NO
VERBATIM_HEADERS = NO
ALPHABETICAL_INDEX = NO
@@ -37,3 +39,7 @@
tuklib_attr_noreturn= \
lzma_attribute(attr)= \
lzma_attr_alloc_size(size)=
+
+# Debian and Ubuntu patch Doxygen so that HAVE_DOT = YES is the default.
+# Set HAVE_DOT explicitly to get consistent behavior across distributions.
+HAVE_DOT = NO
diff -Nru xz-utils-5.8.1/lib/Makefile.in xz-utils-5.8.3/lib/Makefile.in
--- xz-utils-5.8.1/lib/Makefile.in 2025-04-03 11:35:21.000000000 +0000
+++ xz-utils-5.8.3/lib/Makefile.in 2026-03-31 15:27:10.000000000 +0000
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.17 from Makefile.am.
+# Makefile.in generated by automake 1.18.1 from Makefile.am.
# @configure_input@
-# Copyright (C) 1994-2024 Free Software Foundation, Inc.
+# Copyright (C) 1994-2025 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
@@ -231,6 +231,7 @@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
+LINKER_FLAG_UNDEFINED_VERSION = @LINKER_FLAG_UNDEFINED_VERSION@
LIPO = @LIPO@
LN_EXEEXT = @LN_EXEEXT@
LN_S = @LN_S@
@@ -443,6 +444,7 @@
cscope cscopelist:
+
distdir: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) distdir-am
diff -Nru xz-utils-5.8.1/m4/libtool.m4 xz-utils-5.8.3/m4/libtool.m4
--- xz-utils-5.8.1/m4/libtool.m4 2025-04-03 11:35:14.000000000 +0000
+++ xz-utils-5.8.3/m4/libtool.m4 2026-03-31 15:27:09.000000000 +0000
@@ -1,6 +1,6 @@
# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
#
-# Copyright (C) 1996-2001, 2003-2019, 2021-2024 Free Software
+# Copyright (C) 1996-2001, 2003-2019, 2021-2025 Free Software
# Foundation, Inc.
# Written by Gordon Matzigkeit, 1996
#
@@ -9,7 +9,7 @@
# modifications, as long as this notice is preserved.
m4_define([_LT_COPYING], [dnl
-# Copyright (C) 2024 Free Software Foundation, Inc.
+# Copyright (C) 2025 Free Software Foundation, Inc.
# This is free software; see the source for copying conditions. There is NO
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
@@ -32,7 +32,7 @@
# along with this program. If not, see .
])
-# serial 63 LT_INIT
+# serial 66 LT_INIT
# LT_PREREQ(VERSION)
@@ -506,6 +506,56 @@
# ------------------------------
m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
+# _LT_OBJECTIVE_C
+# ------------------------------
+m4_defun([_LT_OBJECTIVE_C], [
+ AC_CACHE_CHECK([for Objective C compilation],
+ [lt_cv_objc_compiles],
+ [ save_CFLAGS=$CFLAGS
+ CFLAGS=$OBJCFLAGS
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([#import
+@interface Addition : NSObject
+- (int)this:(int)a that:(int)b;
+@end
+
+@implementation Addition
+- (int)this:(int)a that:(int)b
+{
+ return a + b;
+}
+@end
+],[])],
+ lt_cv_objc_compiles=yes,
+ lt_cv_objc_compiles=no
+ )
+ CFLAGS=$save_CFLAGS
+ ]
+ )
+ objc_compiles=$lt_cv_objc_compiles
+ _LT_DECL([], [objc_compiles], [1],
+ [Check for compiling Objective C and C++ code])
+])
+
+m4_defun([_LT_ML64], [
+ AC_CACHE_CHECK([for ML64 compilation],
+ [lt_cv_ml64_compiles],
+ [ save_CFLAGS=$CFLAGS
+ CFLAGS=$ML64FLAGS
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([ret
+],[])],
+ lt_cv_ml64_compiles=yes,
+ lt_cv_ml64_compiles=no
+ )
+ CFLAGS=$save_CFLAGS
+ ]
+ )
+ objc_compiles=$lt_cv_objc_compiles
+ _LT_DECL([], [ml64_compiles], [1],
+ [Check for compiling ml64 code])
+])
+
# _LT_CONFIG_COMMANDS
# -------------------
@@ -651,7 +701,7 @@
m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])
configured by $[0], generated by m4_PACKAGE_STRING.
-Copyright (C) 2024 Free Software Foundation, Inc.
+Copyright (C) 2025 Free Software Foundation, Inc.
This config.lt script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."
@@ -826,6 +876,9 @@
m4_case([$1],
[C], [_LT_LANG(C)],
[C++], [_LT_LANG(CXX)],
+ [Objective-C], [_LT_LANG(OBJC)],
+ [Objective-C++], [_LT_LANG(OBJCXX)],
+ [Microsoft Macro Assembler], [_LT_LANG(ML64)],
[Go], [_LT_LANG(GO)],
[Java], [_LT_LANG(GCJ)],
[Fortran 77], [_LT_LANG(F77)],
@@ -848,6 +901,26 @@
])# _LT_LANG
+m4_ifndef([AC_PROG_ML64], [
+m4_defun([AC_PROG_ML64],
+[AC_LANG_PUSH(ML64)dnl
+AC_ARG_VAR([ML64], [ml64 compiler command])dnl
+AC_ARG_VAR([ML64FLAGS], [ml64 compiler flags])dnl
+_AC_ARG_VAR_LDFLAGS()dnl
+AC_CHECK_TOOL(ML64, ml64)
+if test -z "$ML64"; then
+ if test -n "$ac_tool_prefix"; then
+ AC_CHECK_PROG(ML64, [${ac_tool_prefix}ml64], [${ac_tool_prefix}ml64])
+ fi
+fi
+if test -z "$ML64"; then
+ AC_CHECK_PROG(ML64, ml64, ml64, false)
+fi
+])#m4_defun
+])#m4_ifndef
+
+
+
m4_ifndef([AC_PROG_GO], [
############################################################
# NOTE: This macro has been submitted for inclusion into #
@@ -898,19 +971,34 @@
[LT_LANG(GCJ)],
[m4_ifdef([AC_PROG_GCJ],
[m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
+
m4_ifdef([A][M_PROG_GCJ],
[m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
m4_ifdef([LT_PROG_GCJ],
[m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])
-
AC_PROVIDE_IFELSE([AC_PROG_GO],
[LT_LANG(GO)],
[m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])])
+AC_PROVIDE_IFELSE([AC_PROG_OBJC],
+ [LT_LANG(OBJC)],
+ [m4_define([AC_PROG_OBJC], defn([AC_PROG_OBJC])[LT_LANG(OBJC)])])
+
+AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
+ [LT_LANG(OBJCXX)],
+ [m4_define([AC_PROG_OBJCXX], defn([AC_PROG_OBJCXX])[LT_LANG(OBJCXX)])])
+
+AC_PROVIDE_IFELSE([AC_PROG_ML64],
+ [LT_LANG(ML64)],
+ [m4_define([AC_PROG_ML64], defn([AC_PROG_ML64])[LT_LANG(ML64)])])
AC_PROVIDE_IFELSE([LT_PROG_RC],
[LT_LANG(RC)],
[m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
-])# _LT_LANG_DEFAULT_CONFIG
+
+
+])
+
+# _LT_LANG_DEFAULT_CONFIG
# Obsolete macros:
AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
@@ -1161,8 +1249,8 @@
_LT_TAGVAR(module_expsym_cmds, $1)="$SED -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
m4_if([$1], [CXX],
[ if test yes = "$_lt_dar_needs_single_mod" -a yes != "$lt_cv_apple_cc_single_mod"; then
- _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
- _LT_TAGVAR(archive_expsym_cmds, $1)="$SED 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
+ _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs $stdlibflag -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
+ _LT_TAGVAR(archive_expsym_cmds, $1)="$SED 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs $stdlibflag -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
fi
],[])
else
@@ -1537,7 +1625,7 @@
test ${AR_FLAGS+y} || AR_FLAGS=${ARFLAGS-cr}
lt_ar_flags=$AR_FLAGS
-_LT_DECL([], [lt_ar_flags], [0], [Flags to create an archive (by configure)])
+_LT_DECL([], [lt_ar_flags], [1], [Flags to create an archive (by configure)])
# Make AR_FLAGS overridable by 'make ARFLAGS='. Don't try to run-time override
# by AR_FLAGS because that was never working and AR_FLAGS is about to die.
@@ -1640,9 +1728,9 @@
if (exit $ac_status) && test -s "$ac_outfile"; then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings other than the usual output.
- $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.expsym
$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
- if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+ if test ! -s conftest.er2 || diff conftest.expsym conftest.er2 >/dev/null; then
$2=yes
fi
fi
@@ -1680,9 +1768,9 @@
if test -s conftest.err; then
# Append any errors to the config.log.
cat conftest.err 1>&AS_MESSAGE_LOG_FD
- $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+ $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.expsym
$SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
- if diff conftest.exp conftest.er2 >/dev/null; then
+ if diff conftest.expsym conftest.er2 >/dev/null; then
$2=yes
fi
else
@@ -2123,9 +2211,9 @@
then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings
- $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+ $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.expsym
$SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
- if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+ if test ! -s out/conftest.er2 || diff out/conftest.expsym out/conftest.er2 >/dev/null; then
_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
fi
fi
@@ -2628,8 +2716,8 @@
dynamic_linker='Win32 ld.exe'
;;
- *,cl* | *,icl*)
- # Native MSVC or ICC
+ *,cl* | *,icl* | *,icx*)
+ # Native MSVC and Intel compilers
libname_spec='$name'
soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext'
library_names_spec='$libname.dll.lib'
@@ -2889,6 +2977,18 @@
hardcode_into_libs=yes
;;
+*-mlibc)
+ version_type=linux # correct to gnu/linux during the next big refactor
+ need_lib_prefix=no
+ need_version=no
+ library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+ soname_spec='$libname$release$shared_ext$major'
+ dynamic_linker='mlibc ld.so'
+ shlibpath_var=LD_LIBRARY_PATH
+ shlibpath_overrides_runpath=no
+ hardcode_into_libs=yes
+ ;;
+
# No shared lib support for Linux oldld, aout, or coff.
linux*oldld* | linux*aout* | linux*coff*)
dynamic_linker=no
@@ -2976,6 +3076,8 @@
shlibpath_overrides_runpath=no
hardcode_into_libs=yes
dynamic_linker='NetBSD ld.elf_so'
+ enable_cxx_stdlib=yes
+ stdlibflag=
;;
netbsd*)
@@ -2994,18 +3096,8 @@
shlibpath_var=LD_LIBRARY_PATH
shlibpath_overrides_runpath=yes
hardcode_into_libs=yes
- ;;
-
-*-mlibc)
- version_type=linux # correct to gnu/linux during the next big refactor
- need_lib_prefix=no
- need_version=no
- library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
- soname_spec='$libname$release$shared_ext$major'
- dynamic_linker='mlibc ld.so'
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=no
- hardcode_into_libs=yes
+ enable_cxx_stdlib=yes
+ stdlibflag=
;;
newsos6)
@@ -3501,7 +3593,7 @@
;;
darwin*)
if test yes = "$GCC"; then
- reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
+ reload_cmds='$LTCC $LTCFLAGS $stdlibflag $wl-r -o $output$reload_objs'
else
reload_cmds='$LD$reload_flag -o $output$reload_objs'
fi
@@ -3669,12 +3761,12 @@
lt_cv_deplibs_check_method=pass_all
;;
-# This must be glibc/ELF.
-linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+*-mlibc)
lt_cv_deplibs_check_method=pass_all
;;
-*-mlibc)
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
lt_cv_deplibs_check_method=pass_all
;;
@@ -4091,13 +4183,13 @@
if test "$lt_cv_nm_interface" = "MS dumpbin"; then
# Gets list of data symbols to import.
- lt_cv_sys_global_symbol_to_import="$SED -n -e 's/^I .* \(.*\)$/\1/p'"
+ lt_cv_sys_global_symbol_to_import="$SED -n -e 's/^I .* \([[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/\1/p'"
# Adjust the below global symbol transforms to fixup imported variables.
- lt_cdecl_hook=" -e 's/^I .* \(.*\)$/extern __declspec(dllimport) char \1;/p'"
- lt_c_name_hook=" -e 's/^I .* \(.*\)$/ {\"\1\", (void *) 0},/p'"
+ lt_cdecl_hook=" -e 's/^I .* \([[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/extern __declspec(dllimport) char \1;/p'"
+ lt_c_name_hook=" -e 's/^I .* \([[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/ {\"\1\", (void *) 0},/p'"
lt_c_name_lib_hook="\
- -e 's/^I .* \(lib.*\)$/ {\"\1\", (void *) 0},/p'\
- -e 's/^I .* \(.*\)$/ {\"lib\1\", (void *) 0},/p'"
+ -e 's/^I .* \(lib[[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/ {\"\1\", (void *) 0},/p'\
+ -e 's/^I .* \([[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/ {\"lib\1\", (void *) 0},/p'"
else
# Disable hooks by default.
lt_cv_sys_global_symbol_to_import=
@@ -4111,22 +4203,22 @@
# so use this general approach.
lt_cv_sys_global_symbol_to_cdecl="$SED -n"\
$lt_cdecl_hook\
-" -e 's/^T .* \(.*\)$/extern int \1();/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/extern char \1;/p'"
+" -e 's/^T .* \([[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/extern int \1();/p'"\
+" -e 's/^$symcode$symcode* .* \([[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/extern char \1;/p'"
# Transform an extracted symbol line into symbol name and symbol address
lt_cv_sys_global_symbol_to_c_name_address="$SED -n"\
$lt_c_name_hook\
" -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/p'"
+" -e 's/^$symcode$symcode* .* \([[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/ {\"\1\", (void *) \&\1},/p'"
# Transform an extracted symbol line into symbol name with lib prefix and
# symbol address.
lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="$SED -n"\
$lt_c_name_lib_hook\
" -e 's/^: \(.*\) .*$/ {\"\1\", (void *) 0},/p'"\
-" -e 's/^$symcode$symcode* .* \(lib.*\)$/ {\"\1\", (void *) \&\1},/p'"\
-" -e 's/^$symcode$symcode* .* \(.*\)$/ {\"lib\1\", (void *) \&\1},/p'"
+" -e 's/^$symcode$symcode* .* \(lib[[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/ {\"\1\", (void *) \&\1},/p'"\
+" -e 's/^$symcode$symcode* .* \([[a-zA-Z_]][[a-zA-Z0-9_]]*\)$/ {\"lib\1\", (void *) \&\1},/p'"
# Handle CRLF in mingw tool chain
opt_cr=
@@ -4147,8 +4239,10 @@
# Fake it for dumpbin and say T for any non-static function,
# D for any global variable and I for any imported variable.
# Also find C++ and __fastcall symbols from MSVC++ or ICC,
- # which start with @ or ?.
+ # which start with @ or ?. And Cygwin gawk-4.1.4-3 and newer
+ # treats input as binary, have to drop carriage return first.
lt_cv_sys_global_symbol_pipe="$AWK ['"\
+" {sub(/\\r\$/,\"\")};"\
" {last_section=section; section=\$ 3};"\
" /^COFF SYMBOL TABLE/{for(i in hide) delete hide[i]};"\
" /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
@@ -4424,7 +4518,7 @@
# AIX 5 now supports IA64 processor
_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
else
- _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.expsym'
fi
;;
chorus*)
@@ -4497,6 +4591,8 @@
;;
esac
;;
+ *-mlibc)
+ ;;
linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
case $cc_basename in
KCC*)
@@ -4510,7 +4606,7 @@
_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
;;
- icpc* )
+ icpc* | icpx*)
# Intel C++, used to be incompatible with GCC.
# ICC 10 doesn't accept -KPIC any more.
_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
@@ -4563,8 +4659,6 @@
;;
netbsd* | netbsdelf*-gnu)
;;
- *-mlibc)
- ;;
*qnx* | *nto*)
# QNX uses GNU C++, but need to define -shared option too, otherwise
# it will coredump.
@@ -4773,7 +4867,7 @@
# AIX 5 now supports IA64 processor
_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
else
- _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.expsym'
fi
;;
@@ -4825,7 +4919,13 @@
_LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
;;
- linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+ *-mlibc)
+ _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+ _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+ _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+ ;;
+
+ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu* | freebsd*)
case $cc_basename in
# old Intel for x86_64, which still supported -KPIC.
ecc*)
@@ -4841,7 +4941,7 @@
;;
# icc used to be incompatible with GCC.
# ICC 10 doesn't accept -KPIC any more.
- icc* | ifort*)
+ icc* | ifort* | icx* | ifx*)
_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
@@ -4921,12 +5021,6 @@
_LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
;;
- *-mlibc)
- _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
- _LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
- ;;
-
*nto* | *qnx*)
# QNX uses GNU C++, but need to define -shared option too, otherwise
# it will coredump.
@@ -5083,7 +5177,8 @@
;;
cygwin* | mingw* | windows* | cegcc*)
case $cc_basename in
- cl* | icl*)
+ cl* | icl* | icx* | icpx*)
+ # Native MSVC and Intel compilers
_LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
;;
*)
@@ -5328,6 +5423,11 @@
_LT_TAGVAR(archive_expsym_cmds, $1)='$SED "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
;;
+ *-mlibc)
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+ ;;
+
gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
tmp_diet=no
if test linux-dietlibc = "$host_os"; then
@@ -5353,7 +5453,7 @@
tmp_addflag=' -i_dynamic' ;;
efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64
tmp_addflag=' -i_dynamic -nofor_main' ;;
- ifc* | ifort*) # Intel Fortran compiler
+ ifc* | ifort* | ifx*) # Intel Fortran compiler
tmp_addflag=' -nofor_main' ;;
lf95*) # Lahey Fortran 8.1
_LT_TAGVAR(whole_archive_flag_spec, $1)=
@@ -5408,11 +5508,6 @@
fi
;;
- *-mlibc)
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
- _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
- ;;
-
netbsd* | netbsdelf*-gnu)
if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
@@ -5721,8 +5816,8 @@
# hardcode_libdir_flag_spec is actually meaningless, as there is
# no search path for DLLs.
case $cc_basename in
- cl* | icl*)
- # Native MSVC or ICC
+ cl* | icl* | icx* | icpx*)
+ # Native MSVC and Intel compilers
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
_LT_TAGVAR(always_export_symbols, $1)=yes
@@ -5732,14 +5827,20 @@
# Tell ltmain to make .dll files, not .so files.
shrext_cmds=.dll
# FIXME: Setting linknames here is a bad hack.
+ # A check exists to verify if there are linker flags, which will use
+ # different commands when linking.
_LT_TAGVAR(archive_cmds, $1)='$CC -Fe$output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
_LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
cp "$export_symbols" "$output_objdir/$soname.def";
- echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+ echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.expsym";
else
- $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+ $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.expsym;
+ fi~
+ if test -z "$linker_flags"; then
+ $CC -Fe$tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.expsym" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib";
+ else
+ $CC -Fe$tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.expsym" -Wl,$linker_flags-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib";
fi~
- $CC -Fe$tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
linknames='
# The linker will not automatically build a static lib if we build a DLL.
# _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
@@ -5771,7 +5872,7 @@
# Tell ltmain to make .dll files, not .so files.
shrext_cmds=.dll
# FIXME: Setting linknames here is a bad hack.
- _LT_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
+ _LT_TAGVAR(archive_cmds, $1)='$CC -Fe$lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
# The linker will automatically build a .lib file if we build a DLL.
_LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
# FIXME: Should let the user specify the lib program.
@@ -5945,6 +6046,9 @@
_LT_TAGVAR(link_all_deplibs, $1)=yes
;;
+ *-mlibc)
+ ;;
+
linux*)
case $cc_basename in
tcc*)
@@ -5956,9 +6060,6 @@
esac
;;
- *-mlibc)
- ;;
-
netbsd* | netbsdelf*-gnu)
if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out
@@ -6050,8 +6151,8 @@
else
_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
- _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
- $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.expsym; done; printf "%s\\n" "-hidden">> $lib.expsym~
+ $CC -shared$allow_undefined_flag $wl-input $wl$lib.expsym $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.expsym'
# Both c and cxx compiler support -rpath directly
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
@@ -6068,21 +6169,21 @@
if test yes = "$GCC"; then
wlarc='$wl'
_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
- _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
- $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.expsym~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.expsym~echo "local: *; };" >> $lib.expsym~
+ $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.expsym $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.expsym'
else
case `$CC -V 2>&1` in
*"Compilers 5.0"*)
wlarc=''
_LT_TAGVAR(archive_cmds, $1)='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
- $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.expsym~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.expsym~echo "local: *; };" >> $lib.expsym~
+ $LD -G$allow_undefined_flag -M $lib.expsym -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.expsym'
;;
*)
wlarc='$wl'
_LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
- _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
- $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.expsym~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.expsym~echo "local: *; };" >> $lib.expsym~
+ $CC -G$allow_undefined_flag -M $lib.expsym -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.expsym'
;;
esac
fi
@@ -6556,8 +6657,8 @@
# Check if GNU C++ uses GNU ld as the underlying linker, since the
# archiving commands below assume that GNU ld is being used.
if test yes = "$with_gnu_ld"; then
- _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
- _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+ _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared $stdlibflag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared $stdlibflag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir'
_LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic'
@@ -6582,13 +6683,13 @@
# linker, instead of GNU ld. If possible, this setting should
# overridden to take advantage of the native linker features on
# the platform it is being used on.
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $stdlibflag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
fi
# Commands to make compiler produce verbose output that lists
# what "hidden" libraries, object files and flags are used when
# linking a shared library.
- output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " [[-]]L"'
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP -v "^Driving:" | $GREP " [[-]]L"'
else
GXX=no
@@ -6799,8 +6900,8 @@
cygwin* | mingw* | windows* | pw32* | cegcc*)
case $GXX,$cc_basename in
- ,cl* | no,cl* | ,icl* | no,icl*)
- # Native MSVC or ICC
+ ,cl* | no,cl* | ,icl* | no,icl* | ,icx* | no,icx* | ,icpx* | no,icpx*)
+ # Native MSVC and Intel compilers
# hardcode_libdir_flag_spec is actually meaningless, as there is
# no search path for DLLs.
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
@@ -6812,14 +6913,20 @@
# Tell ltmain to make .dll files, not .so files.
shrext_cmds=.dll
# FIXME: Setting linknames here is a bad hack.
- _LT_TAGVAR(archive_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+ # A check exists to verify if there are linker flags, which will use
+ # different commands when linking.
+ _LT_TAGVAR(archive_cmds, $1)='$CC -Fe$output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
_LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
cp "$export_symbols" "$output_objdir/$soname.def";
- echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+ echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.expsym";
else
- $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+ $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.expsym;
+ fi~
+ if test -z "$linker_flags"; then
+ $CC -Fe$tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.expsym" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib";
+ else
+ $CC -Fe$tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.expsym" -Wl,$linker_flags-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib";
fi~
- $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
linknames='
# The linker will not automatically build a static lib if we build a DLL.
# _LT_TAGVAR(old_archive_from_new_cmds, $1)='true'
@@ -6853,7 +6960,7 @@
_LT_TAGVAR(file_list_spec, $1)='@'
if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $stdlibflag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
# If the export-symbols file already is a .def file, use it as
# is; otherwise, prepend EXPORTS...
_LT_TAGVAR(archive_expsym_cmds, $1)='if _LT_DLL_DEF_P([$export_symbols]); then
@@ -6862,7 +6969,7 @@
echo EXPORTS > $output_objdir/$soname.def;
cat $export_symbols >> $output_objdir/$soname.def;
fi~
- $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+ $CC -shared $stdlibflag $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
else
_LT_TAGVAR(ld_shlibs, $1)=no
fi
@@ -6969,7 +7076,7 @@
;;
*)
if test yes = "$GXX"; then
- _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+ _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $stdlibflag $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
else
# FIXME: insert proper C++ library support
_LT_TAGVAR(ld_shlibs, $1)=no
@@ -7037,13 +7144,13 @@
if test no = "$with_gnu_ld"; then
case $host_cpu in
hppa*64*)
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $stdlibflag -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
;;
ia64*)
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $stdlibflag $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
;;
*)
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $stdlibflag $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
;;
esac
fi
@@ -7084,9 +7191,9 @@
*)
if test yes = "$GXX"; then
if test no = "$with_gnu_ld"; then
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $stdlibflag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
else
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $stdlibflag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib'
fi
fi
_LT_TAGVAR(link_all_deplibs, $1)=yes
@@ -7097,6 +7204,10 @@
_LT_TAGVAR(inherit_rpath, $1)=yes
;;
+ *-mlibc)
+ _LT_TAGVAR(ld_shlibs, $1)=yes
+ ;;
+
linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
case $cc_basename in
KCC*)
@@ -7124,7 +7235,7 @@
# "CC -Bstatic", where "CC" is the KAI C++ compiler.
_LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
;;
- icpc* | ecpc* )
+ icpc* | ecpc* | icpx*)
# Intel C++
with_gnu_ld=yes
# version 8.0 and above of icpc choke on multiply defined symbols
@@ -7262,10 +7373,6 @@
esac
;;
- *-mlibc)
- _LT_TAGVAR(ld_shlibs, $1)=yes
- ;;
-
netbsd*)
if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
@@ -7273,9 +7380,11 @@
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
_LT_TAGVAR(hardcode_direct, $1)=yes
_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
+ else
+ _LT_TAGVAR(archive_cmds, $1)='$CC $pic_flag -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='$CC $pic_flag -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
fi
- # Workaround some broken pre-1.5 toolchains
- output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+ output_verbose_link_cmd=func_echo_all
;;
*nto* | *qnx*)
@@ -7335,10 +7444,10 @@
*)
_LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
_LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
- _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
- echo "-hidden">> $lib.exp~
- $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.exp `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~
- $RM $lib.exp'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.expsym; done~
+ echo "-hidden">> $lib.expsym~
+ $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.expsym `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~
+ $RM $lib.expsym'
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
;;
esac
@@ -7360,10 +7469,10 @@
_LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*'
case $host in
osf3*)
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $stdlibflag $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
;;
*)
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $stdlibflag $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
;;
esac
@@ -7373,7 +7482,7 @@
# Commands to make compiler produce verbose output that lists
# what "hidden" libraries, object files and flags are used when
# linking a shared library.
- output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " [[-]]L"'
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP -v "^Driving:" | $GREP " [[-]]L"'
else
# FIXME: insert proper C++ library support
@@ -7417,8 +7526,8 @@
_LT_TAGVAR(archive_cmds_need_lc,$1)=yes
_LT_TAGVAR(no_undefined_flag, $1)=' -zdefs'
_LT_TAGVAR(archive_cmds, $1)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
- _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
- $CC -G$allow_undefined_flag $wl-M $wl$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.expsym~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.expsym~echo "local: *; };" >> $lib.expsym~
+ $CC -G$allow_undefined_flag $wl-M $wl$lib.expsym -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.expsym'
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
_LT_TAGVAR(hardcode_shlibpath_var, $1)=no
@@ -7453,25 +7562,25 @@
if test yes,no = "$GXX,$with_gnu_ld"; then
_LT_TAGVAR(no_undefined_flag, $1)=' $wl-z ${wl}defs'
if $CC --version | $GREP -v '^2\.7' > /dev/null; then
- _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
- _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
- $CC -shared $pic_flag -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $stdlibflag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.expsym~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.expsym~echo "local: *; };" >> $lib.expsym~
+ $CC -shared $pic_flag $stdlibflag $wl-M $wl$lib.expsym $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.expsym'
# Commands to make compiler produce verbose output that lists
# what "hidden" libraries, object files and flags are used when
# linking a shared library.
- output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " [[-]]L"'
+ output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP -v "^Driving:" | $GREP " [[-]]L"'
else
# g++ 2.7 appears to require '-G' NOT '-shared' on this
# platform.
- _LT_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
- _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
- $CC -G -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+ _LT_TAGVAR(archive_cmds, $1)='$CC -G $stdlibflag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+ _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $lib.expsym~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.expsym~echo "local: *; };" >> $lib.expsym~
+ $CC -G $stdlibflag $wl-M $wl$lib.expsym $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.expsym'
# Commands to make compiler produce verbose output that lists
# what "hidden" libraries, object files and flags are used when
# linking a shared library.
- output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " [[-]]L"'
+ output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP -v "^Driving:" | $GREP " [[-]]L"'
fi
_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $wl$libdir'
@@ -7705,10 +7814,14 @@
# the conftest object file.
pre_test_object_deps_done=no
+ if test yes = "$enable_cxx_stdlib"; then
+ output_verbose_link_cmd=
+ fi
+
for p in `eval "$output_verbose_link_cmd"`; do
case $prev$p in
- -L* | -R* | -l*)
+ -L* | -R* | -l* | */libclang_rt.*.a)
# Some compilers place space between "-{L,R,l}" and the path.
# Remove the space.
if test x-L = x"$p" ||
@@ -8171,6 +8284,76 @@
])# _LT_LANG_GCJ_CONFIG
+# _LT_LANG_ML64_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the ML64 assembler
+# are suitably defined. These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_ML64_CONFIG],
+[AC_REQUIRE([LT_PROG_ML64])dnl
+AC_LANG_SAVE
+
+# Source file extension for ML64 test sources.
+ac_ext=asm
+
+#Object file extension for compile ML64 test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="main PROC ret main ENDP"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code="main PROC ret main ENDP"
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# TODO? Check for compilation issues with ML64 flags.
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=yes
+CC=${ML64-"gcc"}
+CFLAGS=$ML64FLAGS
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_TAGVAR(LD, $1)=$LD
+_LT_CC_BASENAME([$compiler])
+
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+ _LT_COMPILER_NO_RTTI($1)
+ _LT_COMPILER_PIC($1)
+ _LT_COMPILER_C_O($1)
+ _LT_COMPILER_FILE_LOCKS($1)
+ _LT_LINKER_SHLIBS($1)
+ _LT_LINKER_HARDCODE_LIBPATH($1)
+
+ _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+
+GCC=$lt_save_GCC
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+])# _LT_LANG_ML64_CONFIG
+
+
# _LT_LANG_GO_CONFIG([TAG])
# --------------------------
# Ensure that the configuration variables for the GNU Go compiler
@@ -8242,6 +8425,151 @@
])# _LT_LANG_GO_CONFIG
+# _LT_LANG_OBJC_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the GNU Objective-C compiler
+# are suitably defined. These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_OBJC_CONFIG],
+[AC_REQUIRE([LT_PROG_OBJC])dnl
+AC_LANG_SAVE
+
+# Source file extension for OBJC test sources.
+ac_ext=m
+
+# Object file extension for compiled OBJC test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(void){return(0);}'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Check for compilation issues with OBJC flags
+_LT_OBJECTIVE_C
+if test "yes" = "$lt_cv_gnustep_exists"; then
+ OBJCFLAGS="$OBJCFLAGS `gnustep-config --objc-flags`"
+fi
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=yes
+CC=${OBJC-"gcc"}
+CFLAGS=$OBJCFLAGS
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_TAGVAR(LD, $1)=$LD
+_LT_CC_BASENAME([$compiler])
+
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+ _LT_COMPILER_NO_RTTI($1)
+ _LT_COMPILER_PIC($1)
+ _LT_COMPILER_C_O($1)
+ _LT_COMPILER_FILE_LOCKS($1)
+ _LT_LINKER_SHLIBS($1)
+ _LT_LINKER_HARDCODE_LIBPATH($1)
+
+ _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+
+GCC=$lt_save_GCC
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+])# _LT_LANG_OBJC_CONFIG
+
+
+# _LT_LANG_OBJCXX_CONFIG([TAG])
+# --------------------------
+# Ensure that the configuration variables for the GNU Objective-C++ compiler
+# are suitably defined. These variables are subsequently used by _LT_CONFIG
+# to write the compiler configuration to 'libtool'.
+m4_defun([_LT_LANG_OBJCXX_CONFIG],
+[AC_REQUIRE([LT_PROG_OBJCXX])dnl
+AC_LANG_SAVE
+
+# Source file extension for OBJCXX test sources.
+ac_ext=mm
+
+# Object file extension for compiled OBJCXX test sources.
+objext=o
+_LT_TAGVAR(objext, $1)=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }'
+
+# ltmain only uses $CC for tagged configurations so make sure $CC is set.
+_LT_TAG_COMPILER
+
+# save warnings/boilerplate of simple test code
+_LT_COMPILER_BOILERPLATE
+_LT_LINKER_BOILERPLATE
+
+# Check for compilation issues with OBJCXX flags
+_LT_OBJECTIVE_C
+
+# Allow CC to be a program name with arguments.
+lt_save_CC=$CC
+lt_save_CFLAGS=$CFLAGS
+lt_save_GCC=$GCC
+GCC=yes
+CC=${OBJCXX-"g++"}
+CFLAGS=$OBJCXXFLAGS
+compiler=$CC
+_LT_TAGVAR(compiler, $1)=$CC
+_LT_TAGVAR(LD, $1)=$LD
+_LT_CC_BASENAME([$compiler])
+
+_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
+_LT_TAGVAR(reload_flag, $1)=$reload_flag
+_LT_TAGVAR(reload_cmds, $1)=$reload_cmds
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+ _LT_COMPILER_NO_RTTI($1)
+ _LT_COMPILER_PIC($1)
+ _LT_COMPILER_C_O($1)
+ _LT_COMPILER_FILE_LOCKS($1)
+ _LT_LINKER_SHLIBS($1)
+ _LT_LINKER_HARDCODE_LIBPATH($1)
+
+ _LT_CONFIG($1)
+fi
+
+AC_LANG_RESTORE
+
+GCC=$lt_save_GCC
+CC=$lt_save_CC
+CFLAGS=$lt_save_CFLAGS
+])# _LT_LANG_OBJCXX_CONFIG
+
+
# _LT_LANG_RC_CONFIG([TAG])
# -------------------------
# Ensure that the configuration variables for the Windows resource compiler
@@ -8294,6 +8622,34 @@
CFLAGS=$lt_save_CFLAGS
])# _LT_LANG_RC_CONFIG
+# LT_PROG_ML64
+# -----------
+AC_DEFUN([LT_PROG_ML64],
+[AC_CHECK_TOOL(ML64, ml64,)
+])
+
+
+# LT_PROG_OBJC
+# -----------
+AC_DEFUN([LT_PROG_OBJC],
+[AC_CHECK_TOOL(OBJC, gcc,)
+ AC_CHECK_TOOL(GNUSTEP_CONFIG, gnustep-config,)
+ if test Xgnustep-config = X"$GNUSTEP_CONFIG"; then
+ test set = "${OBJCFLAGS+set}" || OBJCFLAGS="`gnustep-config --objc-flags`"
+ fi
+ AC_SUBST(OBJCFLAGS)])])[]dnl
+])
+
+# LT_PROG_OBJCXX
+# -----------
+AC_DEFUN([LT_PROG_OBJCXX],
+[AC_CHECK_TOOL(OBJCXX, g++,)
+ AC_CHECK_TOOL(GNUSTEP_CONFIG, gnustep-config,)
+ if test Xgnustep-config = X"$GNUSTEP_CONFIG"; then
+ test set = "${OBJCXXFLAGS+set}" || OBJCXXFLAGS="`gnustep-config --objc-flags`"
+ fi
+ AC_SUBST(OBJCXXFLAGS)])])[]dnl
+])
# LT_PROG_GCJ
# -----------
@@ -8485,4 +8841,40 @@
AC_MSG_RESULT([$lt_cv_to_tool_file_cmd])
_LT_DECL([to_tool_file_cmd], [lt_cv_to_tool_file_cmd],
[0], [convert $build files to toolchain format])dnl
+
+AS_CASE([$host],
+ [*-*-mingw* | *-*-windows* | *-*-cygwin*],
+ [AS_CASE([$build],
+ [*-*-mingw* | *-*-windows* | *-*-cygwin*],
+ [AC_MSG_CHECKING([whether cygpath is installed])
+ AC_CACHE_VAL([lt_cv_cygpath_installed],
+ [lt_cv_cygpath_installed=ignoring
+ cygpath --help &> /dev/null
+ _lt_result=$?
+ AS_IF([test 0 = "$_lt_result"],
+ [lt_cv_cygpath_installed=yes],
+ [lt_cv_cygpath_installed=no])
+ ])
+ AC_MSG_RESULT([$lt_cv_cygpath_installed])
+ _LT_DECL([cygpath_installed], [lt_cv_cygpath_installed],
+ [0], [whether cygpath is installed])dnl
+ AS_IF([test "xyes" != "x$lt_cv_cygpath_installed"],
+ [
+ AC_MSG_CHECKING([whether to use cmd with one slash or two slashes])
+ AC_CACHE_VAL([lt_cv_cmd_slashes],
+ [
+ _lt_result=`cmd /c echo one-slash works. Not checked //c echo two-slashes 2>/dev/null`
+ AS_IF([test 0 != $?],
+ [AC_MSG_ERROR([Do not know how to convert paths])])
+ AS_CASE([$_lt_result],
+ [one-slash*],[lt_cv_cmd_slashes="one"],
+ [two-slashes*],[lt_cv_cmd_slashes="two"],
+ [AC_MSG_ERROR([Do not know how to convert paths])]
+ )
+ ])
+ AC_MSG_RESULT([$lt_cv_cmd_slashes])
+ ])
+ ])
+ ]
+)dnl
])# _LT_PATH_CONVERSION_FUNCTIONS
diff -Nru xz-utils-5.8.1/m4/ltoptions.m4 xz-utils-5.8.3/m4/ltoptions.m4
--- xz-utils-5.8.1/m4/ltoptions.m4 2025-04-03 11:35:14.000000000 +0000
+++ xz-utils-5.8.3/m4/ltoptions.m4 2026-03-31 15:27:09.000000000 +0000
@@ -1,6 +1,6 @@
# Helper functions for option handling. -*- Autoconf -*-
#
-# Copyright (C) 2004-2005, 2007-2009, 2011-2019, 2021-2024 Free
+# Copyright (C) 2004-2005, 2007-2009, 2011-2019, 2021-2025 Free
# Software Foundation, Inc.
# Written by Gary V. Vaughan, 2004
#
@@ -8,7 +8,7 @@
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.
-# serial 10 ltoptions.m4
+# serial 12 ltoptions.m4
# This is to help aclocal find these macros, as it can't see m4_define.
AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
@@ -80,6 +80,7 @@
_LT_UNLESS_OPTIONS([LT_INIT], [shared disable-shared], [_LT_ENABLE_SHARED])
_LT_UNLESS_OPTIONS([LT_INIT], [static disable-static], [_LT_ENABLE_STATIC])
_LT_UNLESS_OPTIONS([LT_INIT], [pic-only no-pic], [_LT_WITH_PIC])
+ _LT_UNLESS_OPTIONS([LT_INIT], [cxx-stdlib no-cxx-stdlib], [_LT_ENABLE_CXX_STDLIB])
_LT_UNLESS_OPTIONS([LT_INIT], [fast-install disable-fast-install],
[_LT_ENABLE_FAST_INSTALL])
_LT_UNLESS_OPTIONS([LT_INIT], [aix-soname=aix aix-soname=both aix-soname=svr4],
@@ -370,8 +371,16 @@
fi
fi
;;
+power*-*-aix[[5-9]]*,'')
+ AC_MSG_WARN([for $host, specify if building shared libraries for versioning (svr4|both)])
+ AC_MSG_CHECKING([which variant of shared library versioning to provide])
+ with_aix_soname=aix
+ AC_MSG_RESULT([(default) $with_aix_soname])
+ ;;
*)
+ AC_MSG_CHECKING([which variant of shared library versioning to provide])
with_aix_soname=aix
+ AC_MSG_RESULT([(default) $with_aix_soname])
;;
esac
@@ -448,6 +457,49 @@
dnl aclocal-1.4 backwards compatibility:
dnl AC_DEFUN([AC_LIBTOOL_PICMODE], [])
+
+# _LT_ENABLE_CXX_STDLIB([MODE])
+# --------------------
+# implement the --enable-cxx-stdlib flag, and support the 'cxx-stdlib' and 'no-cxx-stdlib'
+# LT_INIT options.
+# MODE is either 'yes' or 'no'. If omitted, it defaults to 'no'.
+m4_define([_LT_ENABLE_CXX_STDLIB],
+[m4_define([_LT_ENABLE_CXX_STDLIB_DEFAULT], [m4_if($1, yes, yes, no)])dnl
+stdlibflag=-nostdlib
+AC_ARG_ENABLE([cxx-stdlib],
+ [AS_HELP_STRING([--enable-cxx-stdlib@<:@=PKGS@:>@],
+ [let the compiler frontend decide what standard libraries to link when building C++ shared libraries and modules @<:@default=]_LT_ENABLE_CXX_STDLIB_DEFAULT[@:>@])],
+ [p=${PACKAGE-default}
+ case $enableval in
+ yes) enable_cxx_stdlib=yes ;;
+ no) enable_cxx_stdlib=no ;;
+ *)
+ enable_cxx_stdlib=no
+ # Look at the argument we got. We use all the common list separators.
+ lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+ for pkg in $enableval; do
+ IFS=$lt_save_ifs
+ if test "X$pkg" = "X$p"; then
+ enable_cxx_stdlib=yes
+ fi
+ done
+ IFS=$lt_save_ifs
+ ;;
+ esac],
+ [enable_cxx_stdlib=]_LT_ENABLE_CXX_STDLIB_DEFAULT)
+
+if test yes = "$enable_cxx_stdlib"; then
+ stdlibflag=
+fi
+
+_LT_DECL([], [enable_cxx_stdlib], [0], [Whether to let the compiler frontend decide what standard libraries to link when building C++ shared libraries and modules])dnl
+_LT_DECL([], [stdlibflag], [0], [Flag used for specifying not to link standard libraries])dnl
+])# _LT_ENABLE_CXX_STDLIB
+
+LT_OPTION_DEFINE([LT_INIT], [cxx-stdlib], [_LT_ENABLE_CXX_STDLIB([yes])])
+LT_OPTION_DEFINE([LT_INIT], [no-cxx-stdlib], [_LT_ENABLE_CXX_STDLIB([no])])
+
+
## ----------------- ##
## LTDL_INIT Options ##
## ----------------- ##
diff -Nru xz-utils-5.8.1/m4/ltsugar.m4 xz-utils-5.8.3/m4/ltsugar.m4
--- xz-utils-5.8.1/m4/ltsugar.m4 2025-04-03 11:35:14.000000000 +0000
+++ xz-utils-5.8.3/m4/ltsugar.m4 2026-03-31 15:27:09.000000000 +0000
@@ -1,6 +1,6 @@
# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*-
#
-# Copyright (C) 2004-2005, 2007-2008, 2011-2019, 2021-2024 Free Software
+# Copyright (C) 2004-2005, 2007-2008, 2011-2019, 2021-2025 Free Software
# Foundation, Inc.
# Written by Gary V. Vaughan, 2004
#
diff -Nru xz-utils-5.8.1/m4/ltversion.m4 xz-utils-5.8.3/m4/ltversion.m4
--- xz-utils-5.8.1/m4/ltversion.m4 2025-04-03 11:35:14.000000000 +0000
+++ xz-utils-5.8.3/m4/ltversion.m4 2026-03-31 15:27:09.000000000 +0000
@@ -1,6 +1,6 @@
# ltversion.m4 -- version numbers -*- Autoconf -*-
#
-# Copyright (C) 2004, 2011-2019, 2021-2024 Free Software Foundation,
+# Copyright (C) 2004, 2011-2019, 2021-2025 Free Software Foundation,
# Inc.
# Written by Scott James Remnant, 2004
#
@@ -10,15 +10,15 @@
# @configure_input@
-# serial 4442 ltversion.m4
+# serial 4509 ltversion.m4
# This file is part of GNU Libtool
-m4_define([LT_PACKAGE_VERSION], [2.5.4.1-baa1-dirty])
-m4_define([LT_PACKAGE_REVISION], [2.5.4.1])
+m4_define([LT_PACKAGE_VERSION], [2.6.0])
+m4_define([LT_PACKAGE_REVISION], [2.6.0])
AC_DEFUN([LTVERSION_VERSION],
-[macro_version='2.5.4.1-baa1-dirty'
-macro_revision='2.5.4.1'
+[macro_version='2.6.0'
+macro_revision='2.6.0'
_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
_LT_DECL(, macro_revision, 0)
])
diff -Nru xz-utils-5.8.1/m4/lt~obsolete.m4 xz-utils-5.8.3/m4/lt~obsolete.m4
--- xz-utils-5.8.1/m4/lt~obsolete.m4 2025-04-03 11:35:14.000000000 +0000
+++ xz-utils-5.8.3/m4/lt~obsolete.m4 2026-03-31 15:27:09.000000000 +0000
@@ -1,6 +1,6 @@
# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*-
#
-# Copyright (C) 2004-2005, 2007, 2009, 2011-2019, 2021-2024 Free
+# Copyright (C) 2004-2005, 2007, 2009, 2011-2019, 2021-2025 Free
# Software Foundation, Inc.
# Written by Scott James Remnant, 2004.
#
diff -Nru xz-utils-5.8.1/m4/tuklib_integer.m4 xz-utils-5.8.3/m4/tuklib_integer.m4
--- xz-utils-5.8.1/m4/tuklib_integer.m4 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/m4/tuklib_integer.m4 2026-03-31 15:27:00.000000000 +0000
@@ -62,6 +62,58 @@
fi
])
+# On archs that we use tuklib_integer_strict_align() (see below), we need
+# objdump to detect support for unaligned access. (Libtool needs objdump
+# too, so Libtool does this same tool check as well.)
+AC_CHECK_TOOL([OBJDUMP], [objdump], [false])
+
+# An internal helper that attempts to detect if -mstrict-align or
+# -mno-strict-align is in effect. This sets enable_unaligned_access=yes
+# if compilation succeeds and the regex passed as an argument does *not*
+# match the objdump output of a check program. Otherwise this sets
+# enable_unaligned_access=no.
+tuklib_integer_strict_align ()
+{
+ # First guess no.
+ enable_unaligned_access=no
+
+ # Force -O2 because without optimizations the memcpy()
+ # won't be optimized out.
+ tuklib_integer_saved_CFLAGS=$CFLAGS
+ CFLAGS="$CFLAGS -O2"
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
+ #include
+ unsigned int check_strict_align(const void *p)
+ {
+ unsigned int i;
+ memcpy(&i, p, sizeof(i));
+ return i;
+ }
+ ]])], [
+ # Disassemble the test function from the object file.
+ if $OBJDUMP -d conftest.$ac_objext > conftest.s ; then
+ # This function should be passed a regex that
+ # matches if there are instructions that load
+ # unsigned bytes. Such instructions indicate
+ # that -mstrict-align is in effect.
+ #
+ # NOTE: Use braces to avoid M4 parameter
+ # expansion.
+ if grep -- "${1}" conftest.s > /dev/null ; then
+ :
+ else
+ # No single-byte unsigned load
+ # instructions were found,
+ # so it seems that -mno-strict-align
+ # is in effect.
+ # Override our earlier guess.
+ enable_unaligned_access=yes
+ fi
+ fi
+ ])
+ CFLAGS=$tuklib_integer_saved_CFLAGS
+}
+
AC_MSG_CHECKING([if unaligned memory access should be used])
AC_ARG_ENABLE([unaligned-access], AS_HELP_STRING([--enable-unaligned-access],
[Enable if the system supports *fast* unaligned memory access
@@ -78,34 +130,90 @@
i?86|x86_64|powerpc|powerpc64|powerpc64le)
enable_unaligned_access=yes
;;
- arm*|aarch64*|riscv*)
- # On 32-bit and 64-bit ARM, GCC and Clang
- # #define __ARM_FEATURE_UNALIGNED if
- # unaligned access is supported.
- #
- # Exception: GCC at least up to 13.2.0
- # defines it even when using -mstrict-align
- # so in that case this autodetection goes wrong.
- # Most of the time -mstrict-align isn't used so it
- # shouldn't be a common problem in practice. See:
- # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111555
+ arm*|riscv*)
+ # On 32-bit ARM, GCC and Clang
+ # #define __ARM_FEATURE_UNALIGNED
+ # if and only if unaligned access is supported.
#
# RISC-V C API Specification says that if
# __riscv_misaligned_fast is defined then
# unaligned access is known to be fast.
#
# MSVC is handled as a special case: We assume that
- # 32/64-bit ARM supports fast unaligned access.
+ # 32-bit ARM supports fast unaligned access.
# If MSVC gets RISC-V support then this will assume
# fast unaligned access on RISC-V too.
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
-#if !defined(__ARM_FEATURE_UNALIGNED) \
- && !defined(__riscv_misaligned_fast) \
- && !defined(_MSC_VER)
-compile error
-#endif
-int main(void) { return 0; }
-])], [enable_unaligned_access=yes], [enable_unaligned_access=no])
+ #if !defined(__ARM_FEATURE_UNALIGNED) \
+ && !defined(__riscv_misaligned_fast) \
+ && !defined(_MSC_VER)
+ compile error
+ #endif
+ int main(void) { return 0; }
+ ])],
+ [enable_unaligned_access=yes],
+ [enable_unaligned_access=no])
+ ;;
+ aarch64*)
+ # On ARM64, Clang defines __ARM_FEATURE_UNALIGNED
+ # if and only if unaligned access is supported.
+ # However, GCC (at least up to 15.2.0) defines it
+ # even when using -mstrict-align, so autodetection
+ # with this macro doesn't work with GCC on ARM64.
+ # (It does work on 32-bit ARM.) See:
+ #
+ # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111555
+ #
+ # We need three checks:
+ #
+ # 1. If __ARM_FEATURE_UNALIGNED is defined and the
+ # compiler isn't GCC, unaligned access is enabled.
+ # If the compiler is MSVC, unaligned access is
+ # enabled even without __ARM_FEATURE_UNALIGNED.
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+ #if defined(__ARM_FEATURE_UNALIGNED) \
+ && (!defined(__GNUC__) \
+ || defined(__clang__))
+ #elif defined(_MSC_VER)
+ #else
+ compile error
+ #endif
+ int main(void) { return 0; }
+ ])], [enable_unaligned_access=yes])
+
+ # 2. If __ARM_FEATURE_UNALIGNED is not defined,
+ # unaligned access is disabled.
+ if test "x$enable_unaligned_access" = xauto ; then
+ AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+ #ifdef __ARM_FEATURE_UNALIGNED
+ compile error
+ #endif
+ int main(void) { return 0; }
+ ])], [enable_unaligned_access=no])
+ fi
+
+ # 3. Use heuristics to detect if -mstrict-align is
+ # in effect when building with GCC.
+ if test "x$enable_unaligned_access" = xauto ; then
+ [tuklib_integer_strict_align \
+ '[[:blank:]]ldrb[[:blank:]]']
+ fi
+ ;;
+ loongarch*)
+ # See sections 7.4, 8.1, and 8.2:
+ # https://github.com/loongson/la-softdev-convention/blob/v0.2/la-softdev-convention.adoc
+ #
+ # That is, desktop and server processors likely support
+ # unaligned access in hardware but embedded processors
+ # might not. GCC defaults to -mno-strict-align and so
+ # do majority of GNU/Linux distributions. As of
+ # GCC 15.2, there is no predefined macro to detect
+ # if -mstrict-align or -mno-strict-align is in effect.
+ # Use heuristics based on compiler output.
+ [
+ tuklib_integer_strict_align \
+ '[[:blank:]]ld\.bu[[:blank:]]'
+ ]
;;
*)
enable_unaligned_access=no
diff -Nru xz-utils-5.8.1/po/Makevars xz-utils-5.8.3/po/Makevars
--- xz-utils-5.8.1/po/Makevars 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/Makevars 2026-03-31 15:27:00.000000000 +0000
@@ -14,7 +14,7 @@
top_builddir = ..
# These options get passed to xgettext.
-XGETTEXT_OPTIONS = --add-location=file --no-wrap --keyword=_ --keyword=N_ '--keyword=W_:1,"This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care."'
+XGETTEXT_OPTIONS = --add-location=file --no-wrap --keyword=_ --keyword=N_ '--keyword=W_:1,"This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care."'
# This is the copyright holder that gets inserted into the header of the
# $(DOMAIN).pot file. Set this to the copyright holder of the surrounding
diff -Nru xz-utils-5.8.1/po/POTFILES.in xz-utils-5.8.3/po/POTFILES.in
--- xz-utils-5.8.1/po/POTFILES.in 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/POTFILES.in 2026-03-31 15:27:00.000000000 +0000
@@ -10,6 +10,7 @@
src/xz/message.c
src/xz/mytime.c
src/xz/options.c
+src/xz/sandbox.c
src/xz/signals.c
src/xz/suffix.c
src/xz/util.c
diff -Nru xz-utils-5.8.1/po/ca.po xz-utils-5.8.3/po/ca.po
--- xz-utils-5.8.1/po/ca.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/ca.po 2026-03-31 15:27:00.000000000 +0000
@@ -10,7 +10,7 @@
msgstr ""
"Project-Id-Version: xz 5.6.0-pre2\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2024-08-18 18:19+0300\n"
"Last-Translator: Jordi Mas i Hernàndez \n"
"Language-Team: Catalan \n"
@@ -688,7 +688,7 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -701,7 +701,7 @@
"Comprimeix o descomprimeix FITXERS en format .xz.\n"
"\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Mandatory arguments to long options are mandatory for short options too.\n"
@@ -710,38 +710,38 @@
"Els arguments obligatoris per a opcions llargues també són obligatoris\n"
"per a opcions curtes.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "Operation mode:"
msgstr " Mode d'operació:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "force compression"
msgstr "Descompressió:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "force decompression"
msgstr "Descompressió:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -752,29 +752,29 @@
"\n"
" Modificadors de l'operació:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Writing to standard output failed"
msgid "write to standard output and don't delete input files"
msgstr "Ha fallat l'escriptura a la sortida estàndard"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -785,7 +785,7 @@
" --single-stream descomprimeix només el primer flux, i silenciosament\n"
" ignora les possibles dades d'entrada restants"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr ""
@@ -794,7 +794,7 @@
msgid ".SUF"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr ""
@@ -803,17 +803,17 @@
msgid "FILE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -828,7 +828,7 @@
msgid "FORMAT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr ""
@@ -837,19 +837,19 @@
msgid "NAME"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --ignore-check don't verify the integrity check when decompressing"
msgid "don't verify the integrity check when decompressing"
msgstr " --ignore-check no verifiquis la comprovació d'integritat en descomprimir"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -861,7 +861,7 @@
" compte l'ús de memòria del compressor *i* del\n"
" descompressor abans d'utilitzar 7-9!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -879,7 +879,7 @@
msgid "NUM"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -894,7 +894,7 @@
msgid "SIZE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -912,7 +912,7 @@
msgid "BLOCKS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -929,7 +929,7 @@
" especifiqueu un número de cadena de filtres (0-9) seguit\n"
" d'un «:» abans de la mida de dades sense comprimir"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -948,13 +948,13 @@
msgid "LIMIT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -965,7 +965,7 @@
" --no-adjust si la configuració de compressió excedeix el límit d'ús\n"
" de memòria, dona error en lloc de reduir la configuració"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -981,7 +981,7 @@
msgid "FILTERS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -995,7 +995,7 @@
" de cadena de filtres del liblzma\n"
" Useu --filters-help per a més informació"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1009,7 +1009,7 @@
" la sintaxi de cadena del filtre liblzmava a usar amb\n"
" --block-list"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1030,7 +1030,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr ""
@@ -1042,12 +1042,12 @@
msgid "PRE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr ""
@@ -1056,17 +1056,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Number of processor threads:"
@@ -1077,89 +1077,89 @@
msgid "MODE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "compression mode"
msgstr "Descompressió:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1170,24 +1170,24 @@
"\n"
" Altres opcions:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -Q, --no-warn make warnings not affect the exit status"
msgid "make warnings not affect the exit status"
msgstr " -Q, --no-warn fes que els avisos no afectin l'estat de sortida"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --robot use machine-parsable messages (useful for scripts)"
@@ -1196,7 +1196,7 @@
" --robot usa missatges analitzables per la màquina\n"
" (útil per a scripts)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1207,34 +1207,34 @@
" --info-memory mostra la quantitat total de RAM i els límits actualment\n"
" actius d'ús de memòria, i surt"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -V, --version display the version number and exit"
msgid "display the version number and exit"
msgstr " -V, --version mostra el número de versió i surt"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
@@ -1249,7 +1249,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "Report bugs to <%s> (in English or Finnish).\n"
@@ -1258,19 +1258,19 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "%s home page: <%s>\n"
msgid "%s home page: <%s>"
msgstr "Pàgina inicial de %s: <%s>\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "AQUESTA ÉS UNA VERSIÓ DE DESENVOLUPAMENT NO DESTINADA A L'ÚS EN PRODUCCIÓ."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy, c-format
#| msgid ""
@@ -1285,7 +1285,7 @@
"es pot separar per espais o '--'. Alternativament pot ser un predefinit\n"
" <0-9>[e] especificat en comptes d'una cadena de filtres.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Els filtres admesos i les seves opcions són:"
@@ -1369,7 +1369,7 @@
"Ús: %s [--help] [--version] [FITXER]...\n"
"Mostra la informació emmagatzemada a la capçalera del fitxer .lzma"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
diff -Nru xz-utils-5.8.1/po/cs.po xz-utils-5.8.3/po/cs.po
--- xz-utils-5.8.1/po/cs.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/cs.po 2026-03-31 15:27:00.000000000 +0000
@@ -6,7 +6,7 @@
msgstr ""
"Project-Id-Version: xz-utils\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2010-12-03 11:32+0100\n"
"Last-Translator: Marek Černocký \n"
"Language-Team: Czech \n"
@@ -714,7 +714,7 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -727,45 +727,45 @@
"Komprimuje nebo dekomprimuje SOUBORy ve formátu xz.\n"
"\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Mandatory arguments to long options are mandatory for short options too.\n"
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Povinné argumenty pro dlouhé přepínače jsou povinné rovněž pro krátké přepínače.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "Operation mode:"
msgstr "Operační režim:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Memory usage limit for decompression: "
msgid "force compression"
msgstr "Omezení použitelné paměti pro dekomprimaci:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Memory usage limit for decompression: "
msgid "force decompression"
msgstr "Omezení použitelné paměti pro dekomprimaci:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -776,34 +776,34 @@
"\n"
"Modifikátory operací:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Writing to standard output failed"
msgid "write to standard output and don't delete input files"
msgstr "Zápis do standardního výstupu selhal"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr ""
@@ -812,7 +812,7 @@
msgid ".SUF"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr ""
@@ -821,17 +821,17 @@
msgid "FILE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -846,7 +846,7 @@
msgid "FORMAT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr ""
@@ -855,17 +855,17 @@
msgid "NAME"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -876,7 +876,7 @@
" -0 .. -9 přednastavení komprimace; výchozí je 6; než použijete\n"
" hodnoty 7 – 9, vezměte do úvahy množství použité paměti"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -893,7 +893,7 @@
msgid "NUM"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr ""
@@ -902,7 +902,7 @@
msgid "SIZE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr ""
@@ -911,12 +911,12 @@
msgid "BLOCKS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr ""
@@ -925,13 +925,13 @@
msgid "LIMIT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -942,7 +942,7 @@
" --no-adjust pokud nastavení komprimace přesáhne omezení použitelné\n"
" paměti, předat chybu namísto snížení nastavení"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -957,17 +957,17 @@
msgid "FILTERS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr ""
@@ -982,7 +982,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr ""
@@ -994,12 +994,12 @@
msgid "PRE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr ""
@@ -1008,17 +1008,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr ""
@@ -1027,89 +1027,89 @@
msgid "MODE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "compression mode"
msgstr "Operační režim:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1120,24 +1120,24 @@
"\n"
" Ostatní přepínače:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -Q, --no-warn make warnings not affect the exit status"
msgid "make warnings not affect the exit status"
msgstr " -Q, --no-warn způsobí, že varování neovlivní stav ukončení"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --robot use machine-parsable messages (useful for scripts)"
@@ -1146,7 +1146,7 @@
" --robot použít strojově analyzovatelné zprávy (užitečné pro\n"
" skripty)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1157,34 +1157,34 @@
" --info-memory zobrazit celkové množství paměti RAM a současné aktivní\n"
" omezení použitelné paměti a skončit"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -V, --version display the version number and exit"
msgid "display the version number and exit"
msgstr " -V, --version zobrazit číslo verze a skončit"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
@@ -1199,7 +1199,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "Report bugs to <%s> (in English or Finnish).\n"
@@ -1208,25 +1208,25 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "%s home page: <%s>\n"
msgid "%s home page: <%s>"
msgstr "Domovská stránka %s: <%s>\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Unsupported filter chain or filter options"
@@ -1311,7 +1311,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr ""
diff -Nru xz-utils-5.8.1/po/da.po xz-utils-5.8.3/po/da.po
--- xz-utils-5.8.1/po/da.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/da.po 2026-03-31 15:27:00.000000000 +0000
@@ -6,7 +6,7 @@
msgstr ""
"Project-Id-Version: xz 5.2.4\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2019-03-04 23:08+0100\n"
"Last-Translator: Joe Hansen \n"
"Language-Team: Danish \n"
@@ -716,12 +716,12 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Mandatory arguments to long options are mandatory for short options too.\n"
@@ -730,38 +730,38 @@
"Obligatoriske argumenter til lange tilvalg er også obligatoriske for korte\n"
"tilvalg.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "Operation mode:"
msgstr " Operationstilstand:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Memory usage limit for decompression: "
msgid "force compression"
msgstr "Grænse for hukommelsesforbug til dekomprimering: "
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Memory usage limit for decompression: "
msgid "force decompression"
msgstr "Grænse for hukommelsesforbug til dekomprimering: "
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -772,34 +772,34 @@
"\n"
"Operationsændrere:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Writing to standard output failed"
msgid "write to standard output and don't delete input files"
msgstr "Skrivning til standardud mislykkedes"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr ""
@@ -808,7 +808,7 @@
msgid ".SUF"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr ""
@@ -817,17 +817,17 @@
msgid "FILE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr ""
@@ -836,7 +836,7 @@
msgid "FORMAT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr ""
@@ -845,22 +845,22 @@
msgid "NAME"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr ""
@@ -871,7 +871,7 @@
msgid "NUM"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr ""
@@ -880,7 +880,7 @@
msgid "SIZE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr ""
@@ -889,12 +889,12 @@
msgid "BLOCKS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr ""
@@ -903,18 +903,18 @@
msgid "LIMIT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr ""
@@ -923,17 +923,17 @@
msgid "FILTERS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr ""
@@ -948,7 +948,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr ""
@@ -960,12 +960,12 @@
msgid "PRE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr ""
@@ -974,17 +974,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr ""
@@ -993,89 +993,89 @@
msgid "MODE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "compression mode"
msgstr " Operationstilstand:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1086,22 +1086,22 @@
"\n"
"Andre tilvalg:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --robot use machine-parsable messages (useful for scripts)"
@@ -1110,39 +1110,39 @@
" --robot brug beskeder der kan fortolkes maskinelt (nyttigt\n"
" for skripter)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -V, --version display the version number and exit"
msgid "display the version number and exit"
msgstr " -V, --version vis versionsnummer og afslut"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
@@ -1157,7 +1157,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "Report bugs to <%s> (in English or Finnish).\n"
@@ -1168,25 +1168,25 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "%s home page: <%s>\n"
msgid "%s home page: <%s>"
msgstr "%s hjemmeside: <%s>\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "DETTE ER EN UDVIKLINGSVERSION - BRUG IKKE I PRODUKTION."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Unsupported filter chain or filter options"
@@ -1271,7 +1271,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr ""
diff -Nru xz-utils-5.8.1/po/de.po xz-utils-5.8.3/po/de.po
--- xz-utils-5.8.1/po/de.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/de.po 2026-03-31 15:27:00.000000000 +0000
@@ -9,7 +9,7 @@
msgstr ""
"Project-Id-Version: xz 5.7.1-dev1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-01-26 11:02+0100\n"
"Last-Translator: Mario Blättermann \n"
"Language-Team: German \n"
@@ -682,74 +682,74 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Aufruf: %s [OPTION] … [DATEI] …\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Komprimiert oder dekomprimiert .xz-DATEI(EN)."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr ""
"Obligatorische Argumente für lange Optionen sind auch für kurze Optionen\n"
"zwingend."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "Aktionsmodus:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "Kompression erzwingen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "Dekompression erzwingen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "Integrität der komprimierten Datei überprüfen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "Informationen zu .xz-Dateien auflisten"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Aktionsmodifikatoren:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "Eingabedateien beibehalten (nicht löschen)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "Überschreiben der Ausgabedatei erzwingen und Links (de)komprimieren"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "In die Standardausgabe schreiben und die Eingabedateien nicht löschen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "Ausgabedatei nicht auf dem Speichergerät synchronisieren, bevor die Eingabedatei gelöscht wird"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "Nur den ersten Datenstrom dekomprimieren und stillschweigend mögliche weitere Eingabedaten ignorieren"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "Beim Dekomprimieren keine Sparse-Dateien erzeugen"
@@ -758,7 +758,7 @@
msgid ".SUF"
msgstr ".END"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "».END« als Endung für komprimierte Dateien benutzen"
@@ -767,17 +767,17 @@
msgid "FILE"
msgstr "DATEI"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "Zu verarbeitende Dateinamen aus DATEI lesen; falls keine DATEI angegeben wurde, werden Dateinamen aus der Standardeingabe gelesen. Dateinamen müssen durch einen Zeilenumbruch voneinander getrennt werden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "Wie --files, aber das Null-Zeichen wird als Trenner benutzt"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Grundlegende Optionen für Dateiformat und Kompression:"
@@ -786,7 +786,7 @@
msgid "FORMAT"
msgstr "FORMAT"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "Dateiformat zur Kodierung oder Dekodierung; mögliche Werte sind »auto« (Voreinstellung), »xz«, »lzma«, »lzip« und »raw«"
@@ -795,22 +795,22 @@
msgid "NAME"
msgstr "NAME"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "Typ der Integritätsprüfung: »none« (Vorsicht!), »crc32«, »crc64« (Voreinstellung) oder »sha256«"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "Integritätsprüfung beim Dekomprimieren nicht ausführen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "Kompressionseinstellung; Voreinstellung ist 6. Beachten Sie den Speicherbedarf des Kompressors *und* des Dekompressors, wenn Sie 7-9 benutzen!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "Versuchen, durch stärkere CPU-Auslastung das Kompressionsverhältnis zu verbessern. Dies beeinflusst nicht den Speicherbedarf des Dekompressors."
@@ -821,7 +821,7 @@
msgid "NUM"
msgstr "ANZAHL"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "Höchstens die angegebene ANZAHL Threads erzeugen; die Voreinstellung ist 0, wobei so viele Threads erzeugt werden, wie Prozessorkerne vorhanden sind"
@@ -830,7 +830,7 @@
msgid "SIZE"
msgstr "GRÖẞE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "Einen neuen .xz-Block nach der angegebenen GRÖẞE der Eingabe in Bytes beginnen; benutzen Sie diese Option, um die Blockgröße für die Kompression mit mehreren Threads zu setzen"
@@ -839,12 +839,12 @@
msgid "BLOCKS"
msgstr "BLÖCKE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "Einen neuen .xz-Block gemäß der angegebenen, durch Kommata getrennten Intervalle an unkomprimierten Daten beginnen; optional kann eine Filterkettennummer (0-9) angegeben werden, gefolgt von einem »:« und der unkomprimierten Datengröße"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "Wenn beim Komprimieren mehr als die angegebene ANZAHL an Millisekunden seit der letzten Leerungsaktion vergangen ist und das Lesen von zusätzlichen Eingabedaten den Prozess blockieren würde, dann werden alle noch ausstehenden Daten geschrieben"
@@ -853,18 +853,18 @@
msgid "LIMIT"
msgstr "BEGRENZUNG"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "Speicherbedarfsbegrenzung für Kompression, Dekompression oder beides setzen; die BEGRENZUNG wird in Bytes oder als Prozentsatz RAM angegeben. Geben Sie 0 an, um die Grundeinstellungen zu verwenden."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "Wenn die Kompressionseinstellungen die Speicherbedarfsbegrenzung übersteigen, wird ein Fehler ausgegeben, statt die Einstellungen nach unten anzupassen."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Benutzerdefinierte Filterkette für Kompression (alternativ zur Verwendung von Voreinstellungen):"
@@ -873,17 +873,17 @@
msgid "FILTERS"
msgstr "FILTER"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "Die Filterkette anhand der Liblzma-Filterkettensyntax setzen; mit --filters-help erhalten Sie weitere Informationen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "Zusätzliche Filter anhand der Liblzma-Filterkettensyntax setzen, die mit --block-list verwendet werden sollen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "Weitere Informationen über die Liblzma-Filterkettensyntax anzeigen und beenden."
@@ -898,7 +898,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 oder LZMA2; OPTIONEN ist eine durch Kommata getrennte Liste bestehend aus den folgenden Optionen (zulässige Werte; Voreinstellung):"
@@ -910,12 +910,12 @@
msgid "PRE"
msgstr "ZAHL"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "Optionen auf Voreinstellungsstufe zurücksetzen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "Wörterbuchgröße"
@@ -924,17 +924,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "Anzahl der Literal-Kontext-Bits"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "Anzahl der Literal-Positions-Bits"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "Anzahl der Positions-Bits"
@@ -943,142 +943,142 @@
msgid "MODE"
msgstr "MODUS"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "Kompressionsmodus"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "Nice-Länge eines Treffers"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "Algorithmus zum Auffinden von Übereinstimmungen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "Maximale Suchtiefe; 0=automatisch (Voreinstellung)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "x86 BCJ-Filter (32-bit und 64-bit)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "ARM-BCJ-Filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "ARM-Thumb-BCJ-Filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "ARM64-BCJ-Filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "PowerPC-BCJ-Filter (nur Big Endian)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "IA64-(Itanium-)BCJ-Filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "SPARC-BCJ-Filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "RISC-V-BCJ-Filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "Zulässige Optionen für alle BCJ-Filter:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "Startversatz für Konversion (Voreinstellung=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Delta-Filter; zulässige Optionen (gültige Werte; Voreinstellung):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "Abstand zwischen den Bytes, die voneinander subtrahiert werden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Andere Optionen:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "Warnungen unterdrücken; wird diese Option zweimal angegeben, werden auch Fehlermeldungen unterdrückt"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "Ausführlicher Modus; wird diese Option zweimal angegeben, erfolgen noch ausführlichere Ausgaben"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "Warnungen verändern nicht den Exit-Status"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "Maschinenlesbare Meldungen ausgeben (nützlich für Skripte)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "Gesamtspeicher (RAM) sowie die gegenwärtig aktive Speicherbedarfsbegrenzung anzeigen und das Programm beenden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "Kurze Hilfe anzeigen (zeigt nur die grundlegenden Optionen)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "Diese lange Hilfe anzeigen und das Programm beenden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "Diese kurze Hilfe anzeigen und das Programm beenden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "Die lange Hilfe (und damit auch fortgeschrittene Optionen) anzeigen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "Versionsnummer anzeigen und beenden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Wenn DATEI nicht angegeben wurde oder DATEI gleich - ist, dann wird aus der Standardeingabe gelesen."
@@ -1087,7 +1087,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1095,24 +1095,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "%s-Homepage: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "DIES IST EINE NICHT FÜR DEN PRODUKTIVBETRIEB GEEIGNETE ENTWICKLERVERSION."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "Filterketten werden durch Setzen der Optionen --filters=FILTER oder --filters1=FILTER … --filters9=FILTER definiert. Die Filter können innerhalb der Kette durch Leerzeichen oder »--« getrennt werden. Alternativ kann eine Voreinstellung %s anstelle einer Filterkette verwendet werden."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Folgende Filterkettem und Filteroptionen werden unterstützt:"
@@ -1185,7 +1185,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Aufruf: %s [--help] [--version] [DATEI] …\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Im .lzma-Dateikopf gespeicherte Informationen anzeigen."
diff -Nru xz-utils-5.8.1/po/eo.po xz-utils-5.8.3/po/eo.po
--- xz-utils-5.8.1/po/eo.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/eo.po 2026-03-31 15:27:00.000000000 +0000
@@ -8,7 +8,7 @@
msgstr ""
"Project-Id-Version: xz 5.6.0-pre2\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2024-02-24 00:16-0500\n"
"Last-Translator: Keith Bowes \n"
"Language-Team: Esperanto \n"
@@ -686,7 +686,7 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -699,7 +699,7 @@
"Kunpremi aŭ malkunpremi DOSIEROjN laŭ la .xz-formato.\n"
"\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Mandatory arguments to long options are mandatory for short options too.\n"
@@ -708,38 +708,38 @@
"Devigitaj parametroj por longaj elektoj estas ankaŭ devigitaj por\n"
"mallongaj elektoj.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "Operation mode:"
msgstr " Operacia reĝimo:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "force compression"
msgstr "Malkunmpreno:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "force decompression"
msgstr "Malkunmpreno:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -750,29 +750,29 @@
"\n"
" Operacia modifiloj:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Writing to standard output failed"
msgid "write to standard output and don't delete input files"
msgstr "Skribi al la ĉefeligujo malsukcesis"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -784,7 +784,7 @@
" malkunpremi nur la unuan fluon kaj silente\n"
" ignori eventualajn ceterajn enigajn datumojn"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr ""
@@ -793,7 +793,7 @@
msgid ".SUF"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr ""
@@ -802,17 +802,17 @@
msgid "FILE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -827,7 +827,7 @@
msgid "FORMAT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr ""
@@ -836,19 +836,19 @@
msgid "NAME"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --ignore-check don't verify the integrity check when decompressing"
msgid "don't verify the integrity check when decompressing"
msgstr " --ignore-check ne certigi la integran kontrolon dum malkunpremo"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -859,7 +859,7 @@
" -0 ... -9 kunpremnivelo; apriore 6; pripensu memoruzadon antaŭ ol\n"
" uzi la nivelojn 7-9!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -877,7 +877,7 @@
msgid "NUM"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -893,7 +893,7 @@
msgid "SIZE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -910,7 +910,7 @@
msgid "BLOCKS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -927,7 +927,7 @@
" specifi numero (0-9) de filtrila ĉeno kaj poste ':' antaŭ\n"
" la malkunpremita datuma grando"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -946,13 +946,13 @@
msgid "LIMIT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -963,7 +963,7 @@
" --no-adjust se kunprema agordo superas la memoruzadan limigon\n"
" montri eraron anstataŭ malgrandigi la agordaĵon"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -978,7 +978,7 @@
msgid "FILTERS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -991,7 +991,7 @@
" --filters=FILTRILOJ agordi la filtrilan ĉenan uzanta la sintakso de la\n"
" lzma-filtrila ĉeno. --filters-help or pliaj informoj"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1004,7 +1004,7 @@
" agordi aldonajn filtrilajn ĉenojn por uzi kun\n"
" --block-list per la sintakso de liblzma-filtrila ĉeno"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1025,7 +1025,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr ""
@@ -1037,12 +1037,12 @@
msgid "PRE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr ""
@@ -1051,17 +1051,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Number of processor threads:"
@@ -1072,89 +1072,89 @@
msgid "MODE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "compression mode"
msgstr "Malkunmpreno:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1165,31 +1165,31 @@
"\n"
" Aliaj elektoj:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -Q, --no-warn make warnings not affect the exit status"
msgid "make warnings not affect the exit status"
msgstr " -Q, --no-warn avertoj ne influu la eliran staton"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --robot use machine-parsable messages (useful for scripts)"
msgid "use machine-parsable messages (useful for scripts)"
msgstr " --robot uzi mesaĝojn facile analizeblaj per skriptoj"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1200,34 +1200,34 @@
" --info-memory montri la totalan kiomon de la ĉefmemoro kaj la nune\n"
" aktivaj memoruzadaj limigoj, kaj finiĝi"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -V, --version display the version number and exit"
msgid "display the version number and exit"
msgstr " -V, --version montri la eldonan numeron kaj finiĝi"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
@@ -1242,7 +1242,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "Report bugs to <%s> (in English or Finnish).\n"
@@ -1251,19 +1251,19 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "%s home page: <%s>\n"
msgid "%s home page: <%s>"
msgstr "%s ĉefpaĝo: <%s>\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "ĈI TIU ESTAS DISVOLVA REDAKCIO, NE CELATA POR ĈIUTAGA UZADO."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy, c-format
#| msgid ""
@@ -1278,7 +1278,7 @@
"estas apartigebla per spacetoj aŭ '--'. Alternative antaŭargordo <0-9>[e]\n"
"anstataŭ filtrila ĉeno estas specifebla.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "La komprenataj filtriloj aŭ filtrilaj elektoj estas:"
@@ -1362,7 +1362,7 @@
"Uzmaniero: %s [--help] [--version] [DOSIERO]...\n"
"Montri informojn konservitaj en la .lzma-dosiera ĉapo"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
Binary files /srv/release.debian.org/tmp/12pItju0Xe/xz-utils-5.8.1/po/es.gmo and /srv/release.debian.org/tmp/TeSVVlQ6nq/xz-utils-5.8.3/po/es.gmo differ
diff -Nru xz-utils-5.8.1/po/es.po xz-utils-5.8.3/po/es.po
--- xz-utils-5.8.1/po/es.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/es.po 2026-03-31 15:27:00.000000000 +0000
@@ -1,16 +1,16 @@
# SPDX-License-Identifier: 0BSD
#
-# Spanish translation for xz-5.7.1-dev1.
+# Spanish translation for xz-5.8.0-pre1.
# Copyright (C) 2024, 2025 The XZ Utils authors and contributors
# This file is published under the BSD Zero Clause License.
# Cristian Othón Martínez Vera , 2022, 2023, 2024, 2025.
#
msgid ""
msgstr ""
-"Project-Id-Version: xz 5.7.1-dev1\n"
+"Project-Id-Version: xz 5.8.0-pre1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
-"PO-Revision-Date: 2025-01-24 09:25-0600\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
+"PO-Revision-Date: 2025-05-14 14:23-0600\n"
"Last-Translator: Cristian Othón Martínez Vera \n"
"Language-Team: Spanish \n"
"Language: es\n"
@@ -681,72 +681,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Uso: %s [OPCIÓN]... [FICHERO]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Comprime o descomprime FICHEROs en el formato .xz."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Los argumentos obligatorios para las opciones largas también son obligatorios para las opciones cortas."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "Modo de operación:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "fuerza la compresión"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "fuerza la descompresión"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "prueba la integridad del fichero comprimido"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "muestra la información acerca de los ficheros .xz"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Modificadores de operación:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "conserva (no borra) los ficheros de entrada"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "fuerza la sobreescritura del fichero de salida y (des)comprime enlaces"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "escribe a la salida estándar y no borra los ficheros de entrada"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "no sincroniza el fichero de salida con el dispositivo de almacenamiento antes de borrar el fichero de entrada"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "solo descomprime el primer flujo, y descarta silenciosamente los posibles datos de entrada restantes"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "no crea archivos temporales al descomprimir"
@@ -755,7 +755,7 @@
msgid ".SUF"
msgstr ".SUF"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "usa el sufijo '.SUF' para los ficheros comprimidos"
@@ -764,17 +764,17 @@
msgid "FILE"
msgstr "FICHERO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "lee los nombres de fichero a procesar del FICHERO; si se omite el FICHERO, los nombres de fichero se leen de la entrada estándar; los nombres de fichero deber de terminar con el carácter de línea nueva"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "como --files pero usa el carácter nulo como terminador"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Opciones básicas de compresión y formato de fichero:"
@@ -783,7 +783,7 @@
msgid "FORMAT"
msgstr "FORMATO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "formato de fichero para codificar o decodificar; los valores posibles son 'auto' (por defecto), 'xz', 'lzma', 'lzip', y 'raw'"
@@ -792,22 +792,22 @@
msgid "NAME"
msgstr "NOMBRE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "tipo de verificación de integridad: 'none' (usar con cuidado), 'crc32', 'crc64' (por defecto), o 'sha256'"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "no hace la verificación de integridad al descomprimir"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "valor predefinido de compresión; por defecto es 6. ¡Considere el compresor *y* el uso de memoria del compresor antes de usar 7-9!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "trata de mejorar la razón de compresión usando más tiempo de procesamiento; no afecta los requisitos de memoria del descompresor"
@@ -818,7 +818,7 @@
msgid "NUM"
msgstr "NÚM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "usa como máximo NÚM hilos; por defecto es 0, el cual usa tantos hilos como hayan núcleos de procesador"
@@ -827,7 +827,7 @@
msgid "SIZE"
msgstr "TAMAÑO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "inicia un nuevo bloque .xz después de cada TAMAÑO bytes de entrada; use esta opción para establecer el tamaño de bloque para la compresión con hilos"
@@ -836,12 +836,12 @@
msgid "BLOCKS"
msgstr "BLOQUES"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "inicia un nuevo bloque .xz después de cada intervalo dado, separado por comas, de datos sin comprimir; opcionalmente, especifica un número de cadena de filtros (0-9) a continuación de ':' antes del tamaño de los datos sin comprimir"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "al comprimir, si pasaron más de NÚM milisegundos desde el último descarte y la lectura de más entrada produciría un bloqueo, todos los datos pendientes son descartados"
@@ -850,18 +850,18 @@
msgid "LIMIT"
msgstr "LÍMITE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "define el límite de uso de memoria para compresión, descompresión, descompresión con hilos, o todos los anteriores; el LÍMITE es en bytes, % de RAM, o 0 para valores por defecto"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "si la configuración de compresión excede el límite de uso de memoria, muestra un error en lugar de ajustar los valores hacia abajo"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Cadena de filtros personal para compresión (alternativa a usar valores predefinidos):"
@@ -870,17 +870,17 @@
msgid "FILTERS"
msgstr "FILTROS"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "define la cadena de filtros usando la sintaxis de la cadena de filtros liblzma; use --filters-help para obtener más información"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "define cadenas de filtros adicionales usando la sintaxis de cadena de filtros liblzma para usar con --block-list"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "muestra más información acerca de la sintaxis de cadenas de filtros liblzma y termina"
@@ -895,7 +895,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 o LZMA2: OPCS es una lista separada por comas de cero o más de las siguientes opciones (valores válidos; por defecto):"
@@ -907,12 +907,12 @@
msgid "PRE"
msgstr "PRE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "cambia las opciones al valor predefinido"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "tamaño de diccionario"
@@ -921,17 +921,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "número de bits de contexto literal"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "número de bits de posición literal"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "número de bits de posición"
@@ -940,142 +940,142 @@
msgid "MODE"
msgstr "MODO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "modo de descompresión"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "longitud aceptada de una coincidencia"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "buscador de coincidencias"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "profundidad máxima de búsqueda; 0=automática (por defecto)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "filtro BCJ de x86 (32-bit y 64-bit)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "filtro BCJ de ARM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "filtro BCJ de ARM-Thumb"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "filtro BCJ de ARM64"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "filtro BCJ de PowerPC (sólo big endian)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "filtro BCJ de IA-64 (Itanium)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "filtro BCJ de Sparc"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "filtro BCJ de RISC-V"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "OPCS válidas para todos los filtros BCJ:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "desplazamiento de inicio para las conversiones (por defecto=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Delta de filtro; OPCS válidas (valores válidos; por defecto):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "distancia entre bytes que se restan unos de otros"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Otras opciones:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "suprime los avisos; especificar dos veces para suprimir también los errores"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "descriptivo; especificar dos veces para ser aún más descriptivo"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "los avisos no afectan el estado de la salida"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "usa mensajes analizables por máquina (útil para scripts)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "muestra la cantidad total de RAM y los límites de uso de memoria activos, y termina"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "muestra la ayuda corta (sólo muestra las opciones básicas)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "muestra esta ayuda larga y termina"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "muestra esta ayuda corta y termina"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "muestra la ayuda larga (también muestra las opciones avanzadas)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "muestra el número de versión y termina"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Sin FICHEROs, o cuando el FICHERO es -, lee la entrada estándar."
@@ -1084,7 +1084,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1094,24 +1094,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "Sitio web de %s: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "ESTA ES UNA VERSIÓN EN DESARROLLO Y NO ESTÁ LISTA PARA USO EN PRODUCCIÓN."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "Las cadenas de filtros se definen usando las opciones --filters=FILTROS o --filters1=FILTROS ... --filters9=FILTROS. Cada filtro en la cadena se puede separar con espacios o '--'. Alternativamente, se puede especificar un valor predeterminado %s en lugar de una cadena de filtro."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Los filtros admitidos y sus opciones son:"
@@ -1169,7 +1169,7 @@
#: src/xz/util.c
#, c-format
msgid "Value of the option '%s' must be in the range [%, %]"
-msgstr "El valor de la opción '%s' debe estar en el rango [%, %]"
+msgstr "El valor de la opción '%s' debe estar en el intervalo [%, %]"
#: src/xz/util.c
msgid "Compressed data cannot be read from a terminal"
@@ -1184,7 +1184,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Uso: %s [--help] [--version] [FICHERO]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Muestra información almacenada en la cabecera del fichero .lzma"
@@ -1223,7 +1223,7 @@
#: src/liblzma/common/string_conversion.c
msgid "Value out of range"
-msgstr "Valor fuera de rango"
+msgstr "Valor fuera de intervalo"
#: src/liblzma/common/string_conversion.c
msgid "This option does not support any multiplier suffixes"
diff -Nru xz-utils-5.8.1/po/fi.po xz-utils-5.8.3/po/fi.po
--- xz-utils-5.8.1/po/fi.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/fi.po 2026-03-31 15:27:00.000000000 +0000
@@ -9,7 +9,7 @@
msgstr ""
"Project-Id-Version: xz 5.7.1-dev1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-01-29 21:57+0200\n"
"Last-Translator: Lauri Nurmi \n"
"Language-Team: Finnish \n"
@@ -682,72 +682,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Käyttö: %s [VALITSIN]... [TIEDOSTO]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Tiivistä tai pura .xz-muotoisia TIEDOSTOja."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Pitkien valitsinten pakolliset argumentit ovat pakollisia myös lyhyille."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr " Toimintatila:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "pakota tiivistys"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "pakota purku"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "testaa tiivistetyn tiedoston eheys"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "näytä tietoa .xz-tiedostoista"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Toimintomääreet:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "säilytä syötetiedostot (älä poista)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "pakota tulostiedostojen ylikirjoitus ja pura/tiivistä linkit"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "kirjoita vakiotulosteeseen äläkä poista syötetiedostoja"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "älä synkronoi tulostiedostoa tallennuslaitteelle ennen syötetiedoston poistamista"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "pura vain ensimmäinen virta, ja ohita hiljaisesti mahdollinen jäljellä oleva syötedata"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "älä luo hajanaisia tiedostoja purettaessa"
@@ -756,7 +756,7 @@
msgid ".SUF"
msgstr ".PÄÄTE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "käytä ”.PÄÄTE”-päätettä tiivistetyille tiedostoille"
@@ -765,17 +765,17 @@
msgid "FILE"
msgstr "TIED"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "lue käsiteltävät tiedostonimet TIEDostosta; jos TIED jätetään antamatta, tiedostonimet luetaan vakiosyötteestä; tiedostonimet on päätettävä rivinvaihtomerkillä"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "kuten --files mutta käytä päättämiseen nul-merkkiä"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Tiedostomuodon ja tiivistyksen perusasetukset:"
@@ -784,7 +784,7 @@
msgid "FORMAT"
msgstr "MUOTO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "tuotettava tai luettava tiedostomuoto; vaihtoehdot ovat ”auto” (oletus), ”xz”, ”lzma”, ”lzip” ja ”raw”"
@@ -793,22 +793,22 @@
msgid "NAME"
msgstr "NIMI"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "eheystarkastuksen tyyppi: ”none” (käytä varoen), ”crc32”, ”crc64” (oletus) tai ”sha256”"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "älä suorita eheystarkastusta purettaessa"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "tiivistyksen esiasetus; oletus on 6; ota tiivistyksen *ja* purun muistinkäyttö huomioon ennen arvojen 7–9 käyttämistä!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "yritä parantaa tiivistyssuhdetta käyttämällä enemmän suoritinaikaa; ei vaikuta purkimen muistivaatimuksiin"
@@ -819,7 +819,7 @@
msgid "NUM"
msgstr "MÄÄRÄ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "käytä enintään MÄÄRÄä säiettä; oletus on 0, jolloin käytetään suoritinytimien määrän verran säikeitä"
@@ -828,7 +828,7 @@
msgid "SIZE"
msgstr "KOKO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "aloita uusi .xz-lohko aina KOKO syötetavun jälkeen; käytä tätä säikeistetyn tiivistyksen lohkokoon asettamiseen"
@@ -837,13 +837,13 @@
msgid "BLOCKS"
msgstr "LOHKOT"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "aloita uusi .xz-lohko pilkuin erotettujen tiivistämättömän datan välien jälkeen; vaihtoehtoisesti anna suodatinketjun numeron (0–9) ja sen jälkeen ”:” ennen tiivistämättömän datan kokoa"
# to block: salpautua? kuulostaako hyvältä?
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "jos tiivistettäessä on kulunut yli MÄÄRÄ ms edellisestä huuhtomisesta ja syötteen lukemisen jatkaminen salpautuisi, kaikki odottava data huuhdellaan"
@@ -852,18 +852,18 @@
msgid "LIMIT"
msgstr "RAJA"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "aseta muistinkäytön raja tiivistykselle, purkamiselle, säikeistetylle purkamisella tai näille kaikille; RAJA on tavuja, %-osuus RAM-muistista tai 0 oletusarvoille"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "jos tiivistysasetukset ylittävät muistinkäytön rajan, anna virhe äläkä pudota asetuksia alaspäin"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Mukautettu suodinketju tiivistykselle (vaihtoehto esiasetuksille):"
@@ -872,17 +872,17 @@
msgid "FILTERS"
msgstr "SUOTIMET"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "aseta suodinketju käyttäen libzma:n suodinsyntaksia; lisätietoja valitsimella --filters-help"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "aseta lisäsuodinketjuja käyttäen libzma:n suodinsyntaksia --block-list:in kanssa käytettäväksi"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "näytä lisätietoa liblzma:n suodinsyntaksista ja poistu"
@@ -897,7 +897,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 tai LZMA2; ASET on pilkuilla erotettu lista nollasta tai useammasta seuraavasta asetuksesta (kelvolliset arvot; oletus):"
@@ -909,12 +909,12 @@
msgid "PRE"
msgstr "ESI"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "palauta asetukset esiasetukseen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "sanaston koko"
@@ -923,17 +923,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "literaalien kontekstibittien määrä"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "literaalien sijaintibittien määrä"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "sijaintibittien määrä"
@@ -942,142 +942,142 @@
msgid "MODE"
msgstr "TILA"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "tiivistystila"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "täsmäävyyden kiva pituus"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "täsmäävyydenetsin"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "enimmäishakusyvyys; 0=automaattinen (oletus)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "x86 BCJ -suodin (32- ja 64-bittinen)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "ARM BCJ -suodin"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "ARM-Thumb BJC -suodin"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "ARM64 BCJ -suodin"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "PowerPC BCJ -suodin (vain big endian)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "IA-64 (Itanium) BCJ -suodin"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "SPARC BCJ -suodin"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "RISC-V BCJ -suodin"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "Kelvolliset ASETukset kaikille BJC-suotimille:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "muunnosten aloitussiirtymä (oletus=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Delta-suodin; kelvolliset ASETukset (kelvolliset arvot; oletus):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "toisistaan vähennettävien tavujen välinen etäisyys"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Muut asetukset:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "vaienna varoitukset; kahdesti antamalla myös virheet"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "ole lavea; kahdesti antamalla vieläkin laveampi"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "älkööt varoitukset vaikuttako paluuarvoon"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "käytä koneluettavia viestejä (sopii skripteihin)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "näytä RAM-muistin kokonaismäärä sekä parhaillaan vallitsevat muistinkäytön rajat, ja poistu"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "näytä lyhyt ohje (kertoo vain perusasetukset)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "näytä tämä pitkä ohje ja poistu"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "näytä tämä lyhyt ohje ja poistu"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "näytä pitkä ohje (kertoo myös lisäasetukset)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "näytä versionumero ja poistu"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Jos TIEDOSTOa ei ole annettu, tai se on -, luetaan vakiosyötettä."
@@ -1086,7 +1086,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1094,24 +1094,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "%s -kotisivu: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "TÄMÄ ON KEHITYSVERSIO, JOTA EI OLE TARKOITETTU TUOTANTOKÄYTTÖÖN."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "Suodinketjut asetetaan käyttämällä valitsinta --filters=SUOTIMET tai --filters1=SUOTIMET ... --filters9=SUOTIMET. Kukin ketjun suodin voidaan erottaa välilyönneillä tai ”--”:lla. Vaihtoehtoisesti suodinketjun sijaan voidaan antaa esiasetus %s."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Tuetut suotimet ja niiden asetukset ovat:"
@@ -1184,7 +1184,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Käyttö: %s [--help] [--version] [TIEDOSTO]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Näytä .lzma-tiedosto-otsakkeeseen tallennettu tieto."
diff -Nru xz-utils-5.8.1/po/fr.po xz-utils-5.8.3/po/fr.po
--- xz-utils-5.8.1/po/fr.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/fr.po 2026-03-31 15:27:00.000000000 +0000
@@ -7,7 +7,7 @@
msgstr ""
"Project-Id-Version: xz-5.4.4-pre1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2023-12-19 04:12+0100\n"
"Last-Translator: Stéphane Aulery \n"
"Language-Team: French \n"
@@ -716,7 +716,7 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -729,7 +729,7 @@
"Compresse ou decompresse FICHIER(s) au format .xz.\n"
"\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Mandatory arguments to long options are mandatory for short options too.\n"
@@ -738,36 +738,36 @@
"Les arguments obligatoires pour les options longues le sont aussi pour les\n"
"options courtes.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "Operation mode:"
msgstr " Mode d'opération :\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
msgid "force compression"
msgstr "Limite d'utilisation pour la décompression : "
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
msgid "force decompression"
msgstr "Limite d'utilisation pour la décompression : "
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -778,29 +778,29 @@
"\n"
" Modificateurs :\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Writing to standard output failed"
msgid "write to standard output and don't delete input files"
msgstr "Impossible d'écrire vers la sortie standard"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -811,7 +811,7 @@
" --single-stream décompresser uniquement le premier flux et ignorer\n"
" silencieusement les données éventuellement restantes"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr ""
@@ -820,7 +820,7 @@
msgid ".SUF"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr ""
@@ -829,17 +829,17 @@
msgid "FILE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -854,7 +854,7 @@
msgid "FORMAT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr ""
@@ -863,12 +863,12 @@
msgid "NAME"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --ignore-check don't verify the integrity check when decompressing"
@@ -877,7 +877,7 @@
" --ignore-check ne pas vérifier l'intégrité des données lors de\n"
" la décompression"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -889,7 +889,7 @@
" l'utilisation mémoire du compresseur *et* du décompresseur\n"
" avant d'utiliser 7, 8 ou 9 !"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -907,7 +907,7 @@
msgid "NUM"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -923,7 +923,7 @@
msgid "SIZE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -940,7 +940,7 @@
msgid "BLOCKS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -953,7 +953,7 @@
" débuter des blocs XZ après les TAILLES octets de données\n"
" spécifiées avec des virgules pour séparateur"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -972,13 +972,13 @@
msgid "LIMIT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -990,7 +990,7 @@
" d'utilisation mémoire, renvoyer une erreur plutôt que de\n"
" diminuer les réglages"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1005,17 +1005,17 @@
msgid "FILTERS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr ""
@@ -1030,7 +1030,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr ""
@@ -1042,12 +1042,12 @@
msgid "PRE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr ""
@@ -1056,17 +1056,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr ""
@@ -1075,89 +1075,89 @@
msgid "MODE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "compression mode"
msgstr " Mode d'opération :\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1168,24 +1168,24 @@
"\n"
" Autres options :\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -Q, --no-warn make warnings not affect the exit status"
msgid "make warnings not affect the exit status"
msgstr " -Q, --no-warn les avertissements ne modifient pas le code de sortie"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --robot use machine-parsable messages (useful for scripts)"
@@ -1194,7 +1194,7 @@
" --robot utiliser des messages lisibles par un programme\n"
" (utile pour les scripts)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1205,34 +1205,34 @@
" --info-memory afficher la quantité totale de RAM ainsi que la limite\n"
" actuelle d'utilisation mémoire puis quitter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -V, --version display the version number and exit"
msgid "display the version number and exit"
msgstr " -V, --version afficher le numéro de version puis quitter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
@@ -1247,7 +1247,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "Report bugs to <%s> (in English or Finnish).\n"
@@ -1258,25 +1258,25 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "%s home page: <%s>\n"
msgid "%s home page: <%s>"
msgstr "Page du projet %s : <%s>\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "CECI EST UNE VERSION DE DEVELOPPEMENT QUI NE DOIT PAS ÊTRE UTILISEE EN PRODUCTION."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Unsupported filter chain or filter options"
@@ -1361,7 +1361,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr ""
diff -Nru xz-utils-5.8.1/po/hr.po xz-utils-5.8.3/po/hr.po
--- xz-utils-5.8.1/po/hr.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/hr.po 2026-03-31 15:27:00.000000000 +0000
@@ -12,7 +12,7 @@
msgstr ""
"Project-Id-Version: xz 5.8.0-pre1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-03-26 21:00-0700\n"
"Last-Translator: Božidar Putanec \n"
"Language-Team: Croatian \n"
@@ -686,72 +686,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Uporaba: %s [OPCIJA...][DATOTEKA...]\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Komprimira ili dekomprimira DATOTEKE u .xz formatu."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Obvezni argumenti za duge opcije, obvezni su i za kratke opcije."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "Način rada:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "prisilna kompresija"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "prisilna dekompresija"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "provjera integriteta komprimirane datoteke"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "prikaz informacija o .xz datotekama"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Modifikatori načina rada:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "sprema ulazne datoteke (ne brisati ih)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "prisilno piše preko izlazne datoteke i (de)komprimira linkove"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "ispiše na standardni izlaz i zadrži ulazne datoteke"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "ne sinkronizira izlaznu datoteku s uređajem za pohranu podataka dok ne izbriše ulaznu datoteku"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "dekomprimira samo prvi tok i tiho ignorira moguće preostale ulazne podatke"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "ne stvara raspršene datoteke kad komprimira"
@@ -760,7 +760,7 @@
msgid ".SUF"
msgstr ".EXT"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "koristi sufiks '.EXT' na komprimiranim datotekama"
@@ -769,17 +769,17 @@
msgid "FILE"
msgstr "DATOTEKA"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "imena datoteka koje treba obraditi čita iz DATOTEKA; ako DATOTEKA nije navedena, imena datoteka čita iz standardnog ulaza; svako ime datoteke mora završiti sa znakom novog retka (newline)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "kao '--files', ali s NULA-znakom (null character, Unicode U+0000) kao završetak imena"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Osnovni format datoteke i opcije za kompresiju:"
@@ -788,7 +788,7 @@
msgid "FORMAT"
msgstr "FORMAT"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "format datoteke za kodiranje ili dekodiranje; moguće vrijednosti su 'auto' (zadano), 'xz', 'lzma', 'lzip' i 'raw'"
@@ -797,22 +797,22 @@
msgid "NAME"
msgstr "IME"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "vrsta provjere integriteta: 'none' (koristite s oprezom), 'crc32', 'crc64' (zadano) ili 'sha256'"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "ne verificira provjeru integriteta pri dekompresiji"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "početna postavka kompresije (zadano je 6); razmotrite upotrebu memorije za komprimiranje *i* dekomprimiranje prije upotrebe 7-9!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "pokuša poboljšati omjer kompresije koristeći više vremena procesora (CPU); ne utječe na potrebnu memoriju za dekompresiju"
@@ -823,7 +823,7 @@
msgid "NUM"
msgstr "BROJ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "koristi maksimalno ovaj BROJ dretvi; zadano je 0, što znači da koristi toliko dretvi, koliko procesor ima jezgri"
@@ -832,7 +832,7 @@
msgid "SIZE"
msgstr "VELIČINA"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "započne novi .xz blok nakon svakih toliko (\"VELIČINA) bajtova ulaznih bajtova; to koristite da postavite veličinu bloka za kompresiju s nekoliko dretvi (tokova)"
@@ -841,12 +841,12 @@
msgid "BLOCKS"
msgstr "BLOKOVI"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "započne novi .xz block nakon te veličina (BLOKOVI) nekomprimiranih podataka odvojenih zarezima; opcionalno, navedite lance filtra broj (0-9) iza kojeg slijedi ':' a prije veličine nekomprimiranih podataka"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "ako se pri komprimiranju potroši više od NUM milisekundi od prethodnog pražnjenja, a daljnje čitanje bi blokiralo ulaz, isprazni sve podatke na čekanju"
@@ -855,18 +855,18 @@
msgid "LIMIT"
msgstr "OGRANIČENJE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "postavi ograničenje na količinu memorije za kompresiju, dekompresiju, dekompresiju s dretvama, ili za sve to; OGRANIČENJE je u bajtovima, % od RAM-a, ili 0 za zadano"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "ako dane postavke kompresije prekorače ograničenje upotrebe memorije, završi s greškom umjesto da prilagodi postavke shodno ograničenju memorije"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Prilagođeni lanac filtra za kompresiju (alternativa korištenju početnih postavki):"
@@ -875,17 +875,17 @@
msgid "FILTERS"
msgstr "FILTRI"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "postavi lanac filtra koristeći liblzma filtar string sintaksu; upotrebite '--filters-help' za više informacija"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "postavite dodatne lance filtra koristeći liblzma filtar sintaksu s '--block-list'"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "pokaže više informacija za liblzma filtar sintaksu"
@@ -900,7 +900,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 ili LZMA2; OPCIJE je lista od nula ili više, zarezom odvojenih opcija (valjane vrijednosti; zadano):"
@@ -912,12 +912,12 @@
msgid "PRE"
msgstr "PočP"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "vrati opcije na početne postavke"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "veličina rječnika"
@@ -926,17 +926,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "broj kontekstnih bitova po bajtu"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "broj pozicijskih bitova po bajtu"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "broj pozicijskih bitova"
@@ -945,142 +945,142 @@
msgid "MODE"
msgstr "NAČIN"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "način kompresije"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "lijepa duljina podudaranja"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "tražilica podudaranja"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "maksimalna dubina traženja; 0=automatic (zadano)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "x86 BCJ filtar (32-bit and 64-bit)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "ARM BCJ filtar"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "ARM-Thumb BCJ filtar"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "ARM64 BCJ filtar"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "PowerPC BCJ filtar (samo veliki endian)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "IA-64 (Itanium) BCJ filtar"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "SPARC BCJ filtar"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "RISC-V BCJ filtar"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "Valid OPTS za sve BCJ filtre:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "početni pomak za konverzije (zadano=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Delta filtar; valjane OPCIJE (valjane vrijednosti; zadano:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "razmak između bajtova koji se oduzimaju jedan od drugog"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Ostale opcije:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "potisne upozorenja; navedite dva puta da potisnete i pogreške"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "objašnjava što radi; navedite dva put za još više informacija"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "upozorenja nemaju utjecaja na izlazni status"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "koristite poruke za računalnu obradu (korisno za skripte)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "pokaže ukupnu količinu RAM-a i trenutno aktivna ograničenja korištenja memorije, pa iziđe"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "ispiše kratku pomoć (popis osnovnih opcija)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "ispiše ovu opširnu pomoć i iziđe"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "ispiše ovu kratku pomoć i iziđe"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "ispiše opširnu pomoć (također i popis naprednih opcija)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "pokaže informacije o inačici"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Ako DATOTEKA nije navedena ili je '-' (crtica), čita standardni ulaz."
@@ -1089,7 +1089,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1099,24 +1099,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "%s matična mrežna stranica: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "OVO JE RAZVOJNA INAČICA I NIJE NAMIJENJENA ZA PROIZVODNJU."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "Lanci filtara postavljaju se pomoću '--filters=FILTERS' ili '--filters1=FILTERS ... --filters9=FILTERS' opcije. Svaki filter u lancu može biti odvojen s razmakom ili s '--' (dvije crtice). Alternativno, početna postavka %s može biti navedena umjesto lanca filtra."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Podržani filtri i njihove opcije su:"
@@ -1189,7 +1189,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Uporaba: %s [--help] [--version] [DATOTEKA...]\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Pokaže informacije pohranjene u zaglavlju datoteke .lzma."
diff -Nru xz-utils-5.8.1/po/hu.po xz-utils-5.8.3/po/hu.po
--- xz-utils-5.8.1/po/hu.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/hu.po 2026-03-31 15:27:00.000000000 +0000
@@ -8,7 +8,7 @@
msgstr ""
"Project-Id-Version: xz 5.6.0-pre2\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2024-02-17 18:35+0100\n"
"Last-Translator: Meskó Balázs \n"
"Language-Team: Hungarian \n"
@@ -688,7 +688,7 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -701,45 +701,45 @@
".xz formátumú FÁJLok tömörítése vagy kibontása.\n"
"\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Mandatory arguments to long options are mandatory for short options too.\n"
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "A hosszú kapcsolók kötelező argumentumai a rövid kapcsolók esetén is kötelezők.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "Operation mode:"
msgstr " Működési mód:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "force compression"
msgstr "Kibontás:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "force decompression"
msgstr "Kibontás:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -750,29 +750,29 @@
"\n"
" Műveleti módosítók:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Writing to standard output failed"
msgid "write to standard output and don't delete input files"
msgstr "A szabványos kimenetre írás sikertelen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -783,7 +783,7 @@
" --single-stream csak az első adatfolyam kibontása, és a\n"
" lehetséges hátralévő bemeneti adatok mellőzése"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr ""
@@ -792,7 +792,7 @@
msgid ".SUF"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr ""
@@ -801,17 +801,17 @@
msgid "FILE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -826,7 +826,7 @@
msgid "FORMAT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr ""
@@ -835,19 +835,19 @@
msgid "NAME"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --ignore-check don't verify the integrity check when decompressing"
msgid "don't verify the integrity check when decompressing"
msgstr " --ignore-check kibontáskor ne ellenőrizze az épséget"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -859,7 +859,7 @@
" a 7-9 használata előtt vegye figyelembe a tömörítő\n"
" *és* kibontó memóriahasználatát!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -876,7 +876,7 @@
msgid "NUM"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -892,7 +892,7 @@
msgid "SIZE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -909,7 +909,7 @@
msgid "BLOCKS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -926,7 +926,7 @@
" adatok mérete előtt egy szűrőláncszám (0-9) is megadható\n"
" egy „:” karakter közbeiktatásával"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -945,13 +945,13 @@
msgid "LIMIT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -963,7 +963,7 @@
" korlátot, akkor hibát fog adni a beállítások lefelé\n"
" állítása helyett"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -978,7 +978,7 @@
msgid "FILTERS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -991,7 +991,7 @@
" --filters=SZŰRŐK a szűrőlánc beállítása liblzma szűrőformátummal;\n"
" további információkért lásd a --filters-help kapcsolót"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1004,7 +1004,7 @@
" további szűrőláncok beállítása liblzma formátummal a\n"
" --block-list kapcsolóhoz"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1025,7 +1025,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr ""
@@ -1037,12 +1037,12 @@
msgid "PRE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr ""
@@ -1051,17 +1051,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Number of processor threads:"
@@ -1072,89 +1072,89 @@
msgid "MODE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "compression mode"
msgstr "Kibontás:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1165,17 +1165,17 @@
"\n"
" Egyéb kapcsolók:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -Q, --no-warn make warnings not affect the exit status"
@@ -1184,7 +1184,7 @@
" -Q, --no-warn a figyelmeztetések nem befolyásolják a kilépési\n"
" állapotkódot"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --robot use machine-parsable messages (useful for scripts)"
@@ -1193,7 +1193,7 @@
" --robot géppel értelmezhető üzenetek használata\n"
" (parancsfájlok esetén hasznos)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1204,34 +1204,34 @@
" --info-memory az összes RAM mennyiségének és a jelenlegi\n"
" memóriahasználati korlátok megjelenítése, és kilépés"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -V, --version display the version number and exit"
msgid "display the version number and exit"
msgstr " -V, --version a verziószám kiírása és kilépés"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
@@ -1246,7 +1246,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "Report bugs to <%s> (in English or Finnish).\n"
@@ -1255,19 +1255,19 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "%s home page: <%s>\n"
msgid "%s home page: <%s>"
msgstr "%s honlap: <%s>\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "EZ EGY FEJLESZTŐI VÁLTOZAT, NEM ÉLES HASZNÁLATRA SZÁNT."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy, c-format
#| msgid ""
@@ -1282,7 +1282,7 @@
"szereplő egyes szűrőket szóközökkel vagy „--” karakterekkel kell elválasztani.\n"
"Illetve egy <0-9>[e] előbeállítás is megadható szűrőlánc helyett.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "A támogatott szűrők és azok kapcsolói a következők:"
@@ -1366,7 +1366,7 @@
"Használat: %s [--help] [--version] [FÁJL]…\n"
"Az .lzma fájl fejlécében tárolt információk megjelenítése"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
diff -Nru xz-utils-5.8.1/po/it.po xz-utils-5.8.3/po/it.po
--- xz-utils-5.8.1/po/it.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/it.po 2026-03-31 15:27:00.000000000 +0000
@@ -11,7 +11,7 @@
msgstr ""
"Project-Id-Version: xz 5.8.0-pre1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-03-10 11:31+0000\n"
"Last-Translator: Luca Vercelli \n"
"Language-Team: Italian \n"
@@ -685,72 +685,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Utilizzo: %s [OPZIONE]... [FILE]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Comprime o decomprime i FILE nel formato .xz."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Gli argomenti obbligatori per le opzioni lunghe sono obbligatori anche per quelle brevi."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "Modalità di operazione:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "forza compressione"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "forza decompressione"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "testa l'integrità del file compresso"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "elenca informazioni sui file .xz"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Modificatori di operazioni:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "conserva (non eliminare) i file input"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "forza la sovrascrittura del file output e dei link (de)compressi"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "scrivere sullo standard output e non eliminare i file input"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "non sincronizzare il file output sul supporto di memoria prima di rimuovere il file input"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "decomprime solamente il primo stream e ignora silenziosamente eventuali rimanenti dati di input"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "non creare file sparsi durante la decompressione"
@@ -759,7 +759,7 @@
msgid ".SUF"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "usare il suffisso \".SUF\" sui file compressi"
@@ -768,17 +768,17 @@
msgid "FILE"
msgstr "FILE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "legge da FILE i nomi dei file da processare; se FILE viene omesso, i nomi dei file vengono letti dallo standard input; i nomi dei file devono essere terminati da un carattere \"a capo\""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "come --files ma usa il carattere null come terminatore"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Formato file di base e opzioni di compressione:"
@@ -787,7 +787,7 @@
msgid "FORMAT"
msgstr "FORMATO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "formato di file per codificare o decodificare; i valori possibili sono \"auto\" (il predefinito), \"xz\", \"lzma\", \"lzip\" e \"raw\""
@@ -796,22 +796,22 @@
msgid "NAME"
msgstr "NOME"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "tipo di controllo di integrità: \"none\" (usare con cautela), \"crc32\", \"crc64\" (predefinito), oppure \"sha256\""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "non verifica il codice di integrità quando decomprime"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "preset di compressione; predefinito è 6; prendere in considerazione l'utilizzo di memoria per comprimere *e* decomprimere prima di usare 7-9"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "tenta di migliorare il rapporto di compressione utilizzando più tempo di CPU; non cambia i requisiti di memoria in fase di decompressione"
@@ -822,7 +822,7 @@
msgid "NUM"
msgstr "NUM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "Usa al massimo NUM thread: il valore predefinito è 0, che usa tanti thread quanti core la CPU ha a disposizione"
@@ -831,7 +831,7 @@
msgid "SIZE"
msgstr "DIM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "avvia un nuovo blocco .xz dopo ogni DIM byte di input; usare questo per impostare la dimensione del blocco durante la compressione con thread"
@@ -840,12 +840,12 @@
msgid "BLOCKS"
msgstr "BLOCCHI"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "inizia un nuovo blocco .xz dopo gli intervalli indicati (separati da virgole) di dati non compressi; opzionalmente, specifica il numero di una catena di filtri (0-9) seguito da \":\" prima della dimensione dei dati non compressi"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "durante la compressione, se sono passati più di NUM millisecondi dal flush precedente e la lettura di ulteriore input risulterebbe bloccata, viene eseguito il flush di tutti i dati pendenti"
@@ -854,18 +854,18 @@
msgid "LIMIT"
msgstr "LIMITE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "imposta il limite di utilizzo memoria per compressione, decompressione, decompressione con thread, oppure tutte quante; LIMITE è in byte, % di RAM, oppure 0 per i valori predefiniti"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "se le impostazioni di compressione eccedono il limite di utilizzo della memoria, lancia un errore invece di utilizzare valori più piccoli"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Catena di filtri personalizzati per la compressione (alternative per l'utilizzo di preset):"
@@ -874,17 +874,17 @@
msgid "FILTERS"
msgstr "FILTRI"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "imposta la catena di filtri usando la sintassi delle stringhe di filtri liblzma; usare --filters-help per avere più informazioni"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "imposta catene di filtri addizionali usando la sintassi delle stringhe di filtri liblzma da usare con --block-list"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "mostra più informazioni sulla sintassi della stringa del filtro liblzma ed esce"
@@ -899,7 +899,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "LZMA1 or LZMA2; OPZ is a comma-separated list of zero or more of the following options (valid values; default):"
@@ -913,12 +913,12 @@
msgid "PRE"
msgstr "PRESET"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "reimposta le opzioni a un preset"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "Dimensione del dizionario"
@@ -927,17 +927,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "numero di bit di contesto per carattere"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "numero di bit di posizione per carattere"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "numero di bit di posizione"
@@ -946,142 +946,142 @@
msgid "MODE"
msgstr "MODALITÀ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "modalità di compressione"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "lunghezza ragionevole di una corrispondenza"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "cercatore di corrispondenze"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "massima profondità di ricerca; 0=automatico (predefinito)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "filtro BCJ x86 (32-bit e 64-bit)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "filtro BCJ ARM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "filtro BCJ ARM-Thumb"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "filtro BCJ ARM64"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "filtro BCJ PowerPC (solo big-endian)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "filtro BCJ IA-64 (Itanium)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "filtro BCJ SPARC"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "filtro BCJ RISC-V"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "OPZIONI valide per tutti i filtri BCJ:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "offset iniziale per le conversioni (predefinito=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Filtro delta; OPZIONI valide (valori validi; predefiniti):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "distanza tra i byte sottratti l'uno dall'altro"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Altre opzioni:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "sopprime gli avvertimenti; specificare due volte per sopprimere anche gli errori"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "prolisso; specificare due volte per ancora più prolisso"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "gli avvertimenti non influenzano lo stato d'uscita"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "usa messaggi analizzabili (utile per gli script)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "visualizza la quantità totale di RAM e il limite attuale attivo di utilizzo della memoria ed esce"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "mostra l'aiuto breve (elenca solo le opzioni base)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "mostra l'aiuto esteso ed esce"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "mostra l'aiuto breve ed esce"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "mostra l'aiuto esteso (elenca anche le opzioni avanzate)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "visualizza il numero di versione ed esce"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Senza FILE, o quando FILE è -, legge lo standard input."
@@ -1090,7 +1090,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1098,24 +1098,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "Homepage di %s: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "*Questa è una versione di sviluppo non adatta per utilizzi in produzione.*"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "Le catene di filtri sono impostate usando le opzioni --filters=FILTRI oppure --filters1=FILTRI... --filters9=FILTRI. Ogni filtro nella catena può essere separato da spazi o da \"--\". In alternativa si può specificare un preset %s al posto di una catena di filtri."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "I filtri supportati e le loro opzioni sono:"
@@ -1188,7 +1188,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Utilizzo: %s [--help] [--version] [FILE]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Mostra le informazioni immagazzinate nella header del file .lzma"
diff -Nru xz-utils-5.8.1/po/ka.po xz-utils-5.8.3/po/ka.po
--- xz-utils-5.8.1/po/ka.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/ka.po 2026-03-31 15:27:00.000000000 +0000
@@ -8,7 +8,7 @@
msgstr ""
"Project-Id-Version: xz 5.7.1-dev1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-03-02 06:03+0100\n"
"Last-Translator: Temuri Doghonadze \n"
"Language-Team: Georgian <(nothing)>\n"
@@ -681,72 +681,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "გამოყენება: %s [პარამეტრი].. [ფაილი]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "მითითებული ფაილების .xz ფორმატში შეკუმშვა ან გაშლა."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "გრძელი პარამეტრების აუცილებელი არგუმენტები მათი მოკლე ვარიანტებისთვისაც სავალდებულოა."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "ოპერაციის რეჟიმი:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "ნაძალადევი შეკუმშვა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "ნაძალადევი გაშლა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "შეკუმშული ფალის მთლიანობის შემოწმება"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "ინფორმაციის ჩამოთვლა .xz ფაილების შესახებ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "ოპერაციის მოდიფიკატორები:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "შეყვანის ფაილების შენარჩუნება (არ წაშლა)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "გამოტანის ფაილის თავზე გადაწერა და ბმულების შეკუმშვა/გაშლა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "სტანდარტულ გამოტანაზე ჩაწერა და შეყვანილი ფაილები არ წაიშლება"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "გამოტანის ფაილის საცავის მოწყობილობასთან სინქრონიზაცია შეყვანის ფაილის წაშლამდე არ მოხდება"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "გაშლის, მხოლოდ, პირველ ნაკადს და ჩუმად დააიგნორებს დარჩენილ შეყვანილ მონაცემებს"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "გაშლისას დამატებითი ფაილები არ შეიქმნება"
@@ -755,7 +755,7 @@
msgid ".SUF"
msgstr ".SUF"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "შეკუმშულ ფაილებზე '.SUF' სუფიქსის გამოყენება"
@@ -764,17 +764,17 @@
msgid "FILE"
msgstr "FILE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "დასამუშავებელი ფაილის სახელების FILE-დან წაკითხვა; თუ FILE მითითებული არაა, ფაილის სახელები სტანდარტული შეყვანიდან იქნება წაკითხული. ფაილის სახელები ხაზის გადატანის სიმბოლოთი უნდა სრულდებოდეს"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "--files-ის მსგავსად, მაგრამ ფაილის სახელის დასასრულებლად ნულოვანი სიმბოლოს გამოყენება"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "ფაილის ფორმატისა და შეკუმშვის ძირითადი პარამეტრები:"
@@ -783,7 +783,7 @@
msgid "FORMAT"
msgstr "ფორმატი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "ფაილის ფორმატი გასაშიფრად ან დასაშიფრად. შესაძლო მნიშვნელობებია 'auto' (ნაგულიხმევი), 'xz', 'lzma', 'lzip' და 'raw'"
@@ -792,22 +792,22 @@
msgid "NAME"
msgstr "სახელი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "მთლიანობის შემოწმების ტიპი: 'არცერთი' (გამოიყენეთ ყურადღებით), 'crc32', 'crc64' (ნაგულისხმევი), ან 'sha256'"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "გაშლისას სიმრთელე არ შემოწმდება"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "შეკუმშვის პრესეტი. ნაგულისხმებია 6; 7-9 მნიშვნელობის მითითებამდე გაითვალისწინეთ შემკუმშავისა *და* გამშლელის მეხსიერების მოთხოვნები!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "CPU-ის მეტი დატვირთვის ხარჯზე შეკუმშვის დონის აწევის ცდა. არქივის გაშლისას მეხსიერების მოთხოვნები არ შეიცვლება"
@@ -818,7 +818,7 @@
msgid "NUM"
msgstr "NUM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "გამოყენებული იქნება მაქს. NUM ნაკადი; ნაგულისხმევი მნიშვნელობაა 0, რაც იყენებს იმდენ ნაკადს, რამდენი ბირთვიც აქვს პროცესორს"
@@ -827,7 +827,7 @@
msgid "SIZE"
msgstr "ზომა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "ახალი .xz ბლოკის დაწყება ყოველი მითითებული ზომის მიღწევისას. გამოიყენეთ ეს, რომ დააყენოთ ბლოკის ზომა მრავალნაკადიანი შეკუმშვისას"
@@ -836,12 +836,12 @@
msgid "BLOCKS"
msgstr "ბლოკები"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "დაიწყება ახალი .xz ბლოკი მითითებული მძიმით გამოყოფილი ინტერვალის განმავლობაში შეუკუმშავი მონაცემების მიღების შემდეგ. არასავალდებულოდ შეგიძლიათ მიუთითოთ ფილტრების ჯაჭვის ნომერი (0-9), რომელსაც '.' მოჰყვება შეუკუმშავი მონაცემების ზომის შემდეგ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "კომპრესიის დროს, თუ NUM მილიწამზე მეტი გავიდა მას შემდეგ, რაც წინა ფლეში და მეტი შეყვანის წაკითხვა დაბლოკავს, ყველა მომლოდინე მონაცემი ამოიწურა"
@@ -850,18 +850,18 @@
msgid "LIMIT"
msgstr "ლიმიტი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "მეხსიერების ლიმიტის დაყენება შეკუმშვისთვის, გაშლისთვის, მრავალნაკადიანი გაშლისთვის, ან ყველასთვის ლიმიტი მიეთითება ბაიტებში, RAM-ის %-ში, ან 0, ნაგულისხმევი მნიშვნელობის გამოსაყენებლად"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "თუ შეკუმშვის პარამეტრი გადასცდება მეხსიერების გამოყენების ლიმიტს, პარამეტრის შემცირების მაგიერ შეცდომის გამოტანა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "მომხმარებლის ფილტრის ჯაჭვი შეკუმშვისთვის (პრესეტების გამოყენების ალტერნატივა):"
@@ -870,17 +870,17 @@
msgid "FILTERS"
msgstr "ფილტრები"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "ფილტრების ჯაჭვის აწყობა liblzma-ის ფილტრის პარამეტრის სინტაქსით მეტი ინფორმაციისთვის გამოიყენეთ --filters-help"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "დამატებითი ფილტრის ჯაჭვების დაყენება liblzma-ის ფილტრის სინტაქსით --block-list პარამეტრით გამოსაყენებლად"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "მეტი ინფორმაციის გამოტანა liblzma ფილტრის სტრიქონის სინტაქის შესახებ და გასვლა"
@@ -895,7 +895,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 ან LZMA2. OPTS მძიმით გამოყოფილი სიაა ნული ან მეტი შემდეგი პარამეტრებიდან (სწორი მნიშვნელობა. ნაგულიხმევი):"
@@ -907,12 +907,12 @@
msgid "PRE"
msgstr "პრე"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "პარამეტრების ჩამოყრა პრესეტზე"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "ლექსიკონის ზომა"
@@ -921,17 +921,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "ლიტერალის კონტექსტის ბიტების რაოდენობა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "ლიტერალის მდებარეობის ბიტების რაოდენობა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "მდებარეობის ბიტების რაოდენობა"
@@ -940,142 +940,142 @@
msgid "MODE"
msgstr "რეჟიმი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "შეკუმშვის რეჟიმი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "დაფორმატებული დამთხვევის სიგრძე"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "დამთხვევის მძებნელი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "მაქსიმალური ძებნის სიღრმე. 0=ავტომატური (ნაგულისხმევი)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "x86 BCJ ფილტრი (32-ბიტიანი და 64-ბიტიანი)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "ARM BCJ ფილტრი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "ARM-Thumb BCJ ფილტრი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "ARM64 BCJ ფილტრი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "PowerPC BCJ ფილტრი(მხოლოდ მსხვილბოლოიანი)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "IA-64 (Itanium) BCJ ფილტრი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "SPARC BCJ ფილტრი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "RISC-V BCJ ფილტრი"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "სწორი პარამეტრები ყველა BCJ ფილტრისთვის:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "დაწყების წანაცვლება გადაყვანებისთვის (ნაგულისხმევი=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "დელტა ფილტრი. დაშვებული პარამეტრები (სწორი მნიშვნელობები, ნაგულისხმევი):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "დაშორება ბაიტებს შორის გამოაკლდება ერთმანეთს"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "სხვა პარამეტრები:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "გაფრთხილებების დადუმება. შეცდომების დასამალად მიუთითეთ ორჯერ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "მეტი შეტყობინების გამოტანა. უფრო მეტი შეტყობინებისთვის მიუთითეთ ორჯერ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "გაფრთხილებებს გასვლის სტატუსზე გავლენა არ ექნებათ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "მანქანისთვის დამუშავებადი შეტყობინებები (სკრიპტებისთვის)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "მეხსიერების ჯამური რაოდენობის და ამჟამად აქტიური მეხსიერების ლიმიტების გამოტანა და გასვლა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "მოკლე დახმარების ჩვენება (მხოლოდ, ძირითადი პარამეტრები)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "გრძელი დახმარების ჩვენება და გასვლა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "ამ მოკლე დახმარების ჩვენება და გასვლა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "უფრო გრძელი დახმარების ჩვენება (ასევე ნაჩვენები ქნება დამატებითი პარამეტრებიც)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "ვერსიის ინფორმაციის ჩვენება და გასვლა"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "როცა ფაილი არ არსებობს ან '-'-ია, წაკითხვა stdin-დან მოხდება."
@@ -1084,7 +1084,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1092,24 +1092,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "%s-ის საწყისი გვერდია: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "ეს სატესტო ვერსიაა. ნუ გამოიყენებთ ყოველდღიური მოხმარებისთვის."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "ფილტრის ჯაჭვების დაყენება --filters=ფილტრები ან --filters1=ფილტრები... --filters9=ფილტრები პარამეტრებით ხდება. თითოეული ფილტრი ამ ჯაჭვში ერთმანეთისგან ჰარეებით, ან '--'-ითაა გამოყოფილი. ასევე შეგიძლიათ მიუთითოთ პრესეტი %s ფილტრის ჯაჭვის მაგიერ."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "მხარდაჭერელი ფილტრები და მათ პარამეტრებია:"
@@ -1182,7 +1182,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "გამოყენება: %s [--help] [--version] [ფაილი]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr ".lzma ფაილის თავსართში შენახული ინფორმაციის ჩვენება."
diff -Nru xz-utils-5.8.1/po/ko.po xz-utils-5.8.3/po/ko.po
--- xz-utils-5.8.1/po/ko.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/ko.po 2026-03-31 15:27:00.000000000 +0000
@@ -7,7 +7,7 @@
msgstr ""
"Project-Id-Version: xz 5.7.1-dev1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-01-24 23:22+0900\n"
"Last-Translator: Seong-ho Cho \n"
"Language-Team: Korean \n"
@@ -680,72 +680,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "사용법: %s [옵션]... [파일]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr ".xz 형식의 <파일>로 압축하거나 압축을 해제합니다."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "긴 옵션 버전의 필수 인자는 짧은 옵션에도 해당합니다."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "동작 방식:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "강제 압축"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "강제 압축 해제"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "압축 파일 무결성을 시험합니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr ".xz 파일에 대한 정보를 보여줍니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "동작 지정자:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "입력 파일을 그대로 둡니다 (삭제 안함)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "출력 파일을 강제로 덮어쓰고 링크 압축을 진행(해제)합니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "표준 출력에 기록하고 입력 파일을 삭제하지 않습니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "입력 파일을 제거하기 전 저장 장치로 출력 파일을 동기화하지 않습니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "첫 스트림 압축만 해제하며, 가능한 나머지 입력 데이터는 무시합니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "압축 해제시 희소 처리 파일을 만들지 않습니다"
@@ -754,7 +754,7 @@
msgid ".SUF"
msgstr ".SUF"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "파일 압축시 접미사를 '.SUF'로 사용합니다"
@@ -763,17 +763,17 @@
msgid "FILE"
msgstr "<파일>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "<파일>에서 처리할 파일 이름을 읽습니다. <파일> 값을 생략하면, 표준 입ㄹ겨에서 파일 이름을 읽어들입니다. 파일 이름은 개행 문자로 끝나야 합니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "--files와 비슷하나 널 문자를 종결 문자로 사용합니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "기본 파일 형식 및 압축 옵션:"
@@ -782,7 +782,7 @@
msgid "FORMAT"
msgstr "<형식>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "인코딩 또는 디코딩할 파일 형식입니다. 사용할 수 있는 값은 'auto'(기본), 'xz', 'lzma', 'lzip', 'raw'가 있습니다"
@@ -791,22 +791,22 @@
msgid "NAME"
msgstr "<이름>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "무결성 검사 형식: 'none'(사용에 유의), 'crc32', 'crc64' (기본값), 'sha256'"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "압축 해제시"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "압축 사전 설정. 기본값은 6 입니다. 7-9를 사용하려면 압축 메모리 사용량*과* 압축 해제 메모리 사용량을 지정하십시오!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "CPU 점유 시간을 더 확보하여 압축률을 개선합니다. 압축 해제시 메모리 요구 용량에는 영향을 주지 않습니다"
@@ -817,7 +817,7 @@
msgid "NUM"
msgstr "<숫자>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "최대 스레드 <개수>를 사용합니다. 기본값은 실제 프로세서 코어 수 만큼의 스레드를 사용하도록 지정하는 0 값입니다"
@@ -826,7 +826,7 @@
msgid "SIZE"
msgstr "<크기>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "모든 <크기>의 입력 다음 새 .xz 블록을 시작합니다. 스레드 압축의 블록 크기를 지정할 때 사용합니다"
@@ -835,12 +835,12 @@
msgid "BLOCKS"
msgstr "<블록>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "콤마로 구분한 연속 지정값 만큼 압축 해제한 데이터 용량 다음, 새 .xz 블록을 시작합니다. 압축 해제 데이터 크기 앞에 콜론(':') 표기 후 필터 체인 번호(0-9)를 추가로 지정할 수 있습니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "압축하는 동안, 이전 데이터를 플러싱한 후 더 많은 블록 입력을 읽어들일 때 <숫자> 만큼의 밀리초단위 제한시간을 넘기면 모든 대기 데이터를 소거합니다"
@@ -849,18 +849,18 @@
msgid "LIMIT"
msgstr "<제한>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "압축, 해제, 스레드 분산 압축 해제, 또는 유사 동작 수행시 메모리 사용량 제한을 설정합니다. 바이트 단위 <제한>값, % 단위 RAM 사용량을 지정하든지 아니면 기본값으로 0을 지정하십시오"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "압축 설정이 메모리 사용량 제한을 넘어서면 설정 값을 줄이는 대신 오류 메시지를 나타냅니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "압축용 개별 필터 체인 설정 (사전 설정 사용을 대신함):"
@@ -869,17 +869,17 @@
msgid "FILTERS"
msgstr "<필터>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "liblzma 필터 문자열 문법으로 필터 체인을 설정합니다. 자세한 정보는 --filters-help 옵션을 사용하십시오"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "--block-list 옵션을 함께 사용할 수 있는 liblzma 필터 문자열 문법으로 추가 필터 체인을 설정합니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "liblzma 필터 문자열 문법 추가 정보를 나타낸 후 빠져나갑니다"
@@ -894,7 +894,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 또는 LZMA2입니다. <옵션> 값은 다음과 같은 0개 이상의 쉼표 구분 값입니다 (유효한 값. 기본값):"
@@ -906,12 +906,12 @@
msgid "PRE"
msgstr "<사전설정>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "사전 설정 값으로 옵션 재설정"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "딕셔너리 크기"
@@ -920,17 +920,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "보이는 대로의 컨텍스트 비트 갯수"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "보이는 대로의 위치 비트 갯수"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "위치 비트 수"
@@ -939,142 +939,142 @@
msgid "MODE"
msgstr "<모드>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "압축 모드"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "일치하는 항목의 nice 길이"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "일치 항목 검색기"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "최대 검색 깊이 값. 0=자동 (기본값)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "x86 BCJ 필터 (32비트 및 64비트)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "ARM BCJ 필터"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "ARM-Thumb BCJ 필터"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "ARM64 BCJ 필더"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "PowerPC BCJ 필터 (빅 엔디안 전용)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "IA-64 (아이태니엄) BCJ 필터"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "SPARC BCJ 필터"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "RISC-V BCJ 필터"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "모든 BCJ 필터에 대한 적절한 <옵션>값:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "변환 시작 오프셋 값 (기본값=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "델타 필터. 적절한 <옵션> (적절한 값. 기본값):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "바이트 값 차이 거리"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "기타 옵션:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "경고문 숨김. 더 많은 오류 메시지를 숨가려면 두번 지정하십시오"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "자세하게 표시. 더 자세하게 출력하려면 두번 지정하십시오"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "경고가 종료 상태에 영향을 주지 않게합니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "기계 해석 가능한 메시지를 사용합니다 (스크립트 활용시 유용함)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "RAM 총 용량과 현재 활성 메모리 사용 한계값을 표시하고 나갑니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "간단한 도움말 표시 (기본 옵션만 표시)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "이 긴 도움말을 보여주고 나갑니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "이 간단한 도움말을 보여주고 나갑니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "긴 도움말 표시 (고급 옵션도 보여줍니다)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "버전 번호를 표시하고 빠져나갑니다"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "<파일> 값이 없거나, <파일> 값이 - 문자이면, 표준 입력을 읽어들입니다."
@@ -1083,7 +1083,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1091,18 +1091,18 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "%s 홈페이지: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "!! 주의 !! 개발 버전이며 실제 사용 용도가 아닙니다."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
@@ -1111,7 +1111,7 @@
"필터 체인을 지정합니다. 체인의 각 필터는 공백 문자 또는 '--'으로 구분할 수 있습니다.\n"
"필터 체인 대신 %s 사전 설정 값을 지정할 수 있습니다."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "지원하는 필터와 옵션은 다음과 같습니다:"
@@ -1184,7 +1184,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "사용법: %s [--help] [--version] [<파일>]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr ".lzma 파일 헤더에 저장한 정보를 보여줍니다."
diff -Nru xz-utils-5.8.1/po/nl.po xz-utils-5.8.3/po/nl.po
--- xz-utils-5.8.1/po/nl.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/nl.po 2026-03-31 15:27:00.000000000 +0000
@@ -10,7 +10,7 @@
msgstr ""
"Project-Id-Version: xz 5.7.1-dev1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-01-25 15:51+0100\n"
"Last-Translator: Benno Schulenberg \n"
"Language-Team: Dutch \n"
@@ -682,72 +682,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Gebruikt: %s [OPTIE...] [BESTAND...]\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Comprimeert of decomprimeert BESTANDen in de .xz-indeling."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "(Een verplicht argument bij een lange optie geldt ook voor de korte vorm.)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr " Werkingsmodus:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "comprimeren"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "decomprimeren"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "integriteit van gecomprimeerd bestand controleren"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "informatie tonen over .xz-bestanden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Werkingsaanpassers:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "invoerbestanden behouden (niet verwijderen)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "uitvoerbestand overschrijven, koppelingen (de)comprimeren"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "naar standaarduitvoer schrijven, invoerbestanden behouden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "het uitvoerbestand niet met het opslagmedium synchroniseren alvorens het invoerbestand te verwijderen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "alleen de eerste stream decomprimeren, en stilzwijgend eventuele overige invoergegevens negeren"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "geen bestanden met gaten aanmaken bij het decomprimeren"
@@ -756,7 +756,7 @@
msgid ".SUF"
msgstr ".EXT"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "deze extensie gebruiken voor gecomprimeerde bestanden"
@@ -765,17 +765,17 @@
msgid "FILE"
msgstr "BESTAND"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "namen van te verwerken bestanden uit dit BESTAND halen; als BESTAND weggelaten wordt, dan worden de namen van standaardinvoer gelezen; elke naam moet afgesloten worden met een nieuweregelteken"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "zoals '--files' maar met het NUL-teken als naamsafsluiting"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Bestandsindeling- en compressie-opties:"
@@ -784,7 +784,7 @@
msgid "FORMAT"
msgstr "INDELING"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "te coderen of decoderen bestandsindeling; mogelijke waarden zijn 'auto' (standaard), 'xz', 'lzma', 'lzip', en 'raw'"
@@ -793,22 +793,22 @@
msgid "NAME"
msgstr "NAAM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "soort integriteitscontrole: 'none' (ontraden), 'crc32', 'crc64' (standaard), of 'sha256'"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "geen integriteitscontrole doen tijdens decomprimeren"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "compressiegraad (standaard is 6); denk aan geheugengebruik van compressor *en* decompressor alvorens 7-9 te gebruiken"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "compressieratio verbeteren met meer processortijd; heeft geen invloed op het geheugengebruik bij decompressie"
@@ -819,7 +819,7 @@
msgid "NUM"
msgstr "GETAL"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr ""
@@ -830,7 +830,7 @@
msgid "SIZE"
msgstr "GROOTTE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "een nieuw .xz-blok beginnen na steeds dit aantal invoerbytes; gebruik dit om de blokgrootte voor threaded compressie in te stellen"
@@ -839,12 +839,12 @@
msgid "BLOCKS"
msgstr "BLOKKEN"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "een nieuw .xz-blok beginnen na deze komma-gescheiden groottes van ongecomprimeerde gegevens; geef eventueel het filterketennummer op (0-9) gevolgd door ':' vóór een gegeven grootte"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "als tijdens compressie meer dan dit aantal milliseconden voorbijgegaan is sinds de vorige doorspoeling, en het lezen van meer gegevens zou blokkeren, dan alle wachtende gegevens doorspoelen"
@@ -853,18 +853,18 @@
msgid "LIMIT"
msgstr "GRENS"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "de geheugengebruiksgrens instellen voor compressie, decompressie, threaded decompressie, of allemaal; GRENS is in bytes, % van RAM, of 0 voor de standaardwaarden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "als compressie-instellingen de geheugengebruiksgrens overschrijden, een fout melden i.p.v. de instellingen te verlagen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Aangepaste filterketen voor compressie (een alternatief voor compressiegraden):"
@@ -873,17 +873,17 @@
msgid "FILTERS"
msgstr "FILTERS"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "de filterketen instellen met de liblzma-filtersyntax; gebruik '--filters-help' voor meer informatie"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "extra filterketens instellen met de liblzma-filtersyntax te gebruiken met '--block-list'"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "meer informatie over de liblzma-filtersyntax tonen en stoppen"
@@ -898,7 +898,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 of LZMA2; INSTEL is een komma-gescheiden lijst van nul of meer van de volgende opties (geldige waarden; standaard):"
@@ -910,12 +910,12 @@
msgid "PRE"
msgstr "GRAAD"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "opties terugstellen op een voorinstelling"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "woordenboekgrootte"
@@ -924,17 +924,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "aantal contextbits per byte"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "aantal positiebits per byte"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "aantal positiebits"
@@ -943,142 +943,142 @@
msgid "MODE"
msgstr "MODUS"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "compressiemodus"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "mooie lengte van overeenkomst"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "overeenkomstzoeker"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "maximum zoekdiepte; 0=automatisch (standaard)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "x86 BCJ-filter (32-bit en 64-bit)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "ARM BCJ-filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "ARM-Thumb BCJ-filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "ARM64 BCJ-filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "PowerPC BCJ-filter (alleen big endian)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "IA-64 (Itanium) BCJ-filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "SPARC BCJ-filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "RISC-V BCJ-filter"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "Geldige INSTEL voor alle BCJ-filters:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "beginpunt voor conversies (standaard=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Delta-filter; geldige INSTEL (geldige waarden; standaard):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "afstand tussen bytes die van elkaar afgetrokken worden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Andere opties:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "waarschuwingen onderdrukken; -q -q onderdrukt ook fouten"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "melden wat er gedaan wordt; -v -v geeft nog meer info"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "waarschuwingen de afsluitwaarde niet laten beïnvloeden"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "meldingen in machine-opmaak geven (nuttig voor scripts)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "de totale hoeveelheid RAM en de actieve geheugengebruiksgrenzen tonen en stoppen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "korte hulptekst tonen (met alleen basisopties)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "deze lange hulptekst tonen en stoppen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "deze korte hulptekst tonen en stoppen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "lange hulptekst tonen (met ook geavanceerde opties)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "versienummer tonen en stoppen"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Zonder BESTAND, of wanneer BESTAND '-' is, wordt standaardinvoer gelezen."
@@ -1087,7 +1087,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1097,24 +1097,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "Webpagina van %s: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "DIT IS een ONTWIKKELINGSVERSIE -- NIET BEDOELD voor WERKELIJK GEBRUIK."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "Filterketens worden ingesteld met de opties '--filters=FILTERS' of '--filters1=FILTERS ... --filters9=FILTERS'. Elk filter in de keten kan gescheiden worden door spaties of '--'. In plaats van een filterketen kan ook een voorinstelling %s gegeven worden."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Ondersteunde filters en hun opties zijn:"
@@ -1187,7 +1187,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Gebruik: %s [--help] [--version] [BESTAND...]\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Toont informatie uit de .lzma-bestandskop."
diff -Nru xz-utils-5.8.1/po/pl.po xz-utils-5.8.3/po/pl.po
--- xz-utils-5.8.1/po/pl.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/pl.po 2026-03-31 15:27:00.000000000 +0000
@@ -8,7 +8,7 @@
msgstr ""
"Project-Id-Version: xz 5.7.1-dev1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-02-08 08:02+0100\n"
"Last-Translator: Jakub Bogusz \n"
"Language-Team: Polish \n"
@@ -681,72 +681,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Składnia: %s [OPCJA]... [PLIK]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Kompresja lub dekompresja PLIKÓW w formacie .xz."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Argumenty obowiązkowe dla opcji długich są obowiązkowe również dla opcji krótkich."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "Tryb pracy:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "wymuszenie kompresji"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "wymuszenie dekompresji"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "sprawdzenie integralności plików skompresowanych"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "wypisanie informacji o plikach .xz"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Modyfikatory operacji:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "zachowanie (nieusuwanie) plików wejściowych"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "nadpisywanie plików wyjściowych i (de)kompresja dowiązań"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "zapis na standardowe wyjście, nieusuwanie plików wejściowych"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "bez synchronizacji plików wyjściowych na urządzenie przechowujące przed usunięciem pliku wejściowego"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "dekompresja tylko pierwszego strumienia, ciche zignorowanie pozostałych danych wejściowych"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "nietworzenie plików rzadkich podczas dekompresji"
@@ -755,7 +755,7 @@
msgid ".SUF"
msgstr ".ROZ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "użycie rozszerzenia „.ROZ” dla plików skompresowanych"
@@ -764,17 +764,17 @@
msgid "FILE"
msgstr "PLIK"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "odczyt nazw plików do przetworzenia z PLIKU; jeśli PLIK nie został podany, nazwy są czytane ze standardowego wejścia; muszą być zakończone znakiem nowej linii"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "podobnie do --files, ale znakiem kończącym musi być NUL"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Podstawowe opcje formatu pliku i kompresji:"
@@ -783,7 +783,7 @@
msgid "FORMAT"
msgstr "FORMAT"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "format pliku do kodowania lub dekodowania; możliwe to „auto” (domyślny), „xz”, „lzma”, „lzip” i „raw”"
@@ -792,22 +792,22 @@
msgid "NAME"
msgstr "NAZWA"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "typ kontroli spójności: „none” (ostrożnie!), „crc32”, „crc64” (domyślny) lub „sha256”"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "bez kontroli sprawdzania integralności przy dekompresji"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "predefiniowane opcje kompresji; domyślna to 6; przed użyciem wartości 7-9 należy wziąć pod uwagę wykorzystanie pamięci przy kompresji *oraz* dekompresji!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "próba poprawy współczynnika kompresji z użyciem większej ilości czasu procesora; nie wpływa na wymagania pamięciowe dekompresora"
@@ -818,7 +818,7 @@
msgid "NUM"
msgstr "ILE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "użycie maksymalnie ILU wątków; domyślnie 0, co oznacza tyle, ile jest rdzeni procesorów"
@@ -827,7 +827,7 @@
msgid "SIZE"
msgstr "ROZMIAR"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "rozpoczęcie nowego bloku .xz co ROZMIAR bajtów wejścia; opcja służy do ustawienia rozmiaru bloku dla kompresji wielowątkowej"
@@ -836,12 +836,12 @@
msgid "BLOCKS"
msgstr "BLOKI"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "rozpoczęcie nowego bloku .xz po rozdzielonych przecinkiem przedziałach danych nieskompresowanych; opcjonalnie można podać numer łańcucha filtrów (0-9) ze znakiem „:” przed rozmiarem danych nieskompresowanych"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "przy kompresji, jeśli minęło więcej niż CZAS milisekund ostatniego zapisu bloku, a odczyt kolejnych danych byłby blokujący, wszystkie gotowe dane są zapisywane"
@@ -850,18 +850,18 @@
msgid "LIMIT"
msgstr "LIMIT"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "ustawienie limitu użycia pamięci dla kompresji, dekompresji, dekompresji wielowątkowej lub wszystkich; LIMIT jest w bajtach, % RAM lub 0 dla limitów domyślnych"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "jeśli ustawienia kompresji przekraczają limit użycia pamięci, zostanie zgłoszony błąd zamiast zmniejszania ustawień"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Łańcuch własnych filtrów do kompresji (alternatywa do używania ustawień predefiniowanych):"
@@ -870,17 +870,17 @@
msgid "FILTERS"
msgstr "FILTRY"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "ustawienie łańcucha filtrów przy użyciu składni łańcucha filtrów liblzma; więcej informacji z opcją --filters-help"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "ustawienie dodatkowego łańcucha filtrów przy użyciu składni łańcucha filtrów liblzma do użycia w opcji --block-list"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "więcej informacji o składni lańcuchów filtrów libzma i zakończenie"
@@ -895,7 +895,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 lub LZMA2; OPCJE to oddzielona przecinkami lista zera lub większej liczby następujących opcji (wartości poprawne; domyślne):"
@@ -907,12 +907,12 @@
msgid "PRE"
msgstr "PRE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "ustawienie opcji na predefiniowaną"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "rozmiar słownika"
@@ -921,17 +921,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "liczba bitów kontekstu literału"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "liczba bitów pozycji literału"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "liczba bitów pozycji"
@@ -940,142 +940,142 @@
msgid "MODE"
msgstr "TRYB"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "tryb kompresji"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "długość dopasowania"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "dopasowywacz"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "maksymalna głębokość szukania; 0=automatyczna (domyślne)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "Filtr BCJ x86 (32-bitowy lub 64-bitowy)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "Filtr BCJ ARM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "Filtr BCJ ARM-Thumb"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "Filtr BCJ ARM64"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "Filtr BCJ PowerPC (tylko big-endian)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "Filtr BCJ IA-64 (Itanium)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "Filtr BCJ SPARC"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "Filtr BCJ RISC-V"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "Poprawne OPCJE dla wszystkich filtrów BCJ:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "offset początku konwersji (domyślnie=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Filtr delta; poprawne OPCJE (poprawne wartości; domyślne):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "odległość między bajtami odejmowanymi od siebie"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Inne opcje:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "pominięcie ostrzeżeń; dwukrotne podanie pomija też błędy"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "więcej informacji; dwukrotne podanie to jeszcze więcej"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "ustawienie, że ostrzeżenia nie mają wpływu na status zakończenia"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "komunikaty w formacie dla maszyny (przydatne do skryptów)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "wyświetlenie całkowitej ilości pamięci RAM oraz obecnie aktywnych limitów pamięci i zakończenie pracy"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "wyświetlenie krótkiego opisu (tylko podstawowe opcje)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "wyświetlenie tego długiego opisu i zakończenie"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "wyświetlenie tego krótkiego opisu i zakończenie"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "wyświetlenie długiego opisu (także opcje zaawansowane)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "wyświetlenie numeru wersji i zakończenie"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Jeśli nie podano PLIKU lub PLIK to -, czytane jest standardowe wejście."
@@ -1084,7 +1084,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1094,24 +1094,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "Strona domowa %s: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "TA WERSJA JEST ROZWOJOWA, NIE PRZEZNACZONA DO UŻYTKU PRODUKCYJNEGO."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "Łańcuchy filtrów ustawia się przy użyciu --filters=FILTRY lub --filters1=FILTRY ... --filters9=FILTRY. Każdy filtr w łańcuchu może być rozdzielony spacjami lub „--”. Alternatywnie zamiast łańcucha filtrów można podać predefiniowane %s."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Obsługiwane filtry i ich opcje to:"
@@ -1184,7 +1184,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Składnia: %s [--help] [--version] [PLIK]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Wyświetlanie informacji zapisanych w nagłówku pliku .lzma."
diff -Nru xz-utils-5.8.1/po/pt.po xz-utils-5.8.3/po/pt.po
--- xz-utils-5.8.1/po/pt.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/pt.po 2026-03-31 15:27:00.000000000 +0000
@@ -8,7 +8,7 @@
msgstr ""
"Project-Id-Version: xz 5.8.0-pre1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-03-16 17:37+0000\n"
"Last-Translator: Pedro Albuquerque \n"
"Language-Team: Portuguese \n"
@@ -695,72 +695,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Uso: %s [OPÇÃO]... FICHEIRO...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Comprimir ou descomprimir FICHEIROs no formato .xz."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Argumentos obrigatórios para opções longas são também obrigatórios para opções curtas."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "Modo de operação:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "forçar compressão"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "forçar descompressão"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "testar integridade do ficheiro comprimido"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "listar informação sobre ficheiros .xz"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Modificadores de operação:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "manter (não eliminar) ficheiros de entrada"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "forçar substituição de ficheiros de saída e ligações de (des)compressão"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "escrever na saída padrão e não eliminar ficheiros de entrada"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "não sincronizar o ficheiro de saída com o dispositivo de armazenamento antes de remover o ficheiro de entrada"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "descomprimir só o primeiro fluxo e ignoras silenciosamente possíveis dados de entrada restantes"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "não criar ficheiros esparsos ao descomprimir"
@@ -769,7 +769,7 @@
msgid ".SUF"
msgstr ".SUF"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "usar o sufixo \".SUF\" em ficheiros comprimidos"
@@ -778,17 +778,17 @@
msgid "FILE"
msgstr "FICH"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "ler nomes de ficheiro a processar de FICH; se FICH for omitido, os nomes serão lidos da entrada padrão; os nomes de ficheiro devem terminar com o carácter de nova linha"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "como --files, mas usa o carácter nulo como terminador"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Opções básicas de formato e compressão de ficheiro:"
@@ -797,7 +797,7 @@
msgid "FORMAT"
msgstr "FORMATO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "formato de ficheiro a codificar/descodificar; os valores possíveis são \"auto\" (pré-definição), \"xz\", \"lzma\", \"lzip\", e \"raw\""
@@ -806,22 +806,22 @@
msgid "NAME"
msgstr "NOME"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "tipo de teste de integridade: 'none' (use com cautela), 'crc32', 'crc64' (pré-definição), ou 'sha256'"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "não verificar a integridade ao descomprimir"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "pré-definição de compressão; a pré-definição é 6; ter em conta o uso de memória do compressor *e* descompressor antes de usar 7-9!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "tentar melhorar o rácio de compressão usando mais tempo de CPU; não afecta os requisitos de memória do descompressor"
@@ -832,7 +832,7 @@
msgid "NUM"
msgstr "NÚM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "usa no máximo NÚM linhas; a pré-definição é 1; defina para 0 para usar tantas linhas como núcleos de processadores haja"
@@ -841,7 +841,7 @@
msgid "SIZE"
msgstr "TAMANHO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "iniciar novo bloco .xz após cada TAM bytes de entrada; use para definir o tamanho de bloco para compressão com linhas"
@@ -850,12 +850,12 @@
msgid "BLOCKS"
msgstr "BLOCOS"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "iniciar um bloco .xz após os intervalos de dados descomprimidos indicados, separados por vírgulas; optionalmente, especifique umnúmero de cadeia de filtro (0-9) seguido de ':' antes do tamanho descomprimido"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "ao comprimir, se mais de NÚM milissegundos tiverem passado desde o despejo anterior e ler mais dados daentrada bloquearia, todos os dados pendentes serão despejados"
@@ -864,18 +864,18 @@
msgid "LIMIT"
msgstr "LIMITE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "definir limite de uso da memória para compressão, decompressão, descompressão em linhas, ou todos; LIMITE em bytes, % de RAM, ou 0 para pré-definições"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "se as configurações de compressão excederem o limite de uso de memória, devolve um erro em vez de reduzir as configurações"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Cadeia de filtragem personalizada para compressão (alternativa às pré-definições):"
@@ -884,17 +884,17 @@
msgid "FILTERS"
msgstr "FILTROS"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "definir a cadeia de filtros usando a sintaxe da cadeia de filtragem liblzma; use --filters-help para mais informação"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "definir cadeias de filtros adicionais usando a sintaxe da cadeia de filtragem liblzma com --block-list"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "mostrar mais informação sobre a sintaxe da cadeia de filtragem liblzma e sair"
@@ -909,7 +909,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 ou LZMA2; OPÇS é uma lista separada por vírgulas de zero ou mais das seguintes opções (valores válidos; pré-definição):"
@@ -921,12 +921,12 @@
msgid "PRE"
msgstr "PRE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "repor opções numa pré-definição"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "tamanho do dicionário"
@@ -935,17 +935,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "número de bits de contexto literais"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "número de bits de posição literais"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "número de bits de posição"
@@ -954,142 +954,142 @@
msgid "MODE"
msgstr "MODO"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "modo de compressão"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "tamanho simpático duma correspondência"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "localizador de correspondências"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "profundidade máxima de procura; 0=automática (pré-definição)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "filtro x86 BCJ (32-bit e 64-bit)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "filtro ARM BCJ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "filtro ARM-Thumb BCJ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "filtro ARM64 BCJ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "Filtro PowerPC BCJ (só big endian)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "filtro IA-64 (Itanium) BCJ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "Filtro SPARC BCJ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "Filtro RISC-V BCJ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "OPÇS válidas para todos os filtros BCJ:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "desvio inicial para conversões (pré-definição=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Filtro Delta; OPTS válidas (valores válidos; pré-definição):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "distância entre bytes subtraídos uns dos outros"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Outras opções:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "suprimir avisos; especificar duas vezes para suprimir também os erros"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "ser verboso; especificar duas vezes para ainda mais detalhes"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "fazer avisos não afecta o estado da saída"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "usar mensagens analisáveis por máquina (útil para scripts)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "mostra a quantidade total de RAM e os limites de uso de memória actualmente activos e sai"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "mostrar a ajuda curta (lista só as opções básicas)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "mostrar a ajuda longa e sair"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "mostrar esta ajuda curta e sair"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "mostrar a ajuda longa (lista também as opções avançadas)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "mostrar o número da versão e sai"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Sem FICH, ou quando FICH é -, lê da entrada padrão."
@@ -1098,7 +1098,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1106,24 +1106,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "Página inicial %s: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "ESTA É UMA VERSÃO DE DESENVOLVIMENTO NÃO DESTINADA A USO EM PRODUÇÃO."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "As cadeias de filtragem são definidas com --filters=FILTERS ou --filters1=FILTERS ... --filters9=FILTERS. Cada filtro na cadeia pode ser separado por espaços ou '--'. Como alternativa, pode especificar uma pré-definição %s em vez da cadeia de filtragem."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Os filtros suportados e respectivas opções são:"
@@ -1196,7 +1196,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Uso: %s [--help] [--version] [FICH]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Mostrar informação no cabeçalho do ficheiro .lzma."
diff -Nru xz-utils-5.8.1/po/pt_BR.po xz-utils-5.8.3/po/pt_BR.po
--- xz-utils-5.8.1/po/pt_BR.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/pt_BR.po 2026-03-31 15:27:00.000000000 +0000
@@ -9,7 +9,7 @@
msgstr ""
"Project-Id-Version: xz 5.6.0-pre2\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2024-09-22 23:10-0300\n"
"Last-Translator: Rafael Fontenelle \n"
"Language-Team: Brazilian Portuguese \n"
@@ -699,7 +699,7 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -712,45 +712,45 @@
"Comprime e descomprime ARQUIVOs no formato .xz.\n"
"\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Mandatory arguments to long options are mandatory for short options too.\n"
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Argumentos obrigatórios para opções longas também o são para opções curtas.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " Operation mode:\n"
msgid "Operation mode:"
msgstr " Modo de operação:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "force compression"
msgstr "Descompactação:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "force decompression"
msgstr "Descompactação:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -761,29 +761,29 @@
"\n"
" Modificadores de opções:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Writing to standard output failed"
msgid "write to standard output and don't delete input files"
msgstr "A escrita para a saída padrão falhou"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -794,7 +794,7 @@
" --single-stream descomprime apenas o primeiro fluxo, e ignora de forma\n"
" silenciosa possíveis dados de entrada restantes"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr ""
@@ -803,7 +803,7 @@
msgid ".SUF"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr ""
@@ -812,17 +812,17 @@
msgid "FILE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -837,7 +837,7 @@
msgid "FORMAT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr ""
@@ -846,19 +846,19 @@
msgid "NAME"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --ignore-check don't verify the integrity check when decompressing"
msgid "don't verify the integrity check when decompressing"
msgstr " --ignore-check não faz a verificação de integridade ao descomprimir"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -870,7 +870,7 @@
" memória do compressor *e* descompressor em conta\n"
" antes de usar 7-9!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -888,7 +888,7 @@
msgid "NUM"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -903,7 +903,7 @@
msgid "SIZE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -921,7 +921,7 @@
msgid "BLOCKS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -939,7 +939,7 @@
" filtros (0-9) seguido por um ':' antes do tamanho\n"
" dos dados descompactados"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -959,13 +959,13 @@
msgid "LIMIT"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -977,7 +977,7 @@
" de uso de memória, fornece um erro em vez de\n"
" ajustar as configurações para baixo"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -992,7 +992,7 @@
msgid "FILTERS"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1005,7 +1005,7 @@
" --filters=FILTROS define a cadeia de filtros usando a sintaxe de filtro\n"
" do liblzma; use --filters-help para mais informações"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1018,7 +1018,7 @@
" define cadeias de filtros adicionais usando a sintaxe\n"
" de filtro liblzma para usar com --block-list"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1039,7 +1039,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr ""
@@ -1051,12 +1051,12 @@
msgid "PRE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr ""
@@ -1065,17 +1065,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Number of processor threads:"
@@ -1086,89 +1086,89 @@
msgid "MODE"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid "Decompression:"
msgid "compression mode"
msgstr "Descompactação:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1179,31 +1179,31 @@
"\n"
" Outras opções:\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -Q, --no-warn make warnings not affect the exit status"
msgid "make warnings not affect the exit status"
msgstr " -Q, --no-warn faz os avisos não afetarem o status de saída"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " --robot use machine-parsable messages (useful for scripts)"
msgid "use machine-parsable messages (useful for scripts)"
msgstr " --robot usa mensagens analisáveis por máquina (útil p/ scripts)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid ""
@@ -1214,34 +1214,34 @@
" --info-memory exibe a quantidade total de RAM e os limites de uso\n"
" de memória atualmente ativos e sai"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr ""
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy
#| msgid " -V, --version display the version number and exit"
msgid "display the version number and exit"
msgstr " -V, --version exibe o número de versão e sai"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
@@ -1256,7 +1256,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "Report bugs to <%s> (in English or Finnish).\n"
@@ -1267,19 +1267,19 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, fuzzy, c-format
#| msgid "%s home page: <%s>\n"
msgid "%s home page: <%s>"
msgstr "Site do %s: <%s>\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "ESSA É UMA VERSÃO DE DESENVOLVIMENTO, NÃO DESTINADA PARA USO EM PRODUÇÃO."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, fuzzy, c-format
#| msgid ""
@@ -1294,7 +1294,7 @@
"separado por espaços ou \"--\". Alternativamente, uma predefinição <0-9>[e]\n"
"pode ser especificada em vez de uma cadeia de filtros.\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Os filtros suportados e suas opções são:"
@@ -1378,7 +1378,7 @@
"Uso: %s [--help] [--version] [ARQUIVO]...\n"
"Mostra informações armazenadas no cabeçalho do arquivo .lzma"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
#, fuzzy
#| msgid ""
diff -Nru xz-utils-5.8.1/po/ro.po xz-utils-5.8.3/po/ro.po
--- xz-utils-5.8.1/po/ro.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/ro.po 2026-03-31 15:27:00.000000000 +0000
@@ -24,7 +24,7 @@
msgstr ""
"Project-Id-Version: xz 5.8.0-pre1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-03-09 19:21+0100\n"
"Last-Translator: Remus-Gabriel Chelu \n"
"Language-Team: Romanian \n"
@@ -726,72 +726,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Utilizare: %s [OPȚIUNE]... [FIȘIER]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Comprimă sau decomprimă FIȘIER(e) în formatul .xz ."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Argumentele obligatorii pentru opțiunile lungi sunt de asemenea obligatorii pentru opțiunile scurte."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "Mod de operare:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "forțează comprimarea"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "forțează decomprimarea"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "testează integritatea fișierului comprimat"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "listează informații despre fișierele .xz"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Modificatori operație:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "păstrează (nu șterge) fișierele de intrare"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "forțează suprascrierea fișierului de ieșire și (de)comprimă legăturile"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "scrie la ieșirea standard și nu șterge fișierele de intrare"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "nu sincronizează fișierul de ieșire cu dispozitivul de stocare înainte de a elimina fișierul de intrare"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "decomprimă doar primul flux și ignoră în tăcere posibilele date de intrare rămase"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "nu creează fișiere disperse când decomprimă"
@@ -800,7 +800,7 @@
msgid ".SUF"
msgstr ".SUF"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "utilizează sufixul „.SUF” pentru fișierele comprimate"
@@ -809,17 +809,17 @@
msgid "FILE"
msgstr "FIȘIER"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "citește numele fișierelor de procesat din FIȘIER; dacă FIȘIER este omis, numele de fișiere sunt citite de la intrarea standard; numele de fișiere trebuie să fie terminate cu caracterul de linie nouă"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "ca „--files”, dar folosește caracterul null ca terminator"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Formatul de bază al fișierului și opțiunile de comprimare:"
@@ -828,7 +828,7 @@
msgid "FORMAT"
msgstr "FORMAT"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "formatul de fișier pentru codificare sau decodificare; valorile posibile sunt „auto” (implicit), „xz”, „lzma”, „lzip” și „raw”"
@@ -837,22 +837,22 @@
msgid "NAME"
msgstr "NUME"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "tip de verificare a integrității: „none” (utilizați cu precauție), „crc32”, „crc64” (implicit) sau „sha256”"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "nu se efectuează verificarea integrității la decomprimare"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "presetare comprimare; valoarea implicită este 6; luați în considerare memoria utilizată de instrumentul de comprimare *și* de instrumentul de decomprimare, înainte de a utiliza presetările 7-9!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "încearcă să îmbunătățească raportul de comprimare folosind mai mult timp CPU-ul; nu afectează cerințele de memorie ale instrumentului de decomprimare"
@@ -863,7 +863,7 @@
msgid "NUM"
msgstr "NUMĂR"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "utilizează cel mult NUMĂR fire de execuție; valoarea implicită este 0, care utilizează atâtea fire de execuție câte nuclee există în procesor"
@@ -872,7 +872,7 @@
msgid "SIZE"
msgstr "DIM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "începe un nou bloc .xz după fiecare DIM octeți de intrare utilizați acest lucru pentru a stabili dimensiunea blocului pentru comprimarea cu fire de execuție"
@@ -881,12 +881,12 @@
msgid "BLOCKS"
msgstr "BLOCURI"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "începe un nou bloc .xz după intervalele specificate separate prin virgule, de date necomprimate; opțional, specificați un număr de lanț de filtrare (0-9) urmat de „:” înainte de dimensiunea datelor necomprimate"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "la comprimare, dacă au trecut mai mult de NUMĂR de milisecunde de la curățarea anterioară și citirea mai multor intrări s-ar bloca, toate datele în așteptare sunt eliminate"
@@ -895,18 +895,18 @@
msgid "LIMIT"
msgstr "LIMITA"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "stabilește limita de utilizare a memoriei pentru comprimare, decomprimare, decomprimare cu fire sau toate acestea; LIMITA este în octeți, % din RAM sau 0 pentru valorile implicite"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "dacă valorile de comprimare depășesc limita de utilizare a memoriei, dă o eroare în loc să reducă val. stabilite"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Lanț de filtrare personalizat pentru comprimare (alternativă la utilizarea presetărilor):"
@@ -915,17 +915,17 @@
msgid "FILTERS"
msgstr "FILTRE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "definește lanțul de filtre folosind sintaxa șirului de filtre liblzma; utilizați „--filters-help” pentru mai multe informații"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "definește lanțuri de filtre suplimentare folosind sintaxa șirului de filtre liblzma pentru a fi utilizate cu opțiunea „--block-list”"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "afișează mai multe informații despre sintaxa șirului de filtre liblzma și iese"
@@ -940,7 +940,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 sau LZMA2; OPȚI este o listă separată prin virgule, de niciuna sau de mai multe dintre următoarele opțiuni (între paranteze: valorile valide, și cele implicite)"
@@ -952,12 +952,12 @@
msgid "PRE"
msgstr "PRE"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "restabilește opțiunile la o presetare"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "dimensiunea dicționarului"
@@ -966,17 +966,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "numărul de biți de context literal"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "numărul de biți de poziție literală"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "numărul de biți de poziție"
@@ -985,142 +985,142 @@
msgid "MODE"
msgstr "MOD"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "modul de comprimare"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "lungimea „drăguță” a unei potriviri"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "găsitor de potriviri"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "adâncimea maximă de căutare; 0=automată (valoarea implicită)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "filtru BCJ x86 (32-biți și 64-biți)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "filtru BCJ ARM"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "filtru BCJ ARM-Thumb"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "filtru ARM64 BCJ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "filtru BCJ PowerPC (numai big endian)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "filtru BCJ IA-64 (Itanium)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "filtru BCJ SPARC"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "filtru BCJ RISC-V"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "OPȚIUNI valide pentru toate filtrele BCJ:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "poziția de pornire a conversiilor (implicit=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Filtru delta; OPȚI valabile (valori valabile; implicit):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "distanța dintre octeți fiind dedusă scăzând un octet din celălalt"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Alte opțiuni:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "suprimă avertismentele; specificați-o de două ori pentru a suprima și erorile"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "descriere detaliată; specificați-o de două ori pentru și mai multe detalii"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "face ca avertismentele să nu afecteze starea de ieșire"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "utilizează mesaje analizabile de mașină (utile pentru scripturi)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "afișează cantitatea totală de memorie RAM și limitele de utilizare a memoriei active în prezent, și iese"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "afișează ajutorul scurt (enumeră doar opțiunile de bază)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "afișează acest ajutor lung(detaliat) și iese"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "afișează acest scurt mesaj de ajutor, și iese"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "afișează mesajul detaliat de ajutor (afișează și opțiunile avansate)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "afișează numărul versiunii, și iese"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Fără FIȘIER, sau când FIȘIER este „-”, citește de la intrarea standard."
@@ -1129,7 +1129,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1139,24 +1139,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "Pagina principală a %s: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "ACEASTA ESTE O VERSIUNE DE DEZVOLTARE, NEDESTINATĂ UTILIZĂRII ÎN PRODUCȚIE."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "Lanțurile de filtre sunt definite cu ajutorul opțiunilor „--filters=FILTRE” sau „--filters1=FILTRE ... --filters9=FILTRE”. Fiecare filtru din lanț poate fi separat prin spații sau „--”. Alternativ, se poate specifica o presetare %s în locul unui lanț de filtre."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Filtrele acceptate și opțiunile acestora sunt:"
@@ -1229,7 +1229,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Utilizare: %s [--help] [--version] [FIȘIER]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Afișează informațiile stocate în antetul fișierului .lzma ."
diff -Nru xz-utils-5.8.1/po/sr.po xz-utils-5.8.3/po/sr.po
--- xz-utils-5.8.1/po/sr.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/sr.po 2026-03-31 15:27:00.000000000 +0000
@@ -7,7 +7,7 @@
msgstr ""
"Project-Id-Version: xz 5.7.1-dev1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-02-03 07:28+0100\n"
"Last-Translator: Мирослав Николић \n"
"Language-Team: Serbian <(nothing)>\n"
@@ -681,72 +681,72 @@
msgid "Usage: %s [OPTION]... [FILE]...\n"
msgstr "Коришћење: %s [ОПЦИЈА]... [ДАТОТЕКА]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Compress or decompress FILEs in the .xz format."
msgstr "Пакује или распакује ДАТОТЕКЕ у „.xz“ формату."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Mandatory arguments to long options are mandatory for short options too."
msgstr "Обавезни аргументи за дуге опције су такође обавезни и за кратке опције."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation mode:"
msgstr "Режим рада:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force compression"
msgstr "приморава запакивање"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force decompression"
msgstr "приморава распакивање"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "test compressed file integrity"
msgstr "испробава целовитост запаковане датотеке"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "list information about .xz files"
msgstr "исписује информације о „.xz“ даттотекама"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Operation modifiers:"
msgstr "Измењивачи рада:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "keep (don't delete) input files"
msgstr "задржава (не брише) улазне датотеке"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "force overwrite of output file and (de)compress links"
msgstr "приморава преписивање излазне датотеке и (рас)пакује везе"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "write to standard output and don't delete input files"
msgstr "пише на стандардни излаз и не брише улазне датотеке"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't synchronize the output file to the storage device before removing the input file"
msgstr "не усклађује излазну датотеку са смештајним уређајем пре уклањања улазне датотеке"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "decompress only the first stream, and silently ignore possible remaining input data"
msgstr "распакује само први ток, и тихо занемарује могуће преостале улазне податке"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "do not create sparse files when decompressing"
msgstr "не ствара привидне датотеке када распакује"
@@ -755,7 +755,7 @@
msgid ".SUF"
msgstr ".SUF"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use the suffix '.SUF' on compressed files"
msgstr "користи суфикс „.SUF“ на запакованим датотекама"
@@ -764,17 +764,17 @@
msgid "FILE"
msgstr "ДАТОТЕКА"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "read filenames to process from FILE; if FILE is omitted, filenames are read from the standard input; filenames must be terminated with the newline character"
msgstr "чита називе датотека процесу из ДАТОТЕКА; ако је ДАТОТЕКА изостављено, називи датотека се читају са стандардног улаза; називи датотека се морају завршавати знаком новог реда"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "like --files but use the null character as terminator"
msgstr "исто као „--files“ али користи знак ништице као окончавач"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Basic file format and compression options:"
msgstr "Основне опције формата датотеке и запакивања:"
@@ -783,7 +783,7 @@
msgid "FORMAT"
msgstr "ФОРМАТ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "file format to encode or decode; possible values are 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'"
msgstr "формат датотеке за шифровање или дешифровање; могуће вредности су „auto“ (основно), xz, lzma, lzip, и raw"
@@ -792,22 +792,22 @@
msgid "NAME"
msgstr "НАЗИВ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "integrity check type: 'none' (use with caution), 'crc32', 'crc64' (default), or 'sha256'"
msgstr "врста провере целовитости: „none“ (користите уз опрез), „crc32“, „crc64“ (основно), или „sha256“"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "don't verify the integrity check when decompressing"
msgstr "не потврђује проверу целовитости приликом распакивања"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!"
msgstr "претподешавање запакивања; основно је 6; узмите у обзир коришћење меморије запакивања *и* распакивања пре него ли употребите 7-9!"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements"
msgstr "покушава да побољша однос запакивања користећи више времена процесора; не утиче на потребе меморије распакивача"
@@ -818,7 +818,7 @@
msgid "NUM"
msgstr "БРОЈ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores"
msgstr "користи највише БРОЈ нити; основно је 0 за коришћење онолико нити колико има језгара процесора"
@@ -827,7 +827,7 @@
msgid "SIZE"
msgstr "ВЕЛИЧИНА"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression"
msgstr "започиње нови „.xz“ блок након свака ВЕЛИЧИНА бајта улаза; користите ово да поставите величину блока за нитирано запакивање"
@@ -836,12 +836,12 @@
msgid "BLOCKS"
msgstr "БЛОКОВИ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start a new .xz block after the given comma-separated intervals of uncompressed data; optionally, specify a filter chain number (0-9) followed by a ':' before the uncompressed data size"
msgstr "започиње нови „.xz“ блок након датих зарезом одвојених интервала несажетих података; изборно, наводи број ланца филтера (0-9) за којим следе „:“ пре величине несажетих података"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "when compressing, if more than NUM milliseconds has passed since the previous flush and reading more input would block, all pending data is flushed out"
msgstr "приликом запакивања, ако је прошло више од ВРЕМЕ_ИСТЕКА милисекунди до претходног убацивања и читања још улаза блокираће, сви подаци на чекању се истискују ван"
@@ -850,18 +850,18 @@
msgid "LIMIT"
msgstr "ОГРАНИЧЕЊЕ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, no-c-format
msgid "set memory usage limit for compression, decompression, threaded decompression, or all of these; LIMIT is in bytes, % of RAM, or 0 for defaults"
msgstr "поставља ограничење коришћења меморије за запакивање, распакивање, распакивање нити или за све ово; ОГРАНИЧЕЊЕ је у бајтовима, % РАМ-а или 0 за основно"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards"
msgstr "ако подешавања запакивања пређу ограничење коришћења меморије, даје грешку уместо дотеривања подешавања"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Custom filter chain for compression (an alternative to using presets):"
msgstr "Произвољни ланац филтера за запакивање (алтернатива за коришћење предподешавања):"
@@ -870,17 +870,17 @@
msgid "FILTERS"
msgstr "ФИЛТЕРИ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information"
msgstr "поставља ланац филтера користећи синтаксу ниске „liblzma“ филтера; користите „--filters-help“ за више информација"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list"
msgstr "поставља додатне ланце филтера користећи синтаксу ниске „liblzma“ филтера за коришћење са „--block-list“"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display more information about the liblzma filter string syntax and exit"
msgstr "приказује више информација о синтакси ниске „liblzma“ филтера и излази"
@@ -895,7 +895,7 @@
#. your language. There are non-translatable strings
#. that look like "(foo, bar, baz; foo)" which list
#. the supported values and the default value.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "LZMA1 or LZMA2; OPTS is a comma-separated list of zero or more of the following options (valid values; default):"
msgstr "LZMA1 или LZMA2; ОПЦИЈЕ је зарезом раздвојен списак нула или више следећих опција (исправне вредности; основно):"
@@ -907,12 +907,12 @@
msgid "PRE"
msgstr "ПРЕ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "reset options to a preset"
msgstr "враћа опције на предподешеност"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "dictionary size"
msgstr "величина речника"
@@ -921,17 +921,17 @@
#. bits" means how many "context bits" to use when
#. encoding literals. A literal is a single 8-bit
#. byte. It doesn't mean "literally" here.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal context bits"
msgstr "број битова контекста литерала"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of literal position bits"
msgstr "број битова положаја литерала"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "number of position bits"
msgstr "број битова положаја"
@@ -940,142 +940,142 @@
msgid "MODE"
msgstr "РЕЖИМ"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "compression mode"
msgstr "режим запакивања"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "nice length of a match"
msgstr "фина дужина поклапања"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "match finder"
msgstr "поклапа налазача"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "maximum search depth; 0=automatic (default)"
msgstr "највећа дубина претраге; 0=аутоматски (основно)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "x86 BCJ filter (32-bit and 64-bit)"
msgstr "x86 BCJ филтер (32-бита и 64-бита)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM BCJ filter"
msgstr "ARM BCJ филтер"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM-Thumb BCJ filter"
msgstr "ARM-Thumb BCJ филтер"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "ARM64 BCJ filter"
msgstr "ARM64 BCJ филтер"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "PowerPC BCJ filter (big endian only)"
msgstr "PowerPC BCJ филтер (само велика крајност)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "IA-64 (Itanium) BCJ filter"
msgstr "IA-64 (Itanium) BCJ филтер"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "SPARC BCJ filter"
msgstr "SPARC BCJ филтер"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "RISC-V BCJ filter"
msgstr "RISC-V BCJ филтер"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Valid OPTS for all BCJ filters:"
msgstr "Исправне ОПЦИЈЕ за све BCJ филтере:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "start offset for conversions (default=0)"
msgstr "померај почетка за претварање (основно=0)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Delta filter; valid OPTS (valid values; default):"
msgstr "Делта филтер; исправне ОПЦИЈЕ (исправне вредности; основно):"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "distance between bytes being subtracted from each other"
msgstr "растојање између бајтова који су одузети један од другог"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "Other options:"
msgstr "Остале опције:"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "suppress warnings; specify twice to suppress errors too"
msgstr "потискује упозорења; наведите два пута да би потискивао и грешке"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "be verbose; specify twice for even more verbose"
msgstr "бива опширан; наведите два пута за још више опширности"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "make warnings not affect the exit status"
msgstr "чини да упозорења не делују на стање излаза"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "use machine-parsable messages (useful for scripts)"
msgstr "користи поруке обрадиве рачунаром (корисно за скрипте)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the total amount of RAM and the currently active memory usage limits, and exit"
msgstr "приказује укупан износ РАМ-а и тренутно ограничење коришћења активне меморије, и излази"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the short help (lists only the basic options)"
msgstr "приказује кратку помоћ (исписује само основне опције)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this long help and exit"
msgstr "приказује ову опширну помоћ и излази"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display this short help and exit"
msgstr "приказује ову кратку помоћ и излази"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the long help (lists also the advanced options)"
msgstr "приказује дугу помоћ (исписује такође и напредне опције)"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "display the version number and exit"
msgstr "приказује број издања и излази"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
msgid "With no FILE, or when FILE is -, read standard input."
msgstr "Без ДАТОТЕКЕ, или када је ДАТОТЕКА -, чита стандардни улаз."
@@ -1084,7 +1084,7 @@
#. address for this package. Please add another line saying
#. "\nReport translation bugs to <...>." with the email or WWW
#. address for translation bugs. Thanks!
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "Report bugs to <%s> (in English or Finnish)."
@@ -1092,24 +1092,24 @@
#. TRANSLATORS: The first %s is the name of this software.
#. The second <%s> is an URL.
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c src/lzmainfo/lzmainfo.c
#, c-format
msgid "%s home page: <%s>"
msgstr "„%s“ матична страница: <%s>"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "THIS IS A DEVELOPMENT VERSION NOT INTENDED FOR PRODUCTION USE."
msgstr "ОВО ЈЕ РАЗВОЈНО ИЗДАЊЕ И НИЈЕ НАМЕЊЕНО ЗА ПРОФЕСИОНАЛНУ УПОТРЕБУ."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
#, c-format
msgid "Filter chains are set using the --filters=FILTERS or --filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain can be separated by spaces or '--'. Alternatively a preset %s can be specified instead of a filter chain."
msgstr "Ланци филтера су постављени са опцијама „--filters=ФИЛТЕРИ“ или „--filters1=ФИЛТЕРИ“ ... „--filters9=ФИЛТЕРИ“. Сваки филтер у ланцу се може одвојити размацима или „--“. Или предподешеност „%s“ се може навести уместо ланца филтера."
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/xz/message.c
msgid "The supported filters and their options are:"
msgstr "Подржани филтери и њихове опције су:"
@@ -1182,7 +1182,7 @@
msgid "Usage: %s [--help] [--version] [FILE]...\n"
msgstr "Коришћење: %s [--help] [--version] [ДАТОТЕКА]...\n"
-#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpret as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
+#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab itself is not displayed); U+200B is NOT supported. Manual word wrapping with \n is supported but requires care.
#: src/lzmainfo/lzmainfo.c
msgid "Show information stored in the .lzma file header."
msgstr "Приказује информације смештене у заглављу „.lzma“ датотеке."
diff -Nru xz-utils-5.8.1/po/sv.po xz-utils-5.8.3/po/sv.po
--- xz-utils-5.8.1/po/sv.po 2025-04-03 11:34:58.000000000 +0000
+++ xz-utils-5.8.3/po/sv.po 2026-03-31 15:27:00.000000000 +0000
@@ -12,7 +12,7 @@
msgstr ""
"Project-Id-Version: xz 5.7.1-dev1\n"
"Report-Msgid-Bugs-To: xz@tukaani.org\n"
-"POT-Creation-Date: 2025-01-29 20:59+0200\n"
+"POT-Creation-Date: 2026-03-30 17:13+0300\n"
"PO-Revision-Date: 2025-01-24 11:03+0100\n"
"Last-Translator: Luna Jernberg \n"
"Language-Team: Swedish