diff --git a/.github/workflows/compatibility-test.yml b/.github/workflows/compatibility-test.yml new file mode 100644 index 0000000000..e26a566b2f --- /dev/null +++ b/.github/workflows/compatibility-test.yml @@ -0,0 +1,180 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +name: Compatibility-Test + +on: + push: + branches: + - develop + - iotdb + - rc/* + pull_request: + branches: + - develop + - dev/* + - iotdb + - rc/* + workflow_dispatch: + inputs: + forceUpdates: + description: "Forces a snapshot update" + required: false + default: 'false' + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +env: + MAVEN_OPTS: -Dhttp.keepAlive=false -Dmaven.wagon.http.pool=false -Dmaven.wagon.http.retryHandler.class=standard -Dmaven.wagon.http.retryHandler.count=3 + DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }} + +jobs: + generate-fixtures: + name: Generate ${{ matrix.language }} fixtures + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + language: [ java, cpp ] + steps: + - name: Checkout repository + uses: actions/checkout@v6 + + - name: Set up JDK 17 + uses: actions/setup-java@v5 + with: + distribution: corretto + java-version: 17 + + - name: Cache Maven packages + uses: actions/cache@v5 + with: + path: ~/.m2 + key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }} + restore-keys: ${{ runner.os }}-m2- + + - name: Install C++ dependencies + if: matrix.language == 'cpp' + shell: bash + run: | + sudo apt-get update + sudo apt-get install -y uuid-dev + sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-17 100 + sudo update-alternatives --set clang-format /usr/bin/clang-format-17 + + - name: Generate Java table fixtures + if: matrix.language == 'java' + shell: bash + run: | + mkdir -p compat-fixtures/java + ./mvnw -P with-java \ + -Dtest=TableModelEncodingCompressionCompatibilityTest#generateFixtures \ + -Dsurefire.failIfNoSpecifiedTests=false \ + -Dtsfile.compat.generate.dir="$PWD/compat-fixtures/java" \ + test + + - name: Build C++ tests + if: matrix.language == 'cpp' + shell: bash + run: | + ./mvnw -P with-cpp -Dbuild.type=Release -DskipTests package + + - name: Generate C++ table fixtures + if: matrix.language == 'cpp' + shell: bash + run: | + mkdir -p compat-fixtures/cpp + TSFILE_COMPAT_GENERATE_DIR="$PWD/compat-fixtures/cpp" \ + ./cpp/target/build/test/lib/TsFile_Test \ + --gtest_filter=TableModelEncodingCompressionCompatibilityTest.GenerateFixtures + + - name: Upload ${{ matrix.language }} fixtures + uses: actions/upload-artifact@v7 + with: + name: tsfile-${{ matrix.language }}-compat-fixtures + path: compat-fixtures/${{ matrix.language }}/ + retention-days: 1 + + validate-fixtures: + name: Validate ${{ matrix.writer }} fixtures with ${{ matrix.reader }} + needs: generate-fixtures + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + include: + - writer: java + reader: cpp + - writer: cpp + reader: java + steps: + - name: Checkout repository + uses: actions/checkout@v6 + + - name: Set up JDK 17 + uses: actions/setup-java@v5 + with: + distribution: corretto + java-version: 17 + + - name: Cache Maven packages + uses: actions/cache@v5 + with: + path: ~/.m2 + key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }} + restore-keys: ${{ runner.os }}-m2- + + - name: Install C++ dependencies + if: matrix.reader == 'cpp' + shell: bash + run: | + sudo apt-get update + sudo apt-get install -y uuid-dev + sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-17 100 + sudo update-alternatives --set clang-format /usr/bin/clang-format-17 + + - name: Download ${{ matrix.writer }} fixtures + uses: actions/download-artifact@v8 + with: + name: tsfile-${{ matrix.writer }}-compat-fixtures + path: compat-fixtures/${{ matrix.writer }} + + - name: Validate ${{ matrix.writer }} fixtures with Java + if: matrix.reader == 'java' + shell: bash + run: | + ./mvnw -P with-java \ + -Dtest=TableModelEncodingCompressionCompatibilityTest#validateFixtures \ + -Dsurefire.failIfNoSpecifiedTests=false \ + -Dtsfile.compat.validate.dir="$PWD/compat-fixtures/${{ matrix.writer }}" \ + test + + - name: Build C++ tests + if: matrix.reader == 'cpp' + shell: bash + run: | + ./mvnw -P with-cpp -Dbuild.type=Release -DskipTests package + + - name: Validate ${{ matrix.writer }} fixtures with C++ + if: matrix.reader == 'cpp' + shell: bash + run: | + TSFILE_COMPAT_VALIDATE_DIR="$PWD/compat-fixtures/${{ matrix.writer }}" \ + ./cpp/target/build/test/lib/TsFile_Test \ + --gtest_filter=TableModelEncodingCompressionCompatibilityTest.ValidateFixtures diff --git a/cpp/.gitignore b/cpp/.gitignore index 3dc8c5bafe..546adfd8f2 100644 --- a/cpp/.gitignore +++ b/cpp/.gitignore @@ -1,4 +1,7 @@ build/ +!third_party/zstd-1.5.7/build/ +!third_party/zstd-1.5.7/build/cmake/ +!third_party/zstd-1.5.7/build/cmake/** .idea/ .cproject .project diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index 75cc55a4fc..91ea672dac 100755 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -247,6 +247,23 @@ if (ENABLE_ZLIB) add_definitions(-DENABLE_GZIP) endif() +option(ENABLE_ZSTD "Enable Zstandard compression" ON) +message("cmake using: ENABLE_ZSTD=${ENABLE_ZSTD}") + +if (ENABLE_ZSTD) + add_definitions(-DENABLE_ZSTD) +endif() + +option(ENABLE_LZMA2 "Enable LZMA2 compression through bundled XZ Utils" ON) +message("cmake using: ENABLE_LZMA2=${ENABLE_LZMA2}") + +if (ENABLE_LZMA2) + if (CMAKE_VERSION VERSION_LESS 3.20) + message(FATAL_ERROR "ENABLE_LZMA2 requires CMake 3.20 or newer because bundled XZ Utils 5.8.3 requires it") + endif() + add_definitions(-DENABLE_LZMA2) +endif() + option(ENABLE_THREADS "Enable multi-threaded read/write (requires pthreads)" ON) message("cmake using: ENABLE_THREADS=${ENABLE_THREADS}") diff --git a/cpp/build.sh b/cpp/build.sh index f51c4eded3..d78595929c 100644 --- a/cpp/build.sh +++ b/cpp/build.sh @@ -32,6 +32,8 @@ enable_snappy=ON enable_lz4=ON enable_lzokay=ON enable_zlib=ON +enable_zstd=ON +enable_lzma2=ON shell_dir=$(cd "$(dirname "$0")";pwd) @@ -62,6 +64,10 @@ Options: --disable-lzokay --enable-zlib= --disable-zlib + --enable-zstd= + --disable-zstd + --enable-lzma2= + --disable-lzma2 -h, --help Show this help message. EOF } @@ -79,6 +85,8 @@ function print_config() echo "enable_lz4=$enable_lz4" echo "enable_lzokay=$enable_lzokay" echo "enable_zlib=$enable_zlib" + echo "enable_zstd=$enable_zstd" + echo "enable_lzma2=$enable_lzma2" } function run_test_for_cov() @@ -123,6 +131,10 @@ parse_options() enable_lzokay=$(get_key_value "$1");; --enable-zlib=*) enable_zlib=$(get_key_value "$1");; + --enable-zstd=*) + enable_zstd=$(get_key_value "$1");; + --enable-lzma2=*) + enable_lzma2=$(get_key_value "$1");; --disable-antlr4) enable_antlr4=OFF;; --disable-snappy) @@ -133,6 +145,10 @@ parse_options() enable_lzokay=OFF;; --disable-zlib) enable_zlib=OFF;; + --disable-zstd) + enable_zstd=OFF;; + --disable-lzma2) + enable_lzma2=OFF;; -h | --help) usage exit 0;; @@ -199,7 +215,9 @@ cmake ../../ \ -DENABLE_SNAPPY=$enable_snappy \ -DENABLE_LZ4=$enable_lz4 \ -DENABLE_LZOKAY=$enable_lzokay \ - -DENABLE_ZLIB=$enable_zlib + -DENABLE_ZLIB=$enable_zlib \ + -DENABLE_ZSTD=$enable_zstd \ + -DENABLE_LZMA2=$enable_lzma2 VERBOSE=1 make if [ ${do_install} -eq 1 ] diff --git a/cpp/pom.xml b/cpp/pom.xml index 153e75dc21..e82888645a 100644 --- a/cpp/pom.xml +++ b/cpp/pom.xml @@ -39,6 +39,8 @@ ON ON ON + ON + ON ON OFF @@ -87,6 +89,8 @@ + + "): + + +=====+ + | Foo | + +=====+ + + +=====+ + ---> | Bar | + +=====+ + + The above is equivalent to this: + + +=====+=====+ + | Foo | Bar | + +=====+=====+ + + +1.2. Multibyte Integers + + Multibyte integers of static length, such as CRC values, + are stored in little endian byte order (least significant + byte first). + + When smaller values are more likely than bigger values (for + example file sizes), multibyte integers are encoded in a + variable-length representation: + - Numbers in the range [0, 127] are copied as is, and take + one byte of space. + - Bigger numbers will occupy two or more bytes. All but the + last byte of the multibyte representation have the highest + (eighth) bit set. + + For now, the value of the variable-length integers is limited + to 63 bits, which limits the encoded size of the integer to + nine bytes. These limits may be increased in the future if + needed. + + The following C code illustrates encoding and decoding of + variable-length integers. The functions return the number of + bytes occupied by the integer (1-9), or zero on error. + + #include + #include + + size_t + encode(uint8_t buf[static 9], uint64_t num) + { + if (num > UINT64_MAX / 2) + return 0; + + size_t i = 0; + + while (num >= 0x80) { + buf[i++] = (uint8_t)(num) | 0x80; + num >>= 7; + } + + buf[i++] = (uint8_t)(num); + + return i; + } + + size_t + decode(const uint8_t buf[], size_t size_max, uint64_t *num) + { + if (size_max == 0) + return 0; + + if (size_max > 9) + size_max = 9; + + *num = buf[0] & 0x7F; + size_t i = 0; + + while (buf[i++] & 0x80) { + if (i >= size_max || buf[i] == 0x00) + return 0; + + *num |= (uint64_t)(buf[i] & 0x7F) << (i * 7); + } + + return i; + } + + +2. Overall Structure of .xz File + + A standalone .xz files consist of one or more Streams which may + have Stream Padding between or after them: + + +========+================+========+================+ + | Stream | Stream Padding | Stream | Stream Padding | ... + +========+================+========+================+ + + The sizes of Stream and Stream Padding are always multiples + of four bytes, thus the size of every valid .xz file MUST be + a multiple of four bytes. + + While a typical file contains only one Stream and no Stream + Padding, a decoder handling standalone .xz files SHOULD support + files that have more than one Stream or Stream Padding. + + In contrast to standalone .xz files, when the .xz file format + is used as an internal part of some other file format or + communication protocol, it usually is expected that the decoder + stops after the first Stream, and doesn't look for Stream + Padding or possibly other Streams. + + +2.1. Stream + + +-+-+-+-+-+-+-+-+-+-+-+-+=======+=======+ +=======+ + | Stream Header | Block | Block | ... | Block | + +-+-+-+-+-+-+-+-+-+-+-+-+=======+=======+ +=======+ + + +=======+-+-+-+-+-+-+-+-+-+-+-+-+ + ---> | Index | Stream Footer | + +=======+-+-+-+-+-+-+-+-+-+-+-+-+ + + All the above fields have a size that is a multiple of four. If + Stream is used as an internal part of another file format, it + is RECOMMENDED to make the Stream start at an offset that is + a multiple of four bytes. + + Stream Header, Index, and Stream Footer are always present in + a Stream. The maximum size of the Index field is 16 GiB (2^34). + + There are zero or more Blocks. The maximum number of Blocks is + limited only by the maximum size of the Index field. + + Total size of a Stream MUST be less than 8 EiB (2^63 bytes). + The same limit applies to the total amount of uncompressed + data stored in a Stream. + + If an implementation supports handling .xz files with multiple + concatenated Streams, it MAY apply the above limits to the file + as a whole instead of limiting per Stream basis. + + +2.1.1. Stream Header + + +---+---+---+---+---+---+-------+------+--+--+--+--+ + | Header Magic Bytes | Stream Flags | CRC32 | + +---+---+---+---+---+---+-------+------+--+--+--+--+ + + +2.1.1.1. Header Magic Bytes + + The first six (6) bytes of the Stream are so called Header + Magic Bytes. They can be used to identify the file type. + + Using a C array and ASCII: + const uint8_t HEADER_MAGIC[6] + = { 0xFD, '7', 'z', 'X', 'Z', 0x00 }; + + In plain hexadecimal: + FD 37 7A 58 5A 00 + + Notes: + - The first byte (0xFD) was chosen so that the files cannot + be erroneously detected as being in .lzma format, in which + the first byte is in the range [0x00, 0xE0]. + - The sixth byte (0x00) was chosen to prevent applications + from misdetecting the file as a text file. + + If the Header Magic Bytes don't match, the decoder MUST + indicate an error. + + +2.1.1.2. Stream Flags + + The first byte of Stream Flags is always a null byte. In the + future, this byte may be used to indicate a new Stream version + or other Stream properties. + + The second byte of Stream Flags is a bit field: + + Bit(s) Mask Description + 0-3 0x0F Type of Check (see Section 3.4): + ID Size Check name + 0x00 0 bytes None + 0x01 4 bytes CRC32 + 0x02 4 bytes (Reserved) + 0x03 4 bytes (Reserved) + 0x04 8 bytes CRC64 + 0x05 8 bytes (Reserved) + 0x06 8 bytes (Reserved) + 0x07 16 bytes (Reserved) + 0x08 16 bytes (Reserved) + 0x09 16 bytes (Reserved) + 0x0A 32 bytes SHA-256 + 0x0B 32 bytes (Reserved) + 0x0C 32 bytes (Reserved) + 0x0D 64 bytes (Reserved) + 0x0E 64 bytes (Reserved) + 0x0F 64 bytes (Reserved) + 4-7 0xF0 Reserved for future use; MUST be zero for now. + + Implementations SHOULD support at least the Check IDs 0x00 + (None) and 0x01 (CRC32). Supporting other Check IDs is + OPTIONAL. If an unsupported Check is used, the decoder SHOULD + indicate a warning or error. + + If any reserved bit is set, the decoder MUST indicate an error. + It is possible that there is a new field present which the + decoder is not aware of, and can thus parse the Stream Header + incorrectly. + + +2.1.1.3. CRC32 + + The CRC32 is calculated from the Stream Flags field. It is + stored as an unsigned 32-bit little endian integer. If the + calculated value does not match the stored one, the decoder + MUST indicate an error. + + The idea is that Stream Flags would always be two bytes, even + if new features are needed. This way old decoders will be able + to verify the CRC32 calculated from Stream Flags, and thus + distinguish between corrupt files (CRC32 doesn't match) and + files that the decoder doesn't support (CRC32 matches but + Stream Flags has reserved bits set). + + +2.1.2. Stream Footer + + +-+-+-+-+---+---+---+---+-------+------+----------+---------+ + | CRC32 | Backward Size | Stream Flags | Footer Magic Bytes | + +-+-+-+-+---+---+---+---+-------+------+----------+---------+ + + +2.1.2.1. CRC32 + + The CRC32 is calculated from the Backward Size and Stream Flags + fields. It is stored as an unsigned 32-bit little endian + integer. If the calculated value does not match the stored one, + the decoder MUST indicate an error. + + The reason to have the CRC32 field before the Backward Size and + Stream Flags fields is to keep the four-byte fields aligned to + a multiple of four bytes. + + +2.1.2.2. Backward Size + + Backward Size is stored as a 32-bit little endian integer, + which indicates the size of the Index field as multiple of + four bytes, minimum value being four bytes: + + real_backward_size = (stored_backward_size + 1) * 4; + + If the stored value does not match the real size of the Index + field, the decoder MUST indicate an error. + + Using a fixed-size integer to store Backward Size makes + it slightly simpler to parse the Stream Footer when the + application needs to parse the Stream backwards. + + +2.1.2.3. Stream Flags + + This is a copy of the Stream Flags field from the Stream + Header. The information stored to Stream Flags is needed + when parsing the Stream backwards. The decoder MUST compare + the Stream Flags fields in both Stream Header and Stream + Footer, and indicate an error if they are not identical. + + +2.1.2.4. Footer Magic Bytes + + As the last step of the decoding process, the decoder MUST + verify the existence of Footer Magic Bytes. If they don't + match, an error MUST be indicated. + + Using a C array and ASCII: + const uint8_t FOOTER_MAGIC[2] = { 'Y', 'Z' }; + + In hexadecimal: + 59 5A + + The primary reason to have Footer Magic Bytes is to make + it easier to detect incomplete files quickly, without + uncompressing. If the file does not end with Footer Magic Bytes + (excluding Stream Padding described in Section 2.2), it cannot + be undamaged, unless someone has intentionally appended garbage + after the end of the Stream. + + +2.2. Stream Padding + + Only the decoders that support decoding of concatenated Streams + MUST support Stream Padding. + + Stream Padding MUST contain only null bytes. To preserve the + four-byte alignment of consecutive Streams, the size of Stream + Padding MUST be a multiple of four bytes. Empty Stream Padding + is allowed. If these requirements are not met, the decoder MUST + indicate an error. + + Note that non-empty Stream Padding is allowed at the end of the + file; there doesn't need to be a new Stream after non-empty + Stream Padding. This can be convenient in certain situations + [GNU-tar]. + + The possibility of Stream Padding MUST be taken into account + when designing an application that parses Streams backwards, + and the application supports concatenated Streams. + + +3. Block + + +==============+=================+===============+=======+ + | Block Header | Compressed Data | Block Padding | Check | + +==============+=================+===============+=======+ + + +3.1. Block Header + + +-------------------+-------------+=================+ + | Block Header Size | Block Flags | Compressed Size | + +-------------------+-------------+=================+ + + +===================+======================+ + ---> | Uncompressed Size | List of Filter Flags | + +===================+======================+ + + +================+--+--+--+--+ + ---> | Header Padding | CRC32 | + +================+--+--+--+--+ + + +3.1.1. Block Header Size + + This field overlaps with the Index Indicator field (see + Section 4.1). + + This field contains the size of the Block Header field, + including the Block Header Size field itself. Valid values are + in the range [0x01, 0xFF], which indicate the size of the Block + Header as multiples of four bytes, minimum size being eight + bytes: + + real_header_size = (encoded_header_size + 1) * 4; + + If a Block Header bigger than 1024 bytes is needed in the + future, a new field can be added between the Block Header and + Compressed Data fields. The presence of this new field would + be indicated in the Block Header field. + + +3.1.2. Block Flags + + The Block Flags field is a bit field: + + Bit(s) Mask Description + 0-1 0x03 Number of filters (1-4) + 2-5 0x3C Reserved for future use; MUST be zero for now. + 6 0x40 The Compressed Size field is present. + 7 0x80 The Uncompressed Size field is present. + + If any reserved bit is set, the decoder MUST indicate an error. + It is possible that there is a new field present which the + decoder is not aware of, and can thus parse the Block Header + incorrectly. + + +3.1.3. Compressed Size + + This field is present only if the appropriate bit is set in + the Block Flags field (see Section 3.1.2). + + The Compressed Size field contains the size of the Compressed + Data field, which MUST be non-zero. Compressed Size is stored + using the encoding described in Section 1.2. If the Compressed + Size doesn't match the size of the Compressed Data field, the + decoder MUST indicate an error. + + +3.1.4. Uncompressed Size + + This field is present only if the appropriate bit is set in + the Block Flags field (see Section 3.1.2). + + The Uncompressed Size field contains the size of the Block + after uncompressing. Uncompressed Size is stored using the + encoding described in Section 1.2. If the Uncompressed Size + does not match the real uncompressed size, the decoder MUST + indicate an error. + + Storing the Compressed Size and Uncompressed Size fields serves + several purposes: + - The decoder knows how much memory it needs to allocate + for a temporary buffer in multithreaded mode. + - Simple error detection: wrong size indicates a broken file. + - Seeking forwards to a specific location in streamed mode. + + It should be noted that the only reliable way to determine + the real uncompressed size is to uncompress the Block, + because the Block Header and Index fields may contain + (intentionally or unintentionally) invalid information. + + +3.1.5. List of Filter Flags + + +================+================+ +================+ + | Filter 0 Flags | Filter 1 Flags | ... | Filter n Flags | + +================+================+ +================+ + + The number of Filter Flags fields is stored in the Block Flags + field (see Section 3.1.2). + + The format of each Filter Flags field is as follows: + + +===========+====================+===================+ + | Filter ID | Size of Properties | Filter Properties | + +===========+====================+===================+ + + Both Filter ID and Size of Properties are stored using the + encoding described in Section 1.2. Size of Properties indicates + the size of the Filter Properties field as bytes. The list of + officially defined Filter IDs and the formats of their Filter + Properties are described in Section 5.3. + + Filter IDs greater than or equal to 0x4000_0000_0000_0000 + (2^62) are reserved for implementation-specific internal use. + These Filter IDs MUST never be used in List of Filter Flags. + + +3.1.6. Header Padding + + This field contains as many null byte as it is needed to make + the Block Header have the size specified in Block Header Size. + If any of the bytes are not null bytes, the decoder MUST + indicate an error. It is possible that there is a new field + present which the decoder is not aware of, and can thus parse + the Block Header incorrectly. + + +3.1.7. CRC32 + + The CRC32 is calculated over everything in the Block Header + field except the CRC32 field itself. It is stored as an + unsigned 32-bit little endian integer. If the calculated + value does not match the stored one, the decoder MUST indicate + an error. + + By verifying the CRC32 of the Block Header before parsing the + actual contents allows the decoder to distinguish between + corrupt and unsupported files. + + +3.2. Compressed Data + + The format of Compressed Data depends on Block Flags and List + of Filter Flags. Excluding the descriptions of the simplest + filters in Section 5.3, the format of the filter-specific + encoded data is out of scope of this document. + + +3.3. Block Padding + + Block Padding MUST contain 0-3 null bytes to make the size of + the Block a multiple of four bytes. This can be needed when + the size of Compressed Data is not a multiple of four. If any + of the bytes in Block Padding are not null bytes, the decoder + MUST indicate an error. + + +3.4. Check + + The type and size of the Check field depends on which bits + are set in the Stream Flags field (see Section 2.1.1.2). + + The Check, when used, is calculated from the original + uncompressed data. If the calculated Check does not match the + stored one, the decoder MUST indicate an error. If the selected + type of Check is not supported by the decoder, it SHOULD + indicate a warning or error. + + +4. Index + + +-----------------+===================+ + | Index Indicator | Number of Records | + +-----------------+===================+ + + +=================+===============+-+-+-+-+ + ---> | List of Records | Index Padding | CRC32 | + +=================+===============+-+-+-+-+ + + Index serves several purposes. Using it, one can + - verify that all Blocks in a Stream have been processed; + - find out the uncompressed size of a Stream; and + - quickly access the beginning of any Block (random access). + + +4.1. Index Indicator + + This field overlaps with the Block Header Size field (see + Section 3.1.1). The value of Index Indicator is always 0x00. + + +4.2. Number of Records + + This field indicates how many Records there are in the List + of Records field, and thus how many Blocks there are in the + Stream. The value is stored using the encoding described in + Section 1.2. If the decoder has decoded all the Blocks of the + Stream, and then notices that the Number of Records doesn't + match the real number of Blocks, the decoder MUST indicate an + error. + + +4.3. List of Records + + List of Records consists of as many Records as indicated by the + Number of Records field: + + +========+========+ + | Record | Record | ... + +========+========+ + + Each Record contains information about one Block: + + +===============+===================+ + | Unpadded Size | Uncompressed Size | + +===============+===================+ + + If the decoder has decoded all the Blocks of the Stream, it + MUST verify that the contents of the Records match the real + Unpadded Size and Uncompressed Size of the respective Blocks. + + Implementation hint: It is possible to verify the Index with + constant memory usage by calculating for example SHA-256 of + both the real size values and the List of Records, then + comparing the hash values. Implementing this using + non-cryptographic hash like CRC32 SHOULD be avoided unless + small code size is important. + + If the decoder supports random-access reading, it MUST verify + that Unpadded Size and Uncompressed Size of every completely + decoded Block match the sizes stored in the Index. If only + partial Block is decoded, the decoder MUST verify that the + processed sizes don't exceed the sizes stored in the Index. + + +4.3.1. Unpadded Size + + This field indicates the size of the Block excluding the Block + Padding field. That is, Unpadded Size is the size of the Block + Header, Compressed Data, and Check fields. Unpadded Size is + stored using the encoding described in Section 1.2. The value + MUST never be zero; with the current structure of Blocks, the + actual minimum value for Unpadded Size is five. + + Implementation note: Because the size of the Block Padding + field is not included in Unpadded Size, calculating the total + size of a Stream or doing random-access reading requires + calculating the actual size of the Blocks by rounding Unpadded + Sizes up to the next multiple of four. + + The reason to exclude Block Padding from Unpadded Size is to + ease making a raw copy of Compressed Data without Block + Padding. This can be useful, for example, if someone wants + to convert Streams to some other file format quickly. + + +4.3.2. Uncompressed Size + + This field indicates the Uncompressed Size of the respective + Block as bytes. The value is stored using the encoding + described in Section 1.2. + + +4.4. Index Padding + + This field MUST contain 0-3 null bytes to pad the Index to + a multiple of four bytes. If any of the bytes are not null + bytes, the decoder MUST indicate an error. + + +4.5. CRC32 + + The CRC32 is calculated over everything in the Index field + except the CRC32 field itself. The CRC32 is stored as an + unsigned 32-bit little endian integer. If the calculated + value does not match the stored one, the decoder MUST indicate + an error. + + +5. Filter Chains + + The Block Flags field defines how many filters are used. When + more than one filter is used, the filters are chained; that is, + the output of one filter is the input of another filter. The + following figure illustrates the direction of data flow. + + v Uncompressed Data ^ + | Filter 0 | + Encoder | Filter 1 | Decoder + | Filter n | + v Compressed Data ^ + + +5.1. Alignment + + Alignment of uncompressed input data is usually the job of + the application producing the data. For example, to get the + best results, an archiver tool should make sure that all + PowerPC executable files in the archive stream start at + offsets that are multiples of four bytes. + + Some filters, for example LZMA2, can be configured to take + advantage of specified alignment of input data. Note that + taking advantage of aligned input can be beneficial also when + a filter is not the first filter in the chain. For example, + if you compress PowerPC executables, you may want to use the + PowerPC filter and chain that with the LZMA2 filter. Because + not only the input but also the output alignment of the PowerPC + filter is four bytes, it is now beneficial to set LZMA2 + settings so that the LZMA2 encoder can take advantage of its + four-byte-aligned input data. + + The output of the last filter in the chain is stored to the + Compressed Data field, which is is guaranteed to be aligned + to a multiple of four bytes relative to the beginning of the + Stream. This can increase + - speed, if the filtered data is handled multiple bytes at + a time by the filter-specific encoder and decoder, + because accessing aligned data in computer memory is + usually faster; and + - compression ratio, if the output data is later compressed + with an external compression tool. + + +5.2. Security + + If filters would be allowed to be chained freely, it would be + possible to create malicious files, that would be very slow to + decode. Such files could be used to create denial of service + attacks. + + Slow files could occur when multiple filters are chained: + + v Compressed input data + | Filter 1 decoder (last filter) + | Filter 0 decoder (non-last filter) + v Uncompressed output data + + The decoder of the last filter in the chain produces a lot of + output from little input. Another filter in the chain takes the + output of the last filter, and produces very little output + while consuming a lot of input. As a result, a lot of data is + moved inside the filter chain, but the filter chain as a whole + gets very little work done. + + To prevent this kind of slow files, there are restrictions on + how the filters can be chained. These restrictions MUST be + taken into account when designing new filters. + + The maximum number of filters in the chain has been limited to + four, thus there can be at maximum of three non-last filters. + Of these three non-last filters, only two are allowed to change + the size of the data. + + The non-last filters, that change the size of the data, MUST + have a limit how much the decoder can compress the data: the + decoder SHOULD produce at least n bytes of output when the + filter is given 2n bytes of input. This limit is not + absolute, but significant deviations MUST be avoided. + + The above limitations guarantee that if the last filter in the + chain produces 4n bytes of output, the chain as a whole will + produce at least n bytes of output. + + +5.3. Filters + +5.3.1. LZMA2 + + LZMA (Lempel-Ziv-Markov chain-Algorithm) is a general-purpose + compression algorithm with high compression ratio and fast + decompression. LZMA is based on LZ77 and range coding + algorithms. + + LZMA2 is an extension on top of the original LZMA. LZMA2 uses + LZMA internally, but adds support for flushing the encoder, + uncompressed chunks, eases stateful decoder implementations, + and improves support for multithreading. Thus, the plain LZMA + will not be supported in this file format. + + Filter ID: 0x21 + Size of Filter Properties: 1 byte + Changes size of data: Yes + Allow as a non-last filter: No + Allow as the last filter: Yes + + Preferred alignment: + Input data: Adjustable to 1/2/4/8/16 byte(s) + Output data: 1 byte + + The format of the one-byte Filter Properties field is as + follows: + + Bits Mask Description + 0-5 0x3F Dictionary Size + 6-7 0xC0 Reserved for future use; MUST be zero for now. + + Dictionary Size is encoded with one-bit mantissa and five-bit + exponent. The smallest dictionary size is 4 KiB and the biggest + is 4 GiB. + + Raw value Mantissa Exponent Dictionary size + 0 2 11 4 KiB + 1 3 11 6 KiB + 2 2 12 8 KiB + 3 3 12 12 KiB + 4 2 13 16 KiB + 5 3 13 24 KiB + 6 2 14 32 KiB + ... ... ... ... + 35 3 27 768 MiB + 36 2 28 1024 MiB + 37 3 29 1536 MiB + 38 2 30 2048 MiB + 39 3 30 3072 MiB + 40 2 31 4096 MiB - 1 B + + Instead of having a table in the decoder, the dictionary size + can be decoded using the following C code: + + const uint8_t bits = get_dictionary_flags() & 0x3F; + if (bits > 40) + return DICTIONARY_TOO_BIG; // Bigger than 4 GiB + + uint32_t dictionary_size; + if (bits == 40) { + dictionary_size = UINT32_MAX; + } else { + dictionary_size = 2 | (bits & 1); + dictionary_size <<= bits / 2 + 11; + } + + +5.3.2. Branch/Call/Jump Filters for Executables + + These filters convert relative branch, call, and jump + instructions to their absolute counterparts in executable + files. This conversion increases redundancy and thus + compression ratio. + + Size of Filter Properties: 0 or 4 bytes + Changes size of data: No + Allow as a non-last filter: Yes + Allow as the last filter: No + + Below is the list of filters in this category. The alignment + is the same for both input and output data. + + Filter ID Alignment Description + 0x04 1 byte x86 filter (BCJ) + 0x05 4 bytes PowerPC (big endian) filter + 0x06 16 bytes IA64 filter + 0x07 4 bytes ARM filter [1] + 0x08 2 bytes ARM Thumb filter [1] + 0x09 4 bytes SPARC filter + 0x0A 4 bytes ARM64 filter [2] + 0x0B 2 bytes RISC-V filter + + [1] These are for little endian instruction encoding. + This must not be confused with data endianness. + A processor configured for big endian data access + may still use little endian instruction encoding. + The filters don't care about the data endianness. + + [2] 4096-byte alignment gives the best results + because the address in the ADRP instruction + is a multiple of 4096 bytes. + + If the size of Filter Properties is four bytes, the Filter + Properties field contains the start offset used for address + conversions. It is stored as an unsigned 32-bit little endian + integer. The start offset MUST be a multiple of the alignment + of the filter as listed in the table above; if it isn't, the + decoder MUST indicate an error. If the size of Filter + Properties is zero, the start offset is zero. + + Setting the start offset may be useful if an executable has + multiple sections, and there are many cross-section calls. + Taking advantage of this feature usually requires usage of + the Subblock filter, whose design is not complete yet. + + +5.3.3. Delta + + The Delta filter may increase compression ratio when the value + of the next byte correlates with the value of an earlier byte + at specified distance. + + Filter ID: 0x03 + Size of Filter Properties: 1 byte + Changes size of data: No + Allow as a non-last filter: Yes + Allow as the last filter: No + + Preferred alignment: + Input data: 1 byte + Output data: Same as the original input data + + The Properties byte indicates the delta distance, which can be + 1-256 bytes backwards from the current byte: 0x00 indicates + distance of 1 byte and 0xFF distance of 256 bytes. + + +5.3.3.1. Format of the Encoded Output + + The code below illustrates both encoding and decoding with + the Delta filter. + + // Distance is in the range [1, 256]. + const unsigned int distance = get_properties_byte() + 1; + uint8_t pos = 0; + uint8_t delta[256]; + + memset(delta, 0, sizeof(delta)); + + while (1) { + const int byte = read_byte(); + if (byte == EOF) + break; + + uint8_t tmp = delta[(uint8_t)(distance + pos)]; + if (is_encoder) { + tmp = (uint8_t)(byte) - tmp; + delta[pos] = (uint8_t)(byte); + } else { + tmp = (uint8_t)(byte) + tmp; + delta[pos] = tmp; + } + + write_byte(tmp); + --pos; + } + + +5.4. Custom Filter IDs + + If a developer wants to use custom Filter IDs, there are two + choices. The first choice is to contact Lasse Collin and ask + him to allocate a range of IDs for the developer. + + The second choice is to generate a 40-bit random integer + which the developer can use as a personal Developer ID. + To minimize the risk of collisions, Developer ID has to be + a randomly generated integer, not manually selected "hex word". + The following command, which works on many free operating + systems, can be used to generate Developer ID: + + dd if=/dev/urandom bs=5 count=1 | hexdump + + The developer can then use the Developer ID to create unique + (well, hopefully unique) Filter IDs. + + Bits Mask Description + 0-15 0x0000_0000_0000_FFFF Filter ID + 16-55 0x00FF_FFFF_FFFF_0000 Developer ID + 56-62 0x3F00_0000_0000_0000 Static prefix: 0x3F + + The resulting 63-bit integer will use 9 bytes of space when + stored using the encoding described in Section 1.2. To get + a shorter ID, see the beginning of this Section how to + request a custom ID range. + + +5.4.1. Reserved Custom Filter ID Ranges + + Range Description + 0x0000_0300 - 0x0000_04FF Reserved to ease .7z compatibility + 0x0002_0000 - 0x0007_FFFF Reserved to ease .7z compatibility + 0x0200_0000 - 0x07FF_FFFF Reserved to ease .7z compatibility + + +6. Cyclic Redundancy Checks + + There are several incompatible variations to calculate CRC32 + and CRC64. For simplicity and clarity, complete examples are + provided to calculate the checks as they are used in this file + format. Implementations MAY use different code as long as it + gives identical results. + + The program below reads data from standard input, calculates + the CRC32 and CRC64 values, and prints the calculated values + as big endian hexadecimal strings to standard output. + + #include + #include + #include + + uint32_t crc32_table[256]; + uint64_t crc64_table[256]; + + void + init(void) + { + static const uint32_t poly32 = UINT32_C(0xEDB88320); + static const uint64_t poly64 + = UINT64_C(0xC96C5795D7870F42); + + for (size_t i = 0; i < 256; ++i) { + uint32_t crc32 = i; + uint64_t crc64 = i; + + for (size_t j = 0; j < 8; ++j) { + if (crc32 & 1) + crc32 = (crc32 >> 1) ^ poly32; + else + crc32 >>= 1; + + if (crc64 & 1) + crc64 = (crc64 >> 1) ^ poly64; + else + crc64 >>= 1; + } + + crc32_table[i] = crc32; + crc64_table[i] = crc64; + } + } + + uint32_t + crc32(const uint8_t *buf, size_t size, uint32_t crc) + { + crc = ~crc; + for (size_t i = 0; i < size; ++i) + crc = crc32_table[buf[i] ^ (crc & 0xFF)] + ^ (crc >> 8); + return ~crc; + } + + uint64_t + crc64(const uint8_t *buf, size_t size, uint64_t crc) + { + crc = ~crc; + for (size_t i = 0; i < size; ++i) + crc = crc64_table[buf[i] ^ (crc & 0xFF)] + ^ (crc >> 8); + return ~crc; + } + + int + main() + { + init(); + + uint32_t value32 = 0; + uint64_t value64 = 0; + uint64_t total_size = 0; + uint8_t buf[8192]; + + while (1) { + const size_t buf_size + = fread(buf, 1, sizeof(buf), stdin); + if (buf_size == 0) + break; + + total_size += buf_size; + value32 = crc32(buf, buf_size, value32); + value64 = crc64(buf, buf_size, value64); + } + + printf("Bytes: %" PRIu64 "\n", total_size); + printf("CRC-32: 0x%08" PRIX32 "\n", value32); + printf("CRC-64: 0x%016" PRIX64 "\n", value64); + + return 0; + } + + +7. References + + LZMA SDK - The original LZMA implementation + https://7-zip.org/sdk.html + + LZMA Utils - LZMA adapted to POSIX-like systems + https://tukaani.org/lzma/ + + XZ Utils - The next generation of LZMA Utils + https://tukaani.org/xz/ + + [RFC-1952] + GZIP file format specification version 4.3 + https://www.ietf.org/rfc/rfc1952.txt + - Notation of byte boxes in section "2.1. Overall conventions" + + [RFC-2119] + Key words for use in RFCs to Indicate Requirement Levels + https://www.ietf.org/rfc/rfc2119.txt + + [GNU-tar] + GNU tar 1.35 manual + https://www.gnu.org/software/tar/manual/html_node/Blocking-Factor.html + - Node 9.4.2 "Blocking Factor", paragraph that begins + "gzip will complain about trailing garbage" + - Note that this URL points to the latest version of the + manual, and may some day not contain the note which is in + 1.35. For the exact version of the manual, download GNU + tar 1.35: ftp://ftp.gnu.org/pub/gnu/tar/tar-1.35.tar.gz + diff --git a/cpp/third_party/xz-5.8.3/dos/INSTALL.txt b/cpp/third_party/xz-5.8.3/dos/INSTALL.txt new file mode 100644 index 0000000000..e5ba85bdb1 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/dos/INSTALL.txt @@ -0,0 +1,78 @@ + +Building XZ Utils for DOS +========================= + +Introduction + + This document explains how to build XZ Utils for DOS using DJGPP. + The resulting binaries should run at least on various DOS versions + and under Windows 95/98/98SE/ME. + + This is somewhat experimental and has got very little testing. + + Note: Makefile and config.h are updated only now and then. This + means that if you checked out a development version, building for + DOS might not work without updating Makefile and config.h first. + + +Getting and Installing DJGPP + + You may use to help + deciding what to download. If you are only interested in building + XZ Utils, the zip-picker may list files that you don't strictly + need. However, using the zip-picker can still be worth it to get a + nice short summary of installation instructions (they can be found + from readme.1st too). + + For a more manual method, first select a mirror from + and go the + subdirectory named "current". You need the following files: + + unzip32.exe (if you don't already have a LFN-capable unzipper) + v2/djdev205.zip + v2gnu/bnu234b.zip + v2gnu/gcc920b.zip + v2gnu/mak43b.zip + v2misc/csdpmi7b.zip + + If newer versions are available, probably you should try them first. + Note that versions older than djdev205.zip aren't supported. Also + note that you want csdpmi7b.zip even if you run under Windows or + DOSEMU because the XZ Utils Makefile will embed cwsdstub.exe to + the resulting xz.exe. + + See the instructions in readme.1st found from djdev205.zip. Here's + a short summary, but you should still read readme.1st. + + C:\> mkdir DJGPP + C:\> cd DJGPP + C:\DJGPP> c:\download\unzip32 c:\download\djdev205.zip + C:\DJGPP> c:\download\unzip32 c:\download\bnu234b.zip + C:\DJGPP> c:\download\unzip32 c:\download\gcc920b.zip + C:\DJGPP> c:\download\unzip32 c:\download\mak43b.zip + C:\DJGPP> c:\download\unzip32 c:\download\csdpmi7b.zip + + C:\DJGPP> set PATH=C:\DJGPP\BIN;%PATH% + C:\DJGPP> set DJGPP=C:\DJGPP\DJGPP.ENV + + You may want to add the last two lines into AUTOEXEC.BAT or have, + for example, DJGPP.BAT which you can run before using DJGPP. + + Make sure you use completely upper case path in the DJGPP environment + variable. This is not required by DJGPP, but the XZ Utils Makefile is + a bit stupid and expects that everything in DJGPP environment variable + is uppercase. + + +Building + + You need to have an environment that supports long filenames (LFN). + Once you have built XZ Utils, the resulting binaries can be run + without long filename support. + + Run "make" in this directory (the directory containing this + INSTALL.txt). You should get xz.exe (and a bunch of temporary files). + Other tools are not built. Having e.g. xzdec.exe doesn't save much + space compared to xz.exe because the DJGPP runtime makes the .exe + quite big anyway. + diff --git a/cpp/third_party/xz-5.8.3/dos/Makefile b/cpp/third_party/xz-5.8.3/dos/Makefile new file mode 100644 index 0000000000..a3d4ab4ba2 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/dos/Makefile @@ -0,0 +1,150 @@ +# SPDX-License-Identifier: 0BSD + +############################################################################### +# +# Makefile to build XZ Utils using DJGPP +# +# Author: Lasse Collin +# +############################################################################### + +# For debugging, set comment "#define NDEBUG 1" from config.h to enable +# the assert() macro, set STRIP=rem to disable stripping, and finally +# e.g. CFLAGS="-g -O0". +CC = gcc +STRIP = strip +CPPFLAGS = +CFLAGS = -g -Wall -Wextra -Wfatal-errors -march=i386 -mtune=i686 -O2 +LDFLAGS = -lemu + +ALL_CFLAGS = -std=gnu99 + +ALL_CPPFLAGS = \ + -I. \ + -I../lib \ + -I../src/common \ + -I../src/liblzma/api \ + -I../src/liblzma/common \ + -I../src/liblzma/check \ + -I../src/liblzma/rangecoder \ + -I../src/liblzma/lz \ + -I../src/liblzma/lzma \ + -I../src/liblzma/delta \ + -I../src/liblzma/simple \ + -DHAVE_CONFIG_H + +ALL_CPPFLAGS += $(CPPFLAGS) +ALL_CFLAGS += $(CFLAGS) + +.PHONY: all +all: xz.exe + +SRCS_C = \ + ../lib/getopt.c \ + ../lib/getopt1.c \ + ../src/common/tuklib_cpucores.c \ + ../src/common/tuklib_exit.c \ + ../src/common/tuklib_mbstr_fw.c \ + ../src/common/tuklib_mbstr_nonprint.c \ + ../src/common/tuklib_mbstr_width.c \ + ../src/common/tuklib_mbstr_wrap.c \ + ../src/common/tuklib_open_stdxxx.c \ + ../src/common/tuklib_physmem.c \ + ../src/common/tuklib_progname.c \ + ../src/liblzma/check/check.c \ + ../src/liblzma/check/crc32_fast.c \ + ../src/liblzma/check/crc64_fast.c \ + ../src/liblzma/check/sha256.c \ + ../src/liblzma/common/alone_decoder.c \ + ../src/liblzma/common/alone_encoder.c \ + ../src/liblzma/common/block_decoder.c \ + ../src/liblzma/common/block_encoder.c \ + ../src/liblzma/common/block_header_decoder.c \ + ../src/liblzma/common/block_header_encoder.c \ + ../src/liblzma/common/block_util.c \ + ../src/liblzma/common/common.c \ + ../src/liblzma/common/file_info.c \ + ../src/liblzma/common/filter_common.c \ + ../src/liblzma/common/filter_decoder.c \ + ../src/liblzma/common/filter_encoder.c \ + ../src/liblzma/common/filter_flags_decoder.c \ + ../src/liblzma/common/filter_flags_encoder.c \ + ../src/liblzma/common/hardware_physmem.c \ + ../src/liblzma/common/index.c \ + ../src/liblzma/common/index_decoder.c \ + ../src/liblzma/common/index_encoder.c \ + ../src/liblzma/common/index_hash.c \ + ../src/liblzma/common/lzip_decoder.c \ + ../src/liblzma/common/stream_decoder.c \ + ../src/liblzma/common/stream_encoder.c \ + ../src/liblzma/common/stream_flags_common.c \ + ../src/liblzma/common/stream_flags_decoder.c \ + ../src/liblzma/common/stream_flags_encoder.c \ + ../src/liblzma/common/string_conversion.c \ + ../src/liblzma/common/vli_decoder.c \ + ../src/liblzma/common/vli_encoder.c \ + ../src/liblzma/common/vli_size.c \ + ../src/liblzma/delta/delta_common.c \ + ../src/liblzma/delta/delta_decoder.c \ + ../src/liblzma/delta/delta_encoder.c \ + ../src/liblzma/lz/lz_decoder.c \ + ../src/liblzma/lz/lz_encoder.c \ + ../src/liblzma/lz/lz_encoder_mf.c \ + ../src/liblzma/lzma/fastpos_table.c \ + ../src/liblzma/lzma/lzma2_decoder.c \ + ../src/liblzma/lzma/lzma2_encoder.c \ + ../src/liblzma/lzma/lzma_decoder.c \ + ../src/liblzma/lzma/lzma_encoder.c \ + ../src/liblzma/lzma/lzma_encoder_optimum_fast.c \ + ../src/liblzma/lzma/lzma_encoder_optimum_normal.c \ + ../src/liblzma/lzma/lzma_encoder_presets.c \ + ../src/liblzma/rangecoder/price_table.c \ + ../src/liblzma/simple/arm.c \ + ../src/liblzma/simple/arm64.c \ + ../src/liblzma/simple/armthumb.c \ + ../src/liblzma/simple/ia64.c \ + ../src/liblzma/simple/powerpc.c \ + ../src/liblzma/simple/simple_coder.c \ + ../src/liblzma/simple/simple_decoder.c \ + ../src/liblzma/simple/simple_encoder.c \ + ../src/liblzma/simple/sparc.c \ + ../src/liblzma/simple/x86.c \ + ../src/xz/args.c \ + ../src/xz/coder.c \ + ../src/xz/file_io.c \ + ../src/xz/hardware.c \ + ../src/xz/list.c \ + ../src/xz/main.c \ + ../src/xz/message.c \ + ../src/xz/mytime.c \ + ../src/xz/options.c \ + ../src/xz/signals.c \ + ../src/xz/suffix.c \ + ../src/xz/util.c +SRCS_ASM = \ + ../src/liblzma/check/crc32_x86.S \ + ../src/liblzma/check/crc64_x86.S + +OBJS_C = $(SRCS_C:.c=.o) +OBJS_ASM = $(SRCS_ASM:.S=.o) +OBJS = $(OBJS_C) $(OBJS_ASM) + +getopt.h: + update ../lib/getopt.in.h getopt.h + +$(OBJS): getopt.h + +$(OBJS_C): %.o: %.c + $(CC) $(ALL_CPPFLAGS) $(ALL_CFLAGS) -c -o $@ $< + +$(OBJS_ASM): %.o: %.S + $(CC) $(ALL_CPPFLAGS) $(ALL_CFLAGS) -c -o $@ $< + +# Make xz.exe not depend on an external DPMI server. +xz.exe: $(OBJS) + $(CC) $(ALL_CFLAGS) $(OBJS) $(LDFLAGS) -o $@ + $(STRIP) --strip-all $@ + exe2coff $@ + del $@ + copy /b $(DJGPP:DJGPP.ENV=BIN\CWSDSTUB.EXE) + $(@:.exe=) $@ + del $(@:.exe=) diff --git a/cpp/third_party/xz-5.8.3/dos/README.txt b/cpp/third_party/xz-5.8.3/dos/README.txt new file mode 100644 index 0000000000..0e8f6c086e --- /dev/null +++ b/cpp/third_party/xz-5.8.3/dos/README.txt @@ -0,0 +1,123 @@ + +XZ Utils on DOS +=============== + +DOS-specific filename handling + + xz detects at runtime if long filename (LFN) support is + available and will use it by default. It can be disabled by + setting an environment variable: + + set lfn=n + + When xz is in LFN mode, it behaves pretty much the same as it + does on other operating systems. Examples: + + xz foo.tar -> foo.tar.xz + xz -d foo.tar.xz -> foo.tar + + xz -F lzma foo.tar -> foo.tar.lzma + xz -d foo.tar.lzma -> foo.tar + + When LFN support isn't available or it is disabled with LFN=n + environment setting, xz works in short filename (SFN) mode. This + affects filename suffix handling when compressing. + + When compressing to the .xz format in SFN mode: + + - Files without an extension get .xz just like on LFN systems. + + - *.tar files become *.txz (shorthand for *.tar.xz). *.txz + is recognized by xz on all supported operating systems. + (Try to avoid confusing this with gzipped .txt files.) + + - Files with 1-3 character extension have their extension modified + so that the last character is a dash ("-"). If the extension + is already three characters, the last character is lost. The + resulting *.?- or *.??- filename is recognized in LFN mode, but + it isn't recognized by xz on other operating systems. + + Examples: + + xz foo -> foo.xz | xz -d foo.xz -> foo + xz foo.tar -> foo.txz | xz -d foo.txz -> foo.tar + xz foo.c -> foo.c- | xz -d foo.c- -> foo.c + xz read.me -> read.me- | xz -d read.me- -> read.me + xz foo.txt -> foo.tx- | xz -d foo.tx- -> foo.tx ! + + Note that in the last example above, the third character of the + filename extension is lost. + + When compressing to the legacy .lzma format in SFN mode: + + - *.tar files become *.tlz (shorthand for *.tar.lzma). *.tlz + is recognized by xz on all supported operating systems. + + - Other files become *.lzm. The original filename extension + is lost. *.lzm is recognized also in LFN mode, but it is not + recognized by xz on other operating systems. + + Examples: + + xz -F lzma foo -> foo.lzm | xz -d foo.lzm -> foo + xz -F lzma foo.tar -> foo.tlz | xz -d foo.tlz -> foo.tar + xz -F lzma foo.c -> foo.lzm | xz -d foo.lzm -> foo ! + xz -F lzma read.me -> read.lzm | xz -d read.lzm -> read ! + xz -F lzma foo.txt -> foo.lzm | xz -d foo.lzm -> foo ! + + When compressing with a custom suffix (-S .SUF, --suffix=.SUF) to + any file format: + + - If the suffix begins with a dot, the filename extension is + replaced with the new suffix. The original extension is lost. + + - If the suffix doesn't begin with a dot and the filename has no + extension and the filename given on the command line doesn't + have a dot at the end, the custom suffix is appended just like + on LFN systems. + + - If the suffix doesn't begin with a dot and the filename has + an extension (or an extension-less filename is given with a dot + at the end), the last 1-3 characters of the filename extension + may get overwritten to fit the given custom suffix. + + Examples: + + xz -S x foo -> foox | xz -dS x foox -> foo + xz -S x foo. -> foo.x | xz -dS x foo.x -> foo + xz -S .x foo -> foo.x | xz -dS .x foo.x -> foo + xz -S .x foo. -> foo.x | xz -dS .x foo.x -> foo + xz -S x.y foo -> foox.y | xz -dS x.y foox.y -> foo + xz -S .a foo.c -> foo.a | xz -dS .a foo.a -> foo ! + xz -S a foo.c -> foo.ca | xz -dS a foo.ca -> foo.c + xz -S ab foo.c -> foo.cab | xz -dS ab foo.cab -> foo.c + xz -S ab read.me -> read.mab | xz -dS ab read.mab -> read.m ! + xz -S ab foo.txt -> foo.tab | xz -dS ab foo.tab -> foo.t ! + xz -S abc foo.txt -> foo.abc | xz -dS abc foo.abc -> foo ! + + When decompressing, the suffix handling in SFN mode is the same as + in LFN mode. The DOS-specific filenames *.lzm, *.?-, and *.??- are + recognized also in LFN mode. + + xz handles certain uncommon situations safely: + + - If the generated output filename refers to the same file as + the input file, xz detects this and refuses to compress or + decompress the input file even if --force is used. This can + happen when giving an overlong filename in SFN mode. E.g. + "xz -S x foo.texinfo" would try to write to foo.tex which on + SFN system is the same file as foo.texinfo. + + - If the generated output filename is a special file like "con" + or "prn", xz detects this and refuses to compress or decompress + the input file even if --force is used. + + +Bugs + + xz doesn't necessarily work in Dosbox. It should work in DOSEMU. + + Pressing Ctrl-c or Ctrl-Break won't remove the incomplete target file + when running under Windows XP Command Prompt (something goes wrong + with SIGINT handling). It works correctly under Windows 95/98/98SE/ME. + diff --git a/cpp/third_party/xz-5.8.3/dos/config.h b/cpp/third_party/xz-5.8.3/dos/config.h new file mode 100644 index 0000000000..4bab00e131 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/dos/config.h @@ -0,0 +1,146 @@ +/* SPDX-License-Identifier: 0BSD */ + +/* How many MiB of RAM to assume if the real amount cannot be determined. */ +#define ASSUME_RAM 32 + +/* Define to 1 if crc32 integrity check is enabled. */ +#define HAVE_CHECK_CRC32 1 + +/* Define to 1 if crc64 integrity check is enabled. */ +#define HAVE_CHECK_CRC64 1 + +/* Define to 1 if sha256 integrity check is enabled. */ +#define HAVE_CHECK_SHA256 1 + +/* Define to 1 if the 32-bit x86 CRC assembly files are used. */ +#define HAVE_CRC_X86_ASM 1 + +/* Define to 1 if any of HAVE_DECODER_foo have been defined. */ +#define HAVE_DECODERS 1 + +/* Define to 1 if arm decoder is enabled. */ +#define HAVE_DECODER_ARM 1 + +/* Define to 1 if arm64 decoder is enabled. */ +#define HAVE_DECODER_ARM64 1 + +/* Define to 1 if armthumb decoder is enabled. */ +#define HAVE_DECODER_ARMTHUMB 1 + +/* Define to 1 if delta decoder is enabled. */ +#define HAVE_DECODER_DELTA 1 + +/* Define to 1 if ia64 decoder is enabled. */ +#define HAVE_DECODER_IA64 1 + +/* Define to 1 if lzma1 decoder is enabled. */ +#define HAVE_DECODER_LZMA1 1 + +/* Define to 1 if lzma2 decoder is enabled. */ +#define HAVE_DECODER_LZMA2 1 + +/* Define to 1 if powerpc decoder is enabled. */ +#define HAVE_DECODER_POWERPC 1 + +/* Define to 1 if sparc decoder is enabled. */ +#define HAVE_DECODER_SPARC 1 + +/* Define to 1 if x86 decoder is enabled. */ +#define HAVE_DECODER_X86 1 + +/* Define to 1 if any of HAVE_ENCODER_foo have been defined. */ +#define HAVE_ENCODERS 1 + +/* Define to 1 if arm encoder is enabled. */ +#define HAVE_ENCODER_ARM 1 + +/* Define to 1 if arm64 encoder is enabled. */ +#define HAVE_ENCODER_ARM64 1 + +/* Define to 1 if armthumb encoder is enabled. */ +#define HAVE_ENCODER_ARMTHUMB 1 + +/* Define to 1 if delta encoder is enabled. */ +#define HAVE_ENCODER_DELTA 1 + +/* Define to 1 if ia64 encoder is enabled. */ +#define HAVE_ENCODER_IA64 1 + +/* Define to 1 if lzma1 encoder is enabled. */ +#define HAVE_ENCODER_LZMA1 1 + +/* Define to 1 if lzma2 encoder is enabled. */ +#define HAVE_ENCODER_LZMA2 1 + +/* Define to 1 if powerpc encoder is enabled. */ +#define HAVE_ENCODER_POWERPC 1 + +/* Define to 1 if sparc encoder is enabled. */ +#define HAVE_ENCODER_SPARC 1 + +/* Define to 1 if x86 encoder is enabled. */ +#define HAVE_ENCODER_X86 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if .lz (lzip) decompression support is enabled. */ +#define HAVE_LZIP_DECODER 1 + +/* Define to 1 to enable bt2 match finder. */ +#define HAVE_MF_BT2 1 + +/* Define to 1 to enable bt3 match finder. */ +#define HAVE_MF_BT3 1 + +/* Define to 1 to enable bt4 match finder. */ +#define HAVE_MF_BT4 1 + +/* Define to 1 to enable hc3 match finder. */ +#define HAVE_MF_HC3 1 + +/* Define to 1 to enable hc4 match finder. */ +#define HAVE_MF_HC4 1 + +/* Define to 1 if stdbool.h conforms to C99. */ +#define HAVE_STDBOOL_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the 'utimes' function. */ +#define HAVE_UTIMES 1 + +/* Define to 1 or 0, depending whether the compiler supports simple visibility + declarations. */ +#define HAVE_VISIBILITY 0 + +/* Define to 1 if the system has the type '_Bool'. */ +#define HAVE__BOOL 1 + +/* Define to 1 if the GNU C extension __builtin_assume_aligned is supported. + */ +#define HAVE___BUILTIN_ASSUME_ALIGNED 1 + +/* Define to 1 if the GNU C extensions __builtin_bswap16/32/64 are supported. + */ +#define HAVE___BUILTIN_BSWAPXX 1 + +/* Define to 1 to disable debugging code. */ +#define NDEBUG 1 + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "xz@tukaani.org" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "XZ Utils" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "https://tukaani.org/xz/" + +/* The size of 'size_t', as computed by sizeof. */ +#define SIZEOF_SIZE_T 4 + +/* Define to 1 if the system supports fast unaligned access to 16-bit and + 32-bit integers. */ +#define TUKLIB_FAST_UNALIGNED_ACCESS 1 diff --git a/cpp/third_party/xz-5.8.3/doxygen/Doxyfile b/cpp/third_party/xz-5.8.3/doxygen/Doxyfile new file mode 100644 index 0000000000..e13724e788 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/doxygen/Doxyfile @@ -0,0 +1,45 @@ +# SPDX-License-Identifier: 0BSD + +# Run "doxygen" in this directory to generate the liblzma API documentation +# into ../doc/api. +# +# Use the "update-doxygen" script for more choices: +# - Include the liblzma version number in the generated documentation. +# - 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.9.8 and 1.13.2. + +PROJECT_NAME = "liblzma (XZ Utils)" +OUTPUT_DIRECTORY = ../doc +STRIP_FROM_PATH = ../src/liblzma/api +INPUT = ../src/liblzma/api +FILE_PATTERNS = *.c *.h +RECURSIVE = YES +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 +HTML_OUTPUT = api +HTML_COLORSTYLE_HUE = 210 +HTML_COLORSTYLE_SAT = 180 +HTML_COLORSTYLE_GAMMA = 110 +HTML_DYNAMIC_MENUS = NO +SEARCHENGINE = NO +GENERATE_LATEX = NO +MACRO_EXPANSION = YES +EXPAND_ONLY_PREDEF = YES +PREDEFINED = LZMA_API(type)=type \ + LZMA_API_IMPORT= \ + LZMA_API_CALL= \ + 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 --git a/cpp/third_party/xz-5.8.3/doxygen/update-doxygen b/cpp/third_party/xz-5.8.3/doxygen/update-doxygen new file mode 100755 index 0000000000..c5d6ad39f1 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/doxygen/update-doxygen @@ -0,0 +1,114 @@ +#!/bin/sh +# SPDX-License-Identifier: 0BSD + +############################################################################# +# +# While it's possible to use the Doxyfile as is to generate liblzma API +# documentation, it is recommended to use this script because this adds +# the XZ Utils version number to the generated HTML. +# +# Other features: +# - Generate documentation of the XZ Utils internals. +# - Set input and output paths for out-of-tree builds. +# +############################################################################# +# +# Authors: Jia Tan +# Lasse Collin +# +############################################################################# + +set -e + +show_usage() +{ + echo "Usage: $0 [ABS_TOP_SRCDIR ABS_OUTDIR]" + echo + echo "Supported modes:" + echo " - 'api' (default): liblzma API docs into doc/api" + echo " - 'internal': internal docs into doc/internal" + echo + echo "Absolute source and output dirs may be set" \ + "to do an out-of-tree build." + echo "The output directory must already exist." + exit 1 +} + +case $1 in + api|internal) + ;; + *) + show_usage + ;; +esac + +if type doxygen > /dev/null 2>&1; then + : +else + echo "$0: 'doxygen' command not found" >&2 + exit 1 +fi + +case $# in + 1) + # One argument: Building inside the source tree + ABS_TOP_SRCDIR=`dirname "$0"`/.. + ABS_OUTDIR=$ABS_TOP_SRCDIR/doc + ;; + 3) + # Three arguments: Possibly an out of tree build + ABS_TOP_SRCDIR=$2 + ABS_OUTDIR=$3 + ;; + *) + show_usage + ;; +esac + +if test ! -f "$ABS_TOP_SRCDIR/doxygen/Doxyfile"; then + echo "$0: Source dir '$ABS_TOP_SRCDIR/doxygen/Doxyfile' not found" >&2 + exit 1 +fi +if test ! -d "$ABS_OUTDIR"; then + echo "$0: Output dir '$ABS_OUTDIR' not found" >&2 + exit 1 +fi + +# Get the package version so that it can be included in the generated docs. +PACKAGE_VERSION=`cd "$ABS_TOP_SRCDIR" && sh build-aux/version.sh` + +case $1 in + api) + # Remove old documentation before re-generating the new. + rm -rf "$ABS_OUTDIR/api" + + # Generate the HTML documentation by preparing the Doxyfile + # in stdin and piping the result to the doxygen command. + # With Doxygen, the last assignment of a value to a tag will + # override any earlier assignment. So, we can use this + # feature to override the tags that need to change between + # "api" and "internal" modes. + ABS_SRCDIR=$ABS_TOP_SRCDIR/src/liblzma/api + ( + cat "$ABS_TOP_SRCDIR/doxygen/Doxyfile" + echo "PROJECT_NUMBER = $PACKAGE_VERSION" + echo "OUTPUT_DIRECTORY = $ABS_OUTDIR" + echo "STRIP_FROM_PATH = $ABS_SRCDIR" + echo "INPUT = $ABS_SRCDIR" + ) | doxygen -q - + ;; + + internal) + rm -rf "$ABS_OUTDIR/internal" + ( + cat "$ABS_TOP_SRCDIR/doxygen/Doxyfile" + echo 'PROJECT_NAME = "XZ Utils"' + echo "PROJECT_NUMBER = $PACKAGE_VERSION" + echo "OUTPUT_DIRECTORY = $ABS_OUTDIR" + echo "STRIP_FROM_PATH = $ABS_TOP_SRCDIR" + echo "INPUT = $ABS_TOP_SRCDIR/src" + echo 'HTML_OUTPUT = internal' + echo 'SEARCHENGINE = YES' + ) | doxygen -q - + ;; +esac diff --git a/cpp/third_party/xz-5.8.3/extra/7z2lzma/7z2lzma.bash b/cpp/third_party/xz-5.8.3/extra/7z2lzma/7z2lzma.bash new file mode 100755 index 0000000000..351108c87a --- /dev/null +++ b/cpp/third_party/xz-5.8.3/extra/7z2lzma/7z2lzma.bash @@ -0,0 +1,113 @@ +#!/bin/bash +# SPDX-License-Identifier: 0BSD + +############################################################################# +# +# 7z2lzma.bash is very primitive .7z to .lzma converter. The input file must +# have exactly one LZMA compressed stream, which has been created with the +# default lc, lp, and pb values. The CRC32 in the .7z archive is not checked, +# and the script may seem to succeed while it actually created a corrupt .lzma +# file. You should always try uncompressing both the original .7z and the +# created .lzma and compare that the output is identical. +# +# This script requires basic GNU tools and 7z or 7za tool from p7zip. +# +# Last modified: 2009-01-15 14:25+0200 +# +############################################################################# +# +# Author: Lasse Collin +# +############################################################################# + +# You can use 7z or 7za, both will work. +SEVENZIP=7za + +if [ $# != 2 -o -z "$1" -o -z "$2" ]; then + echo "Usage: $0 input.7z output.lzma" + exit 1 +fi + +# Converts an integer variable to little endian binary integer. +int2bin() +{ + local LEN=$1 + local NUM=$2 + local HEX=(0 1 2 3 4 5 6 7 8 9 A B C D E F) + local I + for ((I=0; I < "$LEN"; ++I)); do + printf "\\x${HEX[(NUM >> 4) & 0x0F]}${HEX[NUM & 0x0F]}" + NUM=$((NUM >> 8)) + done +} + +# Make sure we get possible errors from pipes. +set -o pipefail + +# Get information about the input file. At least older 7z and 7za versions +# may return with zero exit status even when an error occurred, so check +# if the output has any lines beginning with "Error". +INFO=$("$SEVENZIP" l -slt "$1") +if [ $? != 0 ] || printf '%s\n' "$INFO" | grep -q ^Error; then + printf '%s\n' "$INFO" + exit 1 +fi + +# Check if the input file has more than one compressed block. +if printf '%s\n' "$INFO" | grep -q '^Block = 1'; then + echo "Cannot convert, because the input file has more than" + echo "one compressed block." + exit 1 +fi + +# Get compressed, uncompressed, and dictionary size. +CSIZE=$(printf '%s\n' "$INFO" | sed -rn 's|^Packed Size = ([0-9]+$)|\1|p') +USIZE=$(printf '%s\n' "$INFO" | sed -rn 's|^Size = ([0-9]+$)|\1|p') +DICT=$(printf '%s\n' "$INFO" | sed -rn 's|^Method = LZMA:([0-9]+[bkm]?)$|\1|p') + +if [ -z "$CSIZE" -o -z "$USIZE" -o -z "$DICT" ]; then + echo "Parsing output of $SEVENZIP failed. Maybe the file uses some" + echo "other compression method than plain LZMA." + exit 1 +fi + +# The following assumes that the default lc, lp, and pb settings were used. +# Otherwise the output will be corrupt. +printf '\x5D' > "$2" + +# Dictionary size can be either was power of two, bytes, kibibytes, or +# mebibytes. We need to convert it to bytes. +case $DICT in + *b) + DICT=${DICT%b} + ;; + *k) + DICT=${DICT%k} + DICT=$((DICT << 10)) + ;; + *m) + DICT=${DICT%m} + DICT=$((DICT << 20)) + ;; + *) + DICT=$((1 << DICT)) + ;; +esac +int2bin 4 "$DICT" >> "$2" + +# Uncompressed size +int2bin 8 "$USIZE" >> "$2" + +# Copy the actual compressed data. Using multiple dd commands to avoid +# copying large amount of data with one-byte block size, which would be +# annoyingly slow. +BS=8192 +BIGSIZE=$((CSIZE / BS)) +CSIZE=$((CSIZE % BS)) +{ + dd of=/dev/null bs=32 count=1 \ + && dd bs="$BS" count="$BIGSIZE" \ + && dd bs=1 count="$CSIZE" +} < "$1" >> "$2" + +exit $? diff --git a/cpp/third_party/xz-5.8.3/extra/scanlzma/scanlzma.c b/cpp/third_party/xz-5.8.3/extra/scanlzma/scanlzma.c new file mode 100644 index 0000000000..1c8fcd8f48 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/extra/scanlzma/scanlzma.c @@ -0,0 +1,90 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +/* + scanlzma, scan for lzma compressed data in stdin and echo it to stdout. + Copyright (C) 2006 Timo Lindfors + + 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 + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. +*/ + +/* Usage example: + + $ wget http://www.wifi-shop.cz/Files/produkty/wa2204/wa2204av1.4.1.zip + $ unzip wa2204av1.4.1.zip + $ gcc scanlzma.c -o scanlzma -Wall + $ ./scanlzma 0 < WA2204-FW1.4.1/linux-1.4.bin | lzma -c -d | strings | grep -i "copyright" + UpdateDD version 2.5, Copyright (C) 2005 Philipp Benner. + Copyright (C) 2005 Philipp Benner. + Copyright (C) 2005 Philipp Benner. + mawk 1.3%s%s %s, Copyright (C) Michael D. Brennan + # Copyright (C) 1998, 1999, 2001 Henry Spencer. + ... + +*/ + + +/* LZMA compressed file format */ +/* --------------------------- */ +/* Offset Size Description */ +/* 0 1 Special LZMA properties for compressed data */ +/* 1 4 Dictionary size (little endian) */ +/* 5 8 Uncompressed size (little endian). -1 means unknown size */ +/* 13 Compressed data */ + +#include +#include +#include + +#define BUFSIZE 4096 + +int find_lzma_header(unsigned char *buf) { + return (buf[0] < 0xE1 + && buf[0] == 0x5d + && buf[4] < 0x20 + && (memcmp (buf + 10 , "\x00\x00\x00", 3) == 0 + || (memcmp (buf + 5, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 8) == 0))); +} + +int main(int argc, char *argv[]) { + unsigned char buf[BUFSIZE]; + int ret, i, numlzma, blocks=0; + + if (argc != 2) { + printf("usage: %s numlzma < infile | lzma -c -d > outfile\n" + "where numlzma is index of lzma file to extract, starting from zero.\n", + argv[0]); + exit(1); + } + numlzma = atoi(argv[1]); + + for (;;) { + /* Read data. */ + ret = fread(buf, BUFSIZE, 1, stdin); + if (ret != 1) + break; + + /* Scan for signature. */ + for (i = 0; i $@-t + mv -f $@-t $@ diff --git a/cpp/third_party/xz-5.8.3/lib/Makefile.in b/cpp/third_party/xz-5.8.3/lib/Makefile.in new file mode 100644 index 0000000000..f097e04052 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/Makefile.in @@ -0,0 +1,625 @@ +# Makefile.in generated by automake 1.18.1 from Makefile.am. +# @configure_input@ + +# 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, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = { \ + if test -z '$(MAKELEVEL)'; then \ + false; \ + elif test -n '$(MAKE_HOST)'; then \ + true; \ + elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ + true; \ + else \ + false; \ + fi; \ +} +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +am__rm_f = rm -f $(am__rm_f_notfound) +am__rm_rf = rm -rf $(am__rm_f_notfound) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +subdir = lib +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ax_pthread.m4 \ + $(top_srcdir)/m4/build-to-host.m4 $(top_srcdir)/m4/getopt.m4 \ + $(top_srcdir)/m4/gettext.m4 $(top_srcdir)/m4/host-cpu-c-abi.m4 \ + $(top_srcdir)/m4/iconv.m4 $(top_srcdir)/m4/intlmacosx.m4 \ + $(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \ + $(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/libtool.m4 \ + $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \ + $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \ + $(top_srcdir)/m4/nls.m4 $(top_srcdir)/m4/po.m4 \ + $(top_srcdir)/m4/posix-shell.m4 $(top_srcdir)/m4/progtest.m4 \ + $(top_srcdir)/m4/tuklib_common.m4 \ + $(top_srcdir)/m4/tuklib_cpucores.m4 \ + $(top_srcdir)/m4/tuklib_integer.m4 \ + $(top_srcdir)/m4/tuklib_mbstr.m4 \ + $(top_srcdir)/m4/tuklib_physmem.m4 \ + $(top_srcdir)/m4/tuklib_progname.m4 \ + $(top_srcdir)/m4/visibility.m4 $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +LIBRARIES = $(noinst_LIBRARIES) +ARFLAGS = cr +AM_V_AR = $(am__v_AR_@AM_V@) +am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@) +am__v_AR_0 = @echo " AR " $@; +am__v_AR_1 = +libgnu_a_AR = $(AR) $(ARFLAGS) +libgnu_a_RANLIB = $(RANLIB) +am_libgnu_a_OBJECTS = +libgnu_a_OBJECTS = $(am_libgnu_a_OBJECTS) +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) +depcomp = $(SHELL) $(top_srcdir)/build-aux/depcomp +am__maybe_remake_depfiles = depfiles +am__depfiles_remade = $(DEPDIR)/getopt.Po $(DEPDIR)/getopt1.Po +am__mv = mv -f +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +AM_V_lt = $(am__v_lt_@AM_V@) +am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) +am__v_lt_0 = --silent +am__v_lt_1 = +LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CFLAGS) $(CFLAGS) +AM_V_CC = $(am__v_CC_@AM_V@) +am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) +am__v_CC_0 = @echo " CC " $@; +am__v_CC_1 = +CCLD = $(CC) +LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CCLD = $(am__v_CCLD_@AM_V@) +am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) +am__v_CCLD_0 = @echo " CCLD " $@; +am__v_CCLD_1 = +SOURCES = $(libgnu_a_SOURCES) +DIST_SOURCES = $(libgnu_a_SOURCES) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +am__DIST_COMMON = $(srcdir)/Makefile.in \ + $(top_srcdir)/build-aux/depcomp getopt.c getopt1.c +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_CFLAGS = @AM_CFLAGS@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AS = @AS@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCAS = @CCAS@ +CCASDEPMODE = @CCASDEPMODE@ +CCASFLAGS = @CCASFLAGS@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CFLAG_VISIBILITY = @CFLAG_VISIBILITY@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CSCOPE = @CSCOPE@ +CTAGS = @CTAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +ETAGS = @ETAGS@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +FILECMD = @FILECMD@ +GETOPT_H = @GETOPT_H@ +GETTEXT_MACRO_VERSION = @GETTEXT_MACRO_VERSION@ +GMSGFMT = @GMSGFMT@ +GMSGFMT_015 = @GMSGFMT_015@ +GREP = @GREP@ +HAVE_VISIBILITY = @HAVE_VISIBILITY@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +INTLLIBS = @INTLLIBS@ +INTL_MACOSX_LIBS = @INTL_MACOSX_LIBS@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBICONV = @LIBICONV@ +LIBINTL = @LIBINTL@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LINKER_FLAG_UNDEFINED_VERSION = @LINKER_FLAG_UNDEFINED_VERSION@ +LIPO = @LIPO@ +LN_EXEEXT = @LN_EXEEXT@ +LN_S = @LN_S@ +LTLIBICONV = @LTLIBICONV@ +LTLIBINTL = @LTLIBINTL@ +LTLIBOBJS = @LTLIBOBJS@ +LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ +MAKEINFO = @MAKEINFO@ +MANIFEST_TOOL = @MANIFEST_TOOL@ +MKDIR_P = @MKDIR_P@ +MSGFMT = @MSGFMT@ +MSGMERGE = @MSGMERGE@ +MSGMERGE_FOR_MSGFMT_OPTION = @MSGMERGE_FOR_MSGFMT_OPTION@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +POSIX_SHELL = @POSIX_SHELL@ +POSUB = @POSUB@ +PREFERABLY_POSIX_SHELL = @PREFERABLY_POSIX_SHELL@ +PTHREAD_CC = @PTHREAD_CC@ +PTHREAD_CFLAGS = @PTHREAD_CFLAGS@ +PTHREAD_CXX = @PTHREAD_CXX@ +PTHREAD_LIBS = @PTHREAD_LIBS@ +RANLIB = @RANLIB@ +RC = @RC@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +USE_NLS = @USE_NLS@ +VERSION = @VERSION@ +XGETTEXT = @XGETTEXT@ +XGETTEXT_015 = @XGETTEXT_015@ +XGETTEXT_EXTRA_OPTIONS = @XGETTEXT_EXTRA_OPTIONS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_AR = @ac_ct_AR@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__rm_f_notfound = @am__rm_f_notfound@ +am__tar = @am__tar@ +am__untar = @am__untar@ +am__xargs_n = @am__xargs_n@ +ax_pthread_config = @ax_pthread_config@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +enable_path_for_scripts = @enable_path_for_scripts@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localedir_c = @localedir_c@ +localedir_c_make = @localedir_c_make@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +runstatedir = @runstatedir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +xz = @xz@ +noinst_LIBRARIES = libgnu.a +libgnu_a_SOURCES = +libgnu_a_DEPENDENCIES = $(LIBOBJS) +libgnu_a_LIBADD = $(LIBOBJS) +EXTRA_DIST = \ + getopt.in.h \ + getopt.c \ + getopt1.c \ + getopt_int.h \ + getopt-cdefs.h \ + getopt-core.h \ + getopt-ext.h \ + getopt-pfx-core.h \ + getopt-pfx-ext.h + +BUILT_SOURCES = $(GETOPT_H) +MOSTLYCLEANFILES = getopt.h getopt.h-t +all: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) all-am + +.SUFFIXES: +.SUFFIXES: .c .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign lib/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --foreign lib/Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): + +clean-noinstLIBRARIES: + -$(am__rm_f) $(noinst_LIBRARIES) + +libgnu.a: $(libgnu_a_OBJECTS) $(libgnu_a_DEPENDENCIES) $(EXTRA_libgnu_a_DEPENDENCIES) + $(AM_V_at)-rm -f libgnu.a + $(AM_V_AR)$(libgnu_a_AR) libgnu.a $(libgnu_a_OBJECTS) $(libgnu_a_LIBADD) + $(AM_V_at)$(libgnu_a_RANLIB) libgnu.a + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/getopt.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@$(DEPDIR)/getopt1.Po@am__quote@ # am--include-marker + +$(am__depfiles_remade): + @$(MKDIR_P) $(@D) + @: >>$@ + +am--depfiles: $(am__depfiles_remade) + +.c.o: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $< + +.c.obj: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.c.lo: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs +tags TAGS: + +ctags CTAGS: + +cscope cscopelist: + + +distdir: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) distdir-am + +distdir-am: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) check-am +all-am: Makefile $(LIBRARIES) +installdirs: +install: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) install-am +install-exec: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + -$(am__rm_f) $(MOSTLYCLEANFILES) + +clean-generic: + +distclean-generic: + -$(am__rm_f) $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || $(am__rm_f) $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." + -$(am__rm_f) $(BUILT_SOURCES) +clean: clean-am + +clean-am: clean-generic clean-libtool clean-noinstLIBRARIES \ + mostlyclean-am + +distclean: distclean-am + -rm -f $(DEPDIR)/getopt.Po + -rm -f $(DEPDIR)/getopt1.Po + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f $(DEPDIR)/getopt.Po + -rm -f $(DEPDIR)/getopt1.Po + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: + +.MAKE: all check install install-am install-exec install-strip + +.PHONY: all all-am am--depfiles check check-am clean clean-generic \ + clean-libtool clean-noinstLIBRARIES cscopelist-am ctags-am \ + distclean distclean-compile distclean-generic \ + distclean-libtool distdir dvi dvi-am html html-am info info-am \ + install install-am install-data install-data-am install-dvi \ + install-dvi-am install-exec install-exec-am install-html \ + install-html-am install-info install-info-am install-man \ + install-pdf install-pdf-am install-ps install-ps-am \ + install-strip installcheck installcheck-am installdirs \ + maintainer-clean maintainer-clean-generic mostlyclean \ + mostlyclean-compile mostlyclean-generic mostlyclean-libtool \ + pdf pdf-am ps ps-am tags-am uninstall uninstall-am + +.PRECIOUS: Makefile + + +getopt.h: getopt.in.h + { echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */'; \ + cat $(srcdir)/getopt.in.h; \ + } > $@-t + mv -f $@-t $@ + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: + +# Tell GNU make to disable its built-in pattern rules. +%:: %,v +%:: RCS/%,v +%:: RCS/% +%:: s.% +%:: SCCS/s.% diff --git a/cpp/third_party/xz-5.8.3/lib/getopt-cdefs.h b/cpp/third_party/xz-5.8.3/lib/getopt-cdefs.h new file mode 100644 index 0000000000..576428c1c4 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/getopt-cdefs.h @@ -0,0 +1,72 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +/* getopt-on-non-glibc compatibility macros. + Copyright (C) 1989-2023 Free Software Foundation, Inc. + This file is part of gnulib. + Unlike most of the getopt implementation, it is NOT shared + with the GNU C Library. + + This file is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . */ + +#ifndef _GETOPT_CDEFS_H +#define _GETOPT_CDEFS_H 1 + +/* This header should not be used directly; include getopt.h or + unistd.h instead. It does not have a protective #error, because + the guard macro for getopt.h in gnulib is not fixed. */ + +/* getopt-core.h and getopt-ext.h are shared with GNU libc, and expect + a number of the internal macros supplied to GNU libc's headers by + sys/cdefs.h. Provide fallback definitions for all of them. */ +#ifdef HAVE_SYS_CDEFS_H +# include +#endif + +#ifndef __BEGIN_DECLS +# ifdef __cplusplus +# define __BEGIN_DECLS extern "C" { +# else +# define __BEGIN_DECLS /* nothing */ +# endif +#endif +#ifndef __END_DECLS +# ifdef __cplusplus +# define __END_DECLS } +# else +# define __END_DECLS /* nothing */ +# endif +#endif + +#ifndef __GNUC_PREREQ +# if defined __GNUC__ && defined __GNUC_VERSION__ +# define __GNUC_PREREQ(maj, min) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +# else +# define __GNUC_PREREQ(maj, min) 0 +# endif +#endif + +#ifndef __THROW +# if defined __cplusplus && (__GNUC_PREREQ (2,8) || __clang_major__ >= 4) +# if __cplusplus >= 201103L +# define __THROW noexcept (true) +# else +# define __THROW throw () +# endif +# else +# define __THROW +# endif +#endif + +#endif /* _GETOPT_CDEFS_H */ diff --git a/cpp/third_party/xz-5.8.3/lib/getopt-core.h b/cpp/third_party/xz-5.8.3/lib/getopt-core.h new file mode 100644 index 0000000000..126ce80892 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/getopt-core.h @@ -0,0 +1,98 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +/* Declarations for getopt (basic, portable features only). + Copyright (C) 1989-2023 Free Software Foundation, Inc. + This file is part of the GNU C Library and is also part of gnulib. + Patches to this file should be submitted to both projects. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _GETOPT_CORE_H +#define _GETOPT_CORE_H 1 + +/* This header should not be used directly; include getopt.h or + unistd.h instead. Unlike most bits headers, it does not have + a protective #error, because the guard macro for getopt.h in + gnulib is not fixed. */ + +__BEGIN_DECLS + +/* For communication from 'getopt' to the caller. + When 'getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when 'ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +extern char *optarg; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to 'getopt'. + + On entry to 'getopt', zero means this is the first call; initialize. + + When 'getopt' returns -1, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, 'optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +extern int optind; + +/* Callers store zero here to inhibit the error message 'getopt' prints + for unrecognized options. */ + +extern int opterr; + +/* Set to an option character which was unrecognized. */ + +extern int optopt; + +/* Get definitions and prototypes for functions to process the + arguments in ARGV (ARGC of them, minus the program name) for + options given in OPTS. + + Return the option character from OPTS just read. Return -1 when + there are no more options. For unrecognized options, or options + missing arguments, 'optopt' is set to the option letter, and '?' is + returned. + + The OPTS string is a list of characters which are recognized option + letters, optionally followed by colons, specifying that that letter + takes an argument, to be placed in 'optarg'. + + If a letter in OPTS is followed by two colons, its argument is + optional. This behavior is specific to the GNU 'getopt'. + + The argument '--' causes premature termination of argument + scanning, explicitly telling 'getopt' that there are no more + options. + + If OPTS begins with '-', then non-option arguments are treated as + arguments to the option '\1'. This behavior is specific to the GNU + 'getopt'. If OPTS begins with '+', or POSIXLY_CORRECT is set in + the environment, then do not permute arguments. + + For standards compliance, the 'argv' argument has the type + char *const *, but this is inaccurate; if argument permutation is + enabled, the argv array (not the strings it points to) must be + writable. */ + +extern int getopt (int ___argc, char *const *___argv, const char *__shortopts) + __THROW _GL_ARG_NONNULL ((2, 3)); + +__END_DECLS + +#endif /* _GETOPT_CORE_H */ diff --git a/cpp/third_party/xz-5.8.3/lib/getopt-ext.h b/cpp/third_party/xz-5.8.3/lib/getopt-ext.h new file mode 100644 index 0000000000..006037ba86 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/getopt-ext.h @@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +/* Declarations for getopt (GNU extensions). + Copyright (C) 1989-2023 Free Software Foundation, Inc. + This file is part of the GNU C Library and is also part of gnulib. + Patches to this file should be submitted to both projects. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _GETOPT_EXT_H +#define _GETOPT_EXT_H 1 + +/* This header should not be used directly; include getopt.h instead. + Unlike most bits headers, it does not have a protective #error, + because the guard macro for getopt.h in gnulib is not fixed. */ + +__BEGIN_DECLS + +/* Describe the long-named options requested by the application. + The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector + of 'struct option' terminated by an element containing a name which is + zero. + + The field 'has_arg' is: + no_argument (or 0) if the option does not take an argument, + required_argument (or 1) if the option requires an argument, + optional_argument (or 2) if the option takes an optional argument. + + If the field 'flag' is not NULL, it points to a variable that is set + to the value given in the field 'val' when the option is found, but + left unchanged if the option is not found. + + To have a long-named option do something other than set an 'int' to + a compiled-in constant, such as set a value from 'optarg', set the + option's 'flag' field to zero and its 'val' field to a nonzero + value (the equivalent single-letter option character, if there is + one). For long options that have a zero 'flag' field, 'getopt' + returns the contents of the 'val' field. */ + +struct option +{ + const char *name; + /* has_arg can't be an enum because some compilers complain about + type mismatches in all the code that assumes it is an int. */ + int has_arg; + int *flag; + int val; +}; + +/* Names for the values of the 'has_arg' field of 'struct option'. */ + +#define no_argument 0 +#define required_argument 1 +#define optional_argument 2 + +extern int getopt_long (int ___argc, char *__getopt_argv_const *___argv, + const char *__shortopts, + const struct option *__longopts, int *__longind) + __THROW _GL_ARG_NONNULL ((2, 3)); +extern int getopt_long_only (int ___argc, char *__getopt_argv_const *___argv, + const char *__shortopts, + const struct option *__longopts, int *__longind) + __THROW _GL_ARG_NONNULL ((2, 3)); + +__END_DECLS + +#endif /* _GETOPT_EXT_H */ diff --git a/cpp/third_party/xz-5.8.3/lib/getopt-pfx-core.h b/cpp/third_party/xz-5.8.3/lib/getopt-pfx-core.h new file mode 100644 index 0000000000..ee22d3f77f --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/getopt-pfx-core.h @@ -0,0 +1,68 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +/* getopt (basic, portable features) gnulib wrapper header. + Copyright (C) 1989-2023 Free Software Foundation, Inc. + This file is part of gnulib. + Unlike most of the getopt implementation, it is NOT shared + with the GNU C Library. + + This file is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . */ + +#ifndef _GETOPT_PFX_CORE_H +#define _GETOPT_PFX_CORE_H 1 + +/* This header should not be used directly; include getopt.h or + unistd.h instead. It does not have a protective #error, because + the guard macro for getopt.h in gnulib is not fixed. */ + +/* Standalone applications should #define __GETOPT_PREFIX to an + identifier that prefixes the external functions and variables + defined in getopt-core.h and getopt-ext.h. Systematically + rename identifiers so that they do not collide with the system + functions and variables. Renaming avoids problems with some + compilers and linkers. */ +#ifdef __GETOPT_PREFIX +# ifndef __GETOPT_ID +# define __GETOPT_CONCAT(x, y) x ## y +# define __GETOPT_XCONCAT(x, y) __GETOPT_CONCAT (x, y) +# define __GETOPT_ID(y) __GETOPT_XCONCAT (__GETOPT_PREFIX, y) +# endif +# undef getopt +# undef optarg +# undef opterr +# undef optind +# undef optopt +# define getopt __GETOPT_ID (getopt) +# define optarg __GETOPT_ID (optarg) +# define opterr __GETOPT_ID (opterr) +# define optind __GETOPT_ID (optind) +# define optopt __GETOPT_ID (optopt) + +/* Work around a problem on macOS, which declares getopt with a + trailing __DARWIN_ALIAS(getopt) that would expand to something like + __asm("_" "rpl_getopt" "$UNIX2003") were it not for the following + hack to suppress the macOS declaration . */ +# ifdef __APPLE__ +# define _GETOPT +# endif + +/* The system's getopt.h may have already included getopt-core.h to + declare the unprefixed identifiers. Undef _GETOPT_CORE_H so that + getopt-core.h declares them with prefixes. */ +# undef _GETOPT_CORE_H +#endif + +#include + +#endif /* _GETOPT_PFX_CORE_H */ diff --git a/cpp/third_party/xz-5.8.3/lib/getopt-pfx-ext.h b/cpp/third_party/xz-5.8.3/lib/getopt-pfx-ext.h new file mode 100644 index 0000000000..00d2a0952f --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/getopt-pfx-ext.h @@ -0,0 +1,72 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +/* getopt (GNU extensions) gnulib wrapper header. + Copyright (C) 1989-2023 Free Software Foundation, Inc. + This file is part of gnulib. + Unlike most of the getopt implementation, it is NOT shared + with the GNU C Library. + + This file is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . */ + +#ifndef _GETOPT_PFX_EXT_H +#define _GETOPT_PFX_EXT_H 1 + +/* This header should not be used directly; include getopt.h instead. + It does not have a protective #error, because the guard macro for + getopt.h in gnulib is not fixed. */ + +/* Standalone applications should #define __GETOPT_PREFIX to an + identifier that prefixes the external functions and variables + defined in getopt-core.h and getopt-ext.h. Systematically + rename identifiers so that they do not collide with the system + functions and variables. Renaming avoids problems with some + compilers and linkers. */ +#ifdef __GETOPT_PREFIX +# ifndef __GETOPT_ID +# define __GETOPT_CONCAT(x, y) x ## y +# define __GETOPT_XCONCAT(x, y) __GETOPT_CONCAT (x, y) +# define __GETOPT_ID(y) __GETOPT_XCONCAT (__GETOPT_PREFIX, y) +# endif +# undef getopt_long +# undef getopt_long_only +# undef option +# undef _getopt_internal +# define getopt_long __GETOPT_ID (getopt_long) +# define getopt_long_only __GETOPT_ID (getopt_long_only) +# define option __GETOPT_ID (option) +# define _getopt_internal __GETOPT_ID (getopt_internal) + +/* The system's getopt.h may have already included getopt-ext.h to + declare the unprefixed identifiers. Undef _GETOPT_EXT_H so that + getopt-ext.h declares them with prefixes. */ +# undef _GETOPT_EXT_H +#endif + +/* Standalone applications get correct prototypes for getopt_long and + getopt_long_only; they declare "char **argv". For backward + compatibility with old applications, if __GETOPT_PREFIX is not + defined, we supply GNU-libc-compatible, but incorrect, prototypes + using "char *const *argv". (GNU libc is stuck with the incorrect + prototypes, as they are baked into older versions of LSB.) */ +#ifndef __getopt_argv_const +# if defined __GETOPT_PREFIX +# define __getopt_argv_const /* empty */ +# else +# define __getopt_argv_const const +# endif +#endif + +#include + +#endif /* _GETOPT_PFX_EXT_H */ diff --git a/cpp/third_party/xz-5.8.3/lib/getopt.c b/cpp/third_party/xz-5.8.3/lib/getopt.c new file mode 100644 index 0000000000..ab3ff879ce --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/getopt.c @@ -0,0 +1,823 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +/* Getopt for GNU. + Copyright (C) 1987-2023 Free Software Foundation, Inc. + This file is part of the GNU C Library and is also part of gnulib. + Patches to this file should be submitted to both projects. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _LIBC +# ifdef HAVE_CONFIG_H +# include +# endif +#endif + +#include "getopt.h" + +#include +#include +#include +#ifndef _MSC_VER +# include +#endif + +#ifdef _LIBC +/* When used as part of glibc, error printing must be done differently + for standards compliance. getopt is not a cancellation point, so + it must not call functions that are, and it is specified by an + older standard than stdio locking, so it must not refer to + functions in the "user namespace" related to stdio locking. + Finally, it must use glibc's internal message translation so that + the messages are looked up in the proper text domain. */ +# include +# define fprintf __fxprintf_nocancel +# define flockfile(fp) _IO_flockfile (fp) +# define funlockfile(fp) _IO_funlockfile (fp) +#else +/* Completely disable NLS for getopt. We won't include translations for it + anyway. If the system lacks getopt_long, missing translations probably + aren't a problem. */ +//# include "gettext.h" +//# define _(msgid) gettext (msgid) +#define _(msgid) (msgid) +/* When used standalone, flockfile and funlockfile might not be + available. */ +# if (!defined _POSIX_THREAD_SAFE_FUNCTIONS \ + || (defined _WIN32 && ! defined __CYGWIN__)) +# define flockfile(fp) /* nop */ +# define funlockfile(fp) /* nop */ +# endif +/* When used standalone, do not attempt to use alloca. */ +# define __libc_use_alloca(size) 0 +# undef alloca +# define alloca(size) (abort (), (void *)0) +#endif + +/* This implementation of 'getopt' has three modes for handling + options interspersed with non-option arguments. It can stop + scanning for options at the first non-option argument encountered, + as POSIX specifies. It can continue scanning for options after the + first non-option argument, but permute 'argv' as it goes so that, + after 'getopt' is done, all the options precede all the non-option + arguments and 'optind' points to the first non-option argument. + Or, it can report non-option arguments as if they were arguments to + the option character '\x01'. + + The default behavior of 'getopt_long' is to permute the argument list. + When this implementation is used standalone, the default behavior of + 'getopt' is to stop at the first non-option argument, but when it is + used as part of GNU libc it also permutes the argument list. In both + cases, setting the environment variable POSIXLY_CORRECT to any value + disables permutation. + + If the first character of the OPTSTRING argument to 'getopt' or + 'getopt_long' is '+', both functions will stop at the first + non-option argument. If it is '-', both functions will report + non-option arguments as arguments to the option character '\x01'. */ + +#include "getopt_int.h" + +/* For communication from 'getopt' to the caller. + When 'getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when 'ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +char *optarg; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to 'getopt'. + + On entry to 'getopt', zero means this is the first call; initialize. + + When 'getopt' returns -1, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, 'optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +/* 1003.2 says this must be 1 before any call. */ +int optind = 1; + +/* Callers store zero here to inhibit the error message + for unrecognized options. */ + +int opterr = 1; + +/* Set to an option character which was unrecognized. + This must be initialized on some systems to avoid linking in the + system's own getopt implementation. */ + +int optopt = '?'; + +/* Keep a global copy of all internal members of getopt_data. */ + +static struct _getopt_data getopt_data; + +/* Exchange two adjacent subsequences of ARGV. + One subsequence is elements [first_nonopt,last_nonopt) + which contains all the non-options that have been skipped so far. + The other is elements [last_nonopt,optind), which contains all + the options processed since those non-options were skipped. + + 'first_nonopt' and 'last_nonopt' are relocated so that they describe + the new indices of the non-options in ARGV after they are moved. */ + +static void +exchange (char **argv, struct _getopt_data *d) +{ + int bottom = d->__first_nonopt; + int middle = d->__last_nonopt; + int top = d->optind; + char *tem; + + /* Exchange the shorter segment with the far end of the longer segment. + That puts the shorter segment into the right place. + It leaves the longer segment in the right place overall, + but it consists of two parts that need to be swapped next. */ + + while (top > middle && middle > bottom) + { + if (top - middle > middle - bottom) + { + /* Bottom segment is the short one. */ + int len = middle - bottom; + int i; + + /* Swap it with the top part of the top segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[top - (middle - bottom) + i]; + argv[top - (middle - bottom) + i] = tem; + } + /* Exclude the moved bottom segment from further swapping. */ + top -= len; + } + else + { + /* Top segment is the short one. */ + int len = top - middle; + int i; + + /* Swap it with the bottom part of the bottom segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[middle + i]; + argv[middle + i] = tem; + } + /* Exclude the moved top segment from further swapping. */ + bottom += len; + } + } + + /* Update records for the slots the non-options now occupy. */ + + d->__first_nonopt += (d->optind - d->__last_nonopt); + d->__last_nonopt = d->optind; +} + +/* Process the argument starting with d->__nextchar as a long option. + d->optind should *not* have been advanced over this argument. + + If the value returned is -1, it was not actually a long option, the + state is unchanged, and the argument should be processed as a set + of short options (this can only happen when long_only is true). + Otherwise, the option (and its argument, if any) have been consumed + and the return value is the value to return from _getopt_internal_r. */ +static int +process_long_option (int argc, char **argv, const char *optstring, + const struct option *longopts, int *longind, + int long_only, struct _getopt_data *d, + int print_errors, const char *prefix) +{ + char *nameend; + size_t namelen; + const struct option *p; + const struct option *pfound = NULL; + int n_options; + int option_index; + + for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++) + /* Do nothing. */ ; + namelen = (size_t)(nameend - d->__nextchar); + + /* First look for an exact match, counting the options as a side + effect. */ + for (p = longopts, n_options = 0; p->name; p++, n_options++) + if (!strncmp (p->name, d->__nextchar, namelen) + && namelen == strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + option_index = n_options; + break; + } + + if (pfound == NULL) + { + /* Didn't find an exact match, so look for abbreviations. */ + unsigned char *ambig_set = NULL; + int ambig_malloced = 0; + int ambig_fallback = 0; + int indfound = -1; + + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!strncmp (p->name, d->__nextchar, namelen)) + { + if (pfound == NULL) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else if (long_only + || pfound->has_arg != p->has_arg + || pfound->flag != p->flag + || pfound->val != p->val) + { + /* Second or later nonexact match found. */ + if (!ambig_fallback) + { + if (!print_errors) + /* Don't waste effort tracking the ambig set if + we're not going to print it anyway. */ + ambig_fallback = 1; + else if (!ambig_set) + { + if (__libc_use_alloca (n_options)) + ambig_set = alloca (n_options); + else if ((ambig_set = malloc ((size_t)n_options)) == NULL) + /* Fall back to simpler error message. */ + ambig_fallback = 1; + else + ambig_malloced = 1; + + if (ambig_set) + { + memset (ambig_set, 0, (size_t)n_options); + ambig_set[indfound] = 1; + } + } + if (ambig_set) + ambig_set[option_index] = 1; + } + } + } + + if (ambig_set || ambig_fallback) + { + if (print_errors) + { + if (ambig_fallback) + fprintf (stderr, _("%s: option '%s%s' is ambiguous\n"), + argv[0], prefix, d->__nextchar); + else + { + flockfile (stderr); + fprintf (stderr, + _("%s: option '%s%s' is ambiguous; possibilities:"), + argv[0], prefix, d->__nextchar); + + for (option_index = 0; option_index < n_options; option_index++) + if (ambig_set[option_index]) + fprintf (stderr, " '%s%s'", + prefix, longopts[option_index].name); + + /* This must use 'fprintf' even though it's only + printing a single character, so that it goes through + __fxprintf_nocancel when compiled as part of glibc. */ + fprintf (stderr, "\n"); + funlockfile (stderr); + } + } + if (ambig_malloced) + free (ambig_set); + d->__nextchar += strlen (d->__nextchar); + d->optind++; + d->optopt = 0; + return '?'; + } + + option_index = indfound; + } + + if (pfound == NULL) + { + /* Can't find it as a long option. If this is not getopt_long_only, + or the option starts with '--' or is not a valid short option, + then it's an error. */ + if (!long_only || argv[d->optind][1] == '-' + || strchr (optstring, *d->__nextchar) == NULL) + { + if (print_errors) + fprintf (stderr, _("%s: unrecognized option '%s%s'\n"), + argv[0], prefix, d->__nextchar); + + d->__nextchar = NULL; + d->optind++; + d->optopt = 0; + return '?'; + } + + /* Otherwise interpret it as a short option. */ + return -1; + } + + /* We have found a matching long option. Consume it. */ + d->optind++; + d->__nextchar = NULL; + if (*nameend) + { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if (pfound->has_arg) + d->optarg = nameend + 1; + else + { + if (print_errors) + fprintf (stderr, + _("%s: option '%s%s' doesn't allow an argument\n"), + argv[0], prefix, pfound->name); + + d->optopt = pfound->val; + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (d->optind < argc) + d->optarg = argv[d->optind++]; + else + { + if (print_errors) + fprintf (stderr, + _("%s: option '%s%s' requires an argument\n"), + argv[0], prefix, pfound->name); + + d->optopt = pfound->val; + return optstring[0] == ':' ? ':' : '?'; + } + } + + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; +} + +/* Initialize internal data upon the first call to getopt. */ + +static const char * +_getopt_initialize (int argc, + char **argv, const char *optstring, + struct _getopt_data *d, int posixly_correct) +{ + (void)argc; + (void)argv; + /* Start processing options with ARGV-element 1 (since ARGV-element 0 + is the program name); the sequence of previously skipped + non-option ARGV-elements is empty. */ + if (d->optind == 0) + d->optind = 1; + + d->__first_nonopt = d->__last_nonopt = d->optind; + d->__nextchar = NULL; + + /* Determine how to handle the ordering of options and nonoptions. */ + if (optstring[0] == '-') + { + d->__ordering = RETURN_IN_ORDER; + ++optstring; + } + else if (optstring[0] == '+') + { + d->__ordering = REQUIRE_ORDER; + ++optstring; + } + else if (posixly_correct || !!getenv ("POSIXLY_CORRECT")) + d->__ordering = REQUIRE_ORDER; + else + d->__ordering = PERMUTE; + + d->__initialized = 1; + return optstring; +} + +/* Scan elements of ARGV (whose length is ARGC) for option characters + given in OPTSTRING. + + If an element of ARGV starts with '-', and is not exactly "-" or "--", + then it is an option element. The characters of this element + (aside from the initial '-') are option characters. If 'getopt' + is called repeatedly, it returns successively each of the option characters + from each of the option elements. + + If 'getopt' finds another option character, it returns that character, + updating 'optind' and 'nextchar' so that the next call to 'getopt' can + resume the scan with the following option character or ARGV-element. + + If there are no more option characters, 'getopt' returns -1. + Then 'optind' is the index in ARGV of the first ARGV-element + that is not an option. (The ARGV-elements have been permuted + so that those that are not options now come last.) + + OPTSTRING is a string containing the legitimate option characters. + If an option character is seen that is not listed in OPTSTRING, + return '?' after printing an error message. If you set 'opterr' to + zero, the error message is suppressed but we still return '?'. + + If a char in OPTSTRING is followed by a colon, that means it wants an arg, + so the following text in the same ARGV-element, or the text of the following + ARGV-element, is returned in 'optarg'. Two colons mean an option that + wants an optional arg; if there is text in the current ARGV-element, + it is returned in 'optarg', otherwise 'optarg' is set to zero. + + If OPTSTRING starts with '-' or '+', it requests different methods of + handling the non-option ARGV-elements. + See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. + + Long-named options begin with '--' instead of '-'. + Their names may be abbreviated as long as the abbreviation is unique + or is an exact match for some defined option. If they have an + argument, it follows the option name in the same ARGV-element, separated + from the option name by a '=', or else the in next ARGV-element. + When 'getopt' finds a long-named option, it returns 0 if that option's + 'flag' field is nonzero, the value of the option's 'val' field + if the 'flag' field is zero. + + The elements of ARGV aren't really const, because we permute them. + But we pretend they're const in the prototype to be compatible + with other systems. + + LONGOPTS is a vector of 'struct option' terminated by an + element containing a name which is zero. + + LONGIND returns the index in LONGOPT of the long-named option found. + It is only valid when a long-named option has been found by the most + recent call. + + If LONG_ONLY is nonzero, '-' as well as '--' can introduce + long-named options. */ + +int +_getopt_internal_r (int argc, char **argv, const char *optstring, + const struct option *longopts, int *longind, + int long_only, struct _getopt_data *d, int posixly_correct) +{ + int print_errors = d->opterr; + + if (argc < 1) + return -1; + + d->optarg = NULL; + + if (d->optind == 0 || !d->__initialized) + optstring = _getopt_initialize (argc, argv, optstring, d, posixly_correct); + else if (optstring[0] == '-' || optstring[0] == '+') + optstring++; + + if (optstring[0] == ':') + print_errors = 0; + + /* Test whether ARGV[optind] points to a non-option argument. */ +#define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0') + + if (d->__nextchar == NULL || *d->__nextchar == '\0') + { + /* Advance to the next ARGV-element. */ + + /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been + moved back by the user (who may also have changed the arguments). */ + if (d->__last_nonopt > d->optind) + d->__last_nonopt = d->optind; + if (d->__first_nonopt > d->optind) + d->__first_nonopt = d->optind; + + if (d->__ordering == PERMUTE) + { + /* If we have just processed some options following some non-options, + exchange them so that the options come first. */ + + if (d->__first_nonopt != d->__last_nonopt + && d->__last_nonopt != d->optind) + exchange (argv, d); + else if (d->__last_nonopt != d->optind) + d->__first_nonopt = d->optind; + + /* Skip any additional non-options + and extend the range of non-options previously skipped. */ + + while (d->optind < argc && NONOPTION_P) + d->optind++; + d->__last_nonopt = d->optind; + } + + /* The special ARGV-element '--' means premature end of options. + Skip it like a null option, + then exchange with previous non-options as if it were an option, + then skip everything else like a non-option. */ + + if (d->optind != argc && !strcmp (argv[d->optind], "--")) + { + d->optind++; + + if (d->__first_nonopt != d->__last_nonopt + && d->__last_nonopt != d->optind) + exchange (argv, d); + else if (d->__first_nonopt == d->__last_nonopt) + d->__first_nonopt = d->optind; + d->__last_nonopt = argc; + + d->optind = argc; + } + + /* If we have done all the ARGV-elements, stop the scan + and back over any non-options that we skipped and permuted. */ + + if (d->optind == argc) + { + /* Set the next-arg-index to point at the non-options + that we previously skipped, so the caller will digest them. */ + if (d->__first_nonopt != d->__last_nonopt) + d->optind = d->__first_nonopt; + return -1; + } + + /* If we have come to a non-option and did not permute it, + either stop the scan or describe it to the caller and pass it by. */ + + if (NONOPTION_P) + { + if (d->__ordering == REQUIRE_ORDER) + return -1; + d->optarg = argv[d->optind++]; + return 1; + } + + /* We have found another option-ARGV-element. + Check whether it might be a long option. */ + if (longopts) + { + if (argv[d->optind][1] == '-') + { + /* "--foo" is always a long option. The special option + "--" was handled above. */ + d->__nextchar = argv[d->optind] + 2; + return process_long_option (argc, argv, optstring, longopts, + longind, long_only, d, + print_errors, "--"); + } + + /* If long_only and the ARGV-element has the form "-f", + where f is a valid short option, don't consider it an + abbreviated form of a long option that starts with f. + Otherwise there would be no way to give the -f short + option. + + On the other hand, if there's a long option "fubar" and + the ARGV-element is "-fu", do consider that an + abbreviation of the long option, just like "--fu", and + not "-f" with arg "u". + + This distinction seems to be the most useful approach. */ + if (long_only && (argv[d->optind][2] + || !strchr (optstring, argv[d->optind][1]))) + { + int code; + d->__nextchar = argv[d->optind] + 1; + code = process_long_option (argc, argv, optstring, longopts, + longind, long_only, d, + print_errors, "-"); + if (code != -1) + return code; + } + } + + /* It is not a long option. Skip the initial punctuation. */ + d->__nextchar = argv[d->optind] + 1; + } + + /* Look at and handle the next short option-character. */ + + { + char c = *d->__nextchar++; + const char *temp = strchr (optstring, c); + + /* Increment 'optind' when we start to process its last character. */ + if (*d->__nextchar == '\0') + ++d->optind; + + if (temp == NULL || c == ':' || c == ';') + { + if (print_errors) + fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c); + d->optopt = c; + return '?'; + } + + /* Convenience. Treat POSIX -W foo same as long option --foo */ + if (temp[0] == 'W' && temp[1] == ';' && longopts != NULL) + { + /* This is an option that requires an argument. */ + if (*d->__nextchar != '\0') + d->optarg = d->__nextchar; + else if (d->optind == argc) + { + if (print_errors) + fprintf (stderr, + _("%s: option requires an argument -- '%c'\n"), + argv[0], c); + + d->optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + return c; + } + else + d->optarg = argv[d->optind]; + + d->__nextchar = d->optarg; + d->optarg = NULL; + return process_long_option (argc, argv, optstring, longopts, longind, + 0 /* long_only */, d, print_errors, "-W "); + } + if (temp[1] == ':') + { + if (temp[2] == ':') + { + /* This is an option that accepts an argument optionally. */ + if (*d->__nextchar != '\0') + { + d->optarg = d->__nextchar; + d->optind++; + } + else + d->optarg = NULL; + d->__nextchar = NULL; + } + else + { + /* This is an option that requires an argument. */ + if (*d->__nextchar != '\0') + { + d->optarg = d->__nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + d->optind++; + } + else if (d->optind == argc) + { + if (print_errors) + fprintf (stderr, + _("%s: option requires an argument -- '%c'\n"), + argv[0], c); + + d->optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + } + else + /* We already incremented 'optind' once; + increment it again when taking next ARGV-elt as argument. */ + d->optarg = argv[d->optind++]; + d->__nextchar = NULL; + } + } + return c; + } +} + +int +_getopt_internal (int argc, char **argv, const char *optstring, + const struct option *longopts, int *longind, int long_only, + int posixly_correct) +{ + int result; + + getopt_data.optind = optind; + getopt_data.opterr = opterr; + + result = _getopt_internal_r (argc, argv, optstring, longopts, + longind, long_only, &getopt_data, + posixly_correct); + + optind = getopt_data.optind; + optarg = getopt_data.optarg; + optopt = getopt_data.optopt; + + return result; +} + +/* glibc gets a LSB-compliant getopt and a POSIX-complaint __posix_getopt. + Standalone applications just get a POSIX-compliant getopt. + POSIX and LSB both require these functions to take 'char *const *argv' + even though this is incorrect (because of the permutation). */ +#define GETOPT_ENTRY(NAME, POSIXLY_CORRECT) \ + int \ + NAME (int argc, char *const *argv, const char *optstring) \ + { \ + return _getopt_internal (argc, (char **)argv, optstring, \ + 0, 0, 0, POSIXLY_CORRECT); \ + } + +#ifdef _LIBC +GETOPT_ENTRY(getopt, 0) +GETOPT_ENTRY(__posix_getopt, 1) +#else +GETOPT_ENTRY(getopt, 1) +#endif + + +#ifdef TEST + +/* Compile with -DTEST to make an executable for use in testing + the above definition of 'getopt'. */ + +int +main (int argc, char **argv) +{ + int c; + int digit_optind = 0; + + while (1) + { + int this_option_optind = optind ? optind : 1; + + c = getopt (argc, argv, "abc:d:0123456789"); + if (c == -1) + break; + + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value '%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } + } + + if (optind < argc) + { + printf ("non-option ARGV-elements: "); + while (optind < argc) + printf ("%s ", argv[optind++]); + printf ("\n"); + } + + exit (0); +} + +#endif /* TEST */ diff --git a/cpp/third_party/xz-5.8.3/lib/getopt.in.h b/cpp/third_party/xz-5.8.3/lib/getopt.in.h new file mode 100644 index 0000000000..6d602c5da2 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/getopt.in.h @@ -0,0 +1,60 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +/* Declarations for getopt. + Copyright (C) 1989-2023 Free Software Foundation, Inc. + This file is part of gnulib. + Unlike most of the getopt implementation, it is NOT shared + with the GNU C Library, which supplies a different version of + this file. + + This file is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + This file is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . */ + +#ifndef _GETOPT_H + +#define _GETOPT_H 1 + +/* Standalone applications should #define __GETOPT_PREFIX to an + identifier that prefixes the external functions and variables + defined in this header. When this happens, include the + headers that might declare getopt so that they will not cause + confusion if included after this file. Then systematically rename + identifiers so that they do not collide with the system functions + and variables. Renaming avoids problems with some compilers and + linkers. */ +#if defined __GETOPT_PREFIX +# include +# include + +# ifndef _MSC_VER +# include +# endif +#endif + +/* From Gnulib's lib/arg-nonnull.h: */ +/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools + that the values passed as arguments n, ..., m must be non-NULL pointers. + n = 1 stands for the first argument, n = 2 for the second argument etc. */ +#ifndef _GL_ARG_NONNULL +# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || defined __clang__ +# define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params)) +# else +# define _GL_ARG_NONNULL(params) +# endif +#endif + +#include +#include +#include + +#endif /* _GETOPT_H */ diff --git a/cpp/third_party/xz-5.8.3/lib/getopt1.c b/cpp/third_party/xz-5.8.3/lib/getopt1.c new file mode 100644 index 0000000000..5cb3b913d0 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/getopt1.c @@ -0,0 +1,163 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +/* getopt_long and getopt_long_only entry points for GNU getopt. + Copyright (C) 1987-2023 Free Software Foundation, Inc. + This file is part of the GNU C Library and is also part of gnulib. + Patches to this file should be submitted to both projects. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _LIBC +# ifdef HAVE_CONFIG_H +# include +# endif +#endif + +#include "getopt.h" +#include "getopt_int.h" + +int +getopt_long (int argc, char *__getopt_argv_const *argv, const char *options, + const struct option *long_options, int *opt_index) +{ + return _getopt_internal (argc, (char **) argv, options, long_options, + opt_index, 0, 0); +} + +int +_getopt_long_r (int argc, char **argv, const char *options, + const struct option *long_options, int *opt_index, + struct _getopt_data *d) +{ + return _getopt_internal_r (argc, argv, options, long_options, opt_index, + 0, d, 0); +} + +/* Like getopt_long, but '-' as well as '--' can indicate a long option. + If an option that starts with '-' (not '--') doesn't match a long option, + but does match a short option, it is parsed as a short option + instead. */ + +int +getopt_long_only (int argc, char *__getopt_argv_const *argv, + const char *options, + const struct option *long_options, int *opt_index) +{ + return _getopt_internal (argc, (char **) argv, options, long_options, + opt_index, 1, 0); +} + +int +_getopt_long_only_r (int argc, char **argv, const char *options, + const struct option *long_options, int *opt_index, + struct _getopt_data *d) +{ + return _getopt_internal_r (argc, argv, options, long_options, opt_index, + 1, d, 0); +} + + +#ifdef TEST + +#include +#include + +int +main (int argc, char **argv) +{ + int c; + int digit_optind = 0; + + while (1) + { + int this_option_optind = optind ? optind : 1; + int option_index = 0; + static const struct option long_options[] = + { + {"add", 1, 0, 0}, + {"append", 0, 0, 0}, + {"delete", 1, 0, 0}, + {"verbose", 0, 0, 0}, + {"create", 0, 0, 0}, + {"file", 1, 0, 0}, + {0, 0, 0, 0} + }; + + c = getopt_long (argc, argv, "abc:d:0123456789", + long_options, &option_index); + if (c == -1) + break; + + switch (c) + { + case 0: + printf ("option %s", long_options[option_index].name); + if (optarg) + printf (" with arg %s", optarg); + printf ("\n"); + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value '%s'\n", optarg); + break; + + case 'd': + printf ("option d with value '%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } + } + + if (optind < argc) + { + printf ("non-option ARGV-elements: "); + while (optind < argc) + printf ("%s ", argv[optind++]); + printf ("\n"); + } + + exit (0); +} + +#endif /* TEST */ diff --git a/cpp/third_party/xz-5.8.3/lib/getopt_int.h b/cpp/third_party/xz-5.8.3/lib/getopt_int.h new file mode 100644 index 0000000000..2dcb553821 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/lib/getopt_int.h @@ -0,0 +1,120 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ + +/* Internal declarations for getopt. + Copyright (C) 1989-2023 Free Software Foundation, Inc. + This file is part of the GNU C Library and is also part of gnulib. + Patches to this file should be submitted to both projects. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#ifndef _GETOPT_INT_H +#define _GETOPT_INT_H 1 + +#include + +extern int _getopt_internal (int ___argc, char **___argv, + const char *__shortopts, + const struct option *__longopts, int *__longind, + int __long_only, int __posixly_correct); + + +/* Reentrant versions which can handle parsing multiple argument + vectors at the same time. */ + +/* Describe how to deal with options that follow non-option ARGV-elements. + + REQUIRE_ORDER means don't recognize them as options; stop option + processing when the first non-option is seen. This is what POSIX + specifies should happen. + + PERMUTE means permute the contents of ARGV as we scan, so that + eventually all the non-options are at the end. This allows options + to be given in any order, even with programs that were not written + to expect this. + + RETURN_IN_ORDER is an option available to programs that were + written to expect options and other ARGV-elements in any order + and that care about the ordering of the two. We describe each + non-option ARGV-element as if it were the argument of an option + with character code 1. + + The special argument '--' forces an end of option-scanning regardless + of the value of 'ordering'. In the case of RETURN_IN_ORDER, only + '--' can cause 'getopt' to return -1 with 'optind' != ARGC. */ + +enum __ord + { + REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER + }; + +/* Data type for reentrant functions. */ +struct _getopt_data +{ + /* These have exactly the same meaning as the corresponding global + variables, except that they are used for the reentrant + versions of getopt. */ + int optind; + int opterr; + int optopt; + char *optarg; + + /* Internal members. */ + + /* True if the internal members have been initialized. */ + int __initialized; + + /* The next char to be scanned in the option-element + in which the last option character we returned was found. + This allows us to pick up the scan where we left off. + + If this is zero, or a null string, it means resume the scan + by advancing to the next ARGV-element. */ + char *__nextchar; + + /* See __ord above. */ + enum __ord __ordering; + + /* Handle permutation of arguments. */ + + /* Describe the part of ARGV that contains non-options that have + been skipped. 'first_nonopt' is the index in ARGV of the first + of them; 'last_nonopt' is the index after the last of them. */ + + int __first_nonopt; + int __last_nonopt; +}; + +/* The initializer is necessary to set OPTIND and OPTERR to their + default values and to clear the initialization flag. */ +#define _GETOPT_DATA_INITIALIZER { 1, 1 } + +extern int _getopt_internal_r (int ___argc, char **___argv, + const char *__shortopts, + const struct option *__longopts, int *__longind, + int __long_only, struct _getopt_data *__data, + int __posixly_correct); + +extern int _getopt_long_r (int ___argc, char **___argv, + const char *__shortopts, + const struct option *__longopts, int *__longind, + struct _getopt_data *__data); + +extern int _getopt_long_only_r (int ___argc, char **___argv, + const char *__shortopts, + const struct option *__longopts, + int *__longind, + struct _getopt_data *__data); + +#endif /* getopt_int.h */ diff --git a/cpp/third_party/xz-5.8.3/m4/ax_pthread.m4 b/cpp/third_party/xz-5.8.3/m4/ax_pthread.m4 new file mode 100644 index 0000000000..3f26da6265 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/ax_pthread.m4 @@ -0,0 +1,524 @@ +dnl SPDX-License-Identifier: GPL-3.0-or-later WITH Autoconf-exception-macro + +# =========================================================================== +# https://www.gnu.org/software/autoconf-archive/ax_pthread.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) +# +# DESCRIPTION +# +# This macro figures out how to build C programs using POSIX threads. It +# sets the PTHREAD_LIBS output variable to the threads library and linker +# flags, and the PTHREAD_CFLAGS output variable to any special C compiler +# flags that are needed. (The user can also force certain compiler +# flags/libs to be tested by setting these environment variables.) +# +# Also sets PTHREAD_CC and PTHREAD_CXX to any special C compiler that is +# needed for multi-threaded programs (defaults to the value of CC +# respectively CXX otherwise). (This is necessary on e.g. AIX to use the +# special cc_r/CC_r compiler alias.) +# +# NOTE: You are assumed to not only compile your program with these flags, +# but also to link with them as well. For example, you might link with +# $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS +# $PTHREAD_CXX $CXXFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS +# +# If you are only building threaded programs, you may wish to use these +# variables in your default LIBS, CFLAGS, and CC: +# +# LIBS="$PTHREAD_LIBS $LIBS" +# CFLAGS="$CFLAGS $PTHREAD_CFLAGS" +# CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS" +# CC="$PTHREAD_CC" +# CXX="$PTHREAD_CXX" +# +# In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant +# has a nonstandard name, this macro defines PTHREAD_CREATE_JOINABLE to +# that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX). +# +# Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the +# PTHREAD_PRIO_INHERIT symbol is defined when compiling with +# PTHREAD_CFLAGS. +# +# ACTION-IF-FOUND is a list of shell commands to run if a threads library +# is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it +# is not found. If ACTION-IF-FOUND is not specified, the default action +# will define HAVE_PTHREAD. +# +# Please let the authors know if this macro fails on any platform, or if +# you have any other suggestions or comments. This macro was based on work +# by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help +# from M. Frigo), as well as ac_pthread and hb_pthread macros posted by +# Alejandro Forero Cuervo to the autoconf macro repository. We are also +# grateful for the helpful feedback of numerous users. +# +# Updated for Autoconf 2.68 by Daniel Richard G. +# +# LICENSE +# +# Copyright (c) 2008 Steven G. Johnson +# Copyright (c) 2011 Daniel Richard G. +# Copyright (c) 2019 Marc Stevens +# +# 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 the +# Free Software Foundation, either version 3 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 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, see . +# +# As a special exception, the respective Autoconf Macro's copyright owner +# gives unlimited permission to copy, distribute and modify the configure +# scripts that are the output of Autoconf when processing the Macro. You +# need not follow the terms of the GNU General Public License when using +# or distributing such scripts, even though portions of the text of the +# Macro appear in them. The GNU General Public License (GPL) does govern +# all other use of the material that constitutes the Autoconf Macro. +# +# This special exception to the GPL applies to versions of the Autoconf +# Macro released by the Autoconf Archive. When you make and distribute a +# modified version of the Autoconf Macro, you may extend this special +# exception to the GPL to apply to your modified version as well. + +#serial 31 + +AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD]) +AC_DEFUN([AX_PTHREAD], [ +AC_REQUIRE([AC_CANONICAL_HOST]) +AC_REQUIRE([AC_PROG_CC]) +AC_REQUIRE([AC_PROG_SED]) +AC_LANG_PUSH([C]) +ax_pthread_ok=no + +# We used to check for pthread.h first, but this fails if pthread.h +# requires special compiler flags (e.g. on Tru64 or Sequent). +# It gets checked for in the link test anyway. + +# First of all, check if the user has set any of the PTHREAD_LIBS, +# etcetera environment variables, and if threads linking works using +# them: +if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then + ax_pthread_save_CC="$CC" + ax_pthread_save_CFLAGS="$CFLAGS" + ax_pthread_save_LIBS="$LIBS" + AS_IF([test "x$PTHREAD_CC" != "x"], [CC="$PTHREAD_CC"]) + AS_IF([test "x$PTHREAD_CXX" != "x"], [CXX="$PTHREAD_CXX"]) + CFLAGS="$CFLAGS $PTHREAD_CFLAGS" + LIBS="$PTHREAD_LIBS $LIBS" + AC_MSG_CHECKING([for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS]) + AC_LINK_IFELSE([AC_LANG_CALL([], [pthread_join])], [ax_pthread_ok=yes]) + AC_MSG_RESULT([$ax_pthread_ok]) + if test "x$ax_pthread_ok" = "xno"; then + PTHREAD_LIBS="" + PTHREAD_CFLAGS="" + fi + CC="$ax_pthread_save_CC" + CFLAGS="$ax_pthread_save_CFLAGS" + LIBS="$ax_pthread_save_LIBS" +fi + +# We must check for the threads library under a number of different +# names; the ordering is very important because some systems +# (e.g. DEC) have both -lpthread and -lpthreads, where one of the +# libraries is broken (non-POSIX). + +# Create a list of thread flags to try. Items with a "," contain both +# C compiler flags (before ",") and linker flags (after ","). Other items +# starting with a "-" are C compiler flags, and remaining items are +# library names, except for "none" which indicates that we try without +# any flags at all, and "pthread-config" which is a program returning +# the flags for the Pth emulation library. + +ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config" + +# The ordering *is* (sometimes) important. Some notes on the +# individual items follow: + +# pthreads: AIX (must check this before -lpthread) +# none: in case threads are in libc; should be tried before -Kthread and +# other compiler flags to prevent continual compiler warnings +# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) +# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64 +# (Note: HP C rejects this with "bad form for `-t' option") +# -pthreads: Solaris/gcc (Note: HP C also rejects) +# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it +# doesn't hurt to check since this sometimes defines pthreads and +# -D_REENTRANT too), HP C (must be checked before -lpthread, which +# is present but should not be used directly; and before -mthreads, +# because the compiler interprets this as "-mt" + "-hreads") +# -mthreads: Mingw32/gcc, Lynx/gcc +# pthread: Linux, etcetera +# --thread-safe: KAI C++ +# pthread-config: use pthread-config program (for GNU Pth library) + +case $host_os in + + freebsd*) + + # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) + # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) + + ax_pthread_flags="-kthread lthread $ax_pthread_flags" + ;; + + hpux*) + + # From the cc(1) man page: "[-mt] Sets various -D flags to enable + # multi-threading and also sets -lpthread." + + ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags" + ;; + + openedition*) + + # IBM z/OS requires a feature-test macro to be defined in order to + # enable POSIX threads at all, so give the user a hint if this is + # not set. (We don't define these ourselves, as they can affect + # other portions of the system API in unpredictable ways.) + + AC_EGREP_CPP([AX_PTHREAD_ZOS_MISSING], + [ +# if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS) + AX_PTHREAD_ZOS_MISSING +# endif + ], + [AC_MSG_WARN([IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support.])]) + ;; + + solaris*) + + # On Solaris (at least, for some versions), libc contains stubbed + # (non-functional) versions of the pthreads routines, so link-based + # tests will erroneously succeed. (N.B.: The stubs are missing + # pthread_cleanup_push, or rather a function called by this macro, + # so we could check for that, but who knows whether they'll stub + # that too in a future libc.) So we'll check first for the + # standard Solaris way of linking pthreads (-mt -lpthread). + + ax_pthread_flags="-mt,-lpthread pthread $ax_pthread_flags" + ;; +esac + +# Are we compiling with Clang? + +AC_CACHE_CHECK([whether $CC is Clang], + [ax_cv_PTHREAD_CLANG], + [ax_cv_PTHREAD_CLANG=no + # Note that Autoconf sets GCC=yes for Clang as well as GCC + if test "x$GCC" = "xyes"; then + AC_EGREP_CPP([AX_PTHREAD_CC_IS_CLANG], + [/* Note: Clang 2.7 lacks __clang_[a-z]+__ */ +# if defined(__clang__) && defined(__llvm__) + AX_PTHREAD_CC_IS_CLANG +# endif + ], + [ax_cv_PTHREAD_CLANG=yes]) + fi + ]) +ax_pthread_clang="$ax_cv_PTHREAD_CLANG" + + +# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC) + +# Note that for GCC and Clang -pthread generally implies -lpthread, +# except when -nostdlib is passed. +# This is problematic using libtool to build C++ shared libraries with pthread: +# [1] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25460 +# [2] https://bugzilla.redhat.com/show_bug.cgi?id=661333 +# [3] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=468555 +# To solve this, first try -pthread together with -lpthread for GCC + +AS_IF([test "x$GCC" = "xyes"], + [ax_pthread_flags="-pthread,-lpthread -pthread -pthreads $ax_pthread_flags"]) + +# Clang takes -pthread (never supported any other flag), but we'll try with -lpthread first + +AS_IF([test "x$ax_pthread_clang" = "xyes"], + [ax_pthread_flags="-pthread,-lpthread -pthread"]) + + +# The presence of a feature test macro requesting re-entrant function +# definitions is, on some systems, a strong hint that pthreads support is +# correctly enabled + +case $host_os in + darwin* | hpux* | linux* | osf* | solaris*) + ax_pthread_check_macro="_REENTRANT" + ;; + + aix*) + ax_pthread_check_macro="_THREAD_SAFE" + ;; + + *) + ax_pthread_check_macro="--" + ;; +esac +AS_IF([test "x$ax_pthread_check_macro" = "x--"], + [ax_pthread_check_cond=0], + [ax_pthread_check_cond="!defined($ax_pthread_check_macro)"]) + + +if test "x$ax_pthread_ok" = "xno"; then +for ax_pthread_try_flag in $ax_pthread_flags; do + + case $ax_pthread_try_flag in + none) + AC_MSG_CHECKING([whether pthreads work without any flags]) + ;; + + *,*) + PTHREAD_CFLAGS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\1/"` + PTHREAD_LIBS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\2/"` + AC_MSG_CHECKING([whether pthreads work with "$PTHREAD_CFLAGS" and "$PTHREAD_LIBS"]) + ;; + + -*) + AC_MSG_CHECKING([whether pthreads work with $ax_pthread_try_flag]) + PTHREAD_CFLAGS="$ax_pthread_try_flag" + ;; + + pthread-config) + AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no]) + AS_IF([test "x$ax_pthread_config" = "xno"], [continue]) + PTHREAD_CFLAGS="`pthread-config --cflags`" + PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" + ;; + + *) + AC_MSG_CHECKING([for the pthreads library -l$ax_pthread_try_flag]) + PTHREAD_LIBS="-l$ax_pthread_try_flag" + ;; + esac + + ax_pthread_save_CFLAGS="$CFLAGS" + ax_pthread_save_LIBS="$LIBS" + CFLAGS="$CFLAGS $PTHREAD_CFLAGS" + LIBS="$PTHREAD_LIBS $LIBS" + + # Check for various functions. We must include pthread.h, + # since some functions may be macros. (On the Sequent, we + # need a special flag -Kthread to make this header compile.) + # We check for pthread_join because it is in -lpthread on IRIX + # while pthread_create is in libc. We check for pthread_attr_init + # due to DEC craziness with -lpthreads. We check for + # pthread_cleanup_push because it is one of the few pthread + # functions on Solaris that doesn't have a non-functional libc stub. + # We try pthread_create on general principles. + + AC_LINK_IFELSE([AC_LANG_PROGRAM([#include +# if $ax_pthread_check_cond +# error "$ax_pthread_check_macro must be defined" +# endif + static void *some_global = NULL; + static void routine(void *a) + { + /* To avoid any unused-parameter or + unused-but-set-parameter warning. */ + some_global = a; + } + static void *start_routine(void *a) { return a; }], + [pthread_t th; pthread_attr_t attr; + pthread_create(&th, 0, start_routine, 0); + pthread_join(th, 0); + pthread_attr_init(&attr); + pthread_cleanup_push(routine, 0); + pthread_cleanup_pop(0) /* ; */])], + [ax_pthread_ok=yes], + []) + + CFLAGS="$ax_pthread_save_CFLAGS" + LIBS="$ax_pthread_save_LIBS" + + AC_MSG_RESULT([$ax_pthread_ok]) + AS_IF([test "x$ax_pthread_ok" = "xyes"], [break]) + + PTHREAD_LIBS="" + PTHREAD_CFLAGS="" +done +fi + + +# Clang needs special handling, because older versions handle the -pthread +# option in a rather... idiosyncratic way + +if test "x$ax_pthread_clang" = "xyes"; then + + # Clang takes -pthread; it has never supported any other flag + + # (Note 1: This will need to be revisited if a system that Clang + # supports has POSIX threads in a separate library. This tends not + # to be the way of modern systems, but it's conceivable.) + + # (Note 2: On some systems, notably Darwin, -pthread is not needed + # to get POSIX threads support; the API is always present and + # active. We could reasonably leave PTHREAD_CFLAGS empty. But + # -pthread does define _REENTRANT, and while the Darwin headers + # ignore this macro, third-party headers might not.) + + # However, older versions of Clang make a point of warning the user + # that, in an invocation where only linking and no compilation is + # taking place, the -pthread option has no effect ("argument unused + # during compilation"). They expect -pthread to be passed in only + # when source code is being compiled. + # + # Problem is, this is at odds with the way Automake and most other + # C build frameworks function, which is that the same flags used in + # compilation (CFLAGS) are also used in linking. Many systems + # supported by AX_PTHREAD require exactly this for POSIX threads + # support, and in fact it is often not straightforward to specify a + # flag that is used only in the compilation phase and not in + # linking. Such a scenario is extremely rare in practice. + # + # Even though use of the -pthread flag in linking would only print + # a warning, this can be a nuisance for well-run software projects + # that build with -Werror. So if the active version of Clang has + # this misfeature, we search for an option to squash it. + + AC_CACHE_CHECK([whether Clang needs flag to prevent "argument unused" warning when linking with -pthread], + [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG], + [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown + # Create an alternate version of $ac_link that compiles and + # links in two steps (.c -> .o, .o -> exe) instead of one + # (.c -> exe), because the warning occurs only in the second + # step + ax_pthread_save_ac_link="$ac_link" + ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g' + ax_pthread_link_step=`AS_ECHO(["$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 + AS_IF([test "x$ax_pthread_try" = "xunknown"], [break]) + CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS" + ac_link="$ax_pthread_save_ac_link" + AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])], + [ac_link="$ax_pthread_2step_ac_link" + AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])], + [break]) + ]) + done + ac_link="$ax_pthread_save_ac_link" + CFLAGS="$ax_pthread_save_CFLAGS" + AS_IF([test "x$ax_pthread_try" = "x"], [ax_pthread_try=no]) + ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try" + ]) + + case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in + no | unknown) ;; + *) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;; + esac + +fi # $ax_pthread_clang = yes + + + +# Various other checks: +if test "x$ax_pthread_ok" = "xyes"; then + ax_pthread_save_CFLAGS="$CFLAGS" + ax_pthread_save_LIBS="$LIBS" + CFLAGS="$CFLAGS $PTHREAD_CFLAGS" + LIBS="$PTHREAD_LIBS $LIBS" + + # Detect AIX lossage: JOINABLE attribute is called UNDETACHED. + AC_CACHE_CHECK([for joinable pthread attribute], + [ax_cv_PTHREAD_JOINABLE_ATTR], + [ax_cv_PTHREAD_JOINABLE_ATTR=unknown + for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do + AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ], + [int attr = $ax_pthread_attr; return attr /* ; */])], + [ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break], + []) + done + ]) + AS_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"], + [AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE], + [$ax_cv_PTHREAD_JOINABLE_ATTR], + [Define to necessary symbol if this constant + uses a non-standard name on your system.]) + ax_pthread_joinable_attr_defined=yes + ]) + + AC_CACHE_CHECK([whether more special flags are required for pthreads], + [ax_cv_PTHREAD_SPECIAL_FLAGS], + [ax_cv_PTHREAD_SPECIAL_FLAGS=no + case $host_os in + solaris*) + ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS" + ;; + esac + ]) + AS_IF([test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \ + test "x$ax_pthread_special_flags_added" != "xyes"], + [PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS" + ax_pthread_special_flags_added=yes]) + + AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT], + [ax_cv_PTHREAD_PRIO_INHERIT], + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], + [[int i = PTHREAD_PRIO_INHERIT; + return i;]])], + [ax_cv_PTHREAD_PRIO_INHERIT=yes], + [ax_cv_PTHREAD_PRIO_INHERIT=no]) + ]) + AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \ + test "x$ax_pthread_prio_inherit_defined" != "xyes"], + [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.]) + ax_pthread_prio_inherit_defined=yes + ]) + + CFLAGS="$ax_pthread_save_CFLAGS" + LIBS="$ax_pthread_save_LIBS" + + # More AIX lossage: compile with *_r variant + if test "x$GCC" != "xyes"; then + case $host_os in + aix*) + AS_CASE(["x/$CC"], + [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6], + [#handle absolute path differently from PATH based program lookup + AS_CASE(["x$CC"], + [x/*], + [ + AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"]) + AS_IF([test "x${CXX}" != "x"], [AS_IF([AS_EXECUTABLE_P([${CXX}_r])],[PTHREAD_CXX="${CXX}_r"])]) + ], + [ + AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC]) + AS_IF([test "x${CXX}" != "x"], [AC_CHECK_PROGS([PTHREAD_CXX],[${CXX}_r],[$CXX])]) + ] + ) + ]) + ;; + esac + fi +fi + +test -n "$PTHREAD_CC" || PTHREAD_CC="$CC" +test -n "$PTHREAD_CXX" || PTHREAD_CXX="$CXX" + +AC_SUBST([PTHREAD_LIBS]) +AC_SUBST([PTHREAD_CFLAGS]) +AC_SUBST([PTHREAD_CC]) +AC_SUBST([PTHREAD_CXX]) + +# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: +if test "x$ax_pthread_ok" = "xyes"; then + ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1]) + : +else + ax_pthread_ok=no + $2 +fi +AC_LANG_POP +])dnl AX_PTHREAD diff --git a/cpp/third_party/xz-5.8.3/m4/build-to-host.m4 b/cpp/third_party/xz-5.8.3/m4/build-to-host.m4 new file mode 100644 index 0000000000..d13649e0c5 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/build-to-host.m4 @@ -0,0 +1,274 @@ +# build-to-host.m4 +# serial 5 +dnl Copyright (C) 2023-2024 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl This file is offered as-is, without any warranty. + +dnl Written by Bruno Haible. + +dnl When the build environment ($build_os) is different from the target runtime +dnl environment ($host_os), file names may need to be converted from the build +dnl environment syntax to the target runtime environment syntax. This is +dnl because the Makefiles are executed (mostly) by build environment tools and +dnl therefore expect file names in build environment syntax, whereas the runtime +dnl expects file names in target runtime environment syntax. +dnl +dnl For example, if $build_os = cygwin and $host_os = mingw32, filenames need +dnl be converted from Cygwin syntax to native Windows syntax: +dnl /cygdrive/c/foo/bar -> C:\foo\bar +dnl /usr/local/share -> C:\cygwin64\usr\local\share +dnl +dnl gl_BUILD_TO_HOST([somedir]) +dnl This macro takes as input an AC_SUBSTed variable 'somedir', which must +dnl already have its final value assigned, and produces two additional +dnl AC_SUBSTed variables 'somedir_c' and 'somedir_c_make', that designate the +dnl same file name value, just in different syntax: +dnl - somedir_c is the file name in target runtime environment syntax, +dnl as a C string (starting and ending with a double-quote, +dnl and with escaped backslashes and double-quotes in +dnl between). +dnl - somedir_c_make is the same thing, escaped for use in a Makefile. + +AC_DEFUN([gl_BUILD_TO_HOST], +[ + AC_REQUIRE([AC_CANONICAL_BUILD]) + AC_REQUIRE([AC_CANONICAL_HOST]) + AC_REQUIRE([gl_BUILD_TO_HOST_INIT]) + + dnl Define somedir_c. + gl_final_[$1]="$[$1]" + dnl Translate it from build syntax to host syntax. + case "$build_os" in + cygwin*) + case "$host_os" in + mingw* | windows*) + gl_final_[$1]=`cygpath -w "$gl_final_[$1]"` ;; + esac + ;; + esac + dnl Convert it to C string syntax. + [$1]_c=`printf '%s\n' "$gl_final_[$1]" | sed -e "$gl_sed_double_backslashes" -e "$gl_sed_escape_doublequotes" | tr -d "$gl_tr_cr"` + [$1]_c='"'"$[$1]_c"'"' + AC_SUBST([$1_c]) + + dnl Define somedir_c_make. + [$1]_c_make=`printf '%s\n' "$[$1]_c" | sed -e "$gl_sed_escape_for_make_1" -e "$gl_sed_escape_for_make_2" | tr -d "$gl_tr_cr"` + dnl Use the substituted somedir variable, when possible, so that the user + dnl may adjust somedir a posteriori when there are no special characters. + if test "$[$1]_c_make" = '\"'"${gl_final_[$1]}"'\"'; then + [$1]_c_make='\"$([$1])\"' + fi + AC_SUBST([$1_c_make]) +]) + +dnl Some initializations for gl_BUILD_TO_HOST. +AC_DEFUN([gl_BUILD_TO_HOST_INIT], +[ + gl_sed_double_backslashes='s/\\/\\\\/g' + gl_sed_escape_doublequotes='s/"/\\"/g' +changequote(,)dnl + gl_sed_escape_for_make_1="s,\\([ \"&'();<>\\\\\`|]\\),\\\\\\1,g" +changequote([,])dnl + gl_sed_escape_for_make_2='s,\$,\\$$,g' + dnl Find out how to remove carriage returns from output. Solaris /usr/ucb/tr + dnl does not understand '\r'. + case `echo r | tr -d '\r'` in + '') gl_tr_cr='\015' ;; + *) gl_tr_cr='\r' ;; + esac +]) + + +dnl The following macros are convenience invocations of gl_BUILD_TO_HOST +dnl for some of the variables that are defined by Autoconf. +dnl To do so for _all_ the possible variables, use the module 'configmake'. + +dnl Defines bindir_c and bindir_c_make. +AC_DEFUN_ONCE([gl_BUILD_TO_HOST_BINDIR], +[ + dnl Find the final value of bindir. + gl_saved_prefix="${prefix}" + gl_saved_exec_prefix="${exec_prefix}" + gl_saved_bindir="${bindir}" + dnl Unfortunately, prefix and exec_prefix get only finally determined + dnl at the end of configure. + if test "X$prefix" = "XNONE"; then + prefix="$ac_default_prefix" + fi + if test "X$exec_prefix" = "XNONE"; then + exec_prefix='${prefix}' + fi + eval exec_prefix="$exec_prefix" + eval bindir="$bindir" + gl_BUILD_TO_HOST([bindir]) + bindir="${gl_saved_bindir}" + exec_prefix="${gl_saved_exec_prefix}" + prefix="${gl_saved_prefix}" +]) + +dnl Defines datadir_c and datadir_c_make, +dnl where datadir = $(datarootdir) +AC_DEFUN_ONCE([gl_BUILD_TO_HOST_DATADIR], +[ + dnl Find the final value of datadir. + gl_saved_prefix="${prefix}" + gl_saved_datarootdir="${datarootdir}" + gl_saved_datadir="${datadir}" + dnl Unfortunately, prefix gets only finally determined at the end of + dnl configure. + if test "X$prefix" = "XNONE"; then + prefix="$ac_default_prefix" + fi + eval datarootdir="$datarootdir" + eval datadir="$datadir" + gl_BUILD_TO_HOST([datadir]) + datadir="${gl_saved_datadir}" + datarootdir="${gl_saved_datarootdir}" + prefix="${gl_saved_prefix}" +]) + +dnl Defines libdir_c and libdir_c_make. +AC_DEFUN_ONCE([gl_BUILD_TO_HOST_LIBDIR], +[ + dnl Find the final value of libdir. + gl_saved_prefix="${prefix}" + gl_saved_exec_prefix="${exec_prefix}" + gl_saved_libdir="${libdir}" + dnl Unfortunately, prefix and exec_prefix get only finally determined + dnl at the end of configure. + if test "X$prefix" = "XNONE"; then + prefix="$ac_default_prefix" + fi + if test "X$exec_prefix" = "XNONE"; then + exec_prefix='${prefix}' + fi + eval exec_prefix="$exec_prefix" + eval libdir="$libdir" + gl_BUILD_TO_HOST([libdir]) + libdir="${gl_saved_libdir}" + exec_prefix="${gl_saved_exec_prefix}" + prefix="${gl_saved_prefix}" +]) + +dnl Defines libexecdir_c and libexecdir_c_make. +AC_DEFUN_ONCE([gl_BUILD_TO_HOST_LIBEXECDIR], +[ + dnl Find the final value of libexecdir. + gl_saved_prefix="${prefix}" + gl_saved_exec_prefix="${exec_prefix}" + gl_saved_libexecdir="${libexecdir}" + dnl Unfortunately, prefix and exec_prefix get only finally determined + dnl at the end of configure. + if test "X$prefix" = "XNONE"; then + prefix="$ac_default_prefix" + fi + if test "X$exec_prefix" = "XNONE"; then + exec_prefix='${prefix}' + fi + eval exec_prefix="$exec_prefix" + eval libexecdir="$libexecdir" + gl_BUILD_TO_HOST([libexecdir]) + libexecdir="${gl_saved_libexecdir}" + exec_prefix="${gl_saved_exec_prefix}" + prefix="${gl_saved_prefix}" +]) + +dnl Defines localedir_c and localedir_c_make. +AC_DEFUN_ONCE([gl_BUILD_TO_HOST_LOCALEDIR], +[ + dnl Find the final value of localedir. + gl_saved_prefix="${prefix}" + gl_saved_datarootdir="${datarootdir}" + gl_saved_localedir="${localedir}" + dnl Unfortunately, prefix gets only finally determined at the end of + dnl configure. + if test "X$prefix" = "XNONE"; then + prefix="$ac_default_prefix" + fi + eval datarootdir="$datarootdir" + eval localedir="$localedir" + gl_BUILD_TO_HOST([localedir]) + localedir="${gl_saved_localedir}" + datarootdir="${gl_saved_datarootdir}" + prefix="${gl_saved_prefix}" +]) + +dnl Defines pkgdatadir_c and pkgdatadir_c_make, +dnl where pkgdatadir = $(datadir)/$(PACKAGE) +AC_DEFUN_ONCE([gl_BUILD_TO_HOST_PKGDATADIR], +[ + dnl Find the final value of pkgdatadir. + gl_saved_prefix="${prefix}" + gl_saved_datarootdir="${datarootdir}" + gl_saved_datadir="${datadir}" + gl_saved_pkgdatadir="${pkgdatadir}" + dnl Unfortunately, prefix gets only finally determined at the end of + dnl configure. + if test "X$prefix" = "XNONE"; then + prefix="$ac_default_prefix" + fi + eval datarootdir="$datarootdir" + eval datadir="$datadir" + eval pkgdatadir="$pkgdatadir" + gl_BUILD_TO_HOST([pkgdatadir]) + pkgdatadir="${gl_saved_pkgdatadir}" + datadir="${gl_saved_datadir}" + datarootdir="${gl_saved_datarootdir}" + prefix="${gl_saved_prefix}" +]) + +dnl Defines pkglibdir_c and pkglibdir_c_make, +dnl where pkglibdir = $(libdir)/$(PACKAGE) +AC_DEFUN_ONCE([gl_BUILD_TO_HOST_PKGLIBDIR], +[ + dnl Find the final value of pkglibdir. + gl_saved_prefix="${prefix}" + gl_saved_exec_prefix="${exec_prefix}" + gl_saved_libdir="${libdir}" + gl_saved_pkglibdir="${pkglibdir}" + dnl Unfortunately, prefix and exec_prefix get only finally determined + dnl at the end of configure. + if test "X$prefix" = "XNONE"; then + prefix="$ac_default_prefix" + fi + if test "X$exec_prefix" = "XNONE"; then + exec_prefix='${prefix}' + fi + eval exec_prefix="$exec_prefix" + eval libdir="$libdir" + eval pkglibdir="$pkglibdir" + gl_BUILD_TO_HOST([pkglibdir]) + pkglibdir="${gl_saved_pkglibdir}" + libdir="${gl_saved_libdir}" + exec_prefix="${gl_saved_exec_prefix}" + prefix="${gl_saved_prefix}" +]) + +dnl Defines pkglibexecdir_c and pkglibexecdir_c_make, +dnl where pkglibexecdir = $(libexecdir)/$(PACKAGE) +AC_DEFUN_ONCE([gl_BUILD_TO_HOST_PKGLIBEXECDIR], +[ + dnl Find the final value of pkglibexecdir. + gl_saved_prefix="${prefix}" + gl_saved_exec_prefix="${exec_prefix}" + gl_saved_libexecdir="${libexecdir}" + gl_saved_pkglibexecdir="${pkglibexecdir}" + dnl Unfortunately, prefix and exec_prefix get only finally determined + dnl at the end of configure. + if test "X$prefix" = "XNONE"; then + prefix="$ac_default_prefix" + fi + if test "X$exec_prefix" = "XNONE"; then + exec_prefix='${prefix}' + fi + eval exec_prefix="$exec_prefix" + eval libexecdir="$libexecdir" + eval pkglibexecdir="$pkglibexecdir" + gl_BUILD_TO_HOST([pkglibexecdir]) + pkglibexecdir="${gl_saved_pkglibexecdir}" + libexecdir="${gl_saved_libexecdir}" + exec_prefix="${gl_saved_exec_prefix}" + prefix="${gl_saved_prefix}" +]) diff --git a/cpp/third_party/xz-5.8.3/m4/getopt.m4 b/cpp/third_party/xz-5.8.3/m4/getopt.m4 new file mode 100644 index 0000000000..9d9141b28c --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/getopt.m4 @@ -0,0 +1,70 @@ +dnl SPDX-License-Identifier: FSFULLR + +# getopt.m4 serial 49 (modified version) +dnl Copyright (C) 2002-2006, 2008-2023 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +# This version has been modified to reduce complexity since we only need +# GNU getopt_long and do not care about replacing getopt. +# +# Pass gl_replace_getopt=yes (or any non-empty value instead of "yes") as +# an argument to configure to force the use of the getopt_long replacement. + +AC_DEFUN([gl_FUNC_GETOPT_GNU], +[ + AC_REQUIRE([gl_GETOPT_CHECK_HEADERS]) + + if test -n "$gl_replace_getopt"; then + gl_GETOPT_SUBSTITUTE + fi +]) + +AC_DEFUN([gl_GETOPT_CHECK_HEADERS], +[ + if test -z "$gl_replace_getopt"; then + AC_CHECK_HEADERS([getopt.h], [], [gl_replace_getopt=yes]) + fi + + if test -z "$gl_replace_getopt"; then + AC_CHECK_FUNCS([getopt_long], [], [gl_replace_getopt=yes]) + fi + + dnl BSD getopt_long uses a way to reset option processing, that is different + dnl from GNU and Solaris (which copied the GNU behavior). We support both + dnl GNU and BSD style resetting of getopt_long(), so there's no need to use + dnl GNU getopt_long() on BSD due to different resetting style. + if test -z "$gl_replace_getopt"; then + AC_CHECK_DECL([optreset], + [AC_DEFINE([HAVE_OPTRESET], 1, + [Define to 1 if getopt.h declares extern int optreset.])], + [], [#include ]) + fi + + dnl POSIX 2008 does not specify leading '+' behavior, but see + dnl http://austingroupbugs.net/view.php?id=191 for a recommendation on + dnl the next version of POSIX. We don't use that feature, so this + dnl is not a problem for us. Thus, the respective test was removed here. + + dnl Checks for getopt handling '-' as a leading character in an option + dnl string were removed, since we also don't use that feature. + +]) + +AC_DEFUN([gl_GETOPT_SUBSTITUTE], +[ + AC_LIBOBJ([getopt]) + AC_LIBOBJ([getopt1]) + + AC_CHECK_HEADERS_ONCE([sys/cdefs.h]) + + AC_DEFINE([__GETOPT_PREFIX], [[rpl_]], + [Define to rpl_ if the getopt replacement functions and variables + should be used.]) + + GETOPT_H=getopt.h + AC_SUBST([GETOPT_H]) +]) + +AC_DEFUN([gl_GETOPT], [gl_FUNC_GETOPT_GNU]) diff --git a/cpp/third_party/xz-5.8.3/m4/gettext.m4 b/cpp/third_party/xz-5.8.3/m4/gettext.m4 new file mode 100644 index 0000000000..d6a98efbf9 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/gettext.m4 @@ -0,0 +1,392 @@ +# gettext.m4 +# serial 81 (gettext-0.23) +dnl Copyright (C) 1995-2014, 2016, 2018-2024 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl +dnl This file can be used in projects which are not available under +dnl the GNU General Public License or the GNU Lesser General Public +dnl License but which still want to provide support for the GNU gettext +dnl functionality. +dnl Please note that the actual code of the GNU gettext library is covered +dnl by the GNU Lesser General Public License, and the rest of the GNU +dnl gettext package is covered by the GNU General Public License. +dnl They are *not* in the public domain. + +dnl Authors: +dnl Ulrich Drepper , 1995-2000. +dnl Bruno Haible , 2000-2024. + +dnl Macro to add for using GNU gettext. + +dnl Usage: AM_GNU_GETTEXT([INTLSYMBOL], [NEEDSYMBOL], [INTLDIR]). +dnl INTLSYMBOL must be one of 'external', 'use-libtool', 'here'. +dnl INTLSYMBOL should be 'external' for packages other than GNU gettext. +dnl It should be 'use-libtool' for the packages 'gettext-runtime' and +dnl 'gettext-tools'. +dnl It should be 'here' for the package 'gettext-runtime/intl'. +dnl If INTLSYMBOL is 'here', then a libtool library +dnl $(top_builddir)/libintl.la will be created (shared and/or static, +dnl depending on --{enable,disable}-{shared,static} and on the presence of +dnl AM-DISABLE-SHARED). +dnl If NEEDSYMBOL is specified and is 'need-ngettext', then GNU gettext +dnl implementations (in libc or libintl) without the ngettext() function +dnl will be ignored. If NEEDSYMBOL is specified and is +dnl 'need-formatstring-macros', then GNU gettext implementations that don't +dnl support the ISO C 99 formatstring macros will be ignored. +dnl INTLDIR is used to find the intl libraries. If empty, +dnl the value '$(top_builddir)/intl/' is used. +dnl +dnl The result of the configuration is one of three cases: +dnl 1) GNU gettext, as included in the intl subdirectory, will be compiled +dnl and used. +dnl Catalog format: GNU --> install in $(datadir) +dnl Catalog extension: .mo after installation, .gmo in source tree +dnl 2) GNU gettext has been found in the system's C library. +dnl Catalog format: GNU --> install in $(datadir) +dnl Catalog extension: .mo after installation, .gmo in source tree +dnl 3) No internationalization, always use English msgid. +dnl Catalog format: none +dnl Catalog extension: none +dnl If INTLSYMBOL is 'external', only cases 2 and 3 can occur. +dnl The use of .gmo is historical (it was needed to avoid overwriting the +dnl GNU format catalogs when building on a platform with an X/Open gettext), +dnl but we keep it in order not to force irrelevant filename changes on the +dnl maintainers. +dnl +AC_DEFUN([AM_GNU_GETTEXT], +[ + dnl Argument checking. + m4_if([$1], [], , [m4_if([$1], [external], , [m4_if([$1], [use-libtool], , [m4_if([$1], [here], , + [errprint([ERROR: invalid first argument to AM_GNU_GETTEXT +])])])])]) + m4_if(m4_if([$1], [], [old])[]m4_if([$1], [no-libtool], [old]), [old], + [errprint([ERROR: Use of AM_GNU_GETTEXT without [external] argument is no longer supported. +])]) + m4_if([$2], [], , [m4_if([$2], [need-ngettext], , [m4_if([$2], [need-formatstring-macros], , + [errprint([ERROR: invalid second argument to AM_GNU_GETTEXT +])])])]) + define([gt_building_libintl_in_same_build_tree], + m4_if([$1], [use-libtool], [yes], [m4_if([$1], [here], [yes], [no])])) + gt_NEEDS_INIT + AM_GNU_GETTEXT_NEED([$2]) + + AC_REQUIRE([AM_PO_SUBDIRS])dnl + + dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. + AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) + AC_REQUIRE([AC_LIB_RPATH]) + + dnl Sometimes libintl requires libiconv, so first search for libiconv. + dnl Ideally we would do this search only after the + dnl if test "$USE_NLS" = "yes"; then + dnl if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then + dnl tests. But if configure.ac invokes AM_ICONV after AM_GNU_GETTEXT + dnl the configure script would need to contain the same shell code + dnl again, outside any 'if'. There are two solutions: + dnl - Invoke AM_ICONV_LINKFLAGS_BODY here, outside any 'if'. + dnl - Control the expansions in more detail using AC_PROVIDE_IFELSE. + dnl Since AC_PROVIDE_IFELSE is not documented, we avoid it. + m4_if(gt_building_libintl_in_same_build_tree, yes, , [ + AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) + ]) + + dnl Sometimes, on Mac OS X, libintl requires linking with CoreFoundation. + gt_INTL_MACOSX + + dnl Set USE_NLS. + AC_REQUIRE([AM_NLS]) + + m4_if(gt_building_libintl_in_same_build_tree, yes, [ + USE_INCLUDED_LIBINTL=no + ]) + LIBINTL= + LTLIBINTL= + POSUB= + + dnl Add a version number to the cache macros. + case " $gt_needs " in + *" need-formatstring-macros "*) gt_api_version=3 ;; + *" need-ngettext "*) gt_api_version=2 ;; + *) gt_api_version=1 ;; + esac + gt_func_gnugettext_libc="gt_cv_func_gnugettext${gt_api_version}_libc" + gt_func_gnugettext_libintl="gt_cv_func_gnugettext${gt_api_version}_libintl" + + dnl If we use NLS figure out what method + if test "$USE_NLS" = "yes"; then + gt_use_preinstalled_gnugettext=no + m4_if(gt_building_libintl_in_same_build_tree, yes, [ + AC_MSG_CHECKING([whether included gettext is requested]) + AC_ARG_WITH([included-gettext], + [ --with-included-gettext use the GNU gettext library included here], + nls_cv_force_use_gnu_gettext=$withval, + nls_cv_force_use_gnu_gettext=no) + AC_MSG_RESULT([$nls_cv_force_use_gnu_gettext]) + + nls_cv_use_gnu_gettext="$nls_cv_force_use_gnu_gettext" + if test "$nls_cv_force_use_gnu_gettext" != "yes"; then + ]) + dnl User does not insist on using GNU NLS library. Figure out what + dnl to use. If GNU gettext is available we use this. Else we have + dnl to fall back to GNU NLS library. + + if test $gt_api_version -ge 3; then + gt_revision_test_code=' +#ifndef __GNU_GETTEXT_SUPPORTED_REVISION +#define __GNU_GETTEXT_SUPPORTED_REVISION(major) ((major) == 0 ? 0 : -1) +#endif +changequote(,)dnl +typedef int array [2 * (__GNU_GETTEXT_SUPPORTED_REVISION(0) >= 1) - 1]; +changequote([,])dnl +' + else + gt_revision_test_code= + fi + if test $gt_api_version -ge 2; then + gt_expression_test_code=' + * ngettext ("", "", 0)' + else + gt_expression_test_code= + fi + + AC_CACHE_CHECK([for GNU gettext in libc], [$gt_func_gnugettext_libc], + [AC_LINK_IFELSE( + [AC_LANG_PROGRAM( + [[ +#include +#ifndef __GNU_GETTEXT_SUPPORTED_REVISION +extern int _nl_msg_cat_cntr; +extern int *_nl_domain_bindings; +#define __GNU_GETTEXT_SYMBOL_EXPRESSION (_nl_msg_cat_cntr + *_nl_domain_bindings) +#else +#define __GNU_GETTEXT_SYMBOL_EXPRESSION 0 +#endif +$gt_revision_test_code + ]], + [[ +bindtextdomain ("", ""); +return * gettext ("")$gt_expression_test_code + __GNU_GETTEXT_SYMBOL_EXPRESSION + ]])], + [eval "$gt_func_gnugettext_libc=yes"], + [eval "$gt_func_gnugettext_libc=no"])]) + + if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" != "yes"; }; then + dnl Sometimes libintl requires libiconv, so first search for libiconv. + m4_if(gt_building_libintl_in_same_build_tree, yes, , [ + AM_ICONV_LINK + ]) + dnl Search for libintl and define LIBINTL, LTLIBINTL and INCINTL + dnl accordingly. Don't use AC_LIB_LINKFLAGS_BODY([intl],[iconv]) + dnl because that would add "-liconv" to LIBINTL and LTLIBINTL + dnl even if libiconv doesn't exist. + AC_LIB_LINKFLAGS_BODY([intl]) + AC_CACHE_CHECK([for GNU gettext in libintl], + [$gt_func_gnugettext_libintl], + [gt_saved_CPPFLAGS="$CPPFLAGS" + CPPFLAGS="$CPPFLAGS $INCINTL" + gt_saved_LIBS="$LIBS" + LIBS="$LIBS $LIBINTL" + dnl Now see whether libintl exists and does not depend on libiconv. + AC_LINK_IFELSE( + [AC_LANG_PROGRAM( + [[ +#include +#ifndef __GNU_GETTEXT_SUPPORTED_REVISION +extern int _nl_msg_cat_cntr; +extern +#ifdef __cplusplus +"C" +#endif +const char *_nl_expand_alias (const char *); +#define __GNU_GETTEXT_SYMBOL_EXPRESSION (_nl_msg_cat_cntr + *_nl_expand_alias ("")) +#else +#define __GNU_GETTEXT_SYMBOL_EXPRESSION 0 +#endif +$gt_revision_test_code + ]], + [[ +bindtextdomain ("", ""); +return * gettext ("")$gt_expression_test_code + __GNU_GETTEXT_SYMBOL_EXPRESSION + ]])], + [eval "$gt_func_gnugettext_libintl=yes"], + [eval "$gt_func_gnugettext_libintl=no"]) + dnl Now see whether libintl exists and depends on libiconv or other + dnl OS dependent libraries, specifically on macOS and AIX. + gt_LIBINTL_EXTRA="$INTL_MACOSX_LIBS" + AC_REQUIRE([AC_CANONICAL_HOST]) + case "$host_os" in + aix*) gt_LIBINTL_EXTRA="-lpthread" ;; + esac + if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" != yes; } \ + && { test -n "$LIBICONV" || test -n "$gt_LIBINTL_EXTRA"; }; then + LIBS="$LIBS $LIBICONV $gt_LIBINTL_EXTRA" + AC_LINK_IFELSE( + [AC_LANG_PROGRAM( + [[ +#include +#ifndef __GNU_GETTEXT_SUPPORTED_REVISION +extern int _nl_msg_cat_cntr; +extern +#ifdef __cplusplus +"C" +#endif +const char *_nl_expand_alias (const char *); +#define __GNU_GETTEXT_SYMBOL_EXPRESSION (_nl_msg_cat_cntr + *_nl_expand_alias ("")) +#else +#define __GNU_GETTEXT_SYMBOL_EXPRESSION 0 +#endif +$gt_revision_test_code + ]], + [[ +bindtextdomain ("", ""); +return * gettext ("")$gt_expression_test_code + __GNU_GETTEXT_SYMBOL_EXPRESSION + ]])], + [LIBINTL="$LIBINTL $LIBICONV $gt_LIBINTL_EXTRA" + LTLIBINTL="$LTLIBINTL $LTLIBICONV $gt_LIBINTL_EXTRA" + eval "$gt_func_gnugettext_libintl=yes" + ]) + fi + CPPFLAGS="$gt_saved_CPPFLAGS" + LIBS="$gt_saved_LIBS"]) + fi + + dnl If an already present or preinstalled GNU gettext() is found, + dnl use it. But if this macro is used in GNU gettext, and GNU + dnl gettext is already preinstalled in libintl, we update this + dnl libintl. (Cf. the install rule in intl/Makefile.in.) + if { eval "gt_val=\$$gt_func_gnugettext_libc"; test "$gt_val" = "yes"; } \ + || { { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; } \ + && test "$PACKAGE" != gettext-runtime \ + && test "$PACKAGE" != gettext-tools \ + && test "$PACKAGE" != libintl; }; then + gt_use_preinstalled_gnugettext=yes + else + dnl Reset the values set by searching for libintl. + LIBINTL= + LTLIBINTL= + INCINTL= + fi + + m4_if(gt_building_libintl_in_same_build_tree, yes, [ + if test "$gt_use_preinstalled_gnugettext" != "yes"; then + dnl GNU gettext is not found in the C library. + dnl Fall back on included GNU gettext library. + nls_cv_use_gnu_gettext=yes + fi + fi + + if test "$nls_cv_use_gnu_gettext" = "yes"; then + dnl Mark actions used to generate GNU NLS library. + USE_INCLUDED_LIBINTL=yes + LIBINTL="m4_if([$3],[],\${top_builddir}/intl,[$3])/libintl.la $LIBICONV $LIBTHREAD" + LTLIBINTL="m4_if([$3],[],\${top_builddir}/intl,[$3])/libintl.la $LTLIBICONV $LTLIBTHREAD" + LIBS=`echo " $LIBS " | sed -e 's/ -lintl / /' -e 's/^ //' -e 's/ $//'` + fi + + CATOBJEXT= + if test "$gt_use_preinstalled_gnugettext" = "yes" \ + || test "$nls_cv_use_gnu_gettext" = "yes"; then + dnl Mark actions to use GNU gettext tools. + CATOBJEXT=.gmo + fi + ]) + + if test -n "$INTL_MACOSX_LIBS"; then + if test "$gt_use_preinstalled_gnugettext" = "yes" \ + || test "$nls_cv_use_gnu_gettext" = "yes"; then + dnl Some extra flags are needed during linking. + LIBINTL="$LIBINTL $INTL_MACOSX_LIBS" + LTLIBINTL="$LTLIBINTL $INTL_MACOSX_LIBS" + fi + fi + + if test "$gt_use_preinstalled_gnugettext" = "yes" \ + || test "$nls_cv_use_gnu_gettext" = "yes"; then + AC_DEFINE([ENABLE_NLS], [1], + [Define to 1 if translation of program messages to the user's native language + is requested.]) + else + USE_NLS=no + fi + fi + + AC_MSG_CHECKING([whether to use NLS]) + AC_MSG_RESULT([$USE_NLS]) + if test "$USE_NLS" = "yes"; then + AC_MSG_CHECKING([where the gettext function comes from]) + if test "$gt_use_preinstalled_gnugettext" = "yes"; then + if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then + gt_source="external libintl" + else + gt_source="libc" + fi + else + gt_source="included intl directory" + fi + AC_MSG_RESULT([$gt_source]) + fi + + if test "$USE_NLS" = "yes"; then + + if test "$gt_use_preinstalled_gnugettext" = "yes"; then + if { eval "gt_val=\$$gt_func_gnugettext_libintl"; test "$gt_val" = "yes"; }; then + AC_MSG_CHECKING([how to link with libintl]) + AC_MSG_RESULT([$LIBINTL]) + AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCINTL]) + fi + + dnl For backward compatibility. Some packages may be using this. + AC_DEFINE([HAVE_GETTEXT], [1], + [Define if the GNU gettext() function is already present or preinstalled.]) + AC_DEFINE([HAVE_DCGETTEXT], [1], + [Define if the GNU dcgettext() function is already present or preinstalled.]) + fi + + dnl We need to process the po/ directory. + POSUB=po + fi + + m4_if(gt_building_libintl_in_same_build_tree, yes, [ + dnl Make all variables we use known to autoconf. + AC_SUBST([USE_INCLUDED_LIBINTL]) + AC_SUBST([CATOBJEXT]) + ]) + + m4_if(gt_building_libintl_in_same_build_tree, yes, [], [ + dnl For backward compatibility. Some Makefiles may be using this. + INTLLIBS="$LIBINTL" + AC_SUBST([INTLLIBS]) + ]) + + dnl Make all documented variables known to autoconf. + AC_SUBST([LIBINTL]) + AC_SUBST([LTLIBINTL]) + AC_SUBST([POSUB]) + + dnl Define localedir_c and localedir_c_make. + gl_BUILD_TO_HOST_LOCALEDIR +]) + + +dnl gt_NEEDS_INIT ensures that the gt_needs variable is initialized. +m4_define([gt_NEEDS_INIT], +[ + m4_divert_text([DEFAULTS], [gt_needs=]) + m4_define([gt_NEEDS_INIT], []) +]) + + +dnl Usage: AM_GNU_GETTEXT_NEED([NEEDSYMBOL]) +AC_DEFUN([AM_GNU_GETTEXT_NEED], +[ + m4_divert_text([INIT_PREPARE], [gt_needs="$gt_needs $1"]) +]) + + +dnl Usage: AM_GNU_GETTEXT_VERSION([gettext-version]) +AC_DEFUN([AM_GNU_GETTEXT_VERSION], []) + + +dnl Usage: AM_GNU_GETTEXT_REQUIRE_VERSION([gettext-version]) +AC_DEFUN([AM_GNU_GETTEXT_REQUIRE_VERSION], []) diff --git a/cpp/third_party/xz-5.8.3/m4/host-cpu-c-abi.m4 b/cpp/third_party/xz-5.8.3/m4/host-cpu-c-abi.m4 new file mode 100644 index 0000000000..ca021d6a9e --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/host-cpu-c-abi.m4 @@ -0,0 +1,529 @@ +# host-cpu-c-abi.m4 +# serial 18 +dnl Copyright (C) 2002-2024 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl This file is offered as-is, without any warranty. + +dnl From Bruno Haible and Sam Steingold. + +dnl Sets the HOST_CPU variable to the canonical name of the CPU. +dnl Sets the HOST_CPU_C_ABI variable to the canonical name of the CPU with its +dnl C language ABI (application binary interface). +dnl Also defines __${HOST_CPU}__ and __${HOST_CPU_C_ABI}__ as C macros in +dnl config.h. +dnl +dnl This canonical name can be used to select a particular assembly language +dnl source file that will interoperate with C code on the given host. +dnl +dnl For example: +dnl * 'i386' and 'sparc' are different canonical names, because code for i386 +dnl will not run on SPARC CPUs and vice versa. They have different +dnl instruction sets. +dnl * 'sparc' and 'sparc64' are different canonical names, because code for +dnl 'sparc' and code for 'sparc64' cannot be linked together: 'sparc' code +dnl contains 32-bit instructions, whereas 'sparc64' code contains 64-bit +dnl instructions. A process on a SPARC CPU can be in 32-bit mode or in 64-bit +dnl mode, but not both. +dnl * 'mips' and 'mipsn32' are different canonical names, because they use +dnl different argument passing and return conventions for C functions, and +dnl although the instruction set of 'mips' is a large subset of the +dnl instruction set of 'mipsn32'. +dnl * 'mipsn32' and 'mips64' are different canonical names, because they use +dnl different sizes for the C types like 'int' and 'void *', and although +dnl the instruction sets of 'mipsn32' and 'mips64' are the same. +dnl * The same canonical name is used for different endiannesses. You can +dnl determine the endianness through preprocessor symbols: +dnl - 'arm': test __ARMEL__. +dnl - 'mips', 'mipsn32', 'mips64': test _MIPSEB vs. _MIPSEL. +dnl - 'powerpc64': test __BIG_ENDIAN__ vs. __LITTLE_ENDIAN__. +dnl * The same name 'i386' is used for CPUs of type i386, i486, i586 +dnl (Pentium), AMD K7, Pentium II, Pentium IV, etc., because +dnl - Instructions that do not exist on all of these CPUs (cmpxchg, +dnl MMX, SSE, SSE2, 3DNow! etc.) are not frequently used. If your +dnl assembly language source files use such instructions, you will +dnl need to make the distinction. +dnl - Speed of execution of the common instruction set is reasonable across +dnl the entire family of CPUs. If you have assembly language source files +dnl that are optimized for particular CPU types (like GNU gmp has), you +dnl will need to make the distinction. +dnl See . +AC_DEFUN([gl_HOST_CPU_C_ABI], +[ + AC_REQUIRE([AC_CANONICAL_HOST]) + AC_REQUIRE([gl_C_ASM]) + AC_CACHE_CHECK([host CPU and C ABI], [gl_cv_host_cpu_c_abi], + [case "$host_cpu" in + +changequote(,)dnl + i[34567]86 ) +changequote([,])dnl + gl_cv_host_cpu_c_abi=i386 + ;; + + x86_64 ) + # On x86_64 systems, the C compiler may be generating code in one of + # these ABIs: + # - 64-bit instruction set, 64-bit pointers, 64-bit 'long': x86_64. + # - 64-bit instruction set, 64-bit pointers, 32-bit 'long': x86_64 + # with native Windows (mingw, MSVC). + # - 64-bit instruction set, 32-bit pointers, 32-bit 'long': x86_64-x32. + # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': i386. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if (defined __x86_64__ || defined __amd64__ \ + || defined _M_X64 || defined _M_AMD64) + int ok; + #else + error fail + #endif + ]])], + [AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined __ILP32__ || defined _ILP32 + int ok; + #else + error fail + #endif + ]])], + [gl_cv_host_cpu_c_abi=x86_64-x32], + [gl_cv_host_cpu_c_abi=x86_64])], + [gl_cv_host_cpu_c_abi=i386]) + ;; + +changequote(,)dnl + alphaev[4-8] | alphaev56 | alphapca5[67] | alphaev6[78] ) +changequote([,])dnl + gl_cv_host_cpu_c_abi=alpha + ;; + + arm* | aarch64 ) + # Assume arm with EABI. + # On arm64 systems, the C compiler may be generating code in one of + # these ABIs: + # - aarch64 instruction set, 64-bit pointers, 64-bit 'long': arm64. + # - aarch64 instruction set, 32-bit pointers, 32-bit 'long': arm64-ilp32. + # - 32-bit instruction set, 32-bit pointers, 32-bit 'long': arm or armhf. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#ifdef __aarch64__ + int ok; + #else + error fail + #endif + ]])], + [AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined __ILP32__ || defined _ILP32 + int ok; + #else + error fail + #endif + ]])], + [gl_cv_host_cpu_c_abi=arm64-ilp32], + [gl_cv_host_cpu_c_abi=arm64])], + [# Don't distinguish little-endian and big-endian arm, since they + # don't require different machine code for simple operations and + # since the user can distinguish them through the preprocessor + # defines __ARMEL__ vs. __ARMEB__. + # But distinguish arm which passes floating-point arguments and + # return values in integer registers (r0, r1, ...) - this is + # gcc -mfloat-abi=soft or gcc -mfloat-abi=softfp - from arm which + # passes them in float registers (s0, s1, ...) and double registers + # (d0, d1, ...) - this is gcc -mfloat-abi=hard. GCC 4.6 or newer + # sets the preprocessor defines __ARM_PCS (for the first case) and + # __ARM_PCS_VFP (for the second case), but older GCC does not. + echo 'double ddd; void func (double dd) { ddd = dd; }' > conftest.c + # Look for a reference to the register d0 in the .s file. + AC_TRY_COMMAND(${CC-cc} $CFLAGS $CPPFLAGS $gl_c_asm_opt conftest.c) >/dev/null 2>&1 + if LC_ALL=C grep 'd0,' conftest.$gl_asmext >/dev/null; then + gl_cv_host_cpu_c_abi=armhf + else + gl_cv_host_cpu_c_abi=arm + fi + rm -f conftest* + ]) + ;; + + hppa1.0 | hppa1.1 | hppa2.0* | hppa64 ) + # On hppa, the C compiler may be generating 32-bit code or 64-bit + # code. In the latter case, it defines _LP64 and __LP64__. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#ifdef __LP64__ + int ok; + #else + error fail + #endif + ]])], + [gl_cv_host_cpu_c_abi=hppa64], + [gl_cv_host_cpu_c_abi=hppa]) + ;; + + ia64* ) + # On ia64 on HP-UX, the C compiler may be generating 64-bit code or + # 32-bit code. In the latter case, it defines _ILP32. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#ifdef _ILP32 + int ok; + #else + error fail + #endif + ]])], + [gl_cv_host_cpu_c_abi=ia64-ilp32], + [gl_cv_host_cpu_c_abi=ia64]) + ;; + + mips* ) + # We should also check for (_MIPS_SZPTR == 64), but gcc keeps this + # at 32. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined _MIPS_SZLONG && (_MIPS_SZLONG == 64) + int ok; + #else + error fail + #endif + ]])], + [gl_cv_host_cpu_c_abi=mips64], + [# In the n32 ABI, _ABIN32 is defined, _ABIO32 is not defined (but + # may later get defined by ), and _MIPS_SIM == _ABIN32. + # In the 32 ABI, _ABIO32 is defined, _ABIN32 is not defined (but + # may later get defined by ), and _MIPS_SIM == _ABIO32. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if (_MIPS_SIM == _ABIN32) + int ok; + #else + error fail + #endif + ]])], + [gl_cv_host_cpu_c_abi=mipsn32], + [gl_cv_host_cpu_c_abi=mips])]) + ;; + + powerpc* ) + # Different ABIs are in use on AIX vs. Mac OS X vs. Linux,*BSD. + # No need to distinguish them here; the caller may distinguish + # them based on the OS. + # On powerpc64 systems, the C compiler may still be generating + # 32-bit code. And on powerpc-ibm-aix systems, the C compiler may + # be generating 64-bit code. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined __powerpc64__ || defined __LP64__ + int ok; + #else + error fail + #endif + ]])], + [# On powerpc64, there are two ABIs on Linux: The AIX compatible + # one and the ELFv2 one. The latter defines _CALL_ELF=2. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined _CALL_ELF && _CALL_ELF == 2 + int ok; + #else + error fail + #endif + ]])], + [gl_cv_host_cpu_c_abi=powerpc64-elfv2], + [gl_cv_host_cpu_c_abi=powerpc64]) + ], + [gl_cv_host_cpu_c_abi=powerpc]) + ;; + + rs6000 ) + gl_cv_host_cpu_c_abi=powerpc + ;; + + riscv32 | riscv64 ) + # There are 2 architectures (with variants): rv32* and rv64*. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if __riscv_xlen == 64 + int ok; + #else + error fail + #endif + ]])], + [cpu=riscv64], + [cpu=riscv32]) + # There are 6 ABIs: ilp32, ilp32f, ilp32d, lp64, lp64f, lp64d. + # Size of 'long' and 'void *': + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined __LP64__ + int ok; + #else + error fail + #endif + ]])], + [main_abi=lp64], + [main_abi=ilp32]) + # Float ABIs: + # __riscv_float_abi_double: + # 'float' and 'double' are passed in floating-point registers. + # __riscv_float_abi_single: + # 'float' are passed in floating-point registers. + # __riscv_float_abi_soft: + # No values are passed in floating-point registers. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined __riscv_float_abi_double + int ok; + #else + error fail + #endif + ]])], + [float_abi=d], + [AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined __riscv_float_abi_single + int ok; + #else + error fail + #endif + ]])], + [float_abi=f], + [float_abi='']) + ]) + gl_cv_host_cpu_c_abi="${cpu}-${main_abi}${float_abi}" + ;; + + s390* ) + # On s390x, the C compiler may be generating 64-bit (= s390x) code + # or 31-bit (= s390) code. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined __LP64__ || defined __s390x__ + int ok; + #else + error fail + #endif + ]])], + [gl_cv_host_cpu_c_abi=s390x], + [gl_cv_host_cpu_c_abi=s390]) + ;; + + sparc | sparc64 ) + # UltraSPARCs running Linux have `uname -m` = "sparc64", but the + # C compiler still generates 32-bit code. + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[#if defined __sparcv9 || defined __arch64__ + int ok; + #else + error fail + #endif + ]])], + [gl_cv_host_cpu_c_abi=sparc64], + [gl_cv_host_cpu_c_abi=sparc]) + ;; + + *) + gl_cv_host_cpu_c_abi="$host_cpu" + ;; + esac + ]) + + dnl In most cases, $HOST_CPU and $HOST_CPU_C_ABI are the same. + HOST_CPU=`echo "$gl_cv_host_cpu_c_abi" | sed -e 's/-.*//'` + HOST_CPU_C_ABI="$gl_cv_host_cpu_c_abi" + AC_SUBST([HOST_CPU]) + AC_SUBST([HOST_CPU_C_ABI]) + + # This was + # AC_DEFINE_UNQUOTED([__${HOST_CPU}__]) + # AC_DEFINE_UNQUOTED([__${HOST_CPU_C_ABI}__]) + # earlier, but KAI C++ 3.2d doesn't like this. + sed -e 's/-/_/g' >> confdefs.h <. +dnl Don't make changes that are incompatible with that documentation! + +AC_DEFUN([AM_ICONV_LINKFLAGS_BODY], +[ + dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. + AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) + AC_REQUIRE([AC_LIB_RPATH]) + + dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV + dnl accordingly. + AC_LIB_LINKFLAGS_BODY([iconv]) +]) + +AC_DEFUN([AM_ICONV_LINK], +[ + dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and + dnl those with the standalone portable GNU libiconv installed). + AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles + + dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV + dnl accordingly. + AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) + + dnl Add $INCICONV to CPPFLAGS before performing the following checks, + dnl because if the user has installed libiconv and not disabled its use + dnl via --without-libiconv-prefix, he wants to use it. The first + dnl AC_LINK_IFELSE will then fail, the second AC_LINK_IFELSE will succeed. + gl_saved_CPPFLAGS="$CPPFLAGS" + AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV]) + + AC_CACHE_CHECK([for iconv], [am_cv_func_iconv], [ + am_cv_func_iconv="no, consider installing GNU libiconv" + am_cv_lib_iconv=no + AC_LINK_IFELSE( + [AC_LANG_PROGRAM( + [[ +#include +#include + ]], + [[iconv_t cd = iconv_open("",""); + iconv(cd,NULL,NULL,NULL,NULL); + iconv_close(cd);]])], + [am_cv_func_iconv=yes]) + if test "$am_cv_func_iconv" != yes; then + gl_saved_LIBS="$LIBS" + LIBS="$LIBS $LIBICONV" + AC_LINK_IFELSE( + [AC_LANG_PROGRAM( + [[ +#include +#include + ]], + [[iconv_t cd = iconv_open("",""); + iconv(cd,NULL,NULL,NULL,NULL); + iconv_close(cd);]])], + [am_cv_lib_iconv=yes] + [am_cv_func_iconv=yes]) + LIBS="$gl_saved_LIBS" + fi + ]) + if test "$am_cv_func_iconv" = yes; then + AC_CACHE_CHECK([for working iconv], [am_cv_func_iconv_works], [ + dnl This tests against bugs in AIX 5.1, AIX 6.1..7.1, HP-UX 11.11, + dnl Solaris 10, macOS 14.4. + gl_saved_LIBS="$LIBS" + if test $am_cv_lib_iconv = yes; then + LIBS="$LIBS $LIBICONV" + fi + am_cv_func_iconv_works=no + for ac_iconv_const in '' 'const'; do + AC_RUN_IFELSE( + [AC_LANG_PROGRAM( + [[ +#include +#include + +#ifndef ICONV_CONST +# define ICONV_CONST $ac_iconv_const +#endif + ]], + [[int result = 0; + /* Test against AIX 5.1...7.2 bug: Failures are not distinguishable from + successful returns. This is even documented in + */ + { + iconv_t cd_utf8_to_88591 = iconv_open ("ISO8859-1", "UTF-8"); + if (cd_utf8_to_88591 != (iconv_t)(-1)) + { + static ICONV_CONST char input[] = "\342\202\254"; /* EURO SIGN */ + char buf[10]; + ICONV_CONST char *inptr = input; + size_t inbytesleft = strlen (input); + char *outptr = buf; + size_t outbytesleft = sizeof (buf); + size_t res = iconv (cd_utf8_to_88591, + &inptr, &inbytesleft, + &outptr, &outbytesleft); + if (res == 0) + result |= 1; + iconv_close (cd_utf8_to_88591); + } + } + /* Test against macOS 14.4 bug: Failures are not distinguishable from + successful returns. + POSIX:2018 says: "The iconv() function shall ... return the number of + non-identical conversions performed." + But here, the conversion always does transliteration (the suffixes + "//TRANSLIT" and "//IGNORE" have no effect, nor does iconvctl()) and + does not report when it does a non-identical conversion. */ + { + iconv_t cd_utf8_to_88591 = iconv_open ("ISO-8859-1", "UTF-8"); + if (cd_utf8_to_88591 != (iconv_t)(-1)) + { + static ICONV_CONST char input[] = "\305\202"; /* LATIN SMALL LETTER L WITH STROKE */ + char buf[10]; + ICONV_CONST char *inptr = input; + size_t inbytesleft = strlen (input); + char *outptr = buf; + size_t outbytesleft = sizeof (buf); + size_t res = iconv (cd_utf8_to_88591, + &inptr, &inbytesleft, + &outptr, &outbytesleft); + /* Here: + With glibc, GNU libiconv (including macOS up to 13): res == (size_t)-1, errno == EILSEQ. + With musl libc, NetBSD 10, Solaris 11: res == 1. + With macOS 14.4: res == 0, output is "l". */ + if (res == 0) + result |= 2; + iconv_close (cd_utf8_to_88591); + } + } + /* Test against Solaris 10 bug: Failures are not distinguishable from + successful returns. */ + { + iconv_t cd_ascii_to_88591 = iconv_open ("ISO8859-1", "646"); + if (cd_ascii_to_88591 != (iconv_t)(-1)) + { + static ICONV_CONST char input[] = "\263"; + char buf[10]; + ICONV_CONST char *inptr = input; + size_t inbytesleft = strlen (input); + char *outptr = buf; + size_t outbytesleft = sizeof (buf); + size_t res = iconv (cd_ascii_to_88591, + &inptr, &inbytesleft, + &outptr, &outbytesleft); + if (res == 0) + result |= 4; + iconv_close (cd_ascii_to_88591); + } + } + /* Test against AIX 6.1..7.1 bug: Buffer overrun. */ + { + iconv_t cd_88591_to_utf8 = iconv_open ("UTF-8", "ISO-8859-1"); + if (cd_88591_to_utf8 != (iconv_t)(-1)) + { + static ICONV_CONST char input[] = "\304"; + static char buf[2] = { (char)0xDE, (char)0xAD }; + ICONV_CONST char *inptr = input; + size_t inbytesleft = 1; + char *outptr = buf; + size_t outbytesleft = 1; + size_t res = iconv (cd_88591_to_utf8, + &inptr, &inbytesleft, + &outptr, &outbytesleft); + if (res != (size_t)(-1) || outptr - buf > 1 || buf[1] != (char)0xAD) + result |= 8; + iconv_close (cd_88591_to_utf8); + } + } +#if 0 /* This bug could be worked around by the caller. */ + /* Test against HP-UX 11.11 bug: Positive return value instead of 0. */ + { + iconv_t cd_88591_to_utf8 = iconv_open ("utf8", "iso88591"); + if (cd_88591_to_utf8 != (iconv_t)(-1)) + { + static ICONV_CONST char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337"; + char buf[50]; + ICONV_CONST char *inptr = input; + size_t inbytesleft = strlen (input); + char *outptr = buf; + size_t outbytesleft = sizeof (buf); + size_t res = iconv (cd_88591_to_utf8, + &inptr, &inbytesleft, + &outptr, &outbytesleft); + if ((int)res > 0) + result |= 16; + iconv_close (cd_88591_to_utf8); + } + } +#endif + /* Test against HP-UX 11.11 bug: No converter from EUC-JP to UTF-8 is + provided. */ + { + /* Try standardized names. */ + iconv_t cd1 = iconv_open ("UTF-8", "EUC-JP"); + /* Try IRIX, OSF/1 names. */ + iconv_t cd2 = iconv_open ("UTF-8", "eucJP"); + /* Try AIX names. */ + iconv_t cd3 = iconv_open ("UTF-8", "IBM-eucJP"); + /* Try HP-UX names. */ + iconv_t cd4 = iconv_open ("utf8", "eucJP"); + if (cd1 == (iconv_t)(-1) && cd2 == (iconv_t)(-1) + && cd3 == (iconv_t)(-1) && cd4 == (iconv_t)(-1)) + result |= 32; + if (cd1 != (iconv_t)(-1)) + iconv_close (cd1); + if (cd2 != (iconv_t)(-1)) + iconv_close (cd2); + if (cd3 != (iconv_t)(-1)) + iconv_close (cd3); + if (cd4 != (iconv_t)(-1)) + iconv_close (cd4); + } + return result; +]])], + [am_cv_func_iconv_works=yes], , + [case "$host_os" in + aix* | hpux*) am_cv_func_iconv_works="guessing no" ;; + *) am_cv_func_iconv_works="guessing yes" ;; + esac]) + test "$am_cv_func_iconv_works" = no || break + done + LIBS="$gl_saved_LIBS" + ]) + case "$am_cv_func_iconv_works" in + *no) am_func_iconv=no am_cv_lib_iconv=no ;; + *) am_func_iconv=yes ;; + esac + else + am_func_iconv=no am_cv_lib_iconv=no + fi + if test "$am_func_iconv" = yes; then + AC_DEFINE([HAVE_ICONV], [1], + [Define if you have the iconv() function and it works.]) + fi + if test "$am_cv_lib_iconv" = yes; then + AC_MSG_CHECKING([how to link with libiconv]) + AC_MSG_RESULT([$LIBICONV]) + else + dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV + dnl either. + CPPFLAGS="$gl_saved_CPPFLAGS" + LIBICONV= + LTLIBICONV= + fi + AC_SUBST([LIBICONV]) + AC_SUBST([LTLIBICONV]) +]) + +dnl Define AM_ICONV using AC_DEFUN_ONCE, in order to avoid warnings like +dnl "warning: AC_REQUIRE: `AM_ICONV' was expanded before it was required". +AC_DEFUN_ONCE([AM_ICONV], +[ + AM_ICONV_LINK + if test "$am_cv_func_iconv" = yes; then + AC_CACHE_CHECK([whether iconv is compatible with its POSIX signature], + [gl_cv_iconv_nonconst], + [AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[ +#include +#include +extern +#ifdef __cplusplus +"C" +#endif +size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft); + ]], + [[]])], + [gl_cv_iconv_nonconst=yes], + [gl_cv_iconv_nonconst=no]) + ]) + else + dnl When compiling GNU libiconv on a system that does not have iconv yet, + dnl pick the POSIX compliant declaration without 'const'. + gl_cv_iconv_nonconst=yes + fi + if test $gl_cv_iconv_nonconst = yes; then + iconv_arg1="" + else + iconv_arg1="const" + fi + AC_DEFINE_UNQUOTED([ICONV_CONST], [$iconv_arg1], + [Define as const if the declaration of iconv() needs const.]) + dnl Also substitute ICONV_CONST in the gnulib generated . + m4_ifdef([gl_ICONV_H_DEFAULTS], + [AC_REQUIRE([gl_ICONV_H_DEFAULTS]) + if test $gl_cv_iconv_nonconst != yes; then + ICONV_CONST="const" + fi + ]) + + dnl A summary result, for those packages which want to print a summary at the + dnl end of the configuration. + if test "$am_func_iconv" = yes; then + if test -n "$LIBICONV"; then + am_cv_func_iconv_summary='yes, in libiconv' + else + am_cv_func_iconv_summary='yes, in libc' + fi + else + if test "$am_cv_func_iconv" = yes; then + am_cv_func_iconv_summary='not working, consider installing GNU libiconv' + else + am_cv_func_iconv_summary='no, consider installing GNU libiconv' + fi + fi +]) diff --git a/cpp/third_party/xz-5.8.3/m4/intlmacosx.m4 b/cpp/third_party/xz-5.8.3/m4/intlmacosx.m4 new file mode 100644 index 0000000000..4cf791673b --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/intlmacosx.m4 @@ -0,0 +1,71 @@ +# intlmacosx.m4 +# serial 10 (gettext-0.23) +dnl Copyright (C) 2004-2014, 2016, 2019-2024 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl This file is offered as-is, without any warranty. +dnl +dnl This file can be used in projects which are not available under +dnl the GNU General Public License or the GNU Lesser General Public +dnl License but which still want to provide support for the GNU gettext +dnl functionality. +dnl Please note that the actual code of the GNU gettext library is covered +dnl by the GNU Lesser General Public License, and the rest of the GNU +dnl gettext package is covered by the GNU General Public License. +dnl They are *not* in the public domain. + +dnl Checks for special options needed on Mac OS X. +dnl Defines INTL_MACOSX_LIBS. +AC_DEFUN([gt_INTL_MACOSX], +[ + dnl Check for API introduced in Mac OS X 10.4. + AC_CACHE_CHECK([for CFPreferencesCopyAppValue], + [gt_cv_func_CFPreferencesCopyAppValue], + [gt_saved_LIBS="$LIBS" + LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" + AC_LINK_IFELSE( + [AC_LANG_PROGRAM( + [[#include ]], + [[CFPreferencesCopyAppValue(NULL, NULL)]])], + [gt_cv_func_CFPreferencesCopyAppValue=yes], + [gt_cv_func_CFPreferencesCopyAppValue=no]) + LIBS="$gt_saved_LIBS"]) + if test $gt_cv_func_CFPreferencesCopyAppValue = yes; then + AC_DEFINE([HAVE_CFPREFERENCESCOPYAPPVALUE], [1], + [Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in the CoreFoundation framework.]) + fi + dnl Don't check for the API introduced in Mac OS X 10.5, CFLocaleCopyCurrent, + dnl because in macOS 10.13.4 it has the following behaviour: + dnl When two or more languages are specified in the + dnl "System Preferences > Language & Region > Preferred Languages" panel, + dnl it returns en_CC where CC is the territory (even when English is not among + dnl the preferred languages!). What we want instead is what + dnl CFLocaleCopyCurrent returned in earlier macOS releases and what + dnl CFPreferencesCopyAppValue still returns, namely ll_CC where ll is the + dnl first among the preferred languages and CC is the territory. + AC_CACHE_CHECK([for CFLocaleCopyPreferredLanguages], [gt_cv_func_CFLocaleCopyPreferredLanguages], + [gt_saved_LIBS="$LIBS" + LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation" + AC_LINK_IFELSE( + [AC_LANG_PROGRAM( + [[#include ]], + [[CFLocaleCopyPreferredLanguages();]])], + [gt_cv_func_CFLocaleCopyPreferredLanguages=yes], + [gt_cv_func_CFLocaleCopyPreferredLanguages=no]) + LIBS="$gt_saved_LIBS"]) + if test $gt_cv_func_CFLocaleCopyPreferredLanguages = yes; then + AC_DEFINE([HAVE_CFLOCALECOPYPREFERREDLANGUAGES], [1], + [Define to 1 if you have the Mac OS X function CFLocaleCopyPreferredLanguages in the CoreFoundation framework.]) + fi + INTL_MACOSX_LIBS= + if test $gt_cv_func_CFPreferencesCopyAppValue = yes \ + || test $gt_cv_func_CFLocaleCopyPreferredLanguages = yes; then + dnl Starting with macOS version 14, CoreFoundation relies on CoreServices, + dnl and we have to link it in explicitly, otherwise an exception + dnl NSInvalidArgumentException "unrecognized selector sent to instance" + dnl occurs. + INTL_MACOSX_LIBS="-Wl,-framework -Wl,CoreFoundation -Wl,-framework -Wl,CoreServices" + fi + AC_SUBST([INTL_MACOSX_LIBS]) +]) diff --git a/cpp/third_party/xz-5.8.3/m4/lib-ld.m4 b/cpp/third_party/xz-5.8.3/m4/lib-ld.m4 new file mode 100644 index 0000000000..e6e16bb0b5 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/lib-ld.m4 @@ -0,0 +1,170 @@ +# lib-ld.m4 +# serial 13 +dnl Copyright (C) 1996-2003, 2009-2024 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl This file is offered as-is, without any warranty. + +dnl Subroutines of libtool.m4, +dnl with replacements s/_*LT_PATH/AC_LIB_PROG/ and s/lt_/acl_/ to avoid +dnl collision with libtool.m4. + +dnl From libtool-2.4. Sets the variable with_gnu_ld to yes or no. +AC_DEFUN([AC_LIB_PROG_LD_GNU], +[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], [acl_cv_prog_gnu_ld], +[# I'd rather use --version here, but apparently some GNU lds only accept -v. +case `$LD -v 2>&1 /dev/null 2>&1 \ + && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \ + || PATH_SEPARATOR=';' + } +fi + +if test -n "$LD"; then + AC_MSG_CHECKING([for ld]) +elif test "$GCC" = yes; then + AC_MSG_CHECKING([for ld used by $CC]) +elif test "$with_gnu_ld" = yes; then + AC_MSG_CHECKING([for GNU ld]) +else + AC_MSG_CHECKING([for non-GNU ld]) +fi +if test -n "$LD"; then + # Let the user override the test with a path. + : +else + AC_CACHE_VAL([acl_cv_path_LD], + [ + acl_cv_path_LD= # Final result of this test + ac_prog=ld # Program to search in $PATH + if test "$GCC" = yes; then + # Check if gcc -print-prog-name=ld gives a path. + case $host in + *-*-mingw* | windows*) + # gcc leaves a trailing carriage return which upsets mingw + acl_output=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + acl_output=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $acl_output in + # Accept absolute paths. + [[\\/]]* | ?:[[\\/]]*) + re_direlt='/[[^/]][[^/]]*/\.\./' + # Canonicalize the pathname of ld + acl_output=`echo "$acl_output" | sed 's%\\\\%/%g'` + while echo "$acl_output" | grep "$re_direlt" > /dev/null 2>&1; do + acl_output=`echo $acl_output | sed "s%$re_direlt%/%"` + done + # Got the pathname. No search in PATH is needed. + acl_cv_path_LD="$acl_output" + ac_prog= + ;; + "") + # If it fails, then pretend we aren't using GCC. + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac + fi + if test -n "$ac_prog"; then + # Search for $ac_prog in $PATH. + acl_saved_IFS="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS="$acl_saved_IFS" + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + acl_cv_path_LD="$ac_dir/$ac_prog" + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$acl_cv_path_LD" -v 2>&1 conftest.sh + . ./conftest.sh + rm -f ./conftest.sh + acl_cv_rpath=done + ]) + wl="$acl_cv_wl" + acl_libext="$acl_cv_libext" + acl_shlibext="$acl_cv_shlibext" + acl_libname_spec="$acl_cv_libname_spec" + acl_library_names_spec="$acl_cv_library_names_spec" + acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec" + acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator" + acl_hardcode_direct="$acl_cv_hardcode_direct" + acl_hardcode_minus_L="$acl_cv_hardcode_minus_L" + dnl Determine whether the user wants rpath handling at all. + AC_ARG_ENABLE([rpath], + [ --disable-rpath do not hardcode runtime library paths], + :, enable_rpath=yes) +]) + +dnl AC_LIB_FROMPACKAGE(name, package) +dnl declares that libname comes from the given package. The configure file +dnl will then not have a --with-libname-prefix option but a +dnl --with-package-prefix option. Several libraries can come from the same +dnl package. This declaration must occur before an AC_LIB_LINKFLAGS or similar +dnl macro call that searches for libname. +AC_DEFUN([AC_LIB_FROMPACKAGE], +[ + pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], + [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) + define([acl_frompackage_]NAME, [$2]) + popdef([NAME]) + pushdef([PACK],[$2]) + pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-], + [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) + define([acl_libsinpackage_]PACKUP, + m4_ifdef([acl_libsinpackage_]PACKUP, [m4_defn([acl_libsinpackage_]PACKUP)[, ]],)[lib$1]) + popdef([PACKUP]) + popdef([PACK]) +]) + +dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and +dnl the libraries corresponding to explicit and implicit dependencies. +dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables. +dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found +dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem. +AC_DEFUN([AC_LIB_LINKFLAGS_BODY], +[ + AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) + pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], + [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) + pushdef([PACK],[m4_ifdef([acl_frompackage_]NAME, [acl_frompackage_]NAME, lib[$1])]) + pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-], + [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) + pushdef([PACKLIBS],[m4_ifdef([acl_frompackage_]NAME, [acl_libsinpackage_]PACKUP, lib[$1])]) + dnl By default, look in $includedir and $libdir. + use_additional=yes + AC_LIB_WITH_FINAL_PREFIX([ + eval additional_includedir=\"$includedir\" + eval additional_libdir=\"$libdir\" + eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" + eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" + ]) + AC_ARG_WITH(PACK[-prefix], +[[ --with-]]PACK[[-prefix[=DIR] search for ]]PACKLIBS[[ in DIR/include and DIR/lib + --without-]]PACK[[-prefix don't search for ]]PACKLIBS[[ in includedir and libdir]], +[ + if test "X$withval" = "Xno"; then + use_additional=no + else + if test "X$withval" = "X"; then + AC_LIB_WITH_FINAL_PREFIX([ + eval additional_includedir=\"$includedir\" + eval additional_libdir=\"$libdir\" + eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\" + eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\" + ]) + else + additional_includedir="$withval/include" + additional_libdir="$withval/$acl_libdirstem" + additional_libdir2="$withval/$acl_libdirstem2" + additional_libdir3="$withval/$acl_libdirstem3" + fi + fi +]) + if test "X$additional_libdir2" = "X$additional_libdir"; then + additional_libdir2= + fi + if test "X$additional_libdir3" = "X$additional_libdir"; then + additional_libdir3= + fi + dnl Search the library and its dependencies in $additional_libdir and + dnl $LDFLAGS. Use breadth-first search. + LIB[]NAME= + LTLIB[]NAME= + INC[]NAME= + LIB[]NAME[]_PREFIX= + dnl HAVE_LIB${NAME} is an indicator that LIB${NAME}, LTLIB${NAME} have been + dnl computed. So it has to be reset here. + HAVE_LIB[]NAME= + rpathdirs= + ltrpathdirs= + names_already_handled= + names_next_round='$1 $2' + while test -n "$names_next_round"; do + names_this_round="$names_next_round" + names_next_round= + for name in $names_this_round; do + already_handled= + for n in $names_already_handled; do + if test "$n" = "$name"; then + already_handled=yes + break + fi + done + if test -z "$already_handled"; then + names_already_handled="$names_already_handled $name" + dnl See if it was already located by an earlier AC_LIB_LINKFLAGS + dnl or AC_LIB_HAVE_LINKFLAGS call. + uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./+-|ABCDEFGHIJKLMNOPQRSTUVWXYZ____|'` + eval value=\"\$HAVE_LIB$uppername\" + if test -n "$value"; then + if test "$value" = yes; then + eval value=\"\$LIB$uppername\" + test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value" + eval value=\"\$LTLIB$uppername\" + test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value" + else + dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined + dnl that this library doesn't exist. So just drop it. + : + fi + else + dnl Search the library lib$name in $additional_libdir and $LDFLAGS + dnl and the already constructed $LIBNAME/$LTLIBNAME. + found_dir= + found_la= + found_so= + found_a= + eval libname=\"$acl_libname_spec\" # typically: libname=lib$name + if test -n "$acl_shlibext"; then + shrext=".$acl_shlibext" # typically: shrext=.so + else + shrext= + fi + if test $use_additional = yes; then + for additional_libdir_variable in additional_libdir additional_libdir2 additional_libdir3; do + if test "X$found_dir" = "X"; then + eval dir=\$$additional_libdir_variable + if test -n "$dir"; then + dnl The same code as in the loop below: + dnl First look for a shared library. + if test -n "$acl_shlibext"; then + if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then + found_dir="$dir" + found_so="$dir/$libname$shrext" + else + if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then + ver=`(cd "$dir" && \ + for f in "$libname$shrext".*; do echo "$f"; done \ + | sed -e "s,^$libname$shrext\\\\.,," \ + | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ + | sed 1q ) 2>/dev/null` + if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then + found_dir="$dir" + found_so="$dir/$libname$shrext.$ver" + fi + else + eval library_names=\"$acl_library_names_spec\" + for f in $library_names; do + if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then + found_dir="$dir" + found_so="$dir/$f" + break + fi + done + fi + fi + fi + dnl Then look for a static library. + if test "X$found_dir" = "X"; then + if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then + found_dir="$dir" + found_a="$dir/$libname.$acl_libext" + fi + fi + if test "X$found_dir" != "X"; then + if test -f "$dir/$libname.la"; then + found_la="$dir/$libname.la" + fi + fi + fi + fi + done + fi + if test "X$found_dir" = "X"; then + for x in $LDFLAGS $LTLIB[]NAME; do + AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) + case "$x" in + -L*) + dir=`echo "X$x" | sed -e 's/^X-L//'` + dnl First look for a shared library. + if test -n "$acl_shlibext"; then + if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then + found_dir="$dir" + found_so="$dir/$libname$shrext" + else + if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then + ver=`(cd "$dir" && \ + for f in "$libname$shrext".*; do echo "$f"; done \ + | sed -e "s,^$libname$shrext\\\\.,," \ + | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ + | sed 1q ) 2>/dev/null` + if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then + found_dir="$dir" + found_so="$dir/$libname$shrext.$ver" + fi + else + eval library_names=\"$acl_library_names_spec\" + for f in $library_names; do + if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then + found_dir="$dir" + found_so="$dir/$f" + break + fi + done + fi + fi + fi + dnl Then look for a static library. + if test "X$found_dir" = "X"; then + if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then + found_dir="$dir" + found_a="$dir/$libname.$acl_libext" + fi + fi + if test "X$found_dir" != "X"; then + if test -f "$dir/$libname.la"; then + found_la="$dir/$libname.la" + fi + fi + ;; + esac + if test "X$found_dir" != "X"; then + break + fi + done + fi + if test "X$found_dir" != "X"; then + dnl Found the library. + LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name" + if test "X$found_so" != "X"; then + dnl Linking with a shared library. We attempt to hardcode its + dnl directory into the executable's runpath, unless it's the + dnl standard /usr/lib. + if test "$enable_rpath" = no \ + || test "X$found_dir" = "X/usr/$acl_libdirstem" \ + || test "X$found_dir" = "X/usr/$acl_libdirstem2" \ + || test "X$found_dir" = "X/usr/$acl_libdirstem3"; then + dnl No hardcoding is needed. + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" + else + dnl Use an explicit option to hardcode DIR into the resulting + dnl binary. + dnl Potentially add DIR to ltrpathdirs. + dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. + haveit= + for x in $ltrpathdirs; do + if test "X$x" = "X$found_dir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + ltrpathdirs="$ltrpathdirs $found_dir" + fi + dnl The hardcoding into $LIBNAME is system dependent. + if test "$acl_hardcode_direct" = yes; then + dnl Using DIR/libNAME.so during linking hardcodes DIR into the + dnl resulting binary. + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" + else + if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then + dnl Use an explicit option to hardcode DIR into the resulting + dnl binary. + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" + dnl Potentially add DIR to rpathdirs. + dnl The rpathdirs will be appended to $LIBNAME at the end. + haveit= + for x in $rpathdirs; do + if test "X$x" = "X$found_dir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + rpathdirs="$rpathdirs $found_dir" + fi + else + dnl Rely on "-L$found_dir". + dnl But don't add it if it's already contained in the LDFLAGS + dnl or the already constructed $LIBNAME + haveit= + for x in $LDFLAGS $LIB[]NAME; do + AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) + if test "X$x" = "X-L$found_dir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir" + fi + if test "$acl_hardcode_minus_L" != no; then + dnl FIXME: Not sure whether we should use + dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" + dnl here. + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" + else + dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH + dnl here, because this doesn't fit in flags passed to the + dnl compiler. So give up. No hardcoding. This affects only + dnl very old systems. + dnl FIXME: Not sure whether we should use + dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" + dnl here. + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" + fi + fi + fi + fi + else + if test "X$found_a" != "X"; then + dnl Linking with a static library. + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a" + else + dnl We shouldn't come here, but anyway it's good to have a + dnl fallback. + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name" + fi + fi + dnl Assume the include files are nearby. + additional_includedir= + case "$found_dir" in + */$acl_libdirstem | */$acl_libdirstem/) + basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'` + if test "$name" = '$1'; then + LIB[]NAME[]_PREFIX="$basedir" + fi + additional_includedir="$basedir/include" + ;; + */$acl_libdirstem2 | */$acl_libdirstem2/) + basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem2/"'*$,,'` + if test "$name" = '$1'; then + LIB[]NAME[]_PREFIX="$basedir" + fi + additional_includedir="$basedir/include" + ;; + */$acl_libdirstem3 | */$acl_libdirstem3/) + basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem3/"'*$,,'` + if test "$name" = '$1'; then + LIB[]NAME[]_PREFIX="$basedir" + fi + additional_includedir="$basedir/include" + ;; + esac + if test "X$additional_includedir" != "X"; then + dnl Potentially add $additional_includedir to $INCNAME. + dnl But don't add it + dnl 1. if it's the standard /usr/include, + dnl 2. if it's /usr/local/include and we are using GCC on Linux, + dnl 3. if it's already present in $CPPFLAGS or the already + dnl constructed $INCNAME, + dnl 4. if it doesn't exist as a directory. + if test "X$additional_includedir" != "X/usr/include"; then + haveit= + if test "X$additional_includedir" = "X/usr/local/include"; then + if test -n "$GCC"; then + case $host_os in + linux* | gnu* | k*bsd*-gnu) haveit=yes;; + esac + fi + fi + if test -z "$haveit"; then + for x in $CPPFLAGS $INC[]NAME; do + AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) + if test "X$x" = "X-I$additional_includedir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + if test -d "$additional_includedir"; then + dnl Really add $additional_includedir to $INCNAME. + INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir" + fi + fi + fi + fi + fi + dnl Look for dependencies. + if test -n "$found_la"; then + dnl Read the .la file. It defines the variables + dnl dlname, library_names, old_library, dependency_libs, current, + dnl age, revision, installed, dlopen, dlpreopen, libdir. + saved_libdir="$libdir" + case "$found_la" in + */* | *\\*) . "$found_la" ;; + *) . "./$found_la" ;; + esac + libdir="$saved_libdir" + dnl We use only dependency_libs. + for dep in $dependency_libs; do + case "$dep" in + -L*) + dependency_libdir=`echo "X$dep" | sed -e 's/^X-L//'` + dnl Potentially add $dependency_libdir to $LIBNAME and $LTLIBNAME. + dnl But don't add it + dnl 1. if it's the standard /usr/lib, + dnl 2. if it's /usr/local/lib and we are using GCC on Linux, + dnl 3. if it's already present in $LDFLAGS or the already + dnl constructed $LIBNAME, + dnl 4. if it doesn't exist as a directory. + if test "X$dependency_libdir" != "X/usr/$acl_libdirstem" \ + && test "X$dependency_libdir" != "X/usr/$acl_libdirstem2" \ + && test "X$dependency_libdir" != "X/usr/$acl_libdirstem3"; then + haveit= + if test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem" \ + || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem2" \ + || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem3"; then + if test -n "$GCC"; then + case $host_os in + linux* | gnu* | k*bsd*-gnu) haveit=yes;; + esac + fi + fi + if test -z "$haveit"; then + haveit= + for x in $LDFLAGS $LIB[]NAME; do + AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) + if test "X$x" = "X-L$dependency_libdir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + if test -d "$dependency_libdir"; then + dnl Really add $dependency_libdir to $LIBNAME. + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$dependency_libdir" + fi + fi + haveit= + for x in $LDFLAGS $LTLIB[]NAME; do + AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) + if test "X$x" = "X-L$dependency_libdir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + if test -d "$dependency_libdir"; then + dnl Really add $dependency_libdir to $LTLIBNAME. + LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$dependency_libdir" + fi + fi + fi + fi + ;; + -R*) + dir=`echo "X$dep" | sed -e 's/^X-R//'` + if test "$enable_rpath" != no; then + dnl Potentially add DIR to rpathdirs. + dnl The rpathdirs will be appended to $LIBNAME at the end. + haveit= + for x in $rpathdirs; do + if test "X$x" = "X$dir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + rpathdirs="$rpathdirs $dir" + fi + dnl Potentially add DIR to ltrpathdirs. + dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. + haveit= + for x in $ltrpathdirs; do + if test "X$x" = "X$dir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + ltrpathdirs="$ltrpathdirs $dir" + fi + fi + ;; + -l*) + dnl Handle this in the next round. + dnl But on GNU systems, ignore -lc options, because + dnl - linking with libc is the default anyway, + dnl - linking with libc.a may produce an error + dnl "/usr/bin/ld: dynamic STT_GNU_IFUNC symbol `strcmp' with pointer equality in `/usr/lib/libc.a(strcmp.o)' can not be used when making an executable; recompile with -fPIE and relink with -pie" + dnl or may produce an executable that always crashes, see + dnl . + dep=`echo "X$dep" | sed -e 's/^X-l//'` + if test "X$dep" != Xc \ + || case $host_os in + linux* | gnu* | k*bsd*-gnu) false ;; + *) true ;; + esac; then + names_next_round="$names_next_round $dep" + fi + ;; + *.la) + dnl Handle this in the next round. Throw away the .la's + dnl directory; it is already contained in a preceding -L + dnl option. + names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'` + ;; + *) + dnl Most likely an immediate library name. + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep" + LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep" + ;; + esac + done + fi + else + dnl Didn't find the library; assume it is in the system directories + dnl known to the linker and runtime loader. (All the system + dnl directories known to the linker should also be known to the + dnl runtime loader, otherwise the system is severely misconfigured.) + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" + LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name" + fi + fi + fi + done + done + if test "X$rpathdirs" != "X"; then + if test -n "$acl_hardcode_libdir_separator"; then + dnl Weird platform: only the last -rpath option counts, the user must + dnl pass all path elements in one option. We can arrange that for a + dnl single library, but not when more than one $LIBNAMEs are used. + alldirs= + for found_dir in $rpathdirs; do + alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir" + done + dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl. + acl_saved_libdir="$libdir" + libdir="$alldirs" + eval flag=\"$acl_hardcode_libdir_flag_spec\" + libdir="$acl_saved_libdir" + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" + else + dnl The -rpath options are cumulative. + for found_dir in $rpathdirs; do + acl_saved_libdir="$libdir" + libdir="$found_dir" + eval flag=\"$acl_hardcode_libdir_flag_spec\" + libdir="$acl_saved_libdir" + LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" + done + fi + fi + if test "X$ltrpathdirs" != "X"; then + dnl When using libtool, the option that works for both libraries and + dnl executables is -R. The -R options are cumulative. + for found_dir in $ltrpathdirs; do + LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir" + done + fi + popdef([PACKLIBS]) + popdef([PACKUP]) + popdef([PACK]) + popdef([NAME]) +]) + +dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR, +dnl unless already present in VAR. +dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes +dnl contains two or three consecutive elements that belong together. +AC_DEFUN([AC_LIB_APPENDTOVAR], +[ + for element in [$2]; do + haveit= + for x in $[$1]; do + AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) + if test "X$x" = "X$element"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + [$1]="${[$1]}${[$1]:+ }$element" + fi + done +]) + +dnl For those cases where a variable contains several -L and -l options +dnl referring to unknown libraries and directories, this macro determines the +dnl necessary additional linker options for the runtime path. +dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL]) +dnl sets LDADDVAR to linker options needed together with LIBSVALUE. +dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed, +dnl otherwise linking without libtool is assumed. +AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS], +[ + AC_REQUIRE([AC_LIB_RPATH]) + AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) + $1= + if test "$enable_rpath" != no; then + if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then + dnl Use an explicit option to hardcode directories into the resulting + dnl binary. + rpathdirs= + next= + for opt in $2; do + if test -n "$next"; then + dir="$next" + dnl No need to hardcode the standard /usr/lib. + if test "X$dir" != "X/usr/$acl_libdirstem" \ + && test "X$dir" != "X/usr/$acl_libdirstem2" \ + && test "X$dir" != "X/usr/$acl_libdirstem3"; then + rpathdirs="$rpathdirs $dir" + fi + next= + else + case $opt in + -L) next=yes ;; + -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'` + dnl No need to hardcode the standard /usr/lib. + if test "X$dir" != "X/usr/$acl_libdirstem" \ + && test "X$dir" != "X/usr/$acl_libdirstem2" \ + && test "X$dir" != "X/usr/$acl_libdirstem3"; then + rpathdirs="$rpathdirs $dir" + fi + next= ;; + *) next= ;; + esac + fi + done + if test "X$rpathdirs" != "X"; then + if test -n ""$3""; then + dnl libtool is used for linking. Use -R options. + for dir in $rpathdirs; do + $1="${$1}${$1:+ }-R$dir" + done + else + dnl The linker is used for linking directly. + if test -n "$acl_hardcode_libdir_separator"; then + dnl Weird platform: only the last -rpath option counts, the user + dnl must pass all path elements in one option. + alldirs= + for dir in $rpathdirs; do + alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir" + done + acl_saved_libdir="$libdir" + libdir="$alldirs" + eval flag=\"$acl_hardcode_libdir_flag_spec\" + libdir="$acl_saved_libdir" + $1="$flag" + else + dnl The -rpath options are cumulative. + for dir in $rpathdirs; do + acl_saved_libdir="$libdir" + libdir="$dir" + eval flag=\"$acl_hardcode_libdir_flag_spec\" + libdir="$acl_saved_libdir" + $1="${$1}${$1:+ }$flag" + done + fi + fi + fi + fi + fi + AC_SUBST([$1]) +]) diff --git a/cpp/third_party/xz-5.8.3/m4/lib-prefix.m4 b/cpp/third_party/xz-5.8.3/m4/lib-prefix.m4 new file mode 100644 index 0000000000..cf72a5b481 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/lib-prefix.m4 @@ -0,0 +1,334 @@ +# lib-prefix.m4 +# serial 23 +dnl Copyright (C) 2001-2005, 2008-2024 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl This file is offered as-is, without any warranty. + +dnl From Bruno Haible. + +dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed +dnl to access previously installed libraries. The basic assumption is that +dnl a user will want packages to use other packages he previously installed +dnl with the same --prefix option. +dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate +dnl libraries, but is otherwise very convenient. +AC_DEFUN([AC_LIB_PREFIX], +[ + AC_BEFORE([$0], [AC_LIB_LINKFLAGS]) + AC_REQUIRE([AC_PROG_CC]) + AC_REQUIRE([AC_CANONICAL_HOST]) + AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) + AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) + dnl By default, look in $includedir and $libdir. + use_additional=yes + AC_LIB_WITH_FINAL_PREFIX([ + eval additional_includedir=\"$includedir\" + eval additional_libdir=\"$libdir\" + ]) + AC_ARG_WITH([lib-prefix], +[[ --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib + --without-lib-prefix don't search for libraries in includedir and libdir]], +[ + if test "X$withval" = "Xno"; then + use_additional=no + else + if test "X$withval" = "X"; then + AC_LIB_WITH_FINAL_PREFIX([ + eval additional_includedir=\"$includedir\" + eval additional_libdir=\"$libdir\" + ]) + else + additional_includedir="$withval/include" + additional_libdir="$withval/$acl_libdirstem" + fi + fi +]) + if test $use_additional = yes; then + dnl Potentially add $additional_includedir to $CPPFLAGS. + dnl But don't add it + dnl 1. if it's the standard /usr/include, + dnl 2. if it's already present in $CPPFLAGS, + dnl 3. if it's /usr/local/include and we are using GCC on Linux, + dnl 4. if it doesn't exist as a directory. + if test "X$additional_includedir" != "X/usr/include"; then + haveit= + for x in $CPPFLAGS; do + AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) + if test "X$x" = "X-I$additional_includedir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + if test "X$additional_includedir" = "X/usr/local/include"; then + if test -n "$GCC"; then + case $host_os in + linux* | gnu* | k*bsd*-gnu) haveit=yes;; + esac + fi + fi + if test -z "$haveit"; then + if test -d "$additional_includedir"; then + dnl Really add $additional_includedir to $CPPFLAGS. + CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir" + fi + fi + fi + fi + dnl Potentially add $additional_libdir to $LDFLAGS. + dnl But don't add it + dnl 1. if it's the standard /usr/lib, + dnl 2. if it's already present in $LDFLAGS, + dnl 3. if it's /usr/local/lib and we are using GCC on Linux, + dnl 4. if it doesn't exist as a directory. + if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then + haveit= + for x in $LDFLAGS; do + AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) + if test "X$x" = "X-L$additional_libdir"; then + haveit=yes + break + fi + done + if test -z "$haveit"; then + if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then + if test -n "$GCC"; then + case $host_os in + linux*) haveit=yes;; + esac + fi + fi + if test -z "$haveit"; then + if test -d "$additional_libdir"; then + dnl Really add $additional_libdir to $LDFLAGS. + LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir" + fi + fi + fi + fi + fi +]) + +dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix, +dnl acl_final_exec_prefix, containing the values to which $prefix and +dnl $exec_prefix will expand at the end of the configure script. +AC_DEFUN([AC_LIB_PREPARE_PREFIX], +[ + dnl Unfortunately, prefix and exec_prefix get only finally determined + dnl at the end of configure. + if test "X$prefix" = "XNONE"; then + acl_final_prefix="$ac_default_prefix" + else + acl_final_prefix="$prefix" + fi + if test "X$exec_prefix" = "XNONE"; then + acl_final_exec_prefix='${prefix}' + else + acl_final_exec_prefix="$exec_prefix" + fi + acl_saved_prefix="$prefix" + prefix="$acl_final_prefix" + eval acl_final_exec_prefix=\"$acl_final_exec_prefix\" + prefix="$acl_saved_prefix" +]) + +dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the +dnl variables prefix and exec_prefix bound to the values they will have +dnl at the end of the configure script. +AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX], +[ + acl_saved_prefix="$prefix" + prefix="$acl_final_prefix" + acl_saved_exec_prefix="$exec_prefix" + exec_prefix="$acl_final_exec_prefix" + $1 + exec_prefix="$acl_saved_exec_prefix" + prefix="$acl_saved_prefix" +]) + +dnl AC_LIB_PREPARE_MULTILIB creates +dnl - a function acl_is_expected_elfclass, that tests whether standard input +dn; has a 32-bit or 64-bit ELF header, depending on the host CPU ABI, +dnl - 3 variables acl_libdirstem, acl_libdirstem2, acl_libdirstem3, containing +dnl the basename of the libdir to try in turn, either "lib" or "lib64" or +dnl "lib/64" or "lib32" or "lib/sparcv9" or "lib/amd64" or similar. +AC_DEFUN([AC_LIB_PREPARE_MULTILIB], +[ + dnl There is no formal standard regarding lib, lib32, and lib64. + dnl On most glibc systems, the current practice is that on a system supporting + dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under + dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. However, on + dnl Arch Linux based distributions, it's the opposite: 32-bit libraries go + dnl under $prefix/lib32 and 64-bit libraries go under $prefix/lib. + dnl We determine the compiler's default mode by looking at the compiler's + dnl library search path. If at least one of its elements ends in /lib64 or + dnl points to a directory whose absolute pathname ends in /lib64, we use that + dnl for 64-bit ABIs. Similarly for 32-bit ABIs. Otherwise we use the default, + dnl namely "lib". + dnl On Solaris systems, the current practice is that on a system supporting + dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under + dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or + dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib. + AC_REQUIRE([AC_CANONICAL_HOST]) + AC_REQUIRE([gl_HOST_CPU_C_ABI_32BIT]) + + AC_CACHE_CHECK([for ELF binary format], [gl_cv_elf], + [AC_EGREP_CPP([Extensible Linking Format], + [#if defined __ELF__ || (defined __linux__ && (defined __EDG__ || defined __SUNPRO_C)) + Extensible Linking Format + #endif + ], + [gl_cv_elf=yes], + [gl_cv_elf=no]) + ]) + if test $gl_cv_elf = yes; then + # Extract the ELF class of a file (5th byte) in decimal. + # Cf. https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header + if od -A x < /dev/null >/dev/null 2>/dev/null; then + # Use POSIX od. + func_elfclass () + { + od -A n -t d1 -j 4 -N 1 + } + else + # Use BSD hexdump. + func_elfclass () + { + dd bs=1 count=1 skip=4 2>/dev/null | hexdump -e '1/1 "%3d "' + echo + } + fi + # Use 'expr', not 'test', to compare the values of func_elfclass, because on + # Solaris 11 OpenIndiana and Solaris 11 OmniOS, the result is 001 or 002, + # not 1 or 2. +changequote(,)dnl + case $HOST_CPU_C_ABI_32BIT in + yes) + # 32-bit ABI. + acl_is_expected_elfclass () + { + expr "`func_elfclass | sed -e 's/[ ]//g'`" = 1 > /dev/null + } + ;; + no) + # 64-bit ABI. + acl_is_expected_elfclass () + { + expr "`func_elfclass | sed -e 's/[ ]//g'`" = 2 > /dev/null + } + ;; + *) + # Unknown. + acl_is_expected_elfclass () + { + : + } + ;; + esac +changequote([,])dnl + else + acl_is_expected_elfclass () + { + : + } + fi + + dnl Allow the user to override the result by setting acl_cv_libdirstems. + AC_CACHE_CHECK([for the common suffixes of directories in the library search path], + [acl_cv_libdirstems], + [dnl Try 'lib' first, because that's the default for libdir in GNU, see + dnl . + acl_libdirstem=lib + acl_libdirstem2= + acl_libdirstem3= + case "$host_os" in + solaris*) + dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment + dnl . + dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link." + dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the + dnl symlink is missing, so we set acl_libdirstem2 too. + if test $HOST_CPU_C_ABI_32BIT = no; then + acl_libdirstem2=lib/64 + case "$host_cpu" in + sparc*) acl_libdirstem3=lib/sparcv9 ;; + i*86 | x86_64) acl_libdirstem3=lib/amd64 ;; + esac + fi + ;; + netbsd*) + dnl On NetBSD/sparc64, there is a 'sparc' subdirectory that contains + dnl 32-bit libraries. + if test $HOST_CPU_C_ABI_32BIT != no; then + case "$host_cpu" in + sparc*) acl_libdirstem2=lib/sparc ;; + esac + fi + ;; + *) + dnl If $CC generates code for a 32-bit ABI, the libraries are + dnl surely under $prefix/lib or $prefix/lib32, not $prefix/lib64. + dnl Similarly, if $CC generates code for a 64-bit ABI, the libraries + dnl are surely under $prefix/lib or $prefix/lib64, not $prefix/lib32. + dnl Find the compiler's search path. However, non-system compilers + dnl sometimes have odd library search paths. But we can't simply invoke + dnl '/usr/bin/gcc -print-search-dirs' because that would not take into + dnl account the -m32/-m31 or -m64 options from the $CC or $CFLAGS. + searchpath=`(LC_ALL=C $CC $CPPFLAGS $CFLAGS -print-search-dirs) 2>/dev/null \ + | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'` + if test $HOST_CPU_C_ABI_32BIT != no; then + # 32-bit or unknown ABI. + if test -d /usr/lib32; then + acl_libdirstem2=lib32 + fi + fi + if test $HOST_CPU_C_ABI_32BIT != yes; then + # 64-bit or unknown ABI. + if test -d /usr/lib64; then + acl_libdirstem3=lib64 + fi + fi + if test -n "$searchpath"; then + acl_saved_IFS="${IFS= }"; IFS=":" + for searchdir in $searchpath; do + if test -d "$searchdir"; then + case "$searchdir" in + */lib32/ | */lib32 ) acl_libdirstem2=lib32 ;; + */lib64/ | */lib64 ) acl_libdirstem3=lib64 ;; + */../ | */.. ) + # Better ignore directories of this form. They are misleading. + ;; + *) searchdir=`cd "$searchdir" && pwd` + case "$searchdir" in + */lib32 ) acl_libdirstem2=lib32 ;; + */lib64 ) acl_libdirstem3=lib64 ;; + esac ;; + esac + fi + done + IFS="$acl_saved_IFS" + if test $HOST_CPU_C_ABI_32BIT = yes; then + # 32-bit ABI. + acl_libdirstem3= + fi + if test $HOST_CPU_C_ABI_32BIT = no; then + # 64-bit ABI. + acl_libdirstem2= + fi + fi + ;; + esac + test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem" + test -n "$acl_libdirstem3" || acl_libdirstem3="$acl_libdirstem" + acl_cv_libdirstems="$acl_libdirstem,$acl_libdirstem2,$acl_libdirstem3" + ]) + dnl Decompose acl_cv_libdirstems into acl_libdirstem, acl_libdirstem2, and + dnl acl_libdirstem3. +changequote(,)dnl + acl_libdirstem=`echo "$acl_cv_libdirstems" | sed -e 's/,.*//'` + acl_libdirstem2=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,//' -e 's/,.*//'` + acl_libdirstem3=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,[^,]*,//' -e 's/,.*//'` +changequote([,])dnl +]) diff --git a/cpp/third_party/xz-5.8.3/m4/libtool.m4 b/cpp/third_party/xz-5.8.3/m4/libtool.m4 new file mode 100644 index 0000000000..5ccb3a8131 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/libtool.m4 @@ -0,0 +1,8880 @@ +# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*- +# +# Copyright (C) 1996-2001, 2003-2019, 2021-2025 Free Software +# Foundation, Inc. +# Written by Gordon Matzigkeit, 1996 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +m4_define([_LT_COPYING], [dnl +# 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. + +# GNU Libtool is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program or library that is built +# using GNU Libtool, you may include this file under the same +# distribution terms that you use for the rest of that program. +# +# GNU Libtool is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# 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, see . +]) + +# serial 66 LT_INIT + + +# LT_PREREQ(VERSION) +# ------------------ +# Complain and exit if this libtool version is less that VERSION. +m4_defun([LT_PREREQ], +[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1, + [m4_default([$3], + [m4_fatal([Libtool version $1 or higher is required], + 63)])], + [$2])]) + + +# _LT_CHECK_BUILDDIR +# ------------------ +# Complain if the absolute build directory name contains unusual characters +m4_defun([_LT_CHECK_BUILDDIR], +[case `pwd` in + *\ * | *\ *) + AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;; +esac +]) + + +# LT_INIT([OPTIONS]) +# ------------------ +AC_DEFUN([LT_INIT], +[AC_PREREQ([2.64])dnl We use AC_PATH_PROGS_FEATURE_CHECK +AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl +AC_BEFORE([$0], [LT_LANG])dnl +AC_BEFORE([$0], [LT_OUTPUT])dnl +AC_BEFORE([$0], [LTDL_INIT])dnl +m4_require([_LT_CHECK_BUILDDIR])dnl + +dnl Autoconf doesn't catch unexpanded LT_ macros by default: +m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl +m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl +dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4 +dnl unless we require an AC_DEFUNed macro: +AC_REQUIRE([LTOPTIONS_VERSION])dnl +AC_REQUIRE([LTSUGAR_VERSION])dnl +AC_REQUIRE([LTVERSION_VERSION])dnl +AC_REQUIRE([LTOBSOLETE_VERSION])dnl +m4_require([_LT_PROG_LTMAIN])dnl + +_LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}]) + +dnl Parse OPTIONS +_LT_SET_OPTIONS([$0], [$1]) + +# This can be used to rebuild libtool when needed +LIBTOOL_DEPS=$ltmain + +# Always use our own libtool. +LIBTOOL='$(SHELL) $(top_builddir)/libtool' +AC_SUBST(LIBTOOL)dnl + +_LT_SETUP + +# Only expand once: +m4_define([LT_INIT]) +])# LT_INIT + +# Old names: +AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT]) +AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_PROG_LIBTOOL], []) +dnl AC_DEFUN([AM_PROG_LIBTOOL], []) + + +# _LT_PREPARE_CC_BASENAME +# ----------------------- +m4_defun([_LT_PREPARE_CC_BASENAME], [ +# Calculate cc_basename. Skip known compiler wrappers and cross-prefix. +func_cc_basename () +{ + for cc_temp in @S|@*""; do + case $cc_temp in + compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;; + distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;; + \-*) ;; + *) break;; + esac + done + func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"` +} +])# _LT_PREPARE_CC_BASENAME + + +# _LT_CC_BASENAME(CC) +# ------------------- +# It would be clearer to call AC_REQUIREs from _LT_PREPARE_CC_BASENAME, +# but that macro is also expanded into generated libtool script, which +# arranges for $SED and $ECHO to be set by different means. +m4_defun([_LT_CC_BASENAME], +[m4_require([_LT_PREPARE_CC_BASENAME])dnl +AC_REQUIRE([_LT_DECL_SED])dnl +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl +func_cc_basename $1 +cc_basename=$func_cc_basename_result +]) + + +# _LT_FILEUTILS_DEFAULTS +# ---------------------- +# It is okay to use these file commands and assume they have been set +# sensibly after 'm4_require([_LT_FILEUTILS_DEFAULTS])'. +m4_defun([_LT_FILEUTILS_DEFAULTS], +[: ${CP="cp -f"} +: ${MV="mv -f"} +: ${RM="rm -f"} +])# _LT_FILEUTILS_DEFAULTS + + +# _LT_SETUP +# --------- +m4_defun([_LT_SETUP], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl + +_LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl +dnl +_LT_DECL([], [host_alias], [0], [The host system])dnl +_LT_DECL([], [host], [0])dnl +_LT_DECL([], [host_os], [0])dnl +dnl +_LT_DECL([], [build_alias], [0], [The build system])dnl +_LT_DECL([], [build], [0])dnl +_LT_DECL([], [build_os], [0])dnl +dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([LT_PATH_LD])dnl +AC_REQUIRE([LT_PATH_NM])dnl +dnl +AC_REQUIRE([AC_PROG_LN_S])dnl +test -z "$LN_S" && LN_S="ln -s" +_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl +dnl +AC_REQUIRE([LT_CMD_MAX_LEN])dnl +_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl +_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl +dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_CHECK_SHELL_FEATURES])dnl +m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl +m4_require([_LT_CMD_RELOAD])dnl +m4_require([_LT_DECL_FILECMD])dnl +m4_require([_LT_CHECK_MAGIC_METHOD])dnl +m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl +m4_require([_LT_CMD_OLD_ARCHIVE])dnl +m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl +m4_require([_LT_WITH_SYSROOT])dnl +m4_require([_LT_CMD_TRUNCATE])dnl + +_LT_CONFIG_LIBTOOL_INIT([ +# See if we are running on zsh, and set the options that allow our +# commands through without removal of \ escapes INIT. +if test -n "\${ZSH_VERSION+set}"; then + setopt NO_GLOB_SUBST +fi +]) +if test -n "${ZSH_VERSION+set}"; then + setopt NO_GLOB_SUBST +fi + +_LT_CHECK_OBJDIR + +m4_require([_LT_TAG_COMPILER])dnl + +case $host_os in +aix3*) + # AIX sometimes has problems with the GCC collect2 program. For some + # reason, if we set the COLLECT_NAMES environment variable, the problems + # vanish in a puff of smoke. + if test set != "${COLLECT_NAMES+set}"; then + COLLECT_NAMES= + export COLLECT_NAMES + fi + ;; +esac + +# Global variables: +ofile=libtool +can_build_shared=yes + +# All known linkers require a '.a' archive for static linking (except MSVC and +# ICC, which need '.lib'). +libext=a + +with_gnu_ld=$lt_cv_prog_gnu_ld + +old_CC=$CC +old_CFLAGS=$CFLAGS + +# Set sane defaults for various variables +test -z "$CC" && CC=cc +test -z "$LTCC" && LTCC=$CC +test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS +test -z "$LD" && LD=ld +test -z "$ac_objext" && ac_objext=o + +_LT_CC_BASENAME([$compiler]) + +# Only perform the check for file, if the check method requires it +test -z "$MAGIC_CMD" && MAGIC_CMD=file +case $deplibs_check_method in +file_magic*) + if test "$file_magic_cmd" = '$MAGIC_CMD'; then + _LT_PATH_MAGIC + fi + ;; +esac + +# Use C for the default configuration in the libtool script +LT_SUPPORTED_TAG([CC]) +_LT_LANG_C_CONFIG +_LT_LANG_DEFAULT_CONFIG +_LT_CONFIG_COMMANDS +])# _LT_SETUP + + +# _LT_PREPARE_SED_QUOTE_VARS +# -------------------------- +# Define a few sed substitution that help us do robust quoting. +m4_defun([_LT_PREPARE_SED_QUOTE_VARS], +[# Backslashify metacharacters that are still active within +# double-quoted strings. +sed_quote_subst='s/\([["`$\\]]\)/\\\1/g' + +# Same as above, but do not quote variable references. +double_quote_subst='s/\([["`\\]]\)/\\\1/g' + +# Sed substitution to delay expansion of an escaped shell variable in a +# double_quote_subst'ed string. +delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g' + +# Sed substitution to delay expansion of an escaped single quote. +delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g' + +# Sed substitution to avoid accidental globbing in evaled expressions +no_glob_subst='s/\*/\\\*/g' +]) + +# _LT_PROG_LTMAIN +# --------------- +# Note that this code is called both from 'configure', and 'config.status' +# now that we use AC_CONFIG_COMMANDS to generate libtool. Notably, +# 'config.status' has no value for ac_aux_dir unless we are using Automake, +# so we pass a copy along to make sure it has a sensible value anyway. +m4_defun([_LT_PROG_LTMAIN], +[m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl +_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir']) +ltmain=$ac_aux_dir/ltmain.sh +])# _LT_PROG_LTMAIN + + +## ------------------------------------- ## +## Accumulate code for creating libtool. ## +## ------------------------------------- ## + +# So that we can recreate a full libtool script including additional +# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS +# in macros and then make a single call at the end using the 'libtool' +# label. + + +# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS]) +# ---------------------------------------- +# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later. +m4_define([_LT_CONFIG_LIBTOOL_INIT], +[m4_ifval([$1], + [m4_append([_LT_OUTPUT_LIBTOOL_INIT], + [$1 +])])]) + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_INIT]) + + +# _LT_CONFIG_LIBTOOL([COMMANDS]) +# ------------------------------ +# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later. +m4_define([_LT_CONFIG_LIBTOOL], +[m4_ifval([$1], + [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS], + [$1 +])])]) + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS]) + + +# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS]) +# ----------------------------------------------------- +m4_defun([_LT_CONFIG_SAVE_COMMANDS], +[_LT_CONFIG_LIBTOOL([$1]) +_LT_CONFIG_LIBTOOL_INIT([$2]) +]) + + +# _LT_FORMAT_COMMENT([COMMENT]) +# ----------------------------- +# Add leading comment marks to the start of each line, and a trailing +# full-stop to the whole comment if one is not present already. +m4_define([_LT_FORMAT_COMMENT], +[m4_ifval([$1], [ +m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])], + [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.]) +)]) + + + +## ------------------------ ## +## FIXME: Eliminate VARNAME ## +## ------------------------ ## + + +# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?]) +# ------------------------------------------------------------------- +# CONFIGNAME is the name given to the value in the libtool script. +# VARNAME is the (base) name used in the configure script. +# VALUE may be 0, 1 or 2 for a computed quote escaped value based on +# VARNAME. Any other value will be used directly. +m4_define([_LT_DECL], +[lt_if_append_uniq([lt_decl_varnames], [$2], [, ], + [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name], + [m4_ifval([$1], [$1], [$2])]) + lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3]) + m4_ifval([$4], + [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])]) + lt_dict_add_subkey([lt_decl_dict], [$2], + [tagged?], [m4_ifval([$5], [yes], [no])])]) +]) + + +# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION]) +# -------------------------------------------------------- +m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])]) + + +# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...]) +# ------------------------------------------------ +m4_define([lt_decl_tag_varnames], +[_lt_decl_filter([tagged?], [yes], $@)]) + + +# _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..]) +# --------------------------------------------------------- +m4_define([_lt_decl_filter], +[m4_case([$#], + [0], [m4_fatal([$0: too few arguments: $#])], + [1], [m4_fatal([$0: too few arguments: $#: $1])], + [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)], + [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)], + [lt_dict_filter([lt_decl_dict], $@)])[]dnl +]) + + +# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...]) +# -------------------------------------------------- +m4_define([lt_decl_quote_varnames], +[_lt_decl_filter([value], [1], $@)]) + + +# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...]) +# --------------------------------------------------- +m4_define([lt_decl_dquote_varnames], +[_lt_decl_filter([value], [2], $@)]) + + +# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...]) +# --------------------------------------------------- +m4_define([lt_decl_varnames_tagged], +[m4_assert([$# <= 2])dnl +_$0(m4_quote(m4_default([$1], [[, ]])), + m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]), + m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))]) +m4_define([_lt_decl_varnames_tagged], +[m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])]) + + +# lt_decl_all_varnames([SEPARATOR], [VARNAME1...]) +# ------------------------------------------------ +m4_define([lt_decl_all_varnames], +[_$0(m4_quote(m4_default([$1], [[, ]])), + m4_if([$2], [], + m4_quote(lt_decl_varnames), + m4_quote(m4_shift($@))))[]dnl +]) +m4_define([_lt_decl_all_varnames], +[lt_join($@, lt_decl_varnames_tagged([$1], + lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl +]) + + +# _LT_CONFIG_STATUS_DECLARE([VARNAME]) +# ------------------------------------ +# Quote a variable value, and forward it to 'config.status' so that its +# declaration there will have the same value as in 'configure'. VARNAME +# must have a single quote delimited value for this to work. +m4_define([_LT_CONFIG_STATUS_DECLARE], +[$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`']) + + +# _LT_CONFIG_STATUS_DECLARATIONS +# ------------------------------ +# We delimit libtool config variables with single quotes, so when +# we write them to config.status, we have to be sure to quote all +# embedded single quotes properly. In configure, this macro expands +# each variable declared with _LT_DECL (and _LT_TAGDECL) into: +# +# ='`$ECHO "$" | $SED "$delay_single_quote_subst"`' +m4_defun([_LT_CONFIG_STATUS_DECLARATIONS], +[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames), + [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])]) + + +# _LT_LIBTOOL_TAGS +# ---------------- +# Output comment and list of tags supported by the script +m4_defun([_LT_LIBTOOL_TAGS], +[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl +available_tags='_LT_TAGS'dnl +]) + + +# _LT_LIBTOOL_DECLARE(VARNAME, [TAG]) +# ----------------------------------- +# Extract the dictionary values for VARNAME (optionally with TAG) and +# expand to a commented shell variable setting: +# +# # Some comment about what VAR is for. +# visible_name=$lt_internal_name +m4_define([_LT_LIBTOOL_DECLARE], +[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], + [description])))[]dnl +m4_pushdef([_libtool_name], + m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl +m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])), + [0], [_libtool_name=[$]$1], + [1], [_libtool_name=$lt_[]$1], + [2], [_libtool_name=$lt_[]$1], + [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl +m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl +]) + + +# _LT_LIBTOOL_CONFIG_VARS +# ----------------------- +# Produce commented declarations of non-tagged libtool config variables +# suitable for insertion in the LIBTOOL CONFIG section of the 'libtool' +# script. Tagged libtool config variables (even for the LIBTOOL CONFIG +# section) are produced by _LT_LIBTOOL_TAG_VARS. +m4_defun([_LT_LIBTOOL_CONFIG_VARS], +[m4_foreach([_lt_var], + m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)), + [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])]) + + +# _LT_LIBTOOL_TAG_VARS(TAG) +# ------------------------- +m4_define([_LT_LIBTOOL_TAG_VARS], +[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames), + [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])]) + + +# _LT_TAGVAR(VARNAME, [TAGNAME]) +# ------------------------------ +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 +# ------------------- +# Send accumulated output to $CONFIG_STATUS. Thanks to the lists of +# variables for single and double quote escaping we saved from calls +# to _LT_DECL, we can put quote escaped variables declarations +# into 'config.status', and then the shell code to quote escape them in +# for loops in 'config.status'. Finally, any additional code accumulated +# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded. +m4_defun([_LT_CONFIG_COMMANDS], +[AC_PROVIDE_IFELSE([LT_OUTPUT], + dnl If the libtool generation code has been placed in $CONFIG_LT, + dnl instead of duplicating it all over again into config.status, + dnl then we will have config.status run $CONFIG_LT later, so it + dnl needs to know what name is stored there: + [AC_CONFIG_COMMANDS([libtool], + [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])], + dnl If the libtool generation code is destined for config.status, + dnl expand the accumulated commands and init code now: + [AC_CONFIG_COMMANDS([libtool], + [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])]) +])#_LT_CONFIG_COMMANDS + + +# Initialize. +m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT], +[ + +# The HP-UX ksh and POSIX shell print the target directory to stdout +# if CDPATH is set. +(unset CDPATH) >/dev/null 2>&1 && unset CDPATH + +sed_quote_subst='$sed_quote_subst' +double_quote_subst='$double_quote_subst' +delay_variable_subst='$delay_variable_subst' +_LT_CONFIG_STATUS_DECLARATIONS +LTCC='$LTCC' +LTCFLAGS='$LTCFLAGS' +compiler='$compiler_DEFAULT' + +# A function that is used when there is no print builtin or printf. +func_fallback_echo () +{ + eval 'cat <<_LTECHO_EOF +\$[]1 +_LTECHO_EOF' +} + +# Quote evaled strings. +for var in lt_decl_all_varnames([[ \ +]], lt_decl_quote_varnames); do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[[\\\\\\\`\\"\\\$]]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +# Double-quote double-evaled strings. +for var in lt_decl_all_varnames([[ \ +]], lt_decl_dquote_varnames); do + case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in + *[[\\\\\\\`\\"\\\$]]*) + eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes + ;; + *) + eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\"" + ;; + esac +done + +_LT_OUTPUT_LIBTOOL_INIT +]) + +# _LT_GENERATED_FILE_INIT(FILE, [COMMENT]) +# ------------------------------------ +# Generate a child script FILE with all initialization necessary to +# reuse the environment learned by the parent script, and make the +# file executable. If COMMENT is supplied, it is inserted after the +# '#!' sequence but before initialization text begins. After this +# macro, additional text can be appended to FILE to form the body of +# the child script. The macro ends with non-zero status if the +# file could not be fully written (such as if the disk is full). +m4_ifdef([AS_INIT_GENERATED], +[m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])], +[m4_defun([_LT_GENERATED_FILE_INIT], +[m4_require([AS_PREPARE])]dnl +[m4_pushdef([AS_MESSAGE_LOG_FD])]dnl +[lt_write_fail=0 +cat >$1 <<_ASEOF || lt_write_fail=1 +#! $SHELL +# Generated by $as_me. +$2 +SHELL=\${CONFIG_SHELL-$SHELL} +export SHELL +_ASEOF +cat >>$1 <<\_ASEOF || lt_write_fail=1 +AS_SHELL_SANITIZE +_AS_PREPARE +exec AS_MESSAGE_FD>&1 +_ASEOF +test 0 = "$lt_write_fail" && chmod +x $1[]dnl +m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT + +# LT_OUTPUT +# --------- +# This macro allows early generation of the libtool script (before +# AC_OUTPUT is called), in case it is used in configure for compilation +# tests. +AC_DEFUN([LT_OUTPUT], +[: ${CONFIG_LT=./config.lt} +AC_MSG_NOTICE([creating $CONFIG_LT]) +_LT_GENERATED_FILE_INIT(["$CONFIG_LT"], +[# Run this file to recreate a libtool stub with the current configuration.]) + +cat >>"$CONFIG_LT" <<\_LTEOF +lt_cl_silent=false +exec AS_MESSAGE_LOG_FD>>config.log +{ + echo + AS_BOX([Running $as_me.]) +} >&AS_MESSAGE_LOG_FD + +lt_cl_help="\ +'$as_me' creates a local libtool stub from the current configuration, +for use in further configure time tests before the real libtool is +generated. + +Usage: $[0] [[OPTIONS]] + + -h, --help print this help, then exit + -V, --version print version number, then exit + -q, --quiet do not print progress messages + -d, --debug don't remove temporary files + +Report bugs to ." + +lt_cl_version="\ +m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl +m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION]) +configured by $[0], generated by m4_PACKAGE_STRING. + +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." + +while test 0 != $[#] +do + case $[1] in + --version | --v* | -V ) + echo "$lt_cl_version"; exit 0 ;; + --help | --h* | -h ) + echo "$lt_cl_help"; exit 0 ;; + --debug | --d* | -d ) + debug=: ;; + --quiet | --q* | --silent | --s* | -q ) + lt_cl_silent=: ;; + + -*) AC_MSG_ERROR([unrecognized option: $[1] +Try '$[0] --help' for more information.]) ;; + + *) AC_MSG_ERROR([unrecognized argument: $[1] +Try '$[0] --help' for more information.]) ;; + esac + shift +done + +if $lt_cl_silent; then + exec AS_MESSAGE_FD>/dev/null +fi +_LTEOF + +cat >>"$CONFIG_LT" <<_LTEOF +_LT_OUTPUT_LIBTOOL_COMMANDS_INIT +_LTEOF + +cat >>"$CONFIG_LT" <<\_LTEOF +AC_MSG_NOTICE([creating $ofile]) +_LT_OUTPUT_LIBTOOL_COMMANDS +AS_EXIT(0) +_LTEOF +chmod +x "$CONFIG_LT" + +# configure is writing to config.log, but config.lt does its own redirection, +# appending to config.log, which fails on DOS, as config.log is still kept +# open by configure. Here we exec the FD to /dev/null, effectively closing +# config.log, so it can be properly (re)opened and appended to by config.lt. +lt_cl_success=: +test yes = "$silent" && + lt_config_lt_args="$lt_config_lt_args --quiet" +exec AS_MESSAGE_LOG_FD>/dev/null +$SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false +exec AS_MESSAGE_LOG_FD>>config.log +$lt_cl_success || AS_EXIT(1) +])# LT_OUTPUT + + +# _LT_CONFIG(TAG) +# --------------- +# If TAG is the built-in tag, create an initial libtool script with a +# default configuration from the untagged config vars. Otherwise add code +# to config.status for appending the configuration named by TAG from the +# matching tagged config vars. +m4_defun([_LT_CONFIG], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +_LT_CONFIG_SAVE_COMMANDS([ + m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl + m4_if(_LT_TAG, [C], [ + # See if we are running on zsh, and set the options that allow our + # commands through without removal of \ escapes. + if test -n "${ZSH_VERSION+set}"; then + setopt NO_GLOB_SUBST + fi + + cfgfile=${ofile}T + trap "$RM \"$cfgfile\"; exit 1" 1 2 15 + $RM "$cfgfile" + + cat <<_LT_EOF >> "$cfgfile" +#! $SHELL +# Generated automatically by $as_me ($PACKAGE) $VERSION +# NOTE: Changes made to this file will be lost: look at ltmain.sh. + +# Provide generalized library-building support services. +# Written by Gordon Matzigkeit, 1996 + +_LT_COPYING +_LT_LIBTOOL_TAGS + +# Configured defaults for sys_lib_dlsearch_path munging. +: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"} + +# ### BEGIN LIBTOOL CONFIG +_LT_LIBTOOL_CONFIG_VARS +_LT_LIBTOOL_TAG_VARS +# ### END LIBTOOL CONFIG + +_LT_EOF + + cat <<'_LT_EOF' >> "$cfgfile" + +# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE + +_LT_PREPARE_MUNGE_PATH_LIST +_LT_PREPARE_CC_BASENAME + +# ### END FUNCTIONS SHARED WITH CONFIGURE + +_LT_EOF + + case $host_os in + aix3*) + cat <<\_LT_EOF >> "$cfgfile" +# AIX sometimes has problems with the GCC collect2 program. For some +# reason, if we set the COLLECT_NAMES environment variable, the problems +# vanish in a puff of smoke. +if test set != "${COLLECT_NAMES+set}"; then + COLLECT_NAMES= + export COLLECT_NAMES +fi +_LT_EOF + ;; + esac + + _LT_PROG_LTMAIN + + # We use sed instead of cat because bash on DJGPP gets confused if + # if finds mixed CR/LF and LF-only lines. Since sed operates in + # text mode, it properly converts lines to CR/LF. This bash problem + # is reportedly fixed, but why not run on old versions too? + $SED '$q' "$ltmain" >> "$cfgfile" \ + || (rm -f "$cfgfile"; exit 1) + + mv -f "$cfgfile" "$ofile" || + (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile") + chmod +x "$ofile" +], +[cat <<_LT_EOF >> "$ofile" + +dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded +dnl in a comment (ie after a #). +# ### BEGIN LIBTOOL TAG CONFIG: $1 +_LT_LIBTOOL_TAG_VARS(_LT_TAG) +# ### END LIBTOOL TAG CONFIG: $1 +_LT_EOF +])dnl /m4_if +], +[m4_if([$1], [], [ + PACKAGE='$PACKAGE' + VERSION='$VERSION' + RM='$RM' + ofile='$ofile'], []) +])dnl /_LT_CONFIG_SAVE_COMMANDS +])# _LT_CONFIG + + +# LT_SUPPORTED_TAG(TAG) +# --------------------- +# Trace this macro to discover what tags are supported by the libtool +# --tag option, using: +# autoconf --trace 'LT_SUPPORTED_TAG:$1' +AC_DEFUN([LT_SUPPORTED_TAG], []) + + +# C support is built-in for now +m4_define([_LT_LANG_C_enabled], []) +m4_define([_LT_TAGS], []) + + +# LT_LANG(LANG) +# ------------- +# Enable libtool support for the given language if not already enabled. +AC_DEFUN([LT_LANG], +[AC_BEFORE([$0], [LT_OUTPUT])dnl +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)], + [Fortran], [_LT_LANG(FC)], + [Windows Resource], [_LT_LANG(RC)], + [m4_ifdef([_LT_LANG_]$1[_CONFIG], + [_LT_LANG($1)], + [m4_fatal([$0: unsupported language: "$1"])])])dnl +])# LT_LANG + + +# _LT_LANG(LANGNAME) +# ------------------ +m4_defun([_LT_LANG], +[m4_ifdef([_LT_LANG_]$1[_enabled], [], + [LT_SUPPORTED_TAG([$1])dnl + m4_append([_LT_TAGS], [$1 ])dnl + m4_define([_LT_LANG_]$1[_enabled], [])dnl + _LT_LANG_$1_CONFIG($1)])dnl +])# _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 # +# GNU Autoconf as AC_PROG_GO. When it is available in # +# a released version of Autoconf we should remove this # +# macro and use it instead. # +############################################################ +m4_defun([AC_PROG_GO], +[AC_LANG_PUSH(Go)dnl +AC_ARG_VAR([GOC], [Go compiler command])dnl +AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl +_AC_ARG_VAR_LDFLAGS()dnl +AC_CHECK_TOOL(GOC, gccgo) +if test -z "$GOC"; then + if test -n "$ac_tool_prefix"; then + AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo]) + fi +fi +if test -z "$GOC"; then + AC_CHECK_PROG(GOC, gccgo, gccgo, false) +fi +])#m4_defun +])#m4_ifndef + + +# _LT_LANG_DEFAULT_CONFIG +# ----------------------- +m4_defun([_LT_LANG_DEFAULT_CONFIG], +[AC_PROVIDE_IFELSE([AC_PROG_CXX], + [LT_LANG(CXX)], + [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])]) + +AC_PROVIDE_IFELSE([AC_PROG_F77], + [LT_LANG(F77)], + [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])]) + +AC_PROVIDE_IFELSE([AC_PROG_FC], + [LT_LANG(FC)], + [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])]) + +dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal +dnl pulling things in needlessly. +AC_PROVIDE_IFELSE([AC_PROG_GCJ], + [LT_LANG(GCJ)], + [AC_PROVIDE_IFELSE([A][M_PROG_GCJ], + [LT_LANG(GCJ)], + [AC_PROVIDE_IFELSE([LT_PROG_GCJ], + [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 + +# Obsolete macros: +AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)]) +AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)]) +AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)]) +AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)]) +AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_CXX], []) +dnl AC_DEFUN([AC_LIBTOOL_F77], []) +dnl AC_DEFUN([AC_LIBTOOL_FC], []) +dnl AC_DEFUN([AC_LIBTOOL_GCJ], []) +dnl AC_DEFUN([AC_LIBTOOL_RC], []) + + +# _LT_TAG_COMPILER +# ---------------- +m4_defun([_LT_TAG_COMPILER], +[AC_REQUIRE([AC_PROG_CC])dnl + +_LT_DECL([LTCC], [CC], [1], [A C compiler])dnl +_LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl +_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl +_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl + +# If no C compiler was specified, use CC. +LTCC=${LTCC-"$CC"} + +# If no C compiler flags were specified, use CFLAGS. +LTCFLAGS=${LTCFLAGS-"$CFLAGS"} + +# Allow CC to be a program name with arguments. +compiler=$CC +])# _LT_TAG_COMPILER + + +# _LT_COMPILER_BOILERPLATE +# ------------------------ +# Check for compiler boilerplate output or warnings with +# the simple compiler test code. +m4_defun([_LT_COMPILER_BOILERPLATE], +[m4_require([_LT_DECL_SED])dnl +ac_outfile=conftest.$ac_objext +echo "$lt_simple_compile_test_code" >conftest.$ac_ext +eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_compiler_boilerplate=`cat conftest.err` +$RM conftest* +])# _LT_COMPILER_BOILERPLATE + + +# _LT_LINKER_BOILERPLATE +# ---------------------- +# Check for linker boilerplate output or warnings with +# the simple link test code. +m4_defun([_LT_LINKER_BOILERPLATE], +[m4_require([_LT_DECL_SED])dnl +ac_outfile=conftest.$ac_objext +echo "$lt_simple_link_test_code" >conftest.$ac_ext +eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err +_lt_linker_boilerplate=`cat conftest.err` +$RM -r conftest* +])# _LT_LINKER_BOILERPLATE + + +# _LT_REQUIRED_DARWIN_CHECKS +# ------------------------- +m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[ + case $host_os in + rhapsody* | darwin*) + AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:]) + AC_CHECK_TOOL([NMEDIT], [nmedit], [:]) + AC_CHECK_TOOL([LIPO], [lipo], [:]) + AC_CHECK_TOOL([OTOOL], [otool], [:]) + AC_CHECK_TOOL([OTOOL64], [otool64], [:]) + _LT_DECL([], [DSYMUTIL], [1], + [Tool to manipulate archived DWARF debug symbol files on Mac OS X]) + _LT_DECL([], [NMEDIT], [1], + [Tool to change global to local symbols on Mac OS X]) + _LT_DECL([], [LIPO], [1], + [Tool to manipulate fat objects and archives on Mac OS X]) + _LT_DECL([], [OTOOL], [1], + [ldd/readelf like tool for Mach-O binaries on Mac OS X]) + _LT_DECL([], [OTOOL64], [1], + [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4]) + + AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod], + [lt_cv_apple_cc_single_mod=no + if test -z "$LT_MULTI_MODULE"; then + # By default we will add the -single_module flag. You can override + # by either setting the environment variable LT_MULTI_MODULE + # non-empty at configure time, or by adding -multi_module to the + # link flags. + rm -rf libconftest.dylib* + echo "int foo(void){return 1;}" > conftest.c + echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ +-dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \ + -dynamiclib -Wl,-single_module conftest.c 2>conftest.err + _lt_result=$? + # If there is a non-empty error log, and "single_module" + # appears in it, assume the flag caused a linker warning + if test -s conftest.err && $GREP single_module conftest.err; then + cat conftest.err >&AS_MESSAGE_LOG_FD + # Otherwise, if the output was created with a 0 exit code from + # the compiler, it worked. + elif test -f libconftest.dylib && test 0 = "$_lt_result"; then + lt_cv_apple_cc_single_mod=yes + else + cat conftest.err >&AS_MESSAGE_LOG_FD + fi + rm -rf libconftest.dylib* + rm -f conftest.* + fi]) + + # Feature test to disable chained fixups since it is not + # compatible with '-undefined dynamic_lookup' + AC_CACHE_CHECK([for -no_fixup_chains linker flag], + [lt_cv_support_no_fixup_chains], + [ save_LDFLAGS=$LDFLAGS + LDFLAGS="$LDFLAGS -Wl,-no_fixup_chains" + AC_LINK_IFELSE( + [AC_LANG_PROGRAM([],[])], + lt_cv_support_no_fixup_chains=yes, + lt_cv_support_no_fixup_chains=no + ) + LDFLAGS=$save_LDFLAGS + ] + ) + + AC_CACHE_CHECK([for -exported_symbols_list linker flag], + [lt_cv_ld_exported_symbols_list], + [lt_cv_ld_exported_symbols_list=no + save_LDFLAGS=$LDFLAGS + echo "_main" > conftest.sym + LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" + AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], + [lt_cv_ld_exported_symbols_list=yes], + [lt_cv_ld_exported_symbols_list=no]) + LDFLAGS=$save_LDFLAGS + ]) + + AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load], + [lt_cv_ld_force_load=no + cat > conftest.c << _LT_EOF +int forced_loaded() { return 2;} +_LT_EOF + echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD + echo "$AR $AR_FLAGS libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD + $AR $AR_FLAGS libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD + echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD + $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD + cat > conftest.c << _LT_EOF +int main(void) { return 0;} +_LT_EOF + echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD + $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err + _lt_result=$? + if test -s conftest.err && $GREP force_load conftest.err; then + cat conftest.err >&AS_MESSAGE_LOG_FD + elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then + lt_cv_ld_force_load=yes + else + cat conftest.err >&AS_MESSAGE_LOG_FD + fi + rm -f conftest.err libconftest.a conftest conftest.c + rm -rf conftest.dSYM + ]) + case $host_os in + rhapsody* | darwin1.[[012]]) + _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;; + darwin1.*) + _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;; + darwin*) + case $MACOSX_DEPLOYMENT_TARGET,$host in + 10.[[012]],*|,*powerpc*-darwin[[5-8]]*) + _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;; + *) + _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' + if test yes = "$lt_cv_support_no_fixup_chains"; then + AS_VAR_APPEND([_lt_dar_allow_undefined], [' $wl-no_fixup_chains']) + fi + ;; + esac + ;; + esac + if test yes = "$lt_cv_apple_cc_single_mod"; then + _lt_dar_single_mod='$single_module' + fi + _lt_dar_needs_single_mod=no + case $host_os in + rhapsody* | darwin1.*) + _lt_dar_needs_single_mod=yes ;; + darwin*) + # When targeting Mac OS X 10.4 (darwin 8) or later, + # -single_module is the default and -multi_module is unsupported. + # The toolchain on macOS 10.14 (darwin 18) and later cannot + # target any OS version that needs -single_module. + case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in + 10.0,*-darwin[[567]].*|10.[[0-3]],*-darwin[[5-9]].*|10.[[0-3]],*-darwin1[[0-7]].*) + _lt_dar_needs_single_mod=yes ;; + esac + ;; + esac + if test yes = "$lt_cv_ld_exported_symbols_list"; then + _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym' + else + _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib' + fi + if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then + _lt_dsymutil='~$DSYMUTIL $lib || :' + else + _lt_dsymutil= + fi + ;; + esac +]) + + +# _LT_DARWIN_LINKER_FEATURES([TAG]) +# --------------------------------- +# Checks for linker and compiler features on darwin +m4_defun([_LT_DARWIN_LINKER_FEATURES], +[ + m4_require([_LT_REQUIRED_DARWIN_CHECKS]) + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_automatic, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + if test yes = "$lt_cv_ld_force_load"; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`' + m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes], + [FC], [_LT_TAGVAR(compiler_needs_object, $1)=yes]) + else + _LT_TAGVAR(whole_archive_flag_spec, $1)='' + fi + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)=$_lt_dar_allow_undefined + case $cc_basename in + ifort*|nagfor*) _lt_dar_can_shared=yes ;; + *) _lt_dar_can_shared=$GCC ;; + esac + if test yes = "$_lt_dar_can_shared"; then + output_verbose_link_cmd=func_echo_all + _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil" + _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil" + _LT_TAGVAR(archive_expsym_cmds, $1)="$SED 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil" + _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 $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 + _LT_TAGVAR(ld_shlibs, $1)=no + fi +]) + +# _LT_SYS_MODULE_PATH_AIX([TAGNAME]) +# ---------------------------------- +# Links a minimal program and checks the executable +# for the system default hardcoded library path. In most cases, +# this is /usr/lib:/lib, but when the MPI compilers are used +# the location of the communication and MPI libs are included too. +# If we don't find anything, use the default library path according +# to the aix ld manual. +# Store the results from the different compilers for each TAGNAME. +# Allow to override them for all tags through lt_cv_aix_libpath. +m4_defun([_LT_SYS_MODULE_PATH_AIX], +[m4_require([_LT_DECL_SED])dnl +if test set = "${lt_cv_aix_libpath+set}"; then + aix_libpath=$lt_cv_aix_libpath +else + AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])], + [AC_LINK_IFELSE([AC_LANG_PROGRAM],[ + lt_aix_libpath_sed='[ + /Import File Strings/,/^$/ { + /^0/ { + s/^0 *\([^ ]*\) *$/\1/ + p + } + }]' + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + # Check for a 64-bit object if we didn't find anything. + if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"` + fi],[]) + if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then + _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=/usr/lib:/lib + fi + ]) + aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1]) +fi +])# _LT_SYS_MODULE_PATH_AIX + + +# _LT_SHELL_INIT(ARG) +# ------------------- +m4_define([_LT_SHELL_INIT], +[m4_divert_text([M4SH-INIT], [$1 +])])# _LT_SHELL_INIT + + + +# _LT_PROG_ECHO_BACKSLASH +# ----------------------- +# Find how we can fake an echo command that does not interpret backslash. +# In particular, with Autoconf 2.60 or later we add some code to the start +# of the generated configure script that will find a shell with a builtin +# printf (that we can use as an echo command). +m4_defun([_LT_PROG_ECHO_BACKSLASH], +[ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO +ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + +AC_MSG_CHECKING([how to print strings]) +# Test print first, because it will be a builtin if present. +if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \ + test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='print -r --' +elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then + ECHO='printf %s\n' +else + # Use this function as a fallback that always works. + func_fallback_echo () + { + eval 'cat <<_LTECHO_EOF +$[]1 +_LTECHO_EOF' + } + ECHO='func_fallback_echo' +fi + +# func_echo_all arg... +# Invoke $ECHO with all args, space-separated. +func_echo_all () +{ + $ECHO "$*" +} + +case $ECHO in + printf*) AC_MSG_RESULT([printf]) ;; + print*) AC_MSG_RESULT([print -r]) ;; + *) AC_MSG_RESULT([cat]) ;; +esac + +m4_ifdef([_AS_DETECT_SUGGESTED], +[_AS_DETECT_SUGGESTED([ + test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || ( + ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' + ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO + ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO + PATH=/empty FPATH=/empty; export PATH FPATH + test "X`printf %s $ECHO`" = "X$ECHO" \ + || test "X`print -r -- $ECHO`" = "X$ECHO" )])]) + +_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts]) +_LT_DECL([], [ECHO], [1], [An echo program that protects backslashes]) +])# _LT_PROG_ECHO_BACKSLASH + + +# _LT_WITH_SYSROOT +# ---------------- +AC_DEFUN([_LT_WITH_SYSROOT], +[m4_require([_LT_DECL_SED])dnl +AC_MSG_CHECKING([for sysroot]) +AC_ARG_WITH([sysroot], +[AS_HELP_STRING([--with-sysroot@<:@=DIR@:>@], + [Search for dependent libraries within DIR (or the compiler's sysroot + if not specified).])], +[], [with_sysroot=no]) + +dnl lt_sysroot will always be passed unquoted. We quote it here +dnl in case the user passed a directory name. +lt_sysroot= +case $with_sysroot in #( + yes) + if test yes = "$GCC"; then + # Trim trailing / since we'll always append absolute paths and we want + # to avoid //, if only for less confusing output for the user. + lt_sysroot=`$CC --print-sysroot 2>/dev/null | $SED 's:/\+$::'` + fi + ;; #( + /*) + lt_sysroot=`echo "$with_sysroot" | $SED -e "$sed_quote_subst"` + ;; #( + no|'') + ;; #( + *) + AC_MSG_RESULT([$with_sysroot]) + AC_MSG_ERROR([The sysroot must be an absolute path.]) + ;; +esac + + AC_MSG_RESULT([${lt_sysroot:-no}]) +_LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl +[dependent libraries, and where our libraries should be installed.])]) + +# _LT_ENABLE_LOCK +# --------------- +m4_defun([_LT_ENABLE_LOCK], +[AC_ARG_ENABLE([libtool-lock], + [AS_HELP_STRING([--disable-libtool-lock], + [avoid locking (might break parallel builds)])]) +test no = "$enable_libtool_lock" || enable_libtool_lock=yes + +# Some flags need to be propagated to the compiler or linker for good +# libtool support. +case $host in +ia64-*-hpux*) + # Find out what ABI is being produced by ac_compile, and set mode + # options accordingly. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `$FILECMD conftest.$ac_objext` in + *ELF-32*) + HPUX_IA64_MODE=32 + ;; + *ELF-64*) + HPUX_IA64_MODE=64 + ;; + esac + fi + rm -rf conftest* + ;; +*-*-irix6*) + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. + echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + if test yes = "$lt_cv_prog_gnu_ld"; then + case `$FILECMD conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -melf32bsmip" + ;; + *N32*) + LD="${LD-ld} -melf32bmipn32" + ;; + *64-bit*) + LD="${LD-ld} -melf64bmip" + ;; + esac + else + case `$FILECMD conftest.$ac_objext` in + *32-bit*) + LD="${LD-ld} -32" + ;; + *N32*) + LD="${LD-ld} -n32" + ;; + *64-bit*) + LD="${LD-ld} -64" + ;; + esac + fi + fi + rm -rf conftest* + ;; + +mips64*-*linux*) + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. + echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + emul=elf + case `$FILECMD conftest.$ac_objext` in + *32-bit*) + emul="${emul}32" + ;; + *64-bit*) + emul="${emul}64" + ;; + esac + case `$FILECMD conftest.$ac_objext` in + *MSB*) + emul="${emul}btsmip" + ;; + *LSB*) + emul="${emul}ltsmip" + ;; + esac + case `$FILECMD conftest.$ac_objext` in + *N32*) + emul="${emul}n32" + ;; + esac + LD="${LD-ld} -m $emul" + fi + rm -rf conftest* + ;; + +x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \ +s390*-*linux*|s390*-*tpf*|sparc*-*linux*|x86_64-gnu*) + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. Note that the listed cases only cover the + # situations where additional linker options are needed (such as when + # doing 32-bit compilation for a host where ld defaults to 64-bit, or + # vice versa); the common cases where no linker options are needed do + # not appear in the list. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `$FILECMD conftest.o` in + *32-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_i386_fbsd" + ;; + x86_64-*linux*|x86_64-gnu*) + case `$FILECMD conftest.o` in + *x86-64*) + LD="${LD-ld} -m elf32_x86_64" + ;; + *) + LD="${LD-ld} -m elf_i386" + ;; + esac + ;; + powerpc64le-*linux*) + LD="${LD-ld} -m elf32lppclinux" + ;; + powerpc64-*linux*) + LD="${LD-ld} -m elf32ppclinux" + ;; + s390x-*linux*) + LD="${LD-ld} -m elf_s390" + ;; + sparc64-*linux*) + LD="${LD-ld} -m elf32_sparc" + ;; + esac + ;; + *64-bit*) + case $host in + x86_64-*kfreebsd*-gnu) + LD="${LD-ld} -m elf_x86_64_fbsd" + ;; + x86_64-*linux*|x86_64-gnu*) + LD="${LD-ld} -m elf_x86_64" + ;; + powerpcle-*linux*) + LD="${LD-ld} -m elf64lppc" + ;; + powerpc-*linux*) + LD="${LD-ld} -m elf64ppc" + ;; + s390*-*linux*|s390*-*tpf*) + LD="${LD-ld} -m elf64_s390" + ;; + sparc*-*linux*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; + +*-*-sco3.2v5*) + # On SCO OpenServer 5, we need -belf to get full-featured binaries. + SAVE_CFLAGS=$CFLAGS + CFLAGS="$CFLAGS -belf" + AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf, + [AC_LANG_PUSH(C) + AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no]) + AC_LANG_POP]) + 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 + fi + ;; +*-*solaris*) + # Find out what ABI is being produced by ac_compile, and set linker + # options accordingly. + echo 'int i;' > conftest.$ac_ext + if AC_TRY_EVAL(ac_compile); then + case `$FILECMD conftest.o` in + *64-bit*) + case $lt_cv_prog_gnu_ld in + yes*) + case $host in + i?86-*-solaris*|x86_64-*-solaris*) + LD="${LD-ld} -m elf_x86_64" + ;; + sparc*-*-solaris*) + LD="${LD-ld} -m elf64_sparc" + ;; + esac + # GNU ld 2.21 introduced _sol2 emulations. Use them if available. + if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then + LD=${LD-ld}_sol2 + fi + ;; + *) + if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then + LD="${LD-ld} -64" + fi + ;; + esac + ;; + esac + fi + rm -rf conftest* + ;; +esac + +need_locks=$enable_libtool_lock +])# _LT_ENABLE_LOCK + + +# _LT_PROG_AR +# ----------- +m4_defun([_LT_PROG_AR], +[AC_CHECK_TOOLS(AR, [ar], false) +: ${AR=ar} +_LT_DECL([], [AR], [1], [The archiver]) + +# Use ARFLAGS variable as AR's operation code to sync the variable naming with +# Automake. If both AR_FLAGS and ARFLAGS are specified, AR_FLAGS should have +# higher priority because that's what people were doing historically (setting +# ARFLAGS for automake and AR_FLAGS for libtool). FIXME: Make the AR_FLAGS +# variable obsoleted/removed. + +test ${AR_FLAGS+y} || AR_FLAGS=${ARFLAGS-cr} +lt_ar_flags=$AR_FLAGS +_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. +_LT_DECL([], [AR_FLAGS], [\@S|@{ARFLAGS-"\@S|@lt_ar_flags"}], + [Flags to create an archive]) + +AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file], + [lt_cv_ar_at_file=no + AC_COMPILE_IFELSE([AC_LANG_PROGRAM], + [echo conftest.$ac_objext > conftest.lst + lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD' + AC_TRY_EVAL([lt_ar_try]) + if test 0 -eq "$ac_status"; then + # Ensure the archiver fails upon bogus file names. + rm -f conftest.$ac_objext libconftest.a + AC_TRY_EVAL([lt_ar_try]) + if test 0 -ne "$ac_status"; then + lt_cv_ar_at_file=@ + fi + fi + rm -f conftest.* libconftest.a + ]) + ]) + +if test no = "$lt_cv_ar_at_file"; then + archiver_list_spec= +else + archiver_list_spec=$lt_cv_ar_at_file +fi +_LT_DECL([], [archiver_list_spec], [1], + [How to feed a file listing to the archiver]) +])# _LT_PROG_AR + + +# _LT_CMD_OLD_ARCHIVE +# ------------------- +m4_defun([_LT_CMD_OLD_ARCHIVE], +[_LT_PROG_AR + +AC_CHECK_TOOL(STRIP, strip, :) +test -z "$STRIP" && STRIP=: +_LT_DECL([], [STRIP], [1], [A symbol stripping program]) + +AC_REQUIRE([AC_PROG_RANLIB]) +test -z "$RANLIB" && RANLIB=: +_LT_DECL([], [RANLIB], [1], + [Commands used to install an old-style archive]) + +# Determine commands to create old-style static archives. +old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs' +old_postinstall_cmds='chmod 644 $oldlib' +old_postuninstall_cmds= + +if test -n "$RANLIB"; then + old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib" + old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib" +fi + +case $host_os in + darwin*) + lock_old_archive_extraction=yes ;; + *) + lock_old_archive_extraction=no ;; +esac +_LT_DECL([], [old_postinstall_cmds], [2]) +_LT_DECL([], [old_postuninstall_cmds], [2]) +_LT_TAGDECL([], [old_archive_cmds], [2], + [Commands used to build an old-style archive]) +_LT_DECL([], [lock_old_archive_extraction], [0], + [Whether to use a lock for old archive extraction]) +])# _LT_CMD_OLD_ARCHIVE + + +# _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE]) +# ---------------------------------------------------------------- +# Check whether the given compiler option works +AC_DEFUN([_LT_COMPILER_OPTION], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_SED])dnl +AC_CACHE_CHECK([$1], [$2], + [$2=no + m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4]) + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + lt_compiler_flag="$3" ## exclude from sc_useless_quotes_in_assignment + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + # The option is referenced via a variable to avoid confusing sed. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>conftest.err) + ac_status=$? + cat conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + 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.expsym + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if test ! -s conftest.er2 || diff conftest.expsym conftest.er2 >/dev/null; then + $2=yes + fi + fi + $RM conftest* +]) + +if test yes = "[$]$2"; then + m4_if([$5], , :, [$5]) +else + m4_if([$6], , :, [$6]) +fi +])# _LT_COMPILER_OPTION + +# Old name: +AU_ALIAS([AC_LIBTOOL_COMPILER_OPTION], [_LT_COMPILER_OPTION]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION], []) + + +# _LT_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS, +# [ACTION-SUCCESS], [ACTION-FAILURE]) +# ---------------------------------------------------- +# Check whether the given linker option works +AC_DEFUN([_LT_LINKER_OPTION], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_SED])dnl +AC_CACHE_CHECK([$1], [$2], + [$2=no + save_LDFLAGS=$LDFLAGS + LDFLAGS="$LDFLAGS $3" + echo "$lt_simple_link_test_code" > conftest.$ac_ext + if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then + # The linker can only warn and ignore the option if not recognized + # So say no if there are warnings + 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.expsym + $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2 + if diff conftest.expsym conftest.er2 >/dev/null; then + $2=yes + fi + else + $2=yes + fi + fi + $RM -r conftest* + LDFLAGS=$save_LDFLAGS +]) + +if test yes = "[$]$2"; then + m4_if([$4], , :, [$4]) +else + m4_if([$5], , :, [$5]) +fi +])# _LT_LINKER_OPTION + +# Old name: +AU_ALIAS([AC_LIBTOOL_LINKER_OPTION], [_LT_LINKER_OPTION]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_LINKER_OPTION], []) + + +# LT_CMD_MAX_LEN +#--------------- +AC_DEFUN([LT_CMD_MAX_LEN], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +# find the maximum length of command line arguments +AC_MSG_CHECKING([the maximum length of command line arguments]) +AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl + i=0 + teststring=ABCD + + case $build_os in + msdosdjgpp*) + # On DJGPP, this test can blow up pretty badly due to problems in libc + # (any single argument exceeding 2000 bytes causes a buffer overrun + # during glob expansion). Even if it were fixed, the result of this + # check would be larger than it should be. + lt_cv_sys_max_cmd_len=12288; # 12K is about right + ;; + + gnu* | ironclad*) + # Under GNU Hurd and Ironclad, this test is not required because there + # is no limit to the length of command line arguments. + # Libtool will interpret -1 as no limit whatsoever + lt_cv_sys_max_cmd_len=-1; + ;; + + cygwin* | mingw* | windows* | cegcc*) + # On Win9x/ME, this test blows up -- it succeeds, but takes + # about 5 minutes as the teststring grows exponentially. + # Worse, since 9x/ME are not pre-emptively multitasking, + # you end up with a "frozen" computer, even though with patience + # the test eventually succeeds (with a max line length of 256k). + # Instead, let's just punt: use the minimum linelength reported by + # all of the supported platforms: 8192 (on NT/2K/XP). + lt_cv_sys_max_cmd_len=8192; + ;; + + mint*) + # On MiNT this can take a long time and run out of memory. + lt_cv_sys_max_cmd_len=8192; + ;; + + amigaos*) + # On AmigaOS with pdksh, this test takes hours, literally. + # So we just punt and use a minimum line length of 8192. + lt_cv_sys_max_cmd_len=8192; + ;; + + darwin* | dragonfly* | freebsd* | midnightbsd* | netbsd* | openbsd*) + # This has been around since 386BSD, at least. Likely further. + if test -x /sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax` + elif test -x /usr/sbin/sysctl; then + lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax` + else + lt_cv_sys_max_cmd_len=65536 # usable default for all BSDs + fi + # And add a safety zone + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + ;; + + interix*) + # We know the value 262144 and hardcode it with a safety zone (like BSD) + lt_cv_sys_max_cmd_len=196608 + ;; + + os2*) + # The test takes a long time on OS/2. + lt_cv_sys_max_cmd_len=8192 + ;; + + osf*) + # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure + # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not + # nice to cause kernel panics so lets avoid the loop below. + # First set a reasonable default. + lt_cv_sys_max_cmd_len=16384 + # + if test -x /sbin/sysconfig; then + case `/sbin/sysconfig -q proc exec_disable_arg_limit` in + *1*) lt_cv_sys_max_cmd_len=-1 ;; + esac + fi + ;; + sco3.2v5*) + lt_cv_sys_max_cmd_len=102400 + ;; + sysv5* | sco5v6* | sysv4.2uw2*) + kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null` + if test -n "$kargmax"; then + lt_cv_sys_max_cmd_len=`echo $kargmax | $SED 's/.*[[ ]]//'` + else + lt_cv_sys_max_cmd_len=32768 + fi + ;; + *) + lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null` + if test -n "$lt_cv_sys_max_cmd_len" && \ + test undefined != "$lt_cv_sys_max_cmd_len"; then + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4` + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3` + else + # Make teststring a little bigger before we do anything with it. + # a 1K string should be a reasonable start. + for i in 1 2 3 4 5 6 7 8; do + teststring=$teststring$teststring + done + SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}} + # If test is not a shell built-in, we'll probably end up computing a + # maximum length that is only half of the actual maximum length, but + # we can't tell. + while { test X`env echo "$teststring$teststring" 2>/dev/null` \ + = "X$teststring$teststring"; } >/dev/null 2>&1 && + test 17 != "$i" # 1/2 MB should be enough + do + i=`expr $i + 1` + teststring=$teststring$teststring + done + # Only check the string length outside the loop. + lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1` + teststring= + # Add a significant safety factor because C++ compilers can tack on + # massive amounts of additional arguments before passing them to the + # linker. It appears as though 1/2 is a usable value. + lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2` + fi + ;; + esac +]) +if test -n "$lt_cv_sys_max_cmd_len"; then + AC_MSG_RESULT($lt_cv_sys_max_cmd_len) +else + AC_MSG_RESULT(none) +fi +max_cmd_len=$lt_cv_sys_max_cmd_len +_LT_DECL([], [max_cmd_len], [0], + [What is the maximum length of a command?]) +])# LT_CMD_MAX_LEN + +# Old name: +AU_ALIAS([AC_LIBTOOL_SYS_MAX_CMD_LEN], [LT_CMD_MAX_LEN]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN], []) + + +# _LT_HEADER_DLFCN +# ---------------- +m4_defun([_LT_HEADER_DLFCN], +[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl +])# _LT_HEADER_DLFCN + + +# _LT_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE, +# ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING) +# ---------------------------------------------------------------- +m4_defun([_LT_TRY_DLOPEN_SELF], +[m4_require([_LT_HEADER_DLFCN])dnl +if test yes = "$cross_compiling"; then : + [$4] +else + lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 + lt_status=$lt_dlunknown + cat > conftest.$ac_ext <<_LT_EOF +[#line $LINENO "configure" +#include "confdefs.h" + +#if HAVE_DLFCN_H +#include +#endif + +#include + +#ifdef RTLD_GLOBAL +# define LT_DLGLOBAL RTLD_GLOBAL +#else +# ifdef DL_GLOBAL +# define LT_DLGLOBAL DL_GLOBAL +# else +# define LT_DLGLOBAL 0 +# endif +#endif + +/* We may have to define LT_DLLAZY_OR_NOW in the command line if we + find out it does not work in some platform. */ +#ifndef LT_DLLAZY_OR_NOW +# ifdef RTLD_LAZY +# define LT_DLLAZY_OR_NOW RTLD_LAZY +# else +# ifdef DL_LAZY +# define LT_DLLAZY_OR_NOW DL_LAZY +# else +# ifdef RTLD_NOW +# define LT_DLLAZY_OR_NOW RTLD_NOW +# else +# ifdef DL_NOW +# define LT_DLLAZY_OR_NOW DL_NOW +# else +# define LT_DLLAZY_OR_NOW 0 +# endif +# endif +# endif +# endif +#endif + +/* When -fvisibility=hidden is used, assume the code has been annotated + correspondingly for the symbols needed. */ +#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)) +int fnord (void) __attribute__((visibility("default"))); +#endif + +int fnord (void) { return 42; } +int main (void) +{ + void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW); + int status = $lt_dlunknown; + + if (self) + { + if (dlsym (self,"fnord")) status = $lt_dlno_uscore; + else + { + if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore; + else puts (dlerror ()); + } + /* dlclose (self); */ + } + else + puts (dlerror ()); + + return status; +}] +_LT_EOF + if AC_TRY_EVAL(ac_link) && test -s "conftest$ac_exeext" 2>/dev/null; then + (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null + lt_status=$? + case x$lt_status in + x$lt_dlno_uscore) $1 ;; + x$lt_dlneed_uscore) $2 ;; + x$lt_dlunknown|x*) $3 ;; + esac + else : + # compilation failed + $3 + fi +fi +rm -fr conftest* +])# _LT_TRY_DLOPEN_SELF + + +# LT_SYS_DLOPEN_SELF +# ------------------ +AC_DEFUN([LT_SYS_DLOPEN_SELF], +[m4_require([_LT_HEADER_DLFCN])dnl +if test yes != "$enable_dlopen"; then + enable_dlopen=unknown + enable_dlopen_self=unknown + enable_dlopen_self_static=unknown +else + lt_cv_dlopen=no + lt_cv_dlopen_libs= + + case $host_os in + beos*) + lt_cv_dlopen=load_add_on + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ;; + + mingw* | windows* | pw32* | cegcc*) + lt_cv_dlopen=LoadLibrary + lt_cv_dlopen_libs= + ;; + + cygwin*) + lt_cv_dlopen=dlopen + lt_cv_dlopen_libs= + ;; + + darwin*) + # if libdl is installed we need to link against it + AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl],[ + lt_cv_dlopen=dyld + lt_cv_dlopen_libs= + lt_cv_dlopen_self=yes + ]) + ;; + + tpf*) + # Don't try to run any link tests for TPF. We know it's impossible + # because TPF is a cross-compiler, and we know how we open DSOs. + lt_cv_dlopen=dlopen + lt_cv_dlopen_libs= + lt_cv_dlopen_self=no + ;; + + *) + AC_CHECK_FUNC([shl_load], + [lt_cv_dlopen=shl_load], + [AC_CHECK_LIB([dld], [shl_load], + [lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld], + [AC_CHECK_FUNC([dlopen], + [lt_cv_dlopen=dlopen], + [AC_CHECK_LIB([dl], [dlopen], + [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl], + [AC_CHECK_LIB([svld], [dlopen], + [lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld], + [AC_CHECK_LIB([dld], [dld_link], + [lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld]) + ]) + ]) + ]) + ]) + ]) + ;; + esac + + if test no = "$lt_cv_dlopen"; then + enable_dlopen=no + else + enable_dlopen=yes + fi + + case $lt_cv_dlopen in + dlopen) + save_CPPFLAGS=$CPPFLAGS + test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H" + + save_LDFLAGS=$LDFLAGS + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\" + + save_LIBS=$LIBS + LIBS="$lt_cv_dlopen_libs $LIBS" + + AC_CACHE_CHECK([whether a program can dlopen itself], + lt_cv_dlopen_self, [dnl + _LT_TRY_DLOPEN_SELF( + lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes, + lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross) + ]) + + if test yes = "$lt_cv_dlopen_self"; then + wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\" + AC_CACHE_CHECK([whether a statically linked program can dlopen itself], + lt_cv_dlopen_self_static, [dnl + _LT_TRY_DLOPEN_SELF( + lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes, + lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross) + ]) + fi + + CPPFLAGS=$save_CPPFLAGS + LDFLAGS=$save_LDFLAGS + LIBS=$save_LIBS + ;; + esac + + case $lt_cv_dlopen_self in + yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;; + *) enable_dlopen_self=unknown ;; + esac + + case $lt_cv_dlopen_self_static in + yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;; + *) enable_dlopen_self_static=unknown ;; + esac +fi +_LT_DECL([dlopen_support], [enable_dlopen], [0], + [Whether dlopen is supported]) +_LT_DECL([dlopen_self], [enable_dlopen_self], [0], + [Whether dlopen of programs is supported]) +_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0], + [Whether dlopen of statically linked programs is supported]) +])# LT_SYS_DLOPEN_SELF + +# Old name: +AU_ALIAS([AC_LIBTOOL_DLOPEN_SELF], [LT_SYS_DLOPEN_SELF]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF], []) + + +# _LT_COMPILER_C_O([TAGNAME]) +# --------------------------- +# Check to see if options -c and -o are simultaneously supported by compiler. +# This macro does not hard code the compiler like AC_PROG_CC_C_O. +m4_defun([_LT_COMPILER_C_O], +[m4_require([_LT_DECL_SED])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_TAG_COMPILER])dnl +AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext], + [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)], + [_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no + $RM -r conftest 2>/dev/null + mkdir conftest + cd conftest + mkdir out + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + lt_compiler_flag="-o out/conftest2.$ac_objext" + # Insert the option either (1) after the last *FLAGS variable, or + # (2) before a word containing "conftest.", or (3) at the end. + # Note that $ac_compile itself does not contain backslashes and begins + # with a dollar sign (not a hyphen), so the echo should work correctly. + lt_compile=`echo "$ac_compile" | $SED \ + -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \ + -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \ + -e 's:$: $lt_compiler_flag:'` + (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$lt_compile" 2>out/conftest.err) + ac_status=$? + cat out/conftest.err >&AS_MESSAGE_LOG_FD + echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD + if (exit $ac_status) && test -s out/conftest2.$ac_objext + 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.expsym + $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2 + 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 + chmod u+w . 2>&AS_MESSAGE_LOG_FD + $RM conftest* + # SGI C++ compiler will create directory out/ii_files/ for + # template instantiation + test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files + $RM out/* && rmdir out + cd .. + $RM -r conftest + $RM conftest* +]) +_LT_TAGDECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1], + [Does compiler simultaneously support -c and -o options?]) +])# _LT_COMPILER_C_O + + +# _LT_COMPILER_FILE_LOCKS([TAGNAME]) +# ---------------------------------- +# Check to see if we can do hard links to lock some files if needed +m4_defun([_LT_COMPILER_FILE_LOCKS], +[m4_require([_LT_ENABLE_LOCK])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +_LT_COMPILER_C_O([$1]) + +hard_links=nottested +if test no = "$_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)" && test no != "$need_locks"; then + # do not overwrite the value of need_locks provided by the user + AC_MSG_CHECKING([if we can lock with hard links]) + hard_links=yes + $RM conftest* + ln conftest.a conftest.b 2>/dev/null && hard_links=no + touch conftest.a + ln conftest.a conftest.b 2>&5 || hard_links=no + ln conftest.a conftest.b 2>/dev/null && hard_links=no + AC_MSG_RESULT([$hard_links]) + if test no = "$hard_links"; then + AC_MSG_WARN(['$CC' does not support '-c -o', so 'make -j' may be unsafe]) + need_locks=warn + fi +else + need_locks=no +fi +_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?]) +])# _LT_COMPILER_FILE_LOCKS + + +# _LT_CHECK_OBJDIR +# ---------------- +m4_defun([_LT_CHECK_OBJDIR], +[AC_CACHE_CHECK([for objdir], [lt_cv_objdir], +[rm -f .libs 2>/dev/null +mkdir .libs 2>/dev/null +if test -d .libs; then + lt_cv_objdir=.libs +else + # MS-DOS does not allow filenames that begin with a dot. + lt_cv_objdir=_libs +fi +rmdir .libs 2>/dev/null]) +objdir=$lt_cv_objdir +_LT_DECL([], [objdir], [0], + [The name of the directory that contains temporary libtool files])dnl +m4_pattern_allow([LT_OBJDIR])dnl +AC_DEFINE_UNQUOTED([LT_OBJDIR], "$lt_cv_objdir/", + [Define to the sub-directory where libtool stores uninstalled libraries.]) +])# _LT_CHECK_OBJDIR + + +# _LT_LINKER_HARDCODE_LIBPATH([TAGNAME]) +# -------------------------------------- +# Check hardcoding attributes. +m4_defun([_LT_LINKER_HARDCODE_LIBPATH], +[AC_MSG_CHECKING([how to hardcode library paths into programs]) +_LT_TAGVAR(hardcode_action, $1)= +if test -n "$_LT_TAGVAR(hardcode_libdir_flag_spec, $1)" || + test -n "$_LT_TAGVAR(runpath_var, $1)" || + test yes = "$_LT_TAGVAR(hardcode_automatic, $1)"; then + + # We can hardcode non-existent directories. + if test no != "$_LT_TAGVAR(hardcode_direct, $1)" && + # If the only mechanism to avoid hardcoding is shlibpath_var, we + # have to relink, otherwise we might link with an installed library + # when we should be linking with a yet-to-be-installed one + ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, $1)" && + test no != "$_LT_TAGVAR(hardcode_minus_L, $1)"; then + # Linking always hardcodes the temporary library directory. + _LT_TAGVAR(hardcode_action, $1)=relink + else + # We can link without hardcoding, and we can hardcode nonexisting dirs. + _LT_TAGVAR(hardcode_action, $1)=immediate + fi +else + # We cannot hardcode anything, or else we can only hardcode existing + # directories. + _LT_TAGVAR(hardcode_action, $1)=unsupported +fi +AC_MSG_RESULT([$_LT_TAGVAR(hardcode_action, $1)]) + +if test relink = "$_LT_TAGVAR(hardcode_action, $1)" || + test yes = "$_LT_TAGVAR(inherit_rpath, $1)"; then + # Fast installation is not supported + enable_fast_install=no +elif test yes = "$shlibpath_overrides_runpath" || + test no = "$enable_shared"; then + # Fast installation is not necessary + enable_fast_install=needless +fi +_LT_TAGDECL([], [hardcode_action], [0], + [How to hardcode a shared library path into an executable]) +])# _LT_LINKER_HARDCODE_LIBPATH + + +# _LT_CMD_STRIPLIB +# ---------------- +m4_defun([_LT_CMD_STRIPLIB], +[m4_require([_LT_DECL_EGREP]) +striplib= +old_striplib= +AC_MSG_CHECKING([whether stripping libraries is possible]) +if test -z "$STRIP"; then + AC_MSG_RESULT([no]) +else + if $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then + old_striplib="$STRIP --strip-debug" + striplib="$STRIP --strip-unneeded" + AC_MSG_RESULT([yes]) + 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" + AC_MSG_RESULT([yes]) + ;; + freebsd*) + if $STRIP -V 2>&1 | $GREP "elftoolchain" >/dev/null; then + old_striplib="$STRIP --strip-debug" + striplib="$STRIP --strip-unneeded" + AC_MSG_RESULT([yes]) + else + AC_MSG_RESULT([no]) + fi + ;; + *) + AC_MSG_RESULT([no]) + ;; + esac + fi +fi +_LT_DECL([], [old_striplib], [1], [Commands to strip libraries]) +_LT_DECL([], [striplib], [1]) +])# _LT_CMD_STRIPLIB + + +# _LT_PREPARE_MUNGE_PATH_LIST +# --------------------------- +# Make sure func_munge_path_list() is defined correctly. +m4_defun([_LT_PREPARE_MUNGE_PATH_LIST], +[[# func_munge_path_list VARIABLE PATH +# ----------------------------------- +# VARIABLE is name of variable containing _space_ separated list of +# directories to be munged by the contents of PATH, which is string +# having a format: +# "DIR[:DIR]:" +# string "DIR[ DIR]" will be prepended to VARIABLE +# ":DIR[:DIR]" +# string "DIR[ DIR]" will be appended to VARIABLE +# "DIRP[:DIRP]::[DIRA:]DIRA" +# string "DIRP[ DIRP]" will be prepended to VARIABLE and string +# "DIRA[ DIRA]" will be appended to VARIABLE +# "DIR[:DIR]" +# VARIABLE will be replaced by "DIR[ DIR]" +func_munge_path_list () +{ + case x@S|@2 in + x) + ;; + *:) + eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'` \@S|@@S|@1\" + ;; + x:*) + eval @S|@1=\"\@S|@@S|@1 `$ECHO @S|@2 | $SED 's/:/ /g'`\" + ;; + *::*) + eval @S|@1=\"\@S|@@S|@1\ `$ECHO @S|@2 | $SED -e 's/.*:://' -e 's/:/ /g'`\" + eval @S|@1=\"`$ECHO @S|@2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \@S|@@S|@1\" + ;; + *) + eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'`\" + ;; + esac +} +]])# _LT_PREPARE_PATH_LIST + + +# _LT_SYS_DYNAMIC_LINKER([TAG]) +# ----------------------------- +# PORTME Fill in your ld.so characteristics +m4_defun([_LT_SYS_DYNAMIC_LINKER], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_OBJDUMP])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_CHECK_SHELL_FEATURES])dnl +m4_require([_LT_PREPARE_MUNGE_PATH_LIST])dnl +AC_MSG_CHECKING([dynamic linker characteristics]) +m4_if([$1], + [], [ +if test yes = "$GCC"; then + case $host_os in + darwin*) lt_awk_arg='/^libraries:/,/LR/' ;; + *) lt_awk_arg='/^libraries:/' ;; + esac + case $host_os in + mingw* | windows* | cegcc*) lt_sed_strip_eq='s|=\([[A-Za-z]]:\)|\1|g' ;; + *) lt_sed_strip_eq='s|=/|/|g' ;; + esac + lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq` + case $lt_search_path_spec in + *\;*) + # if the path contains ";" then we assume it to be the separator + # otherwise default to the standard path separator (i.e. ":") - it is + # assumed that no part of a normal pathname contains ";" but that should + # okay in the real world where ";" in dirpaths is itself problematic. + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'` + ;; + *) + lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"` + ;; + esac + # Ok, now we have the path, separated by spaces, we can step through it + # and add multilib dir if necessary... + lt_tmp_lt_search_path_spec= + lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null` + # ...but if some path component already ends with the multilib dir we assume + # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer). + case "$lt_multi_os_dir; $lt_search_path_spec " in + "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*) + lt_multi_os_dir= + ;; + esac + for lt_sys_path in $lt_search_path_spec; do + if test -d "$lt_sys_path$lt_multi_os_dir"; then + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path$lt_multi_os_dir" + elif test -n "$lt_multi_os_dir"; then + test -d "$lt_sys_path" && \ + lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path" + fi + done + lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk ' +BEGIN {RS = " "; FS = "/|\n";} { + lt_foo = ""; + lt_count = 0; + for (lt_i = NF; lt_i > 0; lt_i--) { + if ($lt_i != "" && $lt_i != ".") { + if ($lt_i == "..") { + lt_count++; + } else { + if (lt_count == 0) { + lt_foo = "/" $lt_i lt_foo; + } else { + lt_count--; + } + } + } + } + if (lt_foo != "") { lt_freq[[lt_foo]]++; } + if (lt_freq[[lt_foo]] == 1) { print lt_foo; } +}'` + # AWK program above erroneously prepends '/' to C:/dos/paths + # for these hosts. + case $host_os in + mingw* | windows* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\ + $SED 's|/\([[A-Za-z]]:\)|\1|g'` ;; + esac + sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP` +else + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" +fi]) +library_names_spec= +libname_spec='lib$name' +soname_spec= +shrext_cmds=.so +postinstall_cmds= +postuninstall_cmds= +finish_cmds= +finish_eval= +shlibpath_var= +shlibpath_overrides_runpath=unknown +version_type=none +dynamic_linker="$host_os ld.so" +sys_lib_dlsearch_path_spec="/lib /usr/lib" +need_lib_prefix=unknown +hardcode_into_libs=no + +# when you set need_version to no, make sure it does not cause -set_version +# flags to be left without arguments +need_version=unknown + +AC_ARG_VAR([LT_SYS_LIBRARY_PATH], +[User-defined run-time library search path.]) + +case $host_os in +aix3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname$release$shared_ext$versuffix $libname.a' + shlibpath_var=LIBPATH + + # AIX 3 has no versioning support, so we append a major version to the name. + soname_spec='$libname$release$shared_ext$major' + ;; + +aix[[4-9]]*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + hardcode_into_libs=yes + if test ia64 = "$host_cpu"; then + # AIX 5 supports IA64 + library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext' + shlibpath_var=LD_LIBRARY_PATH + else + # With GCC up to 2.95.x, collect2 would create an import file + # for dependence libraries. The import file would start with + # the line '#! .'. This would cause the generated library to + # depend on '.', always an invalid library. This was fixed in + # development snapshots of GCC prior to 3.0. + case $host_os in + aix4 | aix4.[[01]] | aix4.[[01]].*) + if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)' + echo ' yes ' + echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then + : + else + can_build_shared=no + fi + ;; + esac + # Using Import Files as archive members, it is possible to support + # filename-based versioning of shared library archives on AIX. While + # this would work for both with and without runtime linking, it will + # prevent static linking of such archives. So we do filename-based + # shared library versioning with .so extension only, which is used + # when both runtime linking and shared linking is enabled. + # Unfortunately, runtime linking may impact performance, so we do + # not want this to be the default eventually. Also, we use the + # versioned .so libs for executables only if there is the -brtl + # linker flag in LDFLAGS as well, or --enable-aix-soname=svr4 only. + # To allow for filename-based versioning support, we need to create + # libNAME.so.V as an archive file, containing: + # *) an Import File, referring to the versioned filename of the + # archive as well as the shared archive member, telling the + # bitwidth (32 or 64) of that shared object, and providing the + # list of exported symbols of that shared object, eventually + # decorated with the 'weak' keyword + # *) the shared object with the F_LOADONLY flag set, to really avoid + # it being seen by the linker. + # At run time we better use the real file rather than another symlink, + # but for link time we create the symlink libNAME.so -> libNAME.so.V + + case $with_aix_soname,$aix_use_runtimelinking in + # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct + # soname into executable. Probably we can add versioning support to + # collect2, so additional links can be useful in future. + aix,yes) # traditional libtool + dynamic_linker='AIX unversionable lib.so' + # If using run time linking (on AIX 4.2 or later) use lib.so + # instead of lib.a to let people know that these are not + # typical AIX shared libraries. + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + ;; + aix,no) # traditional AIX only + dynamic_linker='AIX lib.a[(]lib.so.V[)]' + # We preserve .a as extension for shared libraries through AIX4.2 + # and later when we are not doing run time linking. + library_names_spec='$libname$release.a $libname.a' + soname_spec='$libname$release$shared_ext$major' + ;; + svr4,*) # full svr4 only + dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)]" + library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' + # We do not specify a path in Import Files, so LIBPATH fires. + shlibpath_overrides_runpath=yes + ;; + *,yes) # both, prefer svr4 + dynamic_linker="AIX lib.so.V[(]$shared_archive_member_spec.o[)], lib.a[(]lib.so.V[)]" + library_names_spec='$libname$release$shared_ext$major $libname$shared_ext' + # unpreferred sharedlib libNAME.a needs extra handling + postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"' + postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"' + # We do not specify a path in Import Files, so LIBPATH fires. + shlibpath_overrides_runpath=yes + ;; + *,no) # both, prefer aix + dynamic_linker="AIX lib.a[(]lib.so.V[)], lib.so.V[(]$shared_archive_member_spec.o[)]" + library_names_spec='$libname$release.a $libname.a' + soname_spec='$libname$release$shared_ext$major' + # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling + postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)' + postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"' + ;; + esac + shlibpath_var=LIBPATH + fi + ;; + +amigaos*) + case $host_cpu in + powerpc) + # Since July 2007 AmigaOS4 officially supports .so libraries. + # When compiling the executable, add -use-dynld -Lsobjs: to the compileline. + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + ;; + m68k) + library_names_spec='$libname.ixlibrary $libname.a' + # Create ${libname}_ixlibrary.a entries in /sys/libs. + finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done' + ;; + esac + ;; + +beos*) + library_names_spec='$libname$shared_ext' + dynamic_linker="$host_os ld.so" + shlibpath_var=LIBRARY_PATH + ;; + +bsdi[[45]]*) + version_type=linux # correct to gnu/linux during the next big refactor + 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' + finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib" + sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib" + # the default ld.so.conf also contains /usr/contrib/lib and + # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow + # libtool to hard-code these into programs + ;; + +cygwin* | mingw* | windows* | pw32* | cegcc*) + version_type=windows + shrext_cmds=.dll + need_version=no + need_lib_prefix=no + + case $GCC,$cc_basename in + yes,*) + # gcc + library_names_spec='$libname.dll.a' + # DLL is installed to $(libdir)/../bin by postinstall_cmds + # If user builds GCC with multilib enabled, + # it should just install on $(libdir) + # not on $(libdir)/../bin or 32 bits dlls would override 64 bit ones. + if test xyes = x"$multilib"; then + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + $install_prog $dir/$dlname $destdir/$dlname~ + chmod a+x $destdir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib $destdir/$dlname'\'' || exit \$?; + fi' + else + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + fi + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + + case $host_os in + cygwin*) + # Cygwin DLLs use 'cyg' prefix rather than 'lib' + soname_spec='`echo $libname | $SED -e 's/^lib/cyg/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext' +m4_if([$1], [],[ + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"]) + ;; + mingw* | windows* | cegcc*) + # MinGW DLLs use traditional 'lib' prefix + soname_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext' + ;; + pw32*) + # pw32 DLLs use 'pw' prefix rather than 'lib' + library_names_spec='`echo $libname | $SED -e 's/^lib/pw/'``echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext' + ;; + esac + dynamic_linker='Win32 ld.exe' + ;; + + *,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' + + case $build_os in + mingw* | windows*) + sys_lib_search_path_spec= + lt_save_ifs=$IFS + IFS=';' + for lt_path in $LIB + do + IFS=$lt_save_ifs + # Let DOS variable expansion print the short 8.3 style file name. + lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"` + sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path" + done + IFS=$lt_save_ifs + # Convert to MSYS style. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's|\\\\|/|g' -e 's| \\([[a-zA-Z]]\\):| /\\1|g' -e 's|^ ||'` + ;; + cygwin*) + # Convert to unix form, then to dos form, then back to unix form + # but this time dos style (no spaces!) so that the unix form looks + # like /cygdrive/c/PROGRA~1:/cygdr... + sys_lib_search_path_spec=`cygpath --path --unix "$LIB"` + sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null` + sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + ;; + *) + sys_lib_search_path_spec=$LIB + if $ECHO "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then + # It is most probably a Windows format PATH. + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'` + else + sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"` + fi + # FIXME: find the short name or the path components, as spaces are + # common. (e.g. "Program Files" -> "PROGRA~1") + ;; + esac + + # DLL is installed to $(libdir)/../bin by postinstall_cmds + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + shlibpath_overrides_runpath=yes + dynamic_linker='Win32 link.exe' + ;; + + *) + # Assume MSVC and ICC wrapper + library_names_spec='$libname`echo $release | $SED -e 's/[[.]]/-/g'`$versuffix$shared_ext $libname.lib' + dynamic_linker='Win32 ld.exe' + ;; + esac + # FIXME: first we should search . and the directory the executable is in + shlibpath_var=PATH + ;; + +darwin* | rhapsody*) + dynamic_linker="$host_os dyld" + version_type=darwin + need_lib_prefix=no + need_version=no + library_names_spec='$libname$release$major$shared_ext $libname$shared_ext' + soname_spec='$libname$release$major$shared_ext' + shlibpath_overrides_runpath=yes + shlibpath_var=DYLD_LIBRARY_PATH + shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`' +m4_if([$1], [],[ + sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"]) + sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib' + ;; + +dgux*) + 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' + shlibpath_var=LD_LIBRARY_PATH + ;; + +freebsd* | dragonfly* | midnightbsd*) + # DragonFly does not have aout. When/if they implement a new + # versioning mechanism, adjust this. + if test -x /usr/bin/objformat; then + objformat=`/usr/bin/objformat` + else + case $host_os in + freebsd[[23]].*) objformat=aout ;; + *) objformat=elf ;; + esac + fi + version_type=freebsd-$objformat + case $version_type in + freebsd-elf*) + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + need_version=no + need_lib_prefix=no + ;; + freebsd-*) + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' + need_version=yes + ;; + esac + case $host_cpu in + powerpc64) + # On FreeBSD bi-arch platforms, a different variable is used for 32-bit + # binaries. See . + AC_COMPILE_IFELSE( + [AC_LANG_SOURCE( + [[int test_pointer_size[sizeof (void *) - 5]; + ]])], + [shlibpath_var=LD_LIBRARY_PATH], + [shlibpath_var=LD_32_LIBRARY_PATH]) + ;; + *) + shlibpath_var=LD_LIBRARY_PATH + ;; + esac + case $host_os in + freebsd2.*) + shlibpath_overrides_runpath=yes + ;; + freebsd3.[[01]]* | freebsdelf3.[[01]]*) + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \ + freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1) + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + *) # from 4.6 on, and DragonFly + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + ;; + esac + ;; + +haiku*) + version_type=linux # correct to gnu/linux during the next big refactor + need_lib_prefix=no + need_version=no + dynamic_linker="$host_os runtime_loader" + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + shlibpath_var=LIBRARY_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/boot/system/non-packaged/develop/lib /boot/system/develop/lib' + sys_lib_dlsearch_path_spec='/boot/home/config/non-packaged/lib /boot/home/config/lib /boot/system/non-packaged/lib /boot/system/lib' + hardcode_into_libs=no + ;; + +hpux9* | hpux10* | hpux11*) + # Give a soname corresponding to the major version so that dld.sl refuses to + # link against other versions. + version_type=sunos + need_lib_prefix=no + need_version=no + case $host_cpu in + ia64*) + shrext_cmds='.so' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.so" + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + if test 32 = "$HPUX_IA64_MODE"; then + sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib" + sys_lib_dlsearch_path_spec=/usr/lib/hpux32 + else + sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64" + sys_lib_dlsearch_path_spec=/usr/lib/hpux64 + fi + ;; + hppa*64*) + shrext_cmds='.sl' + hardcode_into_libs=yes + dynamic_linker="$host_os dld.sl" + shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH + shlibpath_overrides_runpath=yes # Unless +noenvvar is specified. + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + *) + shrext_cmds='.sl' + dynamic_linker="$host_os dld.sl" + shlibpath_var=SHLIB_PATH + shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + ;; + esac + # HP-UX runs *really* slowly unless shared libraries are mode 555, ... + postinstall_cmds='chmod 555 $lib' + # or fails outright, so override atomically: + install_override_mode=555 + ;; + +interix[[3-9]]*) + 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='Interix 3.x ld.so.1 (PE, like ELF)' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +irix5* | irix6* | nonstopux*) + case $host_os in + nonstopux*) version_type=nonstopux ;; + *) + if test yes = "$lt_cv_prog_gnu_ld"; then + version_type=linux # correct to gnu/linux during the next big refactor + else + version_type=irix + fi ;; + esac + need_lib_prefix=no + need_version=no + soname_spec='$libname$release$shared_ext$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext' + case $host_os in + irix5* | nonstopux*) + libsuff= shlibsuff= + ;; + *) + case $LD in # libtool.m4 will add one of these switches to LD + *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") + libsuff= shlibsuff= libmagic=32-bit;; + *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") + libsuff=32 shlibsuff=N32 libmagic=N32;; + *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") + libsuff=64 shlibsuff=64 libmagic=64-bit;; + *) libsuff= shlibsuff= libmagic=never-match;; + esac + ;; + esac + shlibpath_var=LD_LIBRARY${shlibsuff}_PATH + shlibpath_overrides_runpath=no + sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff" + sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff" + 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 + ;; + +linux*android*) + version_type=none # Android doesn't support versioned libraries. + need_lib_prefix=no + need_version=no + library_names_spec='$libname$release$shared_ext $libname$shared_ext' + soname_spec='$libname$release$shared_ext' + finish_cmds= + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + dynamic_linker='Android linker' + # -rpath works at least for libraries that are not overridden by + # libraries installed in system locations. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + 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' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + + # Some binutils ld are patched to set DT_RUNPATH + AC_CACHE_VAL([lt_cv_shlibpath_overrides_runpath], + [lt_cv_shlibpath_overrides_runpath=no + save_LDFLAGS=$LDFLAGS + save_libdir=$libdir + eval "libdir=/foo; wl=\"$_LT_TAGVAR(lt_prog_compiler_wl, $1)\"; \ + LDFLAGS=\"\$LDFLAGS $_LT_TAGVAR(hardcode_libdir_flag_spec, $1)\"" + AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])], + [AS_IF([ ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null], + [lt_cv_shlibpath_overrides_runpath=yes])]) + LDFLAGS=$save_LDFLAGS + libdir=$save_libdir + ]) + shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath + + # This implies no fast_install, which is unacceptable. + # Some rework will be needed to allow for fast_install + # before this can be enabled. + hardcode_into_libs=yes + + # Ideally, we could use ldconfig to report *all* directories which are + # searched for libraries, however this is still not possible. Aside from not + # being certain /sbin/ldconfig is available, command + # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64, + # even though it is searched at run-time. Try to do the best guess by + # appending ld.so.conf contents (and includes) to the search path. + if test -f /etc/ld.so.conf; then + lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" + fi + + # We used to test for /lib/ld.so.1 and disable shared libraries on + # powerpc, because MkLinux only supported shared libraries with the + # GNU dynamic linker. Since this was broken with cross compilers, + # most powerpc-linux boxes support dynamic linking these days and + # people can always --disable-shared, the test was removed, and we + # assume the GNU/Linux dynamic linker is in use. + dynamic_linker='GNU/Linux ld.so' + ;; + +netbsdelf*-gnu) + version_type=linux + 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' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='NetBSD ld.elf_so' + enable_cxx_stdlib=yes + stdlibflag= + ;; + +netbsd*) + version_type=sunos + need_lib_prefix=no + need_version=no + if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + dynamic_linker='NetBSD (a.out) ld.so' + else + 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='NetBSD ld.elf_so' + fi + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + enable_cxx_stdlib=yes + stdlibflag= + ;; + +newsos6) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +*nto* | *qnx*) + version_type=qnx + 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' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + dynamic_linker='ldqnx.so' + ;; + +openbsd*) + version_type=sunos + sys_lib_dlsearch_path_spec=/usr/lib + need_lib_prefix=no + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then + need_version=no + else + need_version=yes + fi + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' + finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + ;; + +os2*) + libname_spec='$name' + version_type=windows + shrext_cmds=.dll + need_version=no + need_lib_prefix=no + # OS/2 can only load a DLL with a base name of 8 characters or less. + soname_spec='`test -n "$os2dllname" && libname="$os2dllname"; + v=$($ECHO $release$versuffix | tr -d .-); + n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _); + $ECHO $n$v`$shared_ext' + library_names_spec='${libname}_dll.$libext' + dynamic_linker='OS/2 ld.exe' + shlibpath_var=BEGINLIBPATH + sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + postinstall_cmds='base_file=`basename \$file`~ + dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~ + dldir=$destdir/`dirname \$dlpath`~ + test -d \$dldir || mkdir -p \$dldir~ + $install_prog $dir/$dlname \$dldir/$dlname~ + chmod a+x \$dldir/$dlname~ + if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then + eval '\''$striplib \$dldir/$dlname'\'' || exit \$?; + fi' + postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~ + dlpath=$dir/\$dldll~ + $RM \$dlpath' + ;; + +osf3* | osf4* | osf5*) + version_type=osf + need_lib_prefix=no + need_version=no + soname_spec='$libname$release$shared_ext$major' + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + shlibpath_var=LD_LIBRARY_PATH + sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib" + sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec + ;; + +rdos*) + dynamic_linker=no + ;; + +serenity*) + 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' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + dynamic_linker='SerenityOS LibELF' + ;; + +solaris*) + 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' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + # ldd complains unless libraries are executable + postinstall_cmds='chmod +x $lib' + ;; + +sunos4*) + version_type=sunos + library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix' + finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + if test yes = "$with_gnu_ld"; then + need_lib_prefix=no + fi + need_version=yes + ;; + +sysv4 | sysv4.3*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + shlibpath_var=LD_LIBRARY_PATH + case $host_vendor in + sni) + shlibpath_overrides_runpath=no + need_lib_prefix=no + runpath_var=LD_RUN_PATH + ;; + siemens) + need_lib_prefix=no + ;; + motorola) + need_lib_prefix=no + need_version=no + shlibpath_overrides_runpath=no + sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib' + ;; + esac + ;; + +sysv4*MP*) + if test -d /usr/nec; then + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext' + soname_spec='$libname$shared_ext.$major' + shlibpath_var=LD_LIBRARY_PATH + fi + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + version_type=sco + need_lib_prefix=no + need_version=no + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=yes + hardcode_into_libs=yes + if test yes = "$with_gnu_ld"; then + sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib' + else + sys_lib_search_path_spec='/usr/ccs/lib /usr/lib' + case $host_os in + sco3.2v5*) + sys_lib_search_path_spec="$sys_lib_search_path_spec /lib" + ;; + esac + fi + sys_lib_dlsearch_path_spec='/usr/lib' + ;; + +tpf*) + # TPF is a cross-target only. Preferred cross-host = GNU/Linux. + 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' + shlibpath_var=LD_LIBRARY_PATH + shlibpath_overrides_runpath=no + hardcode_into_libs=yes + ;; + +uts4*) + version_type=linux # correct to gnu/linux during the next big refactor + library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext' + soname_spec='$libname$release$shared_ext$major' + shlibpath_var=LD_LIBRARY_PATH + ;; + +emscripten*) + version_type=none + need_lib_prefix=no + need_version=no + library_names_spec='$libname$release$shared_ext' + soname_spec='$libname$release$shared_ext' + finish_cmds= + dynamic_linker="Emscripten linker" + _LT_COMPILER_PIC($1)='-fPIC' + _LT_TAGVAR(archive_cmds, $1)='$CC -sSIDE_MODULE=2 -shared $libobjs $deplibs $compiler_flags -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$SED "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -sSIDE_MODULE=2 -shared $libobjs $deplibs $compiler_flags -o $lib -s EXPORTED_FUNCTIONS=@$output_objdir/$soname.expsym' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(no_undefined_flag, $1)= + ;; + +*) + dynamic_linker=no + ;; +esac +AC_MSG_RESULT([$dynamic_linker]) +test no = "$dynamic_linker" && can_build_shared=no + +variables_saved_for_relink="PATH $shlibpath_var $runpath_var" +if test yes = "$GCC"; then + variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH" +fi + +if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then + sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec +fi + +if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then + sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec +fi + +# remember unaugmented sys_lib_dlsearch_path content for libtool script decls... +configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec + +# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code +func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH" + +# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool +configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH + +_LT_DECL([], [variables_saved_for_relink], [1], + [Variables whose values should be saved in libtool wrapper scripts and + restored at link time]) +_LT_DECL([], [need_lib_prefix], [0], + [Do we need the "lib" prefix for modules?]) +_LT_DECL([], [need_version], [0], [Do we need a version for libraries?]) +_LT_DECL([], [version_type], [0], [Library versioning type]) +_LT_DECL([], [runpath_var], [0], [Shared library runtime path variable]) +_LT_DECL([], [shlibpath_var], [0],[Shared library path variable]) +_LT_DECL([], [shlibpath_overrides_runpath], [0], + [Is shlibpath searched before the hard-coded library search path?]) +_LT_DECL([], [libname_spec], [1], [Format of library name prefix]) +_LT_DECL([], [library_names_spec], [1], + [[List of archive names. First name is the real one, the rest are links. + The last name is the one that the linker finds with -lNAME]]) +_LT_DECL([], [soname_spec], [1], + [[The coded name of the library, if different from the real name]]) +_LT_DECL([], [install_override_mode], [1], + [Permission mode override for installation of shared libraries]) +_LT_DECL([], [postinstall_cmds], [2], + [Command to use after installation of a shared archive]) +_LT_DECL([], [postuninstall_cmds], [2], + [Command to use after uninstallation of a shared archive]) +_LT_DECL([], [finish_cmds], [2], + [Commands used to finish a libtool library installation in a directory]) +_LT_DECL([], [finish_eval], [1], + [[As "finish_cmds", except a single script fragment to be evaled but + not shown]]) +_LT_DECL([], [hardcode_into_libs], [0], + [Whether we should hardcode library paths into libraries]) +_LT_DECL([], [sys_lib_search_path_spec], [2], + [Compile-time system search path for libraries]) +_LT_DECL([sys_lib_dlsearch_path_spec], [configure_time_dlsearch_path], [2], + [Detected run-time system search path for libraries]) +_LT_DECL([], [configure_time_lt_sys_library_path], [2], + [Explicit LT_SYS_LIBRARY_PATH set during ./configure time]) +])# _LT_SYS_DYNAMIC_LINKER + + +# _LT_PATH_TOOL_PREFIX(TOOL) +# -------------------------- +# find a file program that can recognize shared library +AC_DEFUN([_LT_PATH_TOOL_PREFIX], +[m4_require([_LT_DECL_EGREP])dnl +AC_MSG_CHECKING([for $1]) +AC_CACHE_VAL(lt_cv_path_MAGIC_CMD, +[case $MAGIC_CMD in +[[\\/*] | ?:[\\/]*]) + lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path. + ;; +*) + lt_save_MAGIC_CMD=$MAGIC_CMD + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR +dnl $ac_dummy forces splitting on constant user-supplied paths. +dnl POSIX.2 word splitting is done only on the output of word expansions, +dnl not every word. This closes a longstanding sh security hole. + ac_dummy="m4_if([$2], , $PATH, [$2])" + for ac_dir in $ac_dummy; do + IFS=$lt_save_ifs + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$1"; then + lt_cv_path_MAGIC_CMD=$ac_dir/"$1" + if test -n "$file_magic_test_file"; then + case $deplibs_check_method in + "file_magic "*) + file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"` + MAGIC_CMD=$lt_cv_path_MAGIC_CMD + if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null | + $EGREP "$file_magic_regex" > /dev/null; then + : + else + cat <<_LT_EOF 1>&2 + +*** Warning: the command libtool uses to detect shared libraries, +*** $file_magic_cmd, produces output that libtool cannot recognize. +*** The result is that libtool may fail to recognize shared libraries +*** as such. This will affect the creation of libtool libraries that +*** depend on shared libraries, but programs linked with such libtool +*** libraries will work regardless of this problem. Nevertheless, you +*** may want to report the problem to your system manager and/or to +*** bug-libtool@gnu.org + +_LT_EOF + fi ;; + esac + fi + break + fi + done + IFS=$lt_save_ifs + MAGIC_CMD=$lt_save_MAGIC_CMD + ;; +esac]) +MAGIC_CMD=$lt_cv_path_MAGIC_CMD +if test -n "$MAGIC_CMD"; then + AC_MSG_RESULT($MAGIC_CMD) +else + AC_MSG_RESULT(no) +fi +_LT_DECL([], [MAGIC_CMD], [0], + [Used to examine libraries when file_magic_cmd begins with "file"])dnl +])# _LT_PATH_TOOL_PREFIX + +# Old name: +AU_ALIAS([AC_PATH_TOOL_PREFIX], [_LT_PATH_TOOL_PREFIX]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_PATH_TOOL_PREFIX], []) + + +# _LT_PATH_MAGIC +# -------------- +# find a file program that can recognize a shared library +m4_defun([_LT_PATH_MAGIC], +[_LT_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH) +if test -z "$lt_cv_path_MAGIC_CMD"; then + if test -n "$ac_tool_prefix"; then + _LT_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH) + else + MAGIC_CMD=: + fi +fi +])# _LT_PATH_MAGIC + + +# LT_PATH_LD +# ---------- +# find the pathname to the GNU or non-GNU linker +AC_DEFUN([LT_PATH_LD], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_PROG_ECHO_BACKSLASH])dnl + +AC_ARG_WITH([gnu-ld], + [AS_HELP_STRING([--with-gnu-ld], + [assume the C compiler uses GNU ld @<:@default=no@:>@])], + [test no = "$withval" || with_gnu_ld=yes], + [with_gnu_ld=no])dnl + +ac_prog=ld +if test yes = "$GCC"; then + # Check if gcc -print-prog-name=ld gives a path. + AC_MSG_CHECKING([for ld used by $CC]) + case $host in + *-*-mingw* | *-*-windows*) + # gcc leaves a trailing carriage return, which upsets mingw + ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; + *) + ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; + esac + case $ac_prog in + # Accept absolute paths. + [[\\/]]* | ?:[[\\/]]*) + re_direlt='/[[^/]][[^/]]*/\.\./' + # Canonicalize the pathname of ld + ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'` + while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do + ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"` + done + test -z "$LD" && LD=$ac_prog + ;; + "") + # If it fails, then pretend we aren't using GCC. + ac_prog=ld + ;; + *) + # If it is relative, then search for the first ld in PATH. + with_gnu_ld=unknown + ;; + esac +elif test yes = "$with_gnu_ld"; then + AC_MSG_CHECKING([for GNU ld]) +else + AC_MSG_CHECKING([for non-GNU ld]) +fi +AC_CACHE_VAL(lt_cv_path_LD, +[if test -z "$LD"; then + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR + for ac_dir in $PATH; do + IFS=$lt_save_ifs + test -z "$ac_dir" && ac_dir=. + if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then + lt_cv_path_LD=$ac_dir/$ac_prog + # Check to see if the program is GNU ld. I'd rather use --version, + # but apparently some variants of GNU ld only accept -v. + # Break only if it was the GNU/non-GNU ld that we prefer. + case `"$lt_cv_path_LD" -v 2>&1 &1 conftest.i +cat conftest.i conftest.i >conftest2.i +: ${lt_DD:=$DD} +AC_PATH_PROGS_FEATURE_CHECK([lt_DD], [dd], +[if "$ac_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then + cmp -s conftest.i conftest.out \ + && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=: +fi]) +rm -f conftest.i conftest2.i conftest.out]) +])# _LT_PATH_DD + + +# _LT_CMD_TRUNCATE +# ---------------- +# find command to truncate a binary pipe +m4_defun([_LT_CMD_TRUNCATE], +[m4_require([_LT_PATH_DD]) +AC_CACHE_CHECK([how to truncate binary pipes], [lt_cv_truncate_bin], +[printf 0123456789abcdef0123456789abcdef >conftest.i +cat conftest.i conftest.i >conftest2.i +lt_cv_truncate_bin= +if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then + cmp -s conftest.i conftest.out \ + && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1" +fi +rm -f conftest.i conftest2.i conftest.out +test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"]) +_LT_DECL([lt_truncate_bin], [lt_cv_truncate_bin], [1], + [Command to truncate a binary pipe]) +])# _LT_CMD_TRUNCATE + + +# _LT_CHECK_MAGIC_METHOD +# ---------------------- +# how to check for library dependencies +# -- PORTME fill in with the dynamic library characteristics +m4_defun([_LT_CHECK_MAGIC_METHOD], +[m4_require([_LT_DECL_EGREP]) +m4_require([_LT_DECL_OBJDUMP]) +AC_CACHE_CHECK([how to recognize dependent libraries], +lt_cv_deplibs_check_method, +[lt_cv_file_magic_cmd='$MAGIC_CMD' +lt_cv_file_magic_test_file= +lt_cv_deplibs_check_method='unknown' +# Need to set the preceding variable on all platforms that support +# interlibrary dependencies. +# 'none' -- dependencies not supported. +# 'unknown' -- same as none, but documents that we really don't know. +# 'pass_all' -- all dependencies passed with no checks. +# 'file_magic [[regex]]' -- check by looking for files in library path +# that responds to the $file_magic_cmd with a given extended regex. +# If you have 'file' or equivalent on your system and you're not sure +# whether 'pass_all' will *always* work, you probably want this one. + +case $host_os in +aix[[4-9]]*) + lt_cv_deplibs_check_method=pass_all + ;; + +beos*) + lt_cv_deplibs_check_method=pass_all + ;; + +bsdi[[45]]*) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)' + lt_cv_file_magic_cmd='$FILECMD -L' + lt_cv_file_magic_test_file=/shlib/libc.so + ;; + +cygwin*) + # func_win32_libid is a shell function defined in ltmain.sh + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + ;; + +mingw* | windows* | pw32*) + # Base MSYS/MinGW do not provide the 'file' command needed by + # func_win32_libid shell function, so use a weaker test based on 'objdump', + # unless we find 'file', for example because we are cross-compiling. + if ( file / ) >/dev/null 2>&1; then + lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL' + lt_cv_file_magic_cmd='func_win32_libid' + else + # Keep this pattern in sync with the one in func_win32_libid. + lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64|pe-aarch64)' + lt_cv_file_magic_cmd='$OBJDUMP -f' + fi + ;; + +cegcc*) + # use the weaker test based on 'objdump'. See mingw*. + lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?' + lt_cv_file_magic_cmd='$OBJDUMP -f' + ;; + +darwin* | rhapsody*) + lt_cv_deplibs_check_method=pass_all + ;; + +freebsd* | dragonfly* | midnightbsd*) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + case $host_cpu in + i*86 ) + # Not sure whether the presence of OpenBSD here was a mistake. + # Let's accept both of them until this is cleared up. + lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library' + lt_cv_file_magic_cmd=$FILECMD + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*` + ;; + esac + else + lt_cv_deplibs_check_method=pass_all + fi + ;; + +haiku*) + lt_cv_deplibs_check_method=pass_all + ;; + +hpux10.20* | hpux11*) + lt_cv_file_magic_cmd=$FILECMD + case $host_cpu in + ia64*) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64' + lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so + ;; + hppa*64*) + [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF[ -][0-9][0-9])(-bit)?( [LM]SB)? shared object( file)?[, -]* PA-RISC [0-9]\.[0-9]'] + lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl + ;; + *) + lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]]\.[[0-9]]) shared library' + lt_cv_file_magic_test_file=/usr/lib/libc.sl + ;; + esac + ;; + +interix[[3-9]]*) + # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$' + ;; + +irix5* | irix6* | nonstopux*) + case $LD in + *-32|*"-32 ") libmagic=32-bit;; + *-n32|*"-n32 ") libmagic=N32;; + *-64|*"-64 ") libmagic=64-bit;; + *) libmagic=never-match;; + esac + lt_cv_deplibs_check_method=pass_all + ;; + +*-mlibc) + lt_cv_deplibs_check_method=pass_all + ;; + +# This must be glibc/ELF. +linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + lt_cv_deplibs_check_method=pass_all + ;; + +netbsd* | netbsdelf*-gnu) + if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$' + fi + ;; + +newos6*) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)' + lt_cv_file_magic_cmd=$FILECMD + lt_cv_file_magic_test_file=/usr/lib/libnls.so + ;; + +*nto* | *qnx*) + lt_cv_deplibs_check_method=pass_all + ;; + +openbsd*) + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$' + else + lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$' + fi + ;; + +osf3* | osf4* | osf5*) + lt_cv_deplibs_check_method=pass_all + ;; + +rdos*) + lt_cv_deplibs_check_method=pass_all + ;; + +serenity*) + lt_cv_deplibs_check_method=pass_all + ;; + +solaris*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) + lt_cv_deplibs_check_method=pass_all + ;; + +sysv4 | sysv4.3*) + case $host_vendor in + motorola) + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]' + lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*` + ;; + ncr) + lt_cv_deplibs_check_method=pass_all + ;; + sequent) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' + ;; + sni) + lt_cv_file_magic_cmd='/bin/file' + lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib" + lt_cv_file_magic_test_file=/lib/libc.so + ;; + siemens) + lt_cv_deplibs_check_method=pass_all + ;; + pc) + lt_cv_deplibs_check_method=pass_all + ;; + esac + ;; + +tpf*) + lt_cv_deplibs_check_method=pass_all + ;; +os2*) + lt_cv_deplibs_check_method=pass_all + ;; +esac +]) + +file_magic_glob= +want_nocaseglob=no +if test "$build" = "$host"; then + case $host_os in + mingw* | windows* | pw32*) + if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then + want_nocaseglob=yes + else + file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/\(..\)/s\/[[\1]]\/[[\1]]\/g;/g"` + fi + ;; + esac +fi + +file_magic_cmd=$lt_cv_file_magic_cmd +deplibs_check_method=$lt_cv_deplibs_check_method +test -z "$deplibs_check_method" && deplibs_check_method=unknown + +_LT_DECL([], [deplibs_check_method], [1], + [Method to check whether dependent libraries are shared objects]) +_LT_DECL([], [file_magic_cmd], [1], + [Command to use when deplibs_check_method = "file_magic"]) +_LT_DECL([], [file_magic_glob], [1], + [How to find potential files when deplibs_check_method = "file_magic"]) +_LT_DECL([], [want_nocaseglob], [1], + [Find potential files using nocaseglob when deplibs_check_method = "file_magic"]) +])# _LT_CHECK_MAGIC_METHOD + + +# LT_PATH_NM +# ---------- +# find the pathname to a BSD- or MS-compatible name lister +AC_DEFUN([LT_PATH_NM], +[AC_REQUIRE([AC_PROG_CC])dnl +AC_CACHE_CHECK([for BSD- or MS-compatible name lister (nm)], lt_cv_path_NM, +[if test -n "$NM"; then + # Let the user override the test. + lt_cv_path_NM=$NM +else + lt_nm_to_check=${ac_tool_prefix}nm + if test -n "$ac_tool_prefix" && test "$build" = "$host"; then + lt_nm_to_check="$lt_nm_to_check nm" + fi + for lt_tmp_nm in $lt_nm_to_check; do + lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR + for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do + IFS=$lt_save_ifs + test -z "$ac_dir" && ac_dir=. + tmp_nm=$ac_dir/$lt_tmp_nm + if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then + # Check to see if the nm accepts a BSD-compat flag. + # Adding the 'sed 1q' prevents false positives on HP-UX, which says: + # nm: unknown option "B" ignored + # Tru64's nm complains that /dev/null is an invalid object file + # MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty + case $build_os in + mingw* | windows*) lt_bad_file=conftest.nm/nofile ;; + *) lt_bad_file=/dev/null ;; + esac + case `"$tmp_nm" -B $lt_bad_file 2>&1 | $SED '1q'` in + *$lt_bad_file* | *'Invalid file or object type'*) + lt_cv_path_NM="$tmp_nm -B" + break 2 + ;; + *) + case `"$tmp_nm" -p /dev/null 2>&1 | $SED '1q'` in + */dev/null*) + lt_cv_path_NM="$tmp_nm -p" + break 2 + ;; + *) + lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but + continue # so that we can try to find one that supports BSD flags + ;; + esac + ;; + esac + fi + done + IFS=$lt_save_ifs + done + : ${lt_cv_path_NM=no} +fi]) +if test no != "$lt_cv_path_NM"; then + NM=$lt_cv_path_NM +else + # Didn't find any BSD compatible name lister, look for dumpbin. + if test -n "$DUMPBIN"; then : + # Let the user override the test. + else + AC_CHECK_TOOLS(DUMPBIN, [dumpbin "link -dump"], :) + case `$DUMPBIN -symbols -headers /dev/null 2>&1 | $SED '1q'` in + *COFF*) + DUMPBIN="$DUMPBIN -symbols -headers" + ;; + *) + DUMPBIN=: + ;; + esac + fi + AC_SUBST([DUMPBIN]) + if test : != "$DUMPBIN"; then + NM=$DUMPBIN + fi +fi +test -z "$NM" && NM=nm +AC_SUBST([NM]) +_LT_DECL([], [NM], [1], [A BSD- or MS-compatible name lister])dnl + +AC_CACHE_CHECK([the name lister ($NM) interface], [lt_cv_nm_interface], + [lt_cv_nm_interface="BSD nm" + echo "int some_variable = 0;" > conftest.$ac_ext + (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&AS_MESSAGE_LOG_FD) + (eval "$ac_compile" 2>conftest.err) + cat conftest.err >&AS_MESSAGE_LOG_FD + (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&AS_MESSAGE_LOG_FD) + (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out) + cat conftest.err >&AS_MESSAGE_LOG_FD + (eval echo "\"\$as_me:$LINENO: output\"" >&AS_MESSAGE_LOG_FD) + cat conftest.out >&AS_MESSAGE_LOG_FD + if $GREP 'External.*some_variable' conftest.out > /dev/null; then + lt_cv_nm_interface="MS dumpbin" + fi + rm -f conftest*]) +])# LT_PATH_NM + +# Old names: +AU_ALIAS([AM_PROG_NM], [LT_PATH_NM]) +AU_ALIAS([AC_PROG_NM], [LT_PATH_NM]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_PROG_NM], []) +dnl AC_DEFUN([AC_PROG_NM], []) + +# _LT_CHECK_SHAREDLIB_FROM_LINKLIB +# -------------------------------- +# how to determine the name of the shared library +# associated with a specific link library. +# -- PORTME fill in with the dynamic library characteristics +m4_defun([_LT_CHECK_SHAREDLIB_FROM_LINKLIB], +[m4_require([_LT_DECL_EGREP]) +m4_require([_LT_DECL_OBJDUMP]) +m4_require([_LT_DECL_DLLTOOL]) +AC_CACHE_CHECK([how to associate runtime and link libraries], +lt_cv_sharedlib_from_linklib_cmd, +[lt_cv_sharedlib_from_linklib_cmd='unknown' + +case $host_os in +cygwin* | mingw* | windows* | pw32* | cegcc*) + # two different shell functions defined in ltmain.sh; + # decide which one to use based on capabilities of $DLLTOOL + case `$DLLTOOL --help 2>&1` in + *--identify-strict*) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib + ;; + *) + lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback + ;; + esac + ;; +*) + # fallback: assume linklib IS sharedlib + lt_cv_sharedlib_from_linklib_cmd=$ECHO + ;; +esac +]) +sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd +test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO + +_LT_DECL([], [sharedlib_from_linklib_cmd], [1], + [Command to associate shared and link libraries]) +])# _LT_CHECK_SHAREDLIB_FROM_LINKLIB + + +# _LT_PATH_MANIFEST_TOOL +# ---------------------- +# locate the manifest tool +m4_defun([_LT_PATH_MANIFEST_TOOL], +[AC_CHECK_TOOL(MANIFEST_TOOL, mt, :) +test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt +AC_CACHE_CHECK([if $MANIFEST_TOOL is a manifest tool], [lt_cv_path_manifest_tool], + [lt_cv_path_manifest_tool=no + echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&AS_MESSAGE_LOG_FD + $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out + cat conftest.err >&AS_MESSAGE_LOG_FD + if $GREP 'Manifest Tool' conftest.out > /dev/null; then + lt_cv_path_manifest_tool=yes + fi + rm -f conftest*]) +if test yes != "$lt_cv_path_manifest_tool"; then + MANIFEST_TOOL=: +fi +_LT_DECL([], [MANIFEST_TOOL], [1], [Manifest tool])dnl +])# _LT_PATH_MANIFEST_TOOL + + +# _LT_DLL_DEF_P([FILE]) +# --------------------- +# True iff FILE is a Windows DLL '.def' file. +# Keep in sync with func_dll_def_p in the libtool script +AC_DEFUN([_LT_DLL_DEF_P], +[dnl + test DEF = "`$SED -n dnl + -e '\''s/^[[ ]]*//'\'' dnl Strip leading whitespace + -e '\''/^\(;.*\)*$/d'\'' dnl Delete empty lines and comments + -e '\''s/^\(EXPORTS\|LIBRARY\)\([[ ]].*\)*$/DEF/p'\'' dnl + -e q dnl Only consider the first "real" line + $1`" dnl +])# _LT_DLL_DEF_P + + +# LT_LIB_M +# -------- +# check for math library +AC_DEFUN([LT_LIB_M], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +LIBM= +case $host in +*-*-beos* | *-*-cegcc* | *-*-cygwin* | *-*-haiku* | *-*-mingw* | *-*-pw32* | *-*-darwin*) + # These system don't have libm, or don't need it + ;; +*-ncr-sysv4.3*) + AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM=-lmw) + AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm") + ;; +*) + AC_CHECK_LIB(m, cos, LIBM=-lm) + ;; +esac +AC_SUBST([LIBM]) +])# LT_LIB_M + +# Old name: +AU_ALIAS([AC_CHECK_LIBM], [LT_LIB_M]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_CHECK_LIBM], []) + + +# _LT_COMPILER_NO_RTTI([TAGNAME]) +# ------------------------------- +m4_defun([_LT_COMPILER_NO_RTTI], +[m4_require([_LT_TAG_COMPILER])dnl + +_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= + +if test yes = "$GCC"; then + case $cc_basename in + nvcc*) + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -Xcompiler -fno-builtin' ;; + *) + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' ;; + esac + + _LT_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions], + lt_cv_prog_compiler_rtti_exceptions, + [-fno-rtti -fno-exceptions], [], + [_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"]) +fi +_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1], + [Compiler flag to turn off builtin functions]) +])# _LT_COMPILER_NO_RTTI + + +# _LT_CMD_GLOBAL_SYMBOLS +# ---------------------- +m4_defun([_LT_CMD_GLOBAL_SYMBOLS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_PROG_CC])dnl +AC_REQUIRE([AC_PROG_AWK])dnl +AC_REQUIRE([LT_PATH_NM])dnl +AC_REQUIRE([LT_PATH_LD])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_TAG_COMPILER])dnl + +# Check for command to grab the raw symbol name followed by C symbol from nm. +AC_MSG_CHECKING([command to parse $NM output from $compiler object]) +AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe], +[ +# These are sane defaults that work on at least a few old systems. +# [They come from Ultrix. What could be older than Ultrix?!! ;)] + +# Character class describing NM global symbol codes. +symcode='[[BCDEGRST]]' + +# Regexp to match symbols that can be accessed directly from C. +sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)' + +# Define system-specific variables. +case $host_os in +aix*) + symcode='[[BCDT]]' + ;; +cygwin* | mingw* | windows* | pw32* | cegcc*) + symcode='[[ABCDGISTW]]' + ;; +hpux*) + if test ia64 = "$host_cpu"; then + symcode='[[ABCDEGRST]]' + fi + ;; +irix* | nonstopux*) + symcode='[[BCDEGRST]]' + ;; +osf*) + symcode='[[BCDEGQRST]]' + ;; +solaris*) + symcode='[[BCDRT]]' + ;; +sco3.2v5*) + symcode='[[DT]]' + ;; +sysv4.2uw2*) + symcode='[[DT]]' + ;; +sysv5* | sco5v6* | unixware* | OpenUNIX*) + symcode='[[ABDT]]' + ;; +sysv4) + symcode='[[DFNSTU]]' + ;; +esac + +# If we're using GNU nm, then use its standard symbol codes. +case `$NM -V 2>&1` in +*GNU* | *'with BFD'*) + symcode='[[ABCDGIRSTW]]' ;; +esac + +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 .* \([[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 .* \([[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[[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= + lt_cdecl_hook= + lt_c_name_hook= + lt_c_name_lib_hook= +fi + +# Transform an extracted symbol line into a proper C declaration. +# Some systems (esp. on ia64) link data and code symbols differently, +# so use this general approach. +lt_cv_sys_global_symbol_to_cdecl="$SED -n"\ +$lt_cdecl_hook\ +" -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* .* \([[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[[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= +case $build_os in +mingw* | windows*) + opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp + ;; +esac + +# Try without a prefix underscore, then with it. +for ac_symprfx in "" "_"; do + + # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol. + symxfrm="\\1 $ac_symprfx\\2 \\2" + + # Write the raw and C identifiers. + if test "$lt_cv_nm_interface" = "MS dumpbin"; then + # 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 ?. 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};"\ +" /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn[2],2)};"\ +" /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\ +" /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\ +" \$ 0!~/External *\|/{next};"\ +" / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\ +" {if(hide[section]) next};"\ +" {f=\"D\"}; \$ 0~/\(\).*\|/{f=\"T\"};"\ +" {split(\$ 0,a,/\||\r/); split(a[2],s)};"\ +" s[1]~/^[@?]/{print f,s[1],s[1]; next};"\ +" s[1]~prfx {split(s[1],t,\"@\"); print f,t[1],substr(t[1],length(prfx))}"\ +" ' prfx=^$ac_symprfx]" + else + lt_cv_sys_global_symbol_pipe="$SED -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'" + fi + lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | $SED '/ __gnu_lto/d'" + + # Check to see that the pipe works correctly. + pipe_works=no + + rm -f conftest* + cat > conftest.$ac_ext <<_LT_EOF +#ifdef __cplusplus +extern "C" { +#endif +char nm_test_var; +void nm_test_func(void); +void nm_test_func(void){} +#ifdef __cplusplus +} +#endif +int main(void){nm_test_var='a';nm_test_func();return(0);} +_LT_EOF + + if AC_TRY_EVAL(ac_compile); then + # Now try to grab the symbols. + nlist=conftest.nm + $ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&AS_MESSAGE_LOG_FD + if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&AS_MESSAGE_LOG_FD && test -s "$nlist"; then + # Try sorting and uniquifying the output. + if sort "$nlist" | uniq > "$nlist"T; then + mv -f "$nlist"T "$nlist" + else + rm -f "$nlist"T + fi + + # Make sure that we snagged all the symbols we need. + if $GREP ' nm_test_var$' "$nlist" >/dev/null; then + if $GREP ' nm_test_func$' "$nlist" >/dev/null; then + cat <<_LT_EOF > conftest.$ac_ext +/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ +#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE +/* DATA imports from DLLs on WIN32 can't be const, because runtime + relocations are performed -- see ld's documentation on pseudo-relocs. */ +# define LT@&t@_DLSYM_CONST +#elif defined __osf__ +/* This system does not cope well with relocations in const data. */ +# define LT@&t@_DLSYM_CONST +#else +# define LT@&t@_DLSYM_CONST const +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +_LT_EOF + # Now generate the symbol file. + eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext' + + cat <<_LT_EOF >> conftest.$ac_ext + +/* The mapping between symbol names and symbols. */ +LT@&t@_DLSYM_CONST struct { + const char *name; + void *address; +} +lt__PROGRAM__LTX_preloaded_symbols[[]] = +{ + { "@PROGRAM@", (void *) 0 }, +_LT_EOF + $SED "s/^$symcode$symcode* .* \(.*\)$/ {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext + cat <<\_LT_EOF >> conftest.$ac_ext + {0, (void *) 0} +}; + +/* This works around a problem in FreeBSD linker */ +#ifdef FREEBSD_WORKAROUND +static const void *lt_preloaded_setup() { + return lt__PROGRAM__LTX_preloaded_symbols; +} +#endif + +#ifdef __cplusplus +} +#endif +_LT_EOF + # Now try linking the two files. + mv conftest.$ac_objext conftstm.$ac_objext + lt_globsym_save_LIBS=$LIBS + lt_globsym_save_CFLAGS=$CFLAGS + LIBS=conftstm.$ac_objext + CFLAGS="$CFLAGS$_LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)" + if AC_TRY_EVAL(ac_link) && test -s conftest$ac_exeext; then + pipe_works=yes + fi + LIBS=$lt_globsym_save_LIBS + CFLAGS=$lt_globsym_save_CFLAGS + else + echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD + fi + else + echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD + fi + else + echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD + cat conftest.$ac_ext >&5 + fi + rm -rf conftest* conftst* + + # Do not use the global_symbol_pipe unless it works. + if test yes = "$pipe_works"; then + break + else + lt_cv_sys_global_symbol_pipe= + fi +done +]) +if test -z "$lt_cv_sys_global_symbol_pipe"; then + 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 + AC_MSG_RESULT(failed) +else + AC_MSG_RESULT(ok) +fi + +# Response file support. +if test "$lt_cv_nm_interface" = "MS dumpbin"; then + nm_file_list_spec='@' +elif $NM --help 2>/dev/null | grep '[[@]]FILE' >/dev/null; then + nm_file_list_spec='@' +fi + +_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1], + [Take the output of nm and produce a listing of raw symbols and C names]) +_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1], + [Transform the output of nm in a proper C declaration]) +_LT_DECL([global_symbol_to_import], [lt_cv_sys_global_symbol_to_import], [1], + [Transform the output of nm into a list of symbols to manually relocate]) +_LT_DECL([global_symbol_to_c_name_address], + [lt_cv_sys_global_symbol_to_c_name_address], [1], + [Transform the output of nm in a C name address pair]) +_LT_DECL([global_symbol_to_c_name_address_lib_prefix], + [lt_cv_sys_global_symbol_to_c_name_address_lib_prefix], [1], + [Transform the output of nm in a C name address pair when lib prefix is needed]) +_LT_DECL([nm_interface], [lt_cv_nm_interface], [1], + [The name lister interface]) +_LT_DECL([], [nm_file_list_spec], [1], + [Specify filename containing input files for $NM]) +]) # _LT_CMD_GLOBAL_SYMBOLS + + +# _LT_COMPILER_PIC([TAGNAME]) +# --------------------------- +m4_defun([_LT_COMPILER_PIC], +[m4_require([_LT_TAG_COMPILER])dnl +_LT_TAGVAR(lt_prog_compiler_wl, $1)= +_LT_TAGVAR(lt_prog_compiler_pic, $1)= +_LT_TAGVAR(lt_prog_compiler_static, $1)= + +m4_if([$1], [CXX], [ + # C++ specific cases for pic, static, wl, etc. + if test yes = "$GXX"; then + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test ia64 = "$host_cpu"; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the '-m68020' flag to GCC prevents building anything better, + # like '-m68040'. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + mingw* | windows* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + case $host_os in + os2*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' + ;; + esac + ;; + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + *djgpp*) + # DJGPP does not support shared libraries at all + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + _LT_TAGVAR(lt_prog_compiler_static, $1)= + ;; + interix[[3-9]]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + else + case $host_os in + aix[[4-9]]*) + # All AIX code is PIC. + if test ia64 = "$host_cpu"; then + # 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.expsym' + fi + ;; + chorus*) + case $cc_basename in + cxch68*) + # Green Hills C++ Compiler + # _LT_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a" + ;; + esac + ;; + mingw* | windows* | cygwin* | os2* | pw32* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + ;; + dgux*) + case $cc_basename in + ec++*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + ghcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + freebsd* | dragonfly* | midnightbsd*) + # FreeBSD uses GNU C++ + ;; + hpux9* | hpux10* | hpux11*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive' + if test ia64 != "$host_cpu"; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + fi + ;; + aCC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive' + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + ;; + *) + ;; + esac + ;; + interix*) + # This is c89, which is MS Visual C++ (no shared libs) + # Anyone wants to do a port? + ;; + irix5* | irix6* | nonstopux*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + # CC pic flag -KPIC is the default. + ;; + *) + ;; + esac + ;; + *-mlibc) + ;; + linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) + case $cc_basename in + KCC*) + # KAI C++ Compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + ecpc* ) + # old Intel C++ for x86_64, which still supported -KPIC. + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + 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,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + cxx*) + # Compaq C++ + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + xlc* | xlC* | bgxl[[cC]]* | mpixl[[cC]]*) + # IBM XL 8.0, 9.0 on PPC and BlueGene + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | $SED 5q` in + *Sun\ C*) + # Sun C++ 5.9 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + esac + ;; + esac + ;; + lynxos*) + ;; + m88k*) + ;; + mvs*) + case $cc_basename in + cxx*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall' + ;; + *) + ;; + esac + ;; + netbsd* | netbsdelf*-gnu) + ;; + *qnx* | *nto*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,' + ;; + RCC*) + # Rational C++ 2.4.1 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + cxx*) + # Digital/Compaq C++ + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # Make sure the PIC flag is empty. It appears that all Alpha + # Linux and Compaq Tru64 Unix objects are PIC. + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + *) + ;; + esac + ;; + psos*) + ;; + serenity*) + ;; + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + gcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + ;; + *) + ;; + esac + ;; + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + lcc*) + # Lucid + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + ;; + *) + ;; + esac + ;; + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + case $cc_basename in + CC*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + ;; + *) + ;; + esac + ;; + vxworks*) + ;; + *) + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +], +[ + if test yes = "$GCC"; then + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + + case $host_os in + aix*) + # All AIX code is PIC. + if test ia64 = "$host_cpu"; then + # AIX 5 now supports IA64 processor + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + m68k) + # FIXME: we need at least 68020 code to build shared libraries, but + # adding the '-m68020' flag to GCC prevents building anything better, + # like '-m68040'. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4' + ;; + esac + ;; + + beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*) + # PIC is the default for these OSes. + ;; + + mingw* | windows* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + # Although the cygwin gcc ignores -fPIC, still need this for old-style + # (--disable-auto-import) libraries + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + case $host_os in + os2*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' + ;; + esac + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + ;; + + haiku*) + # PIC is the default for Haiku. + # The "-static" flag exists, but is broken. + _LT_TAGVAR(lt_prog_compiler_static, $1)= + ;; + + hpux*) + # PIC is the default for 64-bit PA HP-UX, but not for 32-bit + # PA HP-UX. On IA64 HP-UX, PIC is the default but the pic flag + # sets the default TLS model and affects inlining. + case $host_cpu in + hppa*64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + ;; + + interix[[3-9]]*) + # Interix 3.x gcc -fpic/-fPIC options generate broken code. + # Instead, we relocate shared libraries at runtime. + ;; + + msdosdjgpp*) + # Just because we use GCC doesn't mean we suddenly get shared libraries + # on systems that don't support them. + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + enable_shared=no + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic + fi + ;; + + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + ;; + esac + + case $cc_basename in + nvcc*) # Cuda Compiler Driver 2.2 + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Xlinker ' + if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)="-Xcompiler $_LT_TAGVAR(lt_prog_compiler_pic, $1)" + fi + ;; + esac + else + # PORTME Check for flag to pass linker flags through the system compiler. + case $host_os in + aix*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + if test ia64 = "$host_cpu"; then + # 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.expsym' + fi + ;; + + darwin* | rhapsody*) + # PIC is the default on this platform + # Common symbols not allowed in MH_DYLIB files + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common' + case $cc_basename in + nagfor*) + # NAG Fortran compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + + mingw* | windows* | cygwin* | pw32* | os2* | cegcc*) + # This hack is so that the source file can tell whether it is being + # built for inclusion in a dll (and should export symbols for example). + m4_if([$1], [GCJ], [], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT']) + case $host_os in + os2*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static' + ;; + esac + ;; + + hpux9* | hpux10* | hpux11*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but + # not for PA HP-UX. + case $host_cpu in + hppa*64*|ia64*) + # +Z the default + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='+Z' + ;; + esac + # Is there a better lt_prog_compiler_static that works with the bundled CC? + _LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-a ${wl}archive' + ;; + + irix5* | irix6* | nonstopux*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # PIC (with -KPIC) is the default. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + *-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*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + *flang* | ftn | f18* | f95*) + # Flang compiler. + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + # icc used to be incompatible with GCC. + # ICC 10 doesn't accept -KPIC any more. + 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' + ;; + # Lahey Fortran 8.1. + lf95*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='--shared' + _LT_TAGVAR(lt_prog_compiler_static, $1)='--static' + ;; + nagfor*) + # NAG Fortran compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,-Wl,,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + tcc*) + # Fabrice Bellard et al's Tiny C Compiler + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group compilers (*not* the Pentium gcc compiler, + # which looks to be a dead project) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + ccc*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All Alpha code is PIC. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + xl* | bgxl* | bgf* | mpixl*) + # IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-qpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-qstaticlink' + ;; + *) + case `$CC -V 2>&1 | $SED 5q` in + *Sun\ Ceres\ Fortran* | *Sun*Fortran*\ [[1-7]].* | *Sun*Fortran*\ 8.[[0-3]]*) + # Sun Fortran 8.3 passes all unrecognized flags to the linker + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='' + ;; + *Sun\ F* | *Sun*Fortran*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + ;; + *Sun\ C*) + # Sun C 5.9 + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + ;; + *Intel*\ [[CF]]*Compiler*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-static' + ;; + *Portland\ Group*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fpic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + esac + ;; + esac + ;; + + newsos6) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + *nto* | *qnx*) + # QNX uses GNU C++, but need to define -shared option too, otherwise + # it will coredump. + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC -shared' + ;; + + osf3* | osf4* | osf5*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + # All OSF/1 code is PIC. + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + rdos*) + _LT_TAGVAR(lt_prog_compiler_static, $1)='-non_shared' + ;; + + serenity*) + ;; + + solaris*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + case $cc_basename in + f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';; + *) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';; + esac + ;; + + sunos4*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-PIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4 | sysv4.2uw2* | sysv4.3*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + fi + ;; + + sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + unicos*) + _LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,' + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + + uts4*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)='-pic' + _LT_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic' + ;; + + *) + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no + ;; + esac + fi +]) +case $host_os in + # For platforms that do not support PIC, -DPIC is meaningless: + *djgpp*) + _LT_TAGVAR(lt_prog_compiler_pic, $1)= + ;; + *) + _LT_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])" + ;; +esac + +AC_CACHE_CHECK([for $compiler option to produce PIC], + [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)], + [_LT_TAGVAR(lt_cv_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_prog_compiler_pic, $1)]) +_LT_TAGVAR(lt_prog_compiler_pic, $1)=$_LT_TAGVAR(lt_cv_prog_compiler_pic, $1) + +# +# Check to make sure the PIC flag actually works. +# +if test -n "$_LT_TAGVAR(lt_prog_compiler_pic, $1)"; then + _LT_COMPILER_OPTION([if $compiler PIC flag $_LT_TAGVAR(lt_prog_compiler_pic, $1) works], + [_LT_TAGVAR(lt_cv_prog_compiler_pic_works, $1)], + [$_LT_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [], + [case $_LT_TAGVAR(lt_prog_compiler_pic, $1) in + "" | " "*) ;; + *) _LT_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_TAGVAR(lt_prog_compiler_pic, $1)" ;; + esac], + [_LT_TAGVAR(lt_prog_compiler_pic, $1)= + _LT_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no]) +fi +_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1], + [Additional compiler flags for building library objects]) + +_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1], + [How to pass a linker flag through the compiler]) +# +# Check to make sure the static flag actually works. +# +wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_TAGVAR(lt_prog_compiler_static, $1)\" +_LT_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works], + _LT_TAGVAR(lt_cv_prog_compiler_static_works, $1), + $lt_tmp_static_flag, + [], + [_LT_TAGVAR(lt_prog_compiler_static, $1)=]) +_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1], + [Compiler flag to prevent dynamic linking]) +])# _LT_COMPILER_PIC + + +# _LT_LINKER_SHLIBS([TAGNAME]) +# ---------------------------- +# See if the linker supports building shared libraries. +m4_defun([_LT_LINKER_SHLIBS], +[AC_REQUIRE([LT_PATH_LD])dnl +AC_REQUIRE([LT_PATH_NM])dnl +m4_require([_LT_PATH_MANIFEST_TOOL])dnl +m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_DECL_SED])dnl +m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl +m4_require([_LT_TAG_COMPILER])dnl +AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) +m4_if([$1], [CXX], [ + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] + case $host_os in + aix[[4-9]]*) + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to GNU nm, but means don't demangle to AIX nm. + # Without the "-l" option, or with the "-B" option, AIX nm treats + # weak defined symbols like other global defined symbols, whereas + # GNU nm marks them as "W". + # While the 'weak' keyword is ignored in the Export File, we need + # it in the Import File for the 'aix-soname' feature, so we have + # to replace the "-B" option with "-P" for AIX nm. + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' + else + _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols' + fi + ;; + pw32*) + _LT_TAGVAR(export_symbols_cmds, $1)=$ltdll_cmds + ;; + cygwin* | mingw* | windows* | cegcc*) + case $cc_basename in + cl* | icl* | icx* | icpx*) + # Native MSVC and Intel compilers + _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + ;; + *) + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] + ;; + esac + ;; + *) + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + ;; + esac +], [ + runpath_var= + _LT_TAGVAR(allow_undefined_flag, $1)= + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(archive_cmds, $1)= + _LT_TAGVAR(archive_expsym_cmds, $1)= + _LT_TAGVAR(compiler_needs_object, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + _LT_TAGVAR(export_dynamic_flag_spec, $1)= + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(hardcode_automatic, $1)=no + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_TAGVAR(hardcode_libdir_separator, $1)= + _LT_TAGVAR(hardcode_minus_L, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported + _LT_TAGVAR(inherit_rpath, $1)=no + _LT_TAGVAR(link_all_deplibs, $1)=unknown + _LT_TAGVAR(module_cmds, $1)= + _LT_TAGVAR(module_expsym_cmds, $1)= + _LT_TAGVAR(old_archive_from_new_cmds, $1)= + _LT_TAGVAR(old_archive_from_expsyms_cmds, $1)= + _LT_TAGVAR(thread_safe_flag_spec, $1)= + _LT_TAGVAR(whole_archive_flag_spec, $1)= + # include_expsyms should be a list of space-separated symbols to be *always* + # included in the symbol list + _LT_TAGVAR(include_expsyms, $1)= + # exclude_expsyms can be an extended regexp of symbols to exclude + # it will be wrapped by ' (' and ')$', so one must not match beginning or + # end of line. Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc', + # as well as any symbol that contains 'd'. + _LT_TAGVAR(exclude_expsyms, $1)=['_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*'] + # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out + # platforms (ab)use it in PIC code, but their linkers get confused if + # the symbol is explicitly referenced. Since portable code cannot + # rely on this symbol name, it's probably fine to never include it in + # preloaded symbol tables. + # Exclude shared library initialization/finalization symbols. +dnl Note also adjust exclude_expsyms for C++ above. + extract_expsyms_cmds= + + case $host_os in + cygwin* | mingw* | windows* | pw32* | cegcc*) + # FIXME: the MSVC++ and ICC port hasn't been tested in a loooong time + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++ or Intel C++ Compiler. + if test yes != "$GCC"; then + with_gnu_ld=no + fi + ;; + interix*) + # we just hope/assume this is gcc and not c89 (= MSVC++ or ICC) + with_gnu_ld=yes + ;; + esac + + _LT_TAGVAR(ld_shlibs, $1)=yes + + # On some targets, GNU ld is compatible enough with the native linker + # that we're better off using the native interface for both. + lt_use_gnu_ld_interface=no + if test yes = "$with_gnu_ld"; then + case $host_os in + aix*) + # The AIX port of GNU ld has always aspired to compatibility + # with the native linker. However, as the warning in the GNU ld + # block says, versions before 2.19.5* couldn't really create working + # shared libraries, regardless of the interface used. + case `$LD -v 2>&1` in + *\ \(GNU\ Binutils\)\ 2.19.5*) ;; + *\ \(GNU\ Binutils\)\ 2.[[2-9]]*) ;; + *\ \(GNU\ Binutils\)\ [[3-9]]*) ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + ;; + *) + lt_use_gnu_ld_interface=yes + ;; + esac + fi + + if test yes = "$lt_use_gnu_ld_interface"; then + # If archive_cmds runs LD, not CC, wlarc should be empty + wlarc='$wl' + + # Set some defaults for GNU ld with shared library support. These + # are reset later if shared libraries are not supported. Putting them + # here allows them to be overridden if necessary. + runpath_var=LD_RUN_PATH + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then + _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + supports_anon_versioning=no + case `$LD -v | $SED -e 's/([[^)]]\+)\s\+//' 2>&1` in + *GNU\ gold*) supports_anon_versioning=yes ;; + *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11 + *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ... + *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ... + *\ 2.11.*) ;; # other 2.11 versions + *) supports_anon_versioning=yes ;; + esac + + # See if GNU ld supports shared libraries. + case $host_os in + aix[[3-9]]*) + # On AIX/PPC, the GNU linker is very broken + if test ia64 != "$host_cpu"; then + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: the GNU linker, at least up to release 2.19, is reported +*** to be unable to reliably create shared libraries on AIX. +*** Therefore, libtool is disabling shared libraries support. If you +*** really care for shared libraries, you may want to install binutils +*** 2.20 or above, or modify your PATH so that a non-GNU linker is found. +*** You will then need to restart the configuration process. + +_LT_EOF + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='' + ;; + m68k) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + cygwin* | mingw* | windows* | pw32* | cegcc*) + # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1 DATA/;s/^.*[[ ]]__nm__\([[^ ]]*\)[[ ]][[^ ]]*/\1 DATA/;/^I[[ ]]/d;/^[[AITW]][[ ]]/s/.* //'\'' | sort | uniq > $export_symbols' + _LT_TAGVAR(exclude_expsyms, $1)=['[_]+GLOBAL_OFFSET_TABLE_|[_]+GLOBAL__[FID]_.*|[_]+head_[A-Za-z0-9_]+_dll|[A-Za-z0-9_]+_dll_iname'] + _LT_TAGVAR(file_list_spec, $1)='@' + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $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 + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + haiku*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(link_all_deplibs, $1)=no + ;; + + os2*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + shrext_cmds=.dll + _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + prefix_cmds="$SED"~ + if test EXPORTS = "`$SED 1q $export_symbols`"; then + prefix_cmds="$prefix_cmds -e 1d"; + fi~ + prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ + cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + ;; + + interix[[3-9]]*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _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 + case $cc_basename in + diet\ *) tmp_diet=yes;; # linux-dietlibc with static linking (!diet-dyn) + esac + fi + if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \ + && test no = "$tmp_diet" + then + tmp_addflag=' $pic_flag' + tmp_sharedflag='-shared' + case $cc_basename,$host_cpu in + pgcc*) # Portland Group C compiler + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' + tmp_addflag=' $pic_flag' + ;; + pgf77* | pgf90* | pgf95* | pgfortran*) + # Portland Group f77 and f90 compilers + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' + tmp_addflag=' $pic_flag -Mnomain' ;; + ecc*,ia64* | icc*,ia64*) # Intel C compiler on ia64 + tmp_addflag=' -i_dynamic' ;; + efc*,ia64* | ifort*,ia64*) # Intel Fortran compiler on ia64 + tmp_addflag=' -i_dynamic -nofor_main' ;; + ifc* | ifort* | ifx*) # Intel Fortran compiler + tmp_addflag=' -nofor_main' ;; + lf95*) # Lahey Fortran 8.1 + _LT_TAGVAR(whole_archive_flag_spec, $1)= + tmp_sharedflag='--shared' ;; + nagfor*) # NAGFOR 5.3 + tmp_sharedflag='-Wl,-shared' ;; + xl[[cC]]* | bgxl[[cC]]* | mpixl[[cC]]*) # IBM XL C 8.0 on PPC (deal with xlf below) + tmp_sharedflag='-qmkshrobj' + tmp_addflag= ;; + nvcc*) # Cuda Compiler Driver 2.2 + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + ;; + esac + case `$CC -V 2>&1 | $SED 5q` in + *Sun\ C*) # Sun C 5.9 + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + tmp_sharedflag='-G' ;; + *Sun\ F*) # Sun Fortran 8.3 + tmp_sharedflag='-G' ;; + esac + _LT_TAGVAR(archive_cmds, $1)='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + + if test yes = "$supports_anon_versioning"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib' + fi + + case $cc_basename in + tcc*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='-rdynamic' + ;; + xlf* | bgf* | bgxlf* | mpixlf*) + # IBM XL Fortran 10.1 on PPC cannot create shared libs itself + _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib' + if test yes = "$supports_anon_versioning"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib' + fi + ;; + esac + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + 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' + wlarc= + else + _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' + fi + ;; + + solaris*) + if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: The releases 2.8.* of the GNU linker cannot reliably +*** create shared libraries on Solaris systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.9.1 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _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' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) + case `$LD -v 2>&1` in + *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) + _LT_TAGVAR(ld_shlibs, $1)=no + cat <<_LT_EOF 1>&2 + +*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot +*** reliably create shared libraries on SCO systems. Therefore, libtool +*** is disabling shared libraries support. We urge you to upgrade GNU +*** binutils to release 2.16.91.0.3 or newer. Another option is to modify +*** your PATH or compiler configuration so that the native linker is +*** used, and then restart. + +_LT_EOF + ;; + *) + # For security reasons, it is highly recommended that you always + # use absolute paths for naming shared libraries, and exclude the + # DT_RUNPATH tag from executables and libraries. But doing so + # requires that you compile everything twice, which is a pain. + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + sunos4*) + _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags' + wlarc= + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _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' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + + if test no = "$_LT_TAGVAR(ld_shlibs, $1)"; then + runpath_var= + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)= + _LT_TAGVAR(export_dynamic_flag_spec, $1)= + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + else + # PORTME fill in a description of your system's linker (not GNU ld) + case $host_os in + aix3*) + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname' + # Note: this linker hardcodes the directories in LIBPATH if there + # are no directories specified by -L. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then + # Neither direct hardcoding nor static linking is supported with a + # broken collect2. + _LT_TAGVAR(hardcode_direct, $1)=unsupported + fi + ;; + + aix[[4-9]]*) + if test ia64 = "$host_cpu"; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag= + else + # If we're using GNU nm, then we don't want the "-C" option. + # -C means demangle to GNU nm, but means don't demangle to AIX nm. + # Without the "-l" option, or with the "-B" option, AIX nm treats + # weak defined symbols like other global defined symbols, whereas + # GNU nm marks them as "W". + # While the 'weak' keyword is ignored in the Export File, we need + # it in the Import File for the 'aix-soname' feature, so we have + # to replace the "-B" option with "-P" for AIX nm. + if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then + _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && ([substr](\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols' + else + _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B\([[^B]]*\)$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && ([substr](\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols' + fi + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # have runtime linking enabled, and use it for executables. + # For shared libraries, we enable/disable runtime linking + # depending on the kind of the shared library created - + # when "with_aix_soname,aix_use_runtimelinking" is: + # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables + # "aix,yes" lib.so shared, rtl:yes, for executables + # lib.a static archive + # "both,no" lib.so.V(shr.o) shared, rtl:yes + # lib.a(lib.so.V) shared, rtl:no, for executables + # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a(lib.so.V) shared, rtl:no + # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a static archive + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) + for ld_flag in $LDFLAGS; do + if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then + aix_use_runtimelinking=yes + break + fi + done + if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then + # With aix-soname=svr4, we create the lib.so.V shared archives only, + # so we don't have lib.a shared libs to link our executables. + # We have to force runtime linking in this case. + aix_use_runtimelinking=yes + LDFLAGS="$LDFLAGS -Wl,-brtl" + fi + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_TAGVAR(archive_cmds, $1)='' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='$wl-f,' + case $with_aix_soname,$aix_use_runtimelinking in + aix,*) ;; # traditional, no import file + svr4,* | *,yes) # use import file + # The Import File defines what to hardcode. + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=no + ;; + esac + + if test yes = "$GCC"; then + case $host_os in aix4.[[012]]|aix4.[[012]].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`$CC -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + _LT_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)= + fi + ;; + esac + shared_flag='-shared' + if test yes = "$aix_use_runtimelinking"; then + shared_flag="$shared_flag "'$wl-G' + fi + # Need to ensure runtime linking is disabled for the traditional + # shared library, or the linker may eventually find shared libraries + # /with/ Import File - we do not want to mix them. + shared_flag_aix='-shared' + shared_flag_svr4='-shared $wl-G' + else + # not using gcc + if test ia64 = "$host_cpu"; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test yes = "$aix_use_runtimelinking"; then + shared_flag='$wl-G' + else + shared_flag='$wl-bM:SRE' + fi + shared_flag_aix='$wl-bM:SRE' + shared_flag_svr4='$wl-G' + fi + fi + + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to export. + _LT_TAGVAR(always_export_symbols, $1)=yes + if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(allow_undefined_flag, $1)='-berok' + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag + else + if test ia64 = "$host_cpu"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib' + _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok' + if test yes = "$with_gnu_ld"; then + # We only use this code for GNU lds that support --whole-archive. + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' + # -brtl affects multiple linker settings, -berok does not and is overridden later + compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`' + if test svr4 != "$with_aix_soname"; then + # This is similar to how AIX traditionally builds its shared libraries. + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' + fi + if test aix != "$with_aix_soname"; then + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' + else + # used by -dlpreopen to get the symbols + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV $output_objdir/$realname.d/$soname $output_objdir' + fi + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d' + fi + fi + ;; + + amigaos*) + case $host_cpu in + powerpc) + # see comment about AmigaOS4 .so support + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='' + ;; + m68k) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + ;; + + bsdi[[45]]*) + _LT_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic + ;; + + cygwin* | mingw* | windows* | pw32* | cegcc*) + # When not using gcc, we currently assume that we are using + # Microsoft Visual C++ or Intel C++ Compiler. + # hardcode_libdir_flag_spec is actually meaningless, as there is + # no search path for DLLs. + case $cc_basename in + 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 + _LT_TAGVAR(file_list_spec, $1)='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # 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.expsym"; + else + $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~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(exclude_expsyms, $1)='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*' + _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]][[ ]]/s/.*[[ ]]\([[^ ]]*\)/\1,DATA/'\'' | $SED -e '\''/^[[AITW]][[ ]]/s/.*[[ ]]//'\'' | sort | uniq > $export_symbols' + # Don't use ranlib + _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' + _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile=$lt_outputfile.exe + lt_tool_outputfile=$lt_tool_outputfile.exe + ;; + esac~ + if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # Assume MSVC and ICC wrapper + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Tell ltmain to make .lib files, not .a files. + libext=lib + # 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 -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. + _LT_TAGVAR(old_archive_cmds, $1)='lib -OUT:$oldlib$oldobjs$old_deplibs' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + ;; + esac + ;; + + darwin* | rhapsody*) + _LT_DARWIN_LINKER_FEATURES($1) + ;; + + dgux*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor + # support. Future versions do this automatically, but an explicit c++rt0.o + # does not break anything, and helps significantly (at the cost of a little + # extra space). + freebsd2.2*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # Unfortunately, older versions of FreeBSD 2 do not have this feature. + freebsd2.*) + _LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + # FreeBSD 3 and greater uses gcc -shared to do shared libraries. + freebsd* | dragonfly* | midnightbsd*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + hpux9*) + if test yes = "$GCC"; then + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' + else + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib' + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_direct, $1)=yes + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + ;; + + hpux10*) + if test yes,no = "$GCC,$with_gnu_ld"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags' + fi + if test no = "$with_gnu_ld"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + fi + ;; + + hpux11*) + if test yes,no = "$GCC,$with_gnu_ld"; then + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + else + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + m4_if($1, [], [ + # 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) + _LT_LINKER_OPTION([if $CC understands -b], + _LT_TAGVAR(lt_cv_prog_compiler__b, $1), [-b], + [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'], + [_LT_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'])], + [_LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags']) + ;; + esac + fi + if test no = "$with_gnu_ld"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + case $host_cpu in + hppa*64*|ia64*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + *) + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + + # hardcode_minus_L: Not really in the search PATH, + # but as the default location of the library. + _LT_TAGVAR(hardcode_minus_L, $1)=yes + ;; + esac + fi + ;; + + irix5* | irix6* | nonstopux*) + if test yes = "$GCC"; then + _LT_TAGVAR(archive_cmds, $1)='$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 -o $lib' + # Try to use the -exported_symbol ld option, if it does not + # 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. + AC_CACHE_CHECK([whether the $host_os linker accepts -exported_symbol], + [lt_cv_irix_exported_symbol], + [save_LDFLAGS=$LDFLAGS + LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null" + AC_LINK_IFELSE( + [AC_LANG_SOURCE( + [AC_LANG_CASE([C], [[int foo (void) { return 0; }]], + [C++], [[int foo (void) { return 0; }]], + [Fortran 77], [[ + subroutine foo + end]], + [Fortran], [[ + subroutine foo + end]])])], + [lt_cv_irix_exported_symbol=yes], + [lt_cv_irix_exported_symbol=no]) + LDFLAGS=$save_LDFLAGS]) + if test yes = "$lt_cv_irix_exported_symbol"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$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 + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -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)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(inherit_rpath, $1)=yes + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + *-mlibc) + ;; + + linux*) + case $cc_basename in + tcc*) + # Fabrice Bellard et al's Tiny C Compiler + _LT_TAGVAR(ld_shlibs, $1)=yes + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + ;; + esac + ;; + + 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 + else + _LT_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + newsos6) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *nto* | *qnx*) + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + fi + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + os2*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + shrext_cmds=.dll + _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + prefix_cmds="$SED"~ + if test EXPORTS = "`$SED 1q $export_symbols`"; then + prefix_cmds="$prefix_cmds -e 1d"; + fi~ + prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ + cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + ;; + + osf3*) + if test yes = "$GCC"; then + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_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 -o $lib' + else + _LT_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + osf4* | osf5*) # as osf3* with the addition of -msym flag + if test yes = "$GCC"; then + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $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(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + 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.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' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)='no' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + ;; + + serenity*) + ;; + + solaris*) + _LT_TAGVAR(no_undefined_flag, $1)=' -z defs' + 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.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.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.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 + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands '-z linker_flag'. GCC discards it without '$wl', + # but is careful enough not to reorder. + # Supported since Solaris 2.6 (maybe 2.5.1?) + if test yes = "$GCC"; then + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' + fi + ;; + esac + _LT_TAGVAR(link_all_deplibs, $1)=yes + ;; + + sunos4*) + if test sequent = "$host_vendor"; then + # Use $CC to link under sequent, because it throws in some extra .o + # files that make .init and .fini sections work. + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags' + fi + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4) + case $host_vendor in + sni) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=yes # is this really true??? + ;; + siemens) + ## LD is ld it makes a PLAMLIB + ## CC just makes a GrossModule. + _LT_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs' + _LT_TAGVAR(hardcode_direct, $1)=no + ;; + motorola) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie + ;; + esac + runpath_var='LD_RUN_PATH' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + sysv4.3*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport' + ;; + + sysv4*MP*) + if test -d /usr/nec; then + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var=LD_RUN_PATH + hardcode_runpath_var=yes + _LT_TAGVAR(ld_shlibs, $1)=yes + fi + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) + _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var='LD_RUN_PATH' + + if test yes = "$GCC"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We CANNOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport' + runpath_var='LD_RUN_PATH' + + if test yes = "$GCC"; then + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + else + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + fi + ;; + + uts4*) + _LT_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + + *) + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + + if test sni = "$host_vendor"; then + case $host in + sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*) + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Blargedynsym' + ;; + esac + fi + fi +]) +AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) +test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no + +_LT_TAGVAR(with_gnu_ld, $1)=$with_gnu_ld + +_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl +_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl +_LT_DECL([], [extract_expsyms_cmds], [2], + [The commands to extract the exported symbol list from a shared archive]) + +# +# Do we need to explicitly link libc? +# +case "x$_LT_TAGVAR(archive_cmds_need_lc, $1)" in +x|xyes) + # Assume -lc should be added + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + + if test yes,yes = "$GCC,$enable_shared"; then + case $_LT_TAGVAR(archive_cmds, $1) in + *'~'*) + # FIXME: we may have to deal with multi-command sequences. + ;; + '$CC '*) + # 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. + AC_CACHE_CHECK([whether -lc should be explicitly linked in], + [lt_cv_]_LT_TAGVAR(archive_cmds_need_lc, $1), + [$RM conftest* + echo "$lt_simple_compile_test_code" > conftest.$ac_ext + + if AC_TRY_EVAL(ac_compile) 2>conftest.err; then + soname=conftest + lib=conftest + libobjs=conftest.$ac_objext + deplibs= + wl=$_LT_TAGVAR(lt_prog_compiler_wl, $1) + pic_flag=$_LT_TAGVAR(lt_prog_compiler_pic, $1) + compiler_flags=-v + linker_flags=-v + verstring= + output_objdir=. + libname=conftest + lt_save_allow_undefined_flag=$_LT_TAGVAR(allow_undefined_flag, $1) + _LT_TAGVAR(allow_undefined_flag, $1)= + if AC_TRY_EVAL(_LT_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) + then + lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=no + else + lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1)=yes + fi + _LT_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag + else + cat conftest.err 1>&5 + fi + $RM conftest* + ]) + _LT_TAGVAR(archive_cmds_need_lc, $1)=$lt_cv_[]_LT_TAGVAR(archive_cmds_need_lc, $1) + ;; + esac + fi + ;; +esac + +_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0], + [Whether or not to add -lc for building shared libraries]) +_LT_TAGDECL([allow_libtool_libs_with_static_runtimes], + [enable_shared_with_static_runtimes], [0], + [Whether or not to disallow shared libs when runtime libs are static]) +_LT_TAGDECL([], [export_dynamic_flag_spec], [1], + [Compiler flag to allow reflexive dlopens]) +_LT_TAGDECL([], [whole_archive_flag_spec], [1], + [Compiler flag to generate shared objects directly from archives]) +_LT_TAGDECL([], [compiler_needs_object], [1], + [Whether the compiler copes with passing no objects directly]) +_LT_TAGDECL([], [old_archive_from_new_cmds], [2], + [Create an old-style archive from a shared archive]) +_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2], + [Create a temporary old-style archive to link instead of a shared archive]) +_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive]) +_LT_TAGDECL([], [archive_expsym_cmds], [2]) +_LT_TAGDECL([], [module_cmds], [2], + [Commands used to build a loadable module if different from building + a shared archive.]) +_LT_TAGDECL([], [module_expsym_cmds], [2]) +_LT_TAGDECL([], [with_gnu_ld], [1], + [Whether we are building with GNU ld or not]) +_LT_TAGDECL([], [allow_undefined_flag], [1], + [Flag that allows shared libraries with undefined symbols to be built]) +_LT_TAGDECL([], [no_undefined_flag], [1], + [Flag that enforces no undefined symbols]) +_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1], + [Flag to hardcode $libdir into a binary during linking. + This must work even if $libdir does not exist]) +_LT_TAGDECL([], [hardcode_libdir_separator], [1], + [Whether we need a single "-rpath" flag with a separated argument]) +_LT_TAGDECL([], [hardcode_direct], [0], + [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes + DIR into the resulting binary]) +_LT_TAGDECL([], [hardcode_direct_absolute], [0], + [Set to "yes" if using DIR/libNAME$shared_ext during linking hardcodes + DIR into the resulting binary and the resulting library dependency is + "absolute", i.e. impossible to change by setting $shlibpath_var if the + library is relocated]) +_LT_TAGDECL([], [hardcode_minus_L], [0], + [Set to "yes" if using the -LDIR flag during linking hardcodes DIR + into the resulting binary]) +_LT_TAGDECL([], [hardcode_shlibpath_var], [0], + [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR + into the resulting binary]) +_LT_TAGDECL([], [hardcode_automatic], [0], + [Set to "yes" if building a shared library automatically hardcodes DIR + into the library and all subsequent libraries and executables linked + against it]) +_LT_TAGDECL([], [inherit_rpath], [0], + [Set to yes if linker adds runtime paths of dependent libraries + to runtime path list]) +_LT_TAGDECL([], [link_all_deplibs], [0], + [Whether libtool must link a program against all its dependency libraries]) +_LT_TAGDECL([], [always_export_symbols], [0], + [Set to "yes" if exported symbols are required]) +_LT_TAGDECL([], [export_symbols_cmds], [2], + [The commands to list exported symbols]) +_LT_TAGDECL([], [exclude_expsyms], [1], + [Symbols that should not be listed in the preloaded symbols]) +_LT_TAGDECL([], [include_expsyms], [1], + [Symbols that must always be exported]) +_LT_TAGDECL([], [prelink_cmds], [2], + [Commands necessary for linking programs (against libraries) with templates]) +_LT_TAGDECL([], [postlink_cmds], [2], + [Commands necessary for finishing linking programs]) +_LT_TAGDECL([], [file_list_spec], [1], + [Specify filename containing input files]) +dnl FIXME: Not yet implemented +dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1], +dnl [Compiler flag to generate thread safe objects]) +])# _LT_LINKER_SHLIBS + + +# _LT_LANG_C_CONFIG([TAG]) +# ------------------------ +# Ensure that the configuration variables for a C compiler are suitably +# defined. These variables are subsequently used by _LT_CONFIG to write +# the compiler configuration to 'libtool'. +m4_defun([_LT_LANG_C_CONFIG], +[m4_require([_LT_DECL_EGREP])dnl +lt_save_CC=$CC +AC_LANG_PUSH(C) + +# Source file extension for C test sources. +ac_ext=c + +# Object file extension for compiled C 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);}' + +_LT_TAG_COMPILER +# Save the default compiler, since it gets overwritten when the other +# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP. +compiler_DEFAULT=$CC + +# save warnings/boilerplate of simple test code +_LT_COMPILER_BOILERPLATE +_LT_LINKER_BOILERPLATE + +## 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_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + LT_SYS_DLOPEN_SELF + _LT_CMD_STRIPLIB + + # Report what library types will actually be built + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test no = "$can_build_shared" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test yes = "$enable_shared" && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + + aix[[4-9]]*) + if test ia64 != "$host_cpu"; then + case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in + yes,aix,yes) ;; # shared object as lib.so file only + yes,svr4,*) ;; # shared object as lib.so archive member only + yes,*) enable_static=no ;; # shared object in lib.a archive as well + esac + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test yes = "$enable_shared" || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_CONFIG($1) +fi +AC_LANG_POP +CC=$lt_save_CC +])# _LT_LANG_C_CONFIG + + +# _LT_LANG_CXX_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for a C++ compiler are suitably +# defined. These variables are subsequently used by _LT_CONFIG to write +# the compiler configuration to 'libtool'. +m4_defun([_LT_LANG_CXX_CONFIG], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +m4_require([_LT_DECL_EGREP])dnl +m4_require([_LT_PATH_MANIFEST_TOOL])dnl +if test -n "$CXX" && ( test no != "$CXX" && + ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) || + (test g++ != "$CXX"))); then + AC_PROG_CXXCPP +else + _lt_caught_CXX_error=yes +fi + +AC_LANG_PUSH(C++) +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(compiler_needs_object, $1)=no +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for C++ test sources. +ac_ext=cpp + +# Object file extension for compiled C++ test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the CXX compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test yes != "$_lt_caught_CXX_error"; then + # 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 + + # Allow CC to be a program name with arguments. + lt_save_CC=$CC + lt_save_CFLAGS=$CFLAGS + lt_save_LD=$LD + lt_save_GCC=$GCC + GCC=$GXX + lt_save_with_gnu_ld=$with_gnu_ld + lt_save_path_LD=$lt_cv_path_LD + if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then + lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx + else + $as_unset lt_cv_prog_gnu_ld + fi + if test -n "${lt_cv_path_LDCXX+set}"; then + lt_cv_path_LD=$lt_cv_path_LDCXX + else + $as_unset lt_cv_path_LD + fi + test -z "${LDCXX+set}" || LD=$LDCXX + CC=${CXX-"c++"} + CFLAGS=$CXXFLAGS + compiler=$CC + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + + if test -n "$compiler"; then + # We don't want -fno-exception when compiling C++ code, so set the + # no_builtin_flag separately + if test yes = "$GXX"; then + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin' + else + _LT_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)= + fi + + if test yes = "$GXX"; then + # Set up default GNU C++ configuration + + LT_PATH_LD + + # 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 $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' + + # If archive_cmds runs LD, not CC, wlarc should be empty + # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to + # investigate it a little bit more. (MM) + wlarc='$wl' + + # ancient GNU ld didn't support --whole-archive et. al. + if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then + _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' + else + _LT_TAGVAR(whole_archive_flag_spec, $1)= + fi + else + with_gnu_ld=no + wlarc= + + # A generic and very simple default shared library creation + # command for GNU C++ for the case where it uses the native + # 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 $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 -v "^Driving:" | $GREP " [[-]]L"' + + else + GXX=no + with_gnu_ld=no + wlarc= + fi + + # PORTME: fill in a description of your system's C++ link characteristics + AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries]) + _LT_TAGVAR(ld_shlibs, $1)=yes + case $host_os in + aix3*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aix[[4-9]]*) + if test ia64 = "$host_cpu"; then + # On IA64, the linker does run time linking by default, so we don't + # have to do anything special. + aix_use_runtimelinking=no + exp_sym_flag='-Bexport' + no_entry_flag= + else + aix_use_runtimelinking=no + + # Test if we are trying to use run time linking or normal + # AIX style linking. If -brtl is somewhere in LDFLAGS, we + # have runtime linking enabled, and use it for executables. + # For shared libraries, we enable/disable runtime linking + # depending on the kind of the shared library created - + # when "with_aix_soname,aix_use_runtimelinking" is: + # "aix,no" lib.a(lib.so.V) shared, rtl:no, for executables + # "aix,yes" lib.so shared, rtl:yes, for executables + # lib.a static archive + # "both,no" lib.so.V(shr.o) shared, rtl:yes + # lib.a(lib.so.V) shared, rtl:no, for executables + # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a(lib.so.V) shared, rtl:no + # "svr4,*" lib.so.V(shr.o) shared, rtl:yes, for executables + # lib.a static archive + case $host_os in aix4.[[23]]|aix4.[[23]].*|aix[[5-9]]*) + for ld_flag in $LDFLAGS; do + case $ld_flag in + *-brtl*) + aix_use_runtimelinking=yes + break + ;; + esac + done + if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then + # With aix-soname=svr4, we create the lib.so.V shared archives only, + # so we don't have lib.a shared libs to link our executables. + # We have to force runtime linking in this case. + aix_use_runtimelinking=yes + LDFLAGS="$LDFLAGS -Wl,-brtl" + fi + ;; + esac + + exp_sym_flag='-bexport' + no_entry_flag='-bnoentry' + fi + + # When large executables or shared objects are built, AIX ld can + # have problems creating the table of contents. If linking a library + # or program results in "error TOC overflow" add -mminimal-toc to + # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not + # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS. + + _LT_TAGVAR(archive_cmds, $1)='' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='$wl-f,' + case $with_aix_soname,$aix_use_runtimelinking in + aix,*) ;; # no import file + svr4,* | *,yes) # use import file + # The Import File defines what to hardcode. + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=no + ;; + esac + + if test yes = "$GXX"; then + case $host_os in aix4.[[012]]|aix4.[[012]].*) + # We only want to do this on AIX 4.2 and lower, the check + # below for broken collect2 doesn't work under 4.3+ + collect2name=`$CC -print-prog-name=collect2` + if test -f "$collect2name" && + strings "$collect2name" | $GREP resolve_lib_name >/dev/null + then + # We have reworked collect2 + : + else + # We have old collect2 + _LT_TAGVAR(hardcode_direct, $1)=unsupported + # It fails to find uninstalled libraries when the uninstalled + # path is not listed in the libpath. Setting hardcode_minus_L + # to unsupported forces relinking + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)= + fi + esac + shared_flag='-shared' + if test yes = "$aix_use_runtimelinking"; then + shared_flag=$shared_flag' $wl-G' + fi + # Need to ensure runtime linking is disabled for the traditional + # shared library, or the linker may eventually find shared libraries + # /with/ Import File - we do not want to mix them. + shared_flag_aix='-shared' + shared_flag_svr4='-shared $wl-G' + else + # not using gcc + if test ia64 = "$host_cpu"; then + # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release + # chokes on -Wl,-G. The following line is correct: + shared_flag='-G' + else + if test yes = "$aix_use_runtimelinking"; then + shared_flag='$wl-G' + else + shared_flag='$wl-bM:SRE' + fi + shared_flag_aix='$wl-bM:SRE' + shared_flag_svr4='$wl-G' + fi + fi + + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-bexpall' + # It seems that -bexpall does not export symbols beginning with + # underscore (_), so it is better to generate a list of symbols to + # export. + _LT_TAGVAR(always_export_symbols, $1)=yes + if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then + # Warning - without using the other runtime loading flags (-brtl), + # -berok will link without error, but may produce a broken library. + # The "-G" linker flag allows undefined symbols. + _LT_TAGVAR(no_undefined_flag, $1)='-bernotok' + # Determine the default libpath from the value encoded in an empty + # executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" + + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag + else + if test ia64 = "$host_cpu"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $libdir:/usr/lib:/lib' + _LT_TAGVAR(allow_undefined_flag, $1)="-z nodefs" + _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols" + else + # Determine the default libpath from the value encoded in an + # empty executable. + _LT_SYS_MODULE_PATH_AIX([$1]) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-blibpath:$libdir:'"$aix_libpath" + # Warning - without using the other run time loading flags, + # -berok will link without error, but may produce a broken library. + _LT_TAGVAR(no_undefined_flag, $1)=' $wl-bernotok' + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-berok' + if test yes = "$with_gnu_ld"; then + # We only use this code for GNU lds that support --whole-archive. + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive' + else + # Exported symbols can be pulled into shared objects from archives + _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience' + fi + _LT_TAGVAR(archive_cmds_need_lc, $1)=yes + _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d' + # -brtl affects multiple linker settings, -berok does not and is overridden later + compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\\([[, ]]\\)%-berok\\1%g"`' + if test svr4 != "$with_aix_soname"; then + # This is similar to how AIX traditionally builds its shared + # libraries. Need -bnortl late, we may have -brtl in LDFLAGS. + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname' + fi + if test aix != "$with_aix_soname"; then + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp' + else + # used by -dlpreopen to get the symbols + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV $output_objdir/$realname.d/$soname $output_objdir' + fi + _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d' + fi + fi + ;; + + beos*) + if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + # Joseph Beckenbach says some releases of gcc + # support --undefined. This deserves some investigation. FIXME + _LT_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + chorus*) + case $cc_basename in + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + cygwin* | mingw* | windows* | pw32* | cegcc*) + case $GXX,$cc_basename in + ,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)=' ' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + # Tell ltmain to make .lib files, not .a files. + libext=lib + # 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.expsym"; + else + $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~ + linknames=' + # The linker will not automatically build a static lib if we build a DLL. + # _LT_TAGVAR(old_archive_from_new_cmds, $1)='true' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + # Don't use ranlib + _LT_TAGVAR(old_postinstall_cmds, $1)='chmod 644 $oldlib' + _LT_TAGVAR(postlink_cmds, $1)='lt_outputfile="@OUTPUT@"~ + lt_tool_outputfile="@TOOL_OUTPUT@"~ + case $lt_outputfile in + *.exe|*.EXE) ;; + *) + lt_outputfile=$lt_outputfile.exe + lt_tool_outputfile=$lt_tool_outputfile.exe + ;; + esac~ + func_to_tool_file "$lt_outputfile"~ + if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then + $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1; + $RM "$lt_outputfile.manifest"; + fi' + ;; + *) + # g++ + # _LT_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless, + # as there is no search path for DLLs. + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-all-symbols' + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + _LT_TAGVAR(always_export_symbols, $1)=no + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + + if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then + _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 + cp $export_symbols $output_objdir/$soname.def; + else + echo EXPORTS > $output_objdir/$soname.def; + cat $export_symbols >> $output_objdir/$soname.def; + fi~ + $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 + ;; + esac + ;; + darwin* | rhapsody*) + _LT_DARWIN_LINKER_FEATURES($1) + ;; + + os2*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir' + _LT_TAGVAR(hardcode_minus_L, $1)=yes + _LT_TAGVAR(allow_undefined_flag, $1)=unsupported + shrext_cmds=.dll + _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~ + $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~ + $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~ + $ECHO EXPORTS >> $output_objdir/$libname.def~ + prefix_cmds="$SED"~ + if test EXPORTS = "`$SED 1q $export_symbols`"; then + prefix_cmds="$prefix_cmds -e 1d"; + fi~ + prefix_cmds="$prefix_cmds -e \"s/^\(.*\)$/_\1/g\""~ + cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~ + $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~ + emximp -o $lib $output_objdir/$libname.def' + _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def' + _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes + _LT_TAGVAR(file_list_spec, $1)='@' + ;; + + dgux*) + case $cc_basename in + ec++*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + ghcx*) + # Green Hills C++ Compiler + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + freebsd2.*) + # C++ shared libraries reported to be fairly broken before + # switch to ELF + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + freebsd-elf*) + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + ;; + + freebsd* | dragonfly* | midnightbsd*) + # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF + # conventions + _LT_TAGVAR(ld_shlibs, $1)=yes + ;; + + haiku*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(link_all_deplibs, $1)=no + ;; + + hpux9*) + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aCC*) + _LT_TAGVAR(archive_cmds, $1)='$RM $output_objdir/$soname~$CC -b $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' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "[[-]]L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test yes = "$GXX"; then + _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 + fi + ;; + esac + ;; + + hpux10*|hpux11*) + if test no = "$with_gnu_ld"; then + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl+b $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + case $host_cpu in + hppa*64*|ia64*) + ;; + *) + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + ;; + esac + fi + case $host_cpu in + hppa*64*|ia64*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + ;; + *) + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH, + # but as the default + # location of the library. + ;; + esac + + case $cc_basename in + CC*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + aCC*) + case $host_cpu in + hppa*64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + ia64*) + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP " [[-]]L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test yes = "$GXX"; then + if test no = "$with_gnu_ld"; then + case $host_cpu in + hppa*64*) + _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 $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 $stdlibflag $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags' + ;; + esac + fi + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + interix[[3-9]]*) + _LT_TAGVAR(hardcode_direct, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc. + # Instead, shared libraries are loaded at an image base (0x10000000 by + # default) and relocated if they conflict, which is a slow very memory + # consuming and fragmenting process. To avoid this, we pick a random, + # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link + # time. Moving up from 0x10000000 also allows more sbrk(2) space. + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib' + _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' + ;; + irix5* | irix6*) + case $cc_basename in + CC*) + # SGI C++ + _LT_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' + + # Archives containing C++ object files must be created using + # "CC -ar", where "CC" is the IRIX C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs' + ;; + *) + if test yes = "$GXX"; then + if test no = "$with_gnu_ld"; then + _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 $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 + ;; + esac + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + _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*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib $wl-retain-symbols-file,$export_symbols; mv \$templib $lib' + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' + + # Archives containing C++ object files must be created using + # "CC -Bstatic", where "CC" is the KAI C++ compiler. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' + ;; + icpc* | ecpc* | icpx*) + # Intel C++ + with_gnu_ld=yes + # version 8.0 and above of icpc choke on multiply defined symbols + # if we add $predep_objects and $postdep_objects, however 7.1 and + # earlier do not add the objects themselves. + case `$CC -V 2>&1` in + *"Version 7."*) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' + ;; + *) # Version 8.0 or newer + tmp_idyn= + case $host_cpu in + ia64*) tmp_idyn=' -i_dynamic';; + esac + _LT_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' + ;; + esac + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive$convenience $wl--no-whole-archive' + ;; + pgCC* | pgcpp*) + # Portland Group C++ compiler + case `$CC -V` in + *pgCC\ [[1-5]].* | *pgcpp\ [[1-5]].*) + _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~ + compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"' + _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~ + $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~ + $RANLIB $oldlib' + _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~ + rm -rf $tpldir~ + $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~ + $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' + ;; + *) # Version 6 and above use weak symbols + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib' + ;; + esac + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl--rpath $wl$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' + ;; + cxx*) + # Compaq C++ + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib $wl-retain-symbols-file $wl$export_symbols' + + runpath_var=LD_RUN_PATH + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed' + ;; + xl* | mpixl* | bgxl*) + # IBM XL 8.0 on PPC, with GNU ld + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl--export-dynamic' + _LT_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib' + if test yes = "$supports_anon_versioning"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='echo "{ global:" > $output_objdir/$libname.ver~ + cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~ + echo "local: *; };" >> $output_objdir/$libname.ver~ + $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib' + fi + ;; + *) + case `$CC -V 2>&1 | $SED 5q` in + *Sun\ C*) + # Sun C++ 5.9 + _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)='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir' + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive' + _LT_TAGVAR(compiler_needs_object, $1)=yes + + # Not sure whether something based on + # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 + # would be better. + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' + ;; + esac + ;; + esac + ;; + + lynxos*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + m88k*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + mvs*) + case $cc_basename in + cxx*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + 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' + wlarc= + _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 + output_verbose_link_cmd=func_echo_all + ;; + + *nto* | *qnx*) + _LT_TAGVAR(ld_shlibs, $1)=yes + ;; + + openbsd*) + if test -f /usr/libexec/ld.so; then + _LT_TAGVAR(hardcode_direct, $1)=yes + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_direct_absolute, $1)=yes + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib' + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-E' + _LT_TAGVAR(whole_archive_flag_spec, $1)=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive' + fi + output_verbose_link_cmd=func_echo_all + else + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + + osf3* | osf4* | osf5*) + case $cc_basename in + KCC*) + # Kuck and Associates, Inc. (KAI) C++ Compiler + + # KCC will only create a shared library if the output file + # ends with ".so" (or ".sl" for HP-UX), so rename the library + # to its proper name (with version) after linking. + _LT_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib' + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Archives containing C++ object files must be created using + # the KAI C++ compiler. + case $host in + osf3*) _LT_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs' ;; + *) _LT_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs' ;; + esac + ;; + RCC*) + # Rational C++ 2.4.1 + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + cxx*) + case $host in + osf3*) + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' + _LT_TAGVAR(archive_cmds, $1)='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $soname `test -n "$verstring" && func_echo_all "$wl-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib' + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + ;; + *) + _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.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 + + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # Commands to make compiler produce verbose output that lists + # what "hidden" libraries, object files and flags are used when + # linking a shared library. + # + # There doesn't appear to be a way to prevent this compiler from + # explicitly linking system object files so we need to strip them + # from the output so that they don't get included in the library + # dependencies. + output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"' + ;; + *) + if test yes,no = "$GXX,$with_gnu_ld"; then + _LT_TAGVAR(allow_undefined_flag, $1)=' $wl-expect_unresolved $wl\*' + case $host in + osf3*) + _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 $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 + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-rpath $wl$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=: + + # 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 -v "^Driving:" | $GREP " [[-]]L"' + + else + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + fi + ;; + esac + ;; + + psos*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + serenity*) + ;; + + sunos4*) + case $cc_basename in + CC*) + # Sun C++ 4.x + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + lcc*) + # Lucid + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + solaris*) + case $cc_basename in + CC* | sunCC*) + # Sun C++ 4.2, 5.x and Centerline C++ + _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.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 + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + # The compiler driver will combine and reorder linker options, + # but understands '-z linker_flag'. + # Supported since Solaris 2.6 (maybe 2.5.1?) + _LT_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' + ;; + esac + _LT_TAGVAR(link_all_deplibs, $1)=yes + + output_verbose_link_cmd='func_echo_all' + + # Archives containing C++ object files must be created using + # "CC -xar", where "CC" is the Sun C++ compiler. This is + # necessary to make sure instantiated templates are included + # in the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs' + ;; + gcx*) + # Green Hills C++ Compiler + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib' + + # The C++ compiler must be used to create the archive. + _LT_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs' + ;; + *) + # GNU C++ compiler with Solaris linker + 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 $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 -v "^Driving:" | $GREP " [[-]]L"' + else + # g++ 2.7 appears to require '-G' NOT '-shared' on this + # platform. + _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 -v "^Driving:" | $GREP " [[-]]L"' + fi + + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $wl$libdir' + case $host_os in + solaris2.[[0-5]] | solaris2.[[0-5]].*) ;; + *) + _LT_TAGVAR(whole_archive_flag_spec, $1)='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract' + ;; + esac + fi + ;; + esac + ;; + + sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*) + _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + sysv5* | sco3.2v5* | sco5v6*) + # Note: We CANNOT use -z defs as we might desire, because we do not + # link with -lc, and that would cause any symbols used from libc to + # always be unresolved, which means just about no library would + # ever link correctly. If we're not using GNU ld we use -z text + # though, which does catch some bad symbols but isn't as heavy-handed + # as -z defs. + _LT_TAGVAR(no_undefined_flag, $1)='$wl-z,text' + _LT_TAGVAR(allow_undefined_flag, $1)='$wl-z,nodefs' + _LT_TAGVAR(archive_cmds_need_lc, $1)=no + _LT_TAGVAR(hardcode_shlibpath_var, $1)=no + _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R,$libdir' + _LT_TAGVAR(hardcode_libdir_separator, $1)=':' + _LT_TAGVAR(link_all_deplibs, $1)=yes + _LT_TAGVAR(export_dynamic_flag_spec, $1)='$wl-Bexport' + runpath_var='LD_RUN_PATH' + + case $cc_basename in + CC*) + _LT_TAGVAR(archive_cmds, $1)='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(old_archive_cmds, $1)='$CC -Tprelink_objects $oldobjs~ + '"$_LT_TAGVAR(old_archive_cmds, $1)" + _LT_TAGVAR(reload_cmds, $1)='$CC -Tprelink_objects $reload_objs~ + '"$_LT_TAGVAR(reload_cmds, $1)" + ;; + *) + _LT_TAGVAR(archive_cmds, $1)='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags' + ;; + esac + ;; + + tandem*) + case $cc_basename in + NCC*) + # NonStop-UX NCC 3.20 + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + ;; + + vxworks*) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + + *) + # FIXME: insert proper C++ library support + _LT_TAGVAR(ld_shlibs, $1)=no + ;; + esac + + AC_MSG_RESULT([$_LT_TAGVAR(ld_shlibs, $1)]) + test no = "$_LT_TAGVAR(ld_shlibs, $1)" && can_build_shared=no + + _LT_TAGVAR(GCC, $1)=$GXX + _LT_TAGVAR(LD, $1)=$LD + + ## 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... + _LT_SYS_HIDDEN_LIBDEPS($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS + LDCXX=$LD + LD=$lt_save_LD + GCC=$lt_save_GCC + with_gnu_ld=$lt_save_with_gnu_ld + lt_cv_path_LDCXX=$lt_cv_path_LD + lt_cv_path_LD=$lt_save_path_LD + lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld + lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld +fi # test yes != "$_lt_caught_CXX_error" + +AC_LANG_POP +])# _LT_LANG_CXX_CONFIG + + +# _LT_FUNC_STRIPNAME_CNF +# ---------------------- +# func_stripname_cnf prefix suffix name +# strip PREFIX and SUFFIX off of NAME. +# PREFIX and SUFFIX must not contain globbing or regex special +# characters, hashes, percent signs, but SUFFIX may contain a leading +# dot (in which case that matches only a dot). +# +# This function is identical to the (non-XSI) version of func_stripname, +# except this one can be used by m4 code that may be executed by configure, +# rather than the libtool script. +m4_defun([_LT_FUNC_STRIPNAME_CNF],[dnl +AC_REQUIRE([_LT_DECL_SED]) +AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH]) +func_stripname_cnf () +{ + case @S|@2 in + .*) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%\\\\@S|@2\$%%"`;; + *) func_stripname_result=`$ECHO "@S|@3" | $SED "s%^@S|@1%%; s%@S|@2\$%%"`;; + esac +} # func_stripname_cnf +])# _LT_FUNC_STRIPNAME_CNF + + +# _LT_SYS_HIDDEN_LIBDEPS([TAGNAME]) +# --------------------------------- +# Figure out "hidden" library dependencies from verbose +# compiler output when linking a shared library. +# Parse the compiler output and extract the necessary +# objects, libraries and library flags. +m4_defun([_LT_SYS_HIDDEN_LIBDEPS], +[m4_require([_LT_FILEUTILS_DEFAULTS])dnl +AC_REQUIRE([_LT_FUNC_STRIPNAME_CNF])dnl +# Dependencies to place before and after the object being linked: +_LT_TAGVAR(predep_objects, $1)= +_LT_TAGVAR(postdep_objects, $1)= +_LT_TAGVAR(predeps, $1)= +_LT_TAGVAR(postdeps, $1)= +_LT_TAGVAR(compiler_lib_search_path, $1)= + +dnl we can't use the lt_simple_compile_test_code here, +dnl because it contains code intended for an executable, +dnl not a library. It's possible we should let each +dnl tag define a new lt_????_link_test_code variable, +dnl but it's only used here... +m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF +int a; +void foo (void) { a = 0; } +_LT_EOF +], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF +class Foo +{ +public: + Foo (void) { a = 0; } +private: + int a; +}; +_LT_EOF +], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF + subroutine foo + implicit none + integer*4 a + a=0 + return + end +_LT_EOF +], [$1], [FC], [cat > conftest.$ac_ext <<_LT_EOF + subroutine foo + implicit none + integer a + a=0 + return + end +_LT_EOF +], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF +public class foo { + private int a; + public void bar (void) { + a = 0; + } +}; +_LT_EOF +], [$1], [GO], [cat > conftest.$ac_ext <<_LT_EOF +package foo +func foo() { +} +_LT_EOF +]) + +_lt_libdeps_save_CFLAGS=$CFLAGS +case "$CC $CFLAGS " in #( +*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;; +*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;; +*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;; +esac + +dnl Parse the compiler output and extract the necessary +dnl objects, libraries and library flags. +if AC_TRY_EVAL(ac_compile); then + # Parse the compiler output and extract the necessary + # objects, libraries and library flags. + + # Sentinel used to keep track of whether or not we are before + # 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* | */libclang_rt.*.a) + # Some compilers place space between "-{L,R,l}" and the path. + # Remove the space. + if test x-L = x"$p" || + test x-R = x"$p" || + test x-l = x"$p"; then + prev=$p + continue + fi + + # Expand the sysroot to ease extracting the directories later. + if test -z "$prev"; then + case $p in + -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;; + -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;; + -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;; + esac + fi + case $p in + =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;; + esac + if test no = "$pre_test_object_deps_done"; then + case $prev in + -L | -R) + # Internal compiler library paths should come after those + # provided the user. The postdeps already come after the + # user supplied libs so there is no need to process them. + if test -z "$_LT_TAGVAR(compiler_lib_search_path, $1)"; then + _LT_TAGVAR(compiler_lib_search_path, $1)=$prev$p + else + _LT_TAGVAR(compiler_lib_search_path, $1)="${_LT_TAGVAR(compiler_lib_search_path, $1)} $prev$p" + fi + ;; + # The "-l" case would never come before the object being + # linked, so don't bother handling this case. + esac + else + if test -z "$_LT_TAGVAR(postdeps, $1)"; then + _LT_TAGVAR(postdeps, $1)=$prev$p + else + _LT_TAGVAR(postdeps, $1)="${_LT_TAGVAR(postdeps, $1)} $prev$p" + fi + fi + prev= + ;; + + *.lto.$objext) ;; # Ignore GCC LTO objects + *.$objext) + # This assumes that the test object file only shows up + # once in the compiler output. + if test "$p" = "conftest.$objext"; then + pre_test_object_deps_done=yes + continue + fi + + if test no = "$pre_test_object_deps_done"; then + if test -z "$_LT_TAGVAR(predep_objects, $1)"; then + _LT_TAGVAR(predep_objects, $1)=$p + else + _LT_TAGVAR(predep_objects, $1)="$_LT_TAGVAR(predep_objects, $1) $p" + fi + else + if test -z "$_LT_TAGVAR(postdep_objects, $1)"; then + _LT_TAGVAR(postdep_objects, $1)=$p + else + _LT_TAGVAR(postdep_objects, $1)="$_LT_TAGVAR(postdep_objects, $1) $p" + fi + fi + ;; + + *) ;; # Ignore the rest. + + esac + done + + # Clean up. + rm -f a.out a.exe +else + echo "libtool.m4: error: problem compiling $1 test program" +fi + +$RM -f confest.$objext +CFLAGS=$_lt_libdeps_save_CFLAGS + +# PORTME: override above test on systems where it is broken +m4_if([$1], [CXX], +[case $host_os in +interix[[3-9]]*) + # Interix 3.5 installs completely hosed .la files for C++, so rather than + # hack all around it, let's just trust "g++" to DTRT. + _LT_TAGVAR(predep_objects,$1)= + _LT_TAGVAR(postdep_objects,$1)= + _LT_TAGVAR(postdeps,$1)= + ;; +esac +]) + +case " $_LT_TAGVAR(postdeps, $1) " in +*" -lc "*) _LT_TAGVAR(archive_cmds_need_lc, $1)=no ;; +esac + _LT_TAGVAR(compiler_lib_search_dirs, $1)= +if test -n "${_LT_TAGVAR(compiler_lib_search_path, $1)}"; then + _LT_TAGVAR(compiler_lib_search_dirs, $1)=`echo " ${_LT_TAGVAR(compiler_lib_search_path, $1)}" | $SED -e 's! -L! !g' -e 's!^ !!'` +fi +_LT_TAGDECL([], [compiler_lib_search_dirs], [1], + [The directories searched by this compiler when creating a shared library]) +_LT_TAGDECL([], [predep_objects], [1], + [Dependencies to place before and after the objects being linked to + create a shared library]) +_LT_TAGDECL([], [postdep_objects], [1]) +_LT_TAGDECL([], [predeps], [1]) +_LT_TAGDECL([], [postdeps], [1]) +_LT_TAGDECL([], [compiler_lib_search_path], [1], + [The library search path used internally by the compiler when linking + a shared library]) +])# _LT_SYS_HIDDEN_LIBDEPS + + +# _LT_LANG_F77_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for a Fortran 77 compiler are +# suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to 'libtool'. +m4_defun([_LT_LANG_F77_CONFIG], +[AC_LANG_PUSH(Fortran 77) +if test -z "$F77" || test no = "$F77"; then + _lt_disable_F77=yes +fi + +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for f77 test sources. +ac_ext=f + +# Object file extension for compiled f77 test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the F77 compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test yes != "$_lt_disable_F77"; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="\ + subroutine t + return + end +" + + # Code to be used in simple link tests + lt_simple_link_test_code="\ + program t + end +" + + # 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 + + # Allow CC to be a program name with arguments. + lt_save_CC=$CC + lt_save_GCC=$GCC + lt_save_CFLAGS=$CFLAGS + CC=${F77-"f77"} + CFLAGS=$FFLAGS + compiler=$CC + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + GCC=$G77 + if test -n "$compiler"; then + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test no = "$can_build_shared" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test yes = "$enable_shared" && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + aix[[4-9]]*) + if test ia64 != "$host_cpu"; then + case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in + yes,aix,yes) ;; # shared object as lib.so file only + yes,svr4,*) ;; # shared object as lib.so archive member only + yes,*) enable_static=no ;; # shared object in lib.a archive as well + esac + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test yes = "$enable_shared" || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_TAGVAR(GCC, $1)=$G77 + _LT_TAGVAR(LD, $1)=$LD + + ## 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... + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + GCC=$lt_save_GCC + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS +fi # test yes != "$_lt_disable_F77" + +AC_LANG_POP +])# _LT_LANG_F77_CONFIG + + +# _LT_LANG_FC_CONFIG([TAG]) +# ------------------------- +# Ensure that the configuration variables for a Fortran compiler are +# suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to 'libtool'. +m4_defun([_LT_LANG_FC_CONFIG], +[AC_LANG_PUSH(Fortran) + +if test -z "$FC" || test no = "$FC"; then + _lt_disable_FC=yes +fi + +_LT_TAGVAR(archive_cmds_need_lc, $1)=no +_LT_TAGVAR(allow_undefined_flag, $1)= +_LT_TAGVAR(always_export_symbols, $1)=no +_LT_TAGVAR(archive_expsym_cmds, $1)= +_LT_TAGVAR(export_dynamic_flag_spec, $1)= +_LT_TAGVAR(hardcode_direct, $1)=no +_LT_TAGVAR(hardcode_direct_absolute, $1)=no +_LT_TAGVAR(hardcode_libdir_flag_spec, $1)= +_LT_TAGVAR(hardcode_libdir_separator, $1)= +_LT_TAGVAR(hardcode_minus_L, $1)=no +_LT_TAGVAR(hardcode_automatic, $1)=no +_LT_TAGVAR(inherit_rpath, $1)=no +_LT_TAGVAR(module_cmds, $1)= +_LT_TAGVAR(module_expsym_cmds, $1)= +_LT_TAGVAR(link_all_deplibs, $1)=unknown +_LT_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds +_LT_TAGVAR(reload_flag, $1)=$reload_flag +_LT_TAGVAR(reload_cmds, $1)=$reload_cmds +_LT_TAGVAR(no_undefined_flag, $1)= +_LT_TAGVAR(whole_archive_flag_spec, $1)= +_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=no + +# Source file extension for fc test sources. +ac_ext=${ac_fc_srcext-f} + +# Object file extension for compiled fc test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# No sense in running all these tests if we already determined that +# the FC compiler isn't working. Some variables (like enable_shared) +# are currently assumed to apply to all compilers on this platform, +# and will be corrupted by setting them based on a non-working compiler. +if test yes != "$_lt_disable_FC"; then + # Code to be used in simple compile tests + lt_simple_compile_test_code="\ + subroutine t + return + end +" + + # Code to be used in simple link tests + lt_simple_link_test_code="\ + program t + end +" + + # 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 + + # Allow CC to be a program name with arguments. + lt_save_CC=$CC + lt_save_GCC=$GCC + lt_save_CFLAGS=$CFLAGS + CC=${FC-"f95"} + CFLAGS=$FCFLAGS + compiler=$CC + GCC=$ac_cv_fc_compiler_gnu + + _LT_TAGVAR(compiler, $1)=$CC + _LT_CC_BASENAME([$compiler]) + + if test -n "$compiler"; then + AC_MSG_CHECKING([if libtool supports shared libraries]) + AC_MSG_RESULT([$can_build_shared]) + + AC_MSG_CHECKING([whether to build shared libraries]) + test no = "$can_build_shared" && enable_shared=no + + # On AIX, shared libraries and static libraries use the same namespace, and + # are all built from PIC. + case $host_os in + aix3*) + test yes = "$enable_shared" && enable_static=no + if test -n "$RANLIB"; then + archive_cmds="$archive_cmds~\$RANLIB \$lib" + postinstall_cmds='$RANLIB $lib' + fi + ;; + aix[[4-9]]*) + if test ia64 != "$host_cpu"; then + case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in + yes,aix,yes) ;; # shared object as lib.so file only + yes,svr4,*) ;; # shared object as lib.so archive member only + yes,*) enable_static=no ;; # shared object in lib.a archive as well + esac + fi + ;; + esac + AC_MSG_RESULT([$enable_shared]) + + AC_MSG_CHECKING([whether to build static libraries]) + # Make sure either enable_shared or enable_static is yes. + test yes = "$enable_shared" || enable_static=yes + AC_MSG_RESULT([$enable_static]) + + _LT_TAGVAR(GCC, $1)=$ac_cv_fc_compiler_gnu + _LT_TAGVAR(LD, $1)=$LD + + ## 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... + _LT_SYS_HIDDEN_LIBDEPS($1) + _LT_COMPILER_PIC($1) + _LT_COMPILER_C_O($1) + _LT_COMPILER_FILE_LOCKS($1) + _LT_LINKER_SHLIBS($1) + _LT_SYS_DYNAMIC_LINKER($1) + _LT_LINKER_HARDCODE_LIBPATH($1) + + _LT_CONFIG($1) + fi # test -n "$compiler" + + GCC=$lt_save_GCC + CC=$lt_save_CC + CFLAGS=$lt_save_CFLAGS +fi # test yes != "$_lt_disable_FC" + +AC_LANG_POP +])# _LT_LANG_FC_CONFIG + + +# _LT_LANG_GCJ_CONFIG([TAG]) +# -------------------------- +# Ensure that the configuration variables for the GNU Java Compiler compiler +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to 'libtool'. +m4_defun([_LT_LANG_GCJ_CONFIG], +[AC_REQUIRE([LT_PROG_GCJ])dnl +AC_LANG_SAVE + +# Source file extension for Java test sources. +ac_ext=java + +# Object file extension for compiled Java test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="class foo {}" + +# Code to be used in simple link tests +lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }' + +# 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 + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC=yes +CC=${GCJ-"gcj"} +CFLAGS=$GCJFLAGS +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_TAGVAR(LD, $1)=$LD +_LT_CC_BASENAME([$compiler]) + +# GCJ did not exist at the time GCC didn't implicitly link libc in. +_LT_TAGVAR(archive_cmds_need_lc, $1)=no + +_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_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 +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to 'libtool'. +m4_defun([_LT_LANG_GO_CONFIG], +[AC_REQUIRE([LT_PROG_GO])dnl +AC_LANG_SAVE + +# Source file extension for Go test sources. +ac_ext=go + +# Object file extension for compiled Go test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code="package main; func main() { }" + +# Code to be used in simple link tests +lt_simple_link_test_code='package main; func main() { }' + +# 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 + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC=yes +CC=${GOC-"gccgo"} +CFLAGS=$GOFLAGS +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_TAGVAR(LD, $1)=$LD +_LT_CC_BASENAME([$compiler]) + +# Go did not exist at the time GCC didn't implicitly link libc in. +_LT_TAGVAR(archive_cmds_need_lc, $1)=no + +_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_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 +# are suitably defined. These variables are subsequently used by _LT_CONFIG +# to write the compiler configuration to 'libtool'. +m4_defun([_LT_LANG_RC_CONFIG], +[AC_REQUIRE([LT_PROG_RC])dnl +AC_LANG_SAVE + +# Source file extension for RC test sources. +ac_ext=rc + +# Object file extension for compiled RC test sources. +objext=o +_LT_TAGVAR(objext, $1)=$objext + +# Code to be used in simple compile tests +lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }' + +# Code to be used in simple link tests +lt_simple_link_test_code=$lt_simple_compile_test_code + +# 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 + +# Allow CC to be a program name with arguments. +lt_save_CC=$CC +lt_save_CFLAGS=$CFLAGS +lt_save_GCC=$GCC +GCC= +CC=${RC-"windres"} +CFLAGS= +compiler=$CC +_LT_TAGVAR(compiler, $1)=$CC +_LT_CC_BASENAME([$compiler]) +_LT_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes + +if test -n "$compiler"; then + : + _LT_CONFIG($1) +fi + +GCC=$lt_save_GCC +AC_LANG_RESTORE +CC=$lt_save_CC +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 +# ----------- +AC_DEFUN([LT_PROG_GCJ], +[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ], + [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ], + [AC_CHECK_TOOL(GCJ, gcj,) + test set = "${GCJFLAGS+set}" || GCJFLAGS="-g -O2" + AC_SUBST(GCJFLAGS)])])[]dnl +]) + +# Old name: +AU_ALIAS([LT_AC_PROG_GCJ], [LT_PROG_GCJ]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_GCJ], []) + + +# LT_PROG_GO +# ---------- +AC_DEFUN([LT_PROG_GO], +[AC_CHECK_TOOL(GOC, gccgo,) +]) + + +# LT_PROG_RC +# ---------- +AC_DEFUN([LT_PROG_RC], +[AC_CHECK_TOOL(RC, windres,) +]) + +# Old name: +AU_ALIAS([LT_AC_PROG_RC], [LT_PROG_RC]) +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_RC], []) + + +# _LT_DECL_EGREP +# -------------- +# If we don't have a new enough Autoconf to choose the best grep +# available, choose the one first in the user's PATH. +m4_defun([_LT_DECL_EGREP], +[AC_REQUIRE([AC_PROG_EGREP])dnl +AC_REQUIRE([AC_PROG_FGREP])dnl +test -z "$GREP" && GREP=grep +_LT_DECL([], [GREP], [1], [A grep program that handles long lines]) +_LT_DECL([], [EGREP], [1], [An ERE matcher]) +_LT_DECL([], [FGREP], [1], [A literal string matcher]) +dnl Non-bleeding-edge autoconf doesn't subst GREP, so do it here too +AC_SUBST([GREP]) +]) + + +# _LT_DECL_OBJDUMP +# -------------- +# If we don't have a new enough Autoconf to choose the best objdump +# available, choose the one first in the user's PATH. +m4_defun([_LT_DECL_OBJDUMP], +[AC_CHECK_TOOL(OBJDUMP, objdump, false) +test -z "$OBJDUMP" && OBJDUMP=objdump +_LT_DECL([], [OBJDUMP], [1], [An object symbol dumper]) +AC_SUBST([OBJDUMP]) +]) + +# _LT_DECL_DLLTOOL +# ---------------- +# Ensure DLLTOOL variable is set. +m4_defun([_LT_DECL_DLLTOOL], +[AC_CHECK_TOOL(DLLTOOL, dlltool, false) +test -z "$DLLTOOL" && DLLTOOL=dlltool +_LT_DECL([], [DLLTOOL], [1], [DLL creation program]) +AC_SUBST([DLLTOOL]) +]) + +# _LT_DECL_FILECMD +# ---------------- +# Check for a file(cmd) program that can be used to detect file type and magic +m4_defun([_LT_DECL_FILECMD], +[AC_CHECK_PROG([FILECMD], [file], [file], [:]) +_LT_DECL([], [FILECMD], [1], [A file(cmd) program that detects file types]) +])# _LD_DECL_FILECMD + +# _LT_DECL_SED +# ------------ +# Check for a fully-functional sed program, that truncates +# as few characters as possible. Prefer GNU sed if found. +m4_defun([_LT_DECL_SED], +[AC_PROG_SED +test -z "$SED" && SED=sed +Xsed="$SED -e 1s/^X//" +_LT_DECL([], [SED], [1], [A sed program that does not truncate output]) +_LT_DECL([], [Xsed], ["\$SED -e 1s/^X//"], + [Sed that helps us avoid accidentally triggering echo(1) options like -n]) +])# _LT_DECL_SED +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([LT_AC_PROG_SED], []) + + +# _LT_CHECK_SHELL_FEATURES +# ------------------------ +# Find out whether the shell is Bourne or XSI compatible, +# or has some other useful features. +m4_defun([_LT_CHECK_SHELL_FEATURES], +[if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then + lt_unset=unset +else + lt_unset=false +fi +_LT_DECL([], [lt_unset], [0], [whether the shell understands "unset"])dnl + +# test EBCDIC or ASCII +case `echo X|tr X '\101'` in + A) # ASCII based system + # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr + lt_SP2NL='tr \040 \012' + lt_NL2SP='tr \015\012 \040\040' + ;; + *) # EBCDIC based system + lt_SP2NL='tr \100 \n' + lt_NL2SP='tr \r\n \100\100' + ;; +esac +_LT_DECL([SP2NL], [lt_SP2NL], [1], [turn spaces into newlines])dnl +_LT_DECL([NL2SP], [lt_NL2SP], [1], [turn newlines into spaces])dnl +])# _LT_CHECK_SHELL_FEATURES + + +# _LT_PATH_CONVERSION_FUNCTIONS +# ----------------------------- +# Determine what file name conversion functions should be used by +# func_to_host_file (and, implicitly, by func_to_host_path). These are needed +# for certain cross-compile configurations and native mingw. +m4_defun([_LT_PATH_CONVERSION_FUNCTIONS], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +AC_REQUIRE([AC_CANONICAL_BUILD])dnl +AC_MSG_CHECKING([how to convert $build file names to $host format]) +AC_CACHE_VAL(lt_cv_to_host_file_cmd, +[case $host in + *-*-mingw* ) + case $build in + *-*-mingw* | *-*-windows* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32 + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32 + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32 + ;; + esac + ;; + *-*-cygwin* ) + case $build in + *-*-mingw* | *-*-windows* ) # actually msys + lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin + ;; + *-*-cygwin* ) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; + * ) # otherwise, assume *nix + lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin + ;; + esac + ;; + * ) # unhandled hosts (and "normal" native builds) + lt_cv_to_host_file_cmd=func_convert_file_noop + ;; +esac +]) +to_host_file_cmd=$lt_cv_to_host_file_cmd +AC_MSG_RESULT([$lt_cv_to_host_file_cmd]) +_LT_DECL([to_host_file_cmd], [lt_cv_to_host_file_cmd], + [0], [convert $build file names to $host format])dnl + +AC_MSG_CHECKING([how to convert $build file names to toolchain format]) +AC_CACHE_VAL(lt_cv_to_tool_file_cmd, +[#assume ordinary cross tools, or native build. +lt_cv_to_tool_file_cmd=func_convert_file_noop +case $host in + *-*-mingw* | *-*-windows* ) + case $build in + *-*-mingw* | *-*-windows* ) # actually msys + lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32 + ;; + esac + ;; +esac +]) +to_tool_file_cmd=$lt_cv_to_tool_file_cmd +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 --git a/cpp/third_party/xz-5.8.3/m4/ltoptions.m4 b/cpp/third_party/xz-5.8.3/m4/ltoptions.m4 new file mode 100644 index 0000000000..9e93e6f040 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/ltoptions.m4 @@ -0,0 +1,519 @@ +# Helper functions for option handling. -*- Autoconf -*- +# +# Copyright (C) 2004-2005, 2007-2009, 2011-2019, 2021-2025 Free +# Software Foundation, Inc. +# Written by Gary V. Vaughan, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# 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])]) + + +# _LT_MANGLE_OPTION(MACRO-NAME, OPTION-NAME) +# ------------------------------------------ +m4_define([_LT_MANGLE_OPTION], +[[_LT_OPTION_]m4_bpatsubst($1__$2, [[^a-zA-Z0-9_]], [_])]) + + +# _LT_SET_OPTION(MACRO-NAME, OPTION-NAME) +# --------------------------------------- +# Set option OPTION-NAME for macro MACRO-NAME, and if there is a +# matching handler defined, dispatch to it. Other OPTION-NAMEs are +# saved as a flag. +m4_define([_LT_SET_OPTION], +[m4_define(_LT_MANGLE_OPTION([$1], [$2]))dnl +m4_ifdef(_LT_MANGLE_DEFUN([$1], [$2]), + _LT_MANGLE_DEFUN([$1], [$2]), + [m4_warning([Unknown $1 option '$2'])])[]dnl +]) + + +# _LT_IF_OPTION(MACRO-NAME, OPTION-NAME, IF-SET, [IF-NOT-SET]) +# ------------------------------------------------------------ +# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise. +m4_define([_LT_IF_OPTION], +[m4_ifdef(_LT_MANGLE_OPTION([$1], [$2]), [$3], [$4])]) + + +# _LT_UNLESS_OPTIONS(MACRO-NAME, OPTION-LIST, IF-NOT-SET) +# ------------------------------------------------------- +# Execute IF-NOT-SET unless all options in OPTION-LIST for MACRO-NAME +# are set. +m4_define([_LT_UNLESS_OPTIONS], +[m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), + [m4_ifdef(_LT_MANGLE_OPTION([$1], _LT_Option), + [m4_define([$0_found])])])[]dnl +m4_ifdef([$0_found], [m4_undefine([$0_found])], [$3 +])[]dnl +]) + + +# _LT_SET_OPTIONS(MACRO-NAME, OPTION-LIST) +# ---------------------------------------- +# OPTION-LIST is a space-separated list of Libtool options associated +# with MACRO-NAME. If any OPTION has a matching handler declared with +# LT_OPTION_DEFINE, dispatch to that macro; otherwise complain about +# the unknown option and exit. +m4_defun([_LT_SET_OPTIONS], +[# Set options +m4_foreach([_LT_Option], m4_split(m4_normalize([$2])), + [_LT_SET_OPTION([$1], _LT_Option)]) + +m4_if([$1],[LT_INIT],[ + dnl + dnl Simply set some default values (i.e off) if boolean options were not + dnl specified: + _LT_UNLESS_OPTIONS([LT_INIT], [dlopen], [enable_dlopen=no + ]) + _LT_UNLESS_OPTIONS([LT_INIT], [win32-dll], [enable_win32_dll=no + ]) + dnl + dnl If no reference was made to various pairs of opposing options, then + dnl we run the default mode handler for the pair. For example, if neither + dnl 'shared' nor 'disable-shared' was passed, we enable building of shared + dnl archives by default: + _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], + [_LT_WITH_AIX_SONAME([aix])]) + ]) +])# _LT_SET_OPTIONS + + +## --------------------------------- ## +## Macros to handle LT_INIT options. ## +## --------------------------------- ## + +# _LT_MANGLE_DEFUN(MACRO-NAME, OPTION-NAME) +# ----------------------------------------- +m4_define([_LT_MANGLE_DEFUN], +[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1__$2]), [[^A-Z0-9_]], [_])]) + + +# LT_OPTION_DEFINE(MACRO-NAME, OPTION-NAME, CODE) +# ----------------------------------------------- +m4_define([LT_OPTION_DEFINE], +[m4_define(_LT_MANGLE_DEFUN([$1], [$2]), [$3])[]dnl +])# LT_OPTION_DEFINE + + +# dlopen +# ------ +LT_OPTION_DEFINE([LT_INIT], [dlopen], [enable_dlopen=yes +]) + +AU_DEFUN([AC_LIBTOOL_DLOPEN], +[_LT_SET_OPTION([LT_INIT], [dlopen]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the 'dlopen' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_DLOPEN], []) + + +# win32-dll +# --------- +# Declare package support for building win32 dll's. +LT_OPTION_DEFINE([LT_INIT], [win32-dll], +[enable_win32_dll=yes + +case $host in +*-*-cygwin* | *-*-mingw* | *-*-windows* | *-*-pw32* | *-*-cegcc*) + AC_CHECK_TOOL(AS, as, false) + AC_CHECK_TOOL(DLLTOOL, dlltool, false) + AC_CHECK_TOOL(OBJDUMP, objdump, false) + ;; +esac + +test -z "$AS" && AS=as +_LT_DECL([], [AS], [1], [Assembler program])dnl + +test -z "$DLLTOOL" && DLLTOOL=dlltool +_LT_DECL([], [DLLTOOL], [1], [DLL creation program])dnl + +test -z "$OBJDUMP" && OBJDUMP=objdump +_LT_DECL([], [OBJDUMP], [1], [Object dumper program])dnl +])# win32-dll + +AU_DEFUN([AC_LIBTOOL_WIN32_DLL], +[AC_REQUIRE([AC_CANONICAL_HOST])dnl +_LT_SET_OPTION([LT_INIT], [win32-dll]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the 'win32-dll' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_LIBTOOL_WIN32_DLL], []) + + +# _LT_ENABLE_SHARED([DEFAULT]) +# ---------------------------- +# implement the --enable-shared flag, and supports the 'shared' and +# 'disable-shared' LT_INIT options. +# DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'. +m4_define([_LT_ENABLE_SHARED], +[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([shared], + [AS_HELP_STRING([--enable-shared@<:@=PKGS@:>@], + [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_shared=yes ;; + no) enable_shared=no ;; + *) + enable_shared=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_shared=yes + fi + done + IFS=$lt_save_ifs + ;; + esac], + [enable_shared=]_LT_ENABLE_SHARED_DEFAULT) + + _LT_DECL([build_libtool_libs], [enable_shared], [0], + [Whether or not to build shared libraries]) +])# _LT_ENABLE_SHARED + +LT_OPTION_DEFINE([LT_INIT], [shared], [_LT_ENABLE_SHARED([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-shared], [_LT_ENABLE_SHARED([no])]) + +# Old names: +AC_DEFUN([AC_ENABLE_SHARED], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[shared]) +]) + +AC_DEFUN([AC_DISABLE_SHARED], +[_LT_SET_OPTION([LT_INIT], [disable-shared]) +]) + +AU_DEFUN([AM_ENABLE_SHARED], [AC_ENABLE_SHARED($@)]) +AU_DEFUN([AM_DISABLE_SHARED], [AC_DISABLE_SHARED($@)]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_ENABLE_SHARED], []) +dnl AC_DEFUN([AM_DISABLE_SHARED], []) + + + +# _LT_ENABLE_STATIC([DEFAULT]) +# ---------------------------- +# implement the --enable-static flag, and support the 'static' and +# 'disable-static' LT_INIT options. +# DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'. +m4_define([_LT_ENABLE_STATIC], +[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([static], + [AS_HELP_STRING([--enable-static@<:@=PKGS@:>@], + [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_static=yes ;; + no) enable_static=no ;; + *) + enable_static=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_static=yes + fi + done + IFS=$lt_save_ifs + ;; + esac], + [enable_static=]_LT_ENABLE_STATIC_DEFAULT) + + _LT_DECL([build_old_libs], [enable_static], [0], + [Whether or not to build static libraries]) +])# _LT_ENABLE_STATIC + +LT_OPTION_DEFINE([LT_INIT], [static], [_LT_ENABLE_STATIC([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-static], [_LT_ENABLE_STATIC([no])]) + +# Old names: +AC_DEFUN([AC_ENABLE_STATIC], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[static]) +]) + +AC_DEFUN([AC_DISABLE_STATIC], +[_LT_SET_OPTION([LT_INIT], [disable-static]) +]) + +AU_DEFUN([AM_ENABLE_STATIC], [AC_ENABLE_STATIC($@)]) +AU_DEFUN([AM_DISABLE_STATIC], [AC_DISABLE_STATIC($@)]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AM_ENABLE_STATIC], []) +dnl AC_DEFUN([AM_DISABLE_STATIC], []) + + + +# _LT_ENABLE_FAST_INSTALL([DEFAULT]) +# ---------------------------------- +# implement the --enable-fast-install flag, and support the 'fast-install' +# and 'disable-fast-install' LT_INIT options. +# DEFAULT is either 'yes' or 'no'. If omitted, it defaults to 'yes'. +m4_define([_LT_ENABLE_FAST_INSTALL], +[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl +AC_ARG_ENABLE([fast-install], + [AS_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@], + [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])], + [p=${PACKAGE-default} + case $enableval in + yes) enable_fast_install=yes ;; + no) enable_fast_install=no ;; + *) + enable_fast_install=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_fast_install=yes + fi + done + IFS=$lt_save_ifs + ;; + esac], + [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT) + +_LT_DECL([fast_install], [enable_fast_install], [0], + [Whether or not to optimize for fast installation])dnl +])# _LT_ENABLE_FAST_INSTALL + +LT_OPTION_DEFINE([LT_INIT], [fast-install], [_LT_ENABLE_FAST_INSTALL([yes])]) +LT_OPTION_DEFINE([LT_INIT], [disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])]) + +# Old names: +AU_DEFUN([AC_ENABLE_FAST_INSTALL], +[_LT_SET_OPTION([LT_INIT], m4_if([$1], [no], [disable-])[fast-install]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you put +the 'fast-install' option into LT_INIT's first parameter.]) +]) + +AU_DEFUN([AC_DISABLE_FAST_INSTALL], +[_LT_SET_OPTION([LT_INIT], [disable-fast-install]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you put +the 'disable-fast-install' option into LT_INIT's first parameter.]) +]) + +dnl aclocal-1.4 backwards compatibility: +dnl AC_DEFUN([AC_ENABLE_FAST_INSTALL], []) +dnl AC_DEFUN([AM_DISABLE_FAST_INSTALL], []) + + +# _LT_WITH_AIX_SONAME([DEFAULT]) +# ---------------------------------- +# implement the --enable-aix-soname configure option, and support the +# `aix-soname=aix' and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. +# DEFAULT is either `aix', `both', or `svr4'. If omitted, it defaults to `aix'. +m4_define([_LT_WITH_AIX_SONAME], +[m4_define([_LT_WITH_AIX_SONAME_DEFAULT], [m4_if($1, svr4, svr4, m4_if($1, both, both, aix))])dnl +shared_archive_member_spec= +case $host,$enable_shared in +power*-*-aix[[5-9]]*,yes) + AC_MSG_CHECKING([which variant of shared library versioning to provide]) + AC_ARG_ENABLE([aix-soname], + [AS_HELP_STRING([--enable-aix-soname=aix|svr4|both], + [shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=]_LT_WITH_AIX_SONAME_DEFAULT[@:>@.])], + [case $enableval in + aix|svr4|both) + ;; + *) + AC_MSG_ERROR([Unknown argument to --enable-aix-soname]) + ;; + esac + lt_cv_with_aix_soname=$enable_aix_soname], + [_AC_ENABLE_IF([with], [aix-soname], + [case $withval in + aix|svr4|both) + ;; + *) + AC_MSG_ERROR([Unknown argument to --with-aix-soname]) + ;; + esac + lt_cv_with_aix_soname=$with_aix_soname], + [AC_CACHE_VAL([lt_cv_with_aix_soname], + [lt_cv_with_aix_soname=]_LT_WITH_AIX_SONAME_DEFAULT)]) + enable_aix_soname=$lt_cv_with_aix_soname]) + with_aix_soname=$enable_aix_soname + AC_MSG_RESULT([$with_aix_soname]) + 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', + # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File. + # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag, + # the AIX toolchain works better with OBJECT_MODE set (default 32). + if test 64 = "${OBJECT_MODE-32}"; then + shared_archive_member_spec=shr_64 + else + shared_archive_member_spec=shr + 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 + +_LT_DECL([], [shared_archive_member_spec], [0], + [Shared archive member basename, for filename based shared library versioning on AIX])dnl +])# _LT_WITH_AIX_SONAME + +LT_OPTION_DEFINE([LT_INIT], [aix-soname=aix], [_LT_WITH_AIX_SONAME([aix])]) +LT_OPTION_DEFINE([LT_INIT], [aix-soname=both], [_LT_WITH_AIX_SONAME([both])]) +LT_OPTION_DEFINE([LT_INIT], [aix-soname=svr4], [_LT_WITH_AIX_SONAME([svr4])]) + + +# _LT_WITH_PIC([MODE]) +# -------------------- +# implement the --enable-pic flag, and support the 'pic-only' and 'no-pic' +# LT_INIT options. +# MODE is either 'yes' or 'no'. If omitted, it defaults to 'both'. +m4_define([_LT_WITH_PIC], +[AC_ARG_ENABLE([pic], + [AS_HELP_STRING([--enable-pic@<:@=PKGS@:>@], + [try to use only PIC/non-PIC objects @<:@default=use both@:>@])], + [lt_p=${PACKAGE-default} + case $enableval in + yes|no) pic_mode=$enableval ;; + *) + pic_mode=default + # Look at the argument we got. We use all the common list separators. + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, + for lt_pkg in $enableval; do + IFS=$lt_save_ifs + if test "X$lt_pkg" = "X$lt_p"; then + pic_mode=yes + fi + done + IFS=$lt_save_ifs + ;; + esac], + [dnl Continue to support --with-pic and --without-pic, for backward + dnl compatibility. + _AC_ENABLE_IF([with], [pic], + [lt_p=${PACKAGE-default} + case $withval in + yes|no) pic_mode=$withval ;; + *) + pic_mode=default + # Look at the argument we got. We use all the common list separators. + lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR, + for lt_pkg in $withval; do + IFS=$lt_save_ifs + if test "X$lt_pkg" = "X$lt_p"; then + pic_mode=yes + fi + done + IFS=$lt_save_ifs + ;; + esac], + [pic_mode=m4_default([$1], [default])])] + ) + +_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl +])# _LT_WITH_PIC + +LT_OPTION_DEFINE([LT_INIT], [pic-only], [_LT_WITH_PIC([yes])]) +LT_OPTION_DEFINE([LT_INIT], [no-pic], [_LT_WITH_PIC([no])]) + +# Old name: +AU_DEFUN([AC_LIBTOOL_PICMODE], +[_LT_SET_OPTION([LT_INIT], [pic-only]) +AC_DIAGNOSE([obsolete], +[$0: Remove this warning and the call to _LT_SET_OPTION when you +put the 'pic-only' option into LT_INIT's first parameter.]) +]) + +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 ## +## ----------------- ## + +m4_define([_LTDL_MODE], []) +LT_OPTION_DEFINE([LTDL_INIT], [nonrecursive], + [m4_define([_LTDL_MODE], [nonrecursive])]) +LT_OPTION_DEFINE([LTDL_INIT], [recursive], + [m4_define([_LTDL_MODE], [recursive])]) +LT_OPTION_DEFINE([LTDL_INIT], [subproject], + [m4_define([_LTDL_MODE], [subproject])]) + +m4_define([_LTDL_TYPE], []) +LT_OPTION_DEFINE([LTDL_INIT], [installable], + [m4_define([_LTDL_TYPE], [installable])]) +LT_OPTION_DEFINE([LTDL_INIT], [convenience], + [m4_define([_LTDL_TYPE], [convenience])]) diff --git a/cpp/third_party/xz-5.8.3/m4/ltsugar.m4 b/cpp/third_party/xz-5.8.3/m4/ltsugar.m4 new file mode 100644 index 0000000000..5698955ba8 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/ltsugar.m4 @@ -0,0 +1,124 @@ +# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- +# +# Copyright (C) 2004-2005, 2007-2008, 2011-2019, 2021-2025 Free Software +# Foundation, Inc. +# Written by Gary V. Vaughan, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 6 ltsugar.m4 + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])]) + + +# lt_join(SEP, ARG1, [ARG2...]) +# ----------------------------- +# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their +# associated separator. +# Needed until we can rely on m4_join from Autoconf 2.62, since all earlier +# versions in m4sugar had bugs. +m4_define([lt_join], +[m4_if([$#], [1], [], + [$#], [2], [[$2]], + [m4_if([$2], [], [], [[$2]_])$0([$1], m4_shift(m4_shift($@)))])]) +m4_define([_lt_join], +[m4_if([$#$2], [2], [], + [m4_if([$2], [], [], [[$1$2]])$0([$1], m4_shift(m4_shift($@)))])]) + + +# lt_car(LIST) +# lt_cdr(LIST) +# ------------ +# Manipulate m4 lists. +# These macros are necessary as long as will still need to support +# Autoconf-2.59, which quotes differently. +m4_define([lt_car], [[$1]]) +m4_define([lt_cdr], +[m4_if([$#], 0, [m4_fatal([$0: cannot be called without arguments])], + [$#], 1, [], + [m4_dquote(m4_shift($@))])]) +m4_define([lt_unquote], $1) + + +# lt_append(MACRO-NAME, STRING, [SEPARATOR]) +# ------------------------------------------ +# Redefine MACRO-NAME to hold its former content plus 'SEPARATOR''STRING'. +# Note that neither SEPARATOR nor STRING are expanded; they are appended +# to MACRO-NAME as is (leaving the expansion for when MACRO-NAME is invoked). +# No SEPARATOR is output if MACRO-NAME was previously undefined (different +# than defined and empty). +# +# This macro is needed until we can rely on Autoconf 2.62, since earlier +# versions of m4sugar mistakenly expanded SEPARATOR but not STRING. +m4_define([lt_append], +[m4_define([$1], + m4_ifdef([$1], [m4_defn([$1])[$3]])[$2])]) + + + +# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...]) +# ---------------------------------------------------------- +# Produce a SEP delimited list of all paired combinations of elements of +# PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list +# has the form PREFIXmINFIXSUFFIXn. +# Needed until we can rely on m4_combine added in Autoconf 2.62. +m4_define([lt_combine], +[m4_if(m4_eval([$# > 3]), [1], + [m4_pushdef([_Lt_sep], [m4_define([_Lt_sep], m4_defn([lt_car]))])]]dnl +[[m4_foreach([_Lt_prefix], [$2], + [m4_foreach([_Lt_suffix], + ]m4_dquote(m4_dquote(m4_shift(m4_shift(m4_shift($@)))))[, + [_Lt_sep([$1])[]m4_defn([_Lt_prefix])[$3]m4_defn([_Lt_suffix])])])])]) + + +# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ]) +# ----------------------------------------------------------------------- +# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited +# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ. +m4_define([lt_if_append_uniq], +[m4_ifdef([$1], + [m4_if(m4_index([$3]m4_defn([$1])[$3], [$3$2$3]), [-1], + [lt_append([$1], [$2], [$3])$4], + [$5])], + [lt_append([$1], [$2], [$3])$4])]) + + +# lt_dict_add(DICT, KEY, VALUE) +# ----------------------------- +m4_define([lt_dict_add], +[m4_define([$1($2)], [$3])]) + + +# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE) +# -------------------------------------------- +m4_define([lt_dict_add_subkey], +[m4_define([$1($2:$3)], [$4])]) + + +# lt_dict_fetch(DICT, KEY, [SUBKEY]) +# ---------------------------------- +m4_define([lt_dict_fetch], +[m4_ifval([$3], + m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]), + m4_ifdef([$1($2)], [m4_defn([$1($2)])]))]) + + +# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE]) +# ----------------------------------------------------------------- +m4_define([lt_if_dict_fetch], +[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4], + [$5], + [$6])]) + + +# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...]) +# -------------------------------------------------------------- +m4_define([lt_dict_filter], +[m4_if([$5], [], [], + [lt_join(m4_quote(m4_default([$4], [[, ]])), + lt_unquote(m4_split(m4_normalize(m4_foreach(_Lt_key, lt_car([m4_shiftn(4, $@)]), + [lt_if_dict_fetch([$1], _Lt_key, [$2], [$3], [_Lt_key ])])))))])[]dnl +]) diff --git a/cpp/third_party/xz-5.8.3/m4/ltversion.m4 b/cpp/third_party/xz-5.8.3/m4/ltversion.m4 new file mode 100644 index 0000000000..09bdaa5ee3 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/ltversion.m4 @@ -0,0 +1,24 @@ +# ltversion.m4 -- version numbers -*- Autoconf -*- +# +# Copyright (C) 2004, 2011-2019, 2021-2025 Free Software Foundation, +# Inc. +# Written by Scott James Remnant, 2004 +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# @configure_input@ + +# serial 4509 ltversion.m4 +# This file is part of GNU Libtool + +m4_define([LT_PACKAGE_VERSION], [2.6.0]) +m4_define([LT_PACKAGE_REVISION], [2.6.0]) + +AC_DEFUN([LTVERSION_VERSION], +[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 --git a/cpp/third_party/xz-5.8.3/m4/lt~obsolete.m4 b/cpp/third_party/xz-5.8.3/m4/lt~obsolete.m4 new file mode 100644 index 0000000000..c1d7729b4a --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/lt~obsolete.m4 @@ -0,0 +1,99 @@ +# lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- +# +# Copyright (C) 2004-2005, 2007, 2009, 2011-2019, 2021-2025 Free +# Software Foundation, Inc. +# Written by Scott James Remnant, 2004. +# +# This file is free software; the Free Software Foundation gives +# unlimited permission to copy and/or distribute it, with or without +# modifications, as long as this notice is preserved. + +# serial 5 lt~obsolete.m4 + +# These exist entirely to fool aclocal when bootstrapping libtool. +# +# In the past libtool.m4 has provided macros via AC_DEFUN (or AU_DEFUN), +# which have later been changed to m4_define as they aren't part of the +# exported API, or moved to Autoconf or Automake where they belong. +# +# The trouble is, aclocal is a bit thick. It'll see the old AC_DEFUN +# in /usr/share/aclocal/libtool.m4 and remember it, then when it sees us +# using a macro with the same name in our local m4/libtool.m4 it'll +# pull the old libtool.m4 in (it doesn't see our shiny new m4_define +# and doesn't know about Autoconf macros at all.) +# +# So we provide this file, which has a silly filename so it's always +# included after everything else. This provides aclocal with the +# AC_DEFUNs it wants, but when m4 processes it, it doesn't do anything +# because those macros already exist, or will be overwritten later. +# We use AC_DEFUN over AU_DEFUN for compatibility with aclocal-1.6. +# +# Anytime we withdraw an AC_DEFUN or AU_DEFUN, remember to add it here. +# Yes, that means every name once taken will need to remain here until +# we give up compatibility with versions before 1.7, at which point +# we need to keep only those names which we still refer to. + +# This is to help aclocal find these macros, as it can't see m4_define. +AC_DEFUN([LTOBSOLETE_VERSION], [m4_if([1])]) + +m4_ifndef([AC_LIBTOOL_LINKER_OPTION], [AC_DEFUN([AC_LIBTOOL_LINKER_OPTION])]) +m4_ifndef([AC_PROG_EGREP], [AC_DEFUN([AC_PROG_EGREP])]) +m4_ifndef([_LT_AC_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_AC_PROG_ECHO_BACKSLASH])]) +m4_ifndef([_LT_AC_SHELL_INIT], [AC_DEFUN([_LT_AC_SHELL_INIT])]) +m4_ifndef([_LT_AC_SYS_LIBPATH_AIX], [AC_DEFUN([_LT_AC_SYS_LIBPATH_AIX])]) +m4_ifndef([_LT_PROG_LTMAIN], [AC_DEFUN([_LT_PROG_LTMAIN])]) +m4_ifndef([_LT_AC_TAGVAR], [AC_DEFUN([_LT_AC_TAGVAR])]) +m4_ifndef([AC_LTDL_ENABLE_INSTALL], [AC_DEFUN([AC_LTDL_ENABLE_INSTALL])]) +m4_ifndef([AC_LTDL_PREOPEN], [AC_DEFUN([AC_LTDL_PREOPEN])]) +m4_ifndef([_LT_AC_SYS_COMPILER], [AC_DEFUN([_LT_AC_SYS_COMPILER])]) +m4_ifndef([_LT_AC_LOCK], [AC_DEFUN([_LT_AC_LOCK])]) +m4_ifndef([AC_LIBTOOL_SYS_OLD_ARCHIVE], [AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE])]) +m4_ifndef([_LT_AC_TRY_DLOPEN_SELF], [AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF])]) +m4_ifndef([AC_LIBTOOL_PROG_CC_C_O], [AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O])]) +m4_ifndef([AC_LIBTOOL_SYS_HARD_LINK_LOCKS], [AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS])]) +m4_ifndef([AC_LIBTOOL_OBJDIR], [AC_DEFUN([AC_LIBTOOL_OBJDIR])]) +m4_ifndef([AC_LTDL_OBJDIR], [AC_DEFUN([AC_LTDL_OBJDIR])]) +m4_ifndef([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH], [AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH])]) +m4_ifndef([AC_LIBTOOL_SYS_LIB_STRIP], [AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP])]) +m4_ifndef([AC_PATH_MAGIC], [AC_DEFUN([AC_PATH_MAGIC])]) +m4_ifndef([AC_PROG_LD_GNU], [AC_DEFUN([AC_PROG_LD_GNU])]) +m4_ifndef([AC_PROG_LD_RELOAD_FLAG], [AC_DEFUN([AC_PROG_LD_RELOAD_FLAG])]) +m4_ifndef([AC_DEPLIBS_CHECK_METHOD], [AC_DEFUN([AC_DEPLIBS_CHECK_METHOD])]) +m4_ifndef([AC_LIBTOOL_PROG_COMPILER_NO_RTTI], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI])]) +m4_ifndef([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE], [AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])]) +m4_ifndef([AC_LIBTOOL_PROG_COMPILER_PIC], [AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC])]) +m4_ifndef([AC_LIBTOOL_PROG_LD_SHLIBS], [AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS])]) +m4_ifndef([AC_LIBTOOL_POSTDEP_PREDEP], [AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP])]) +m4_ifndef([LT_AC_PROG_EGREP], [AC_DEFUN([LT_AC_PROG_EGREP])]) +m4_ifndef([LT_AC_PROG_SED], [AC_DEFUN([LT_AC_PROG_SED])]) +m4_ifndef([_LT_CC_BASENAME], [AC_DEFUN([_LT_CC_BASENAME])]) +m4_ifndef([_LT_COMPILER_BOILERPLATE], [AC_DEFUN([_LT_COMPILER_BOILERPLATE])]) +m4_ifndef([_LT_LINKER_BOILERPLATE], [AC_DEFUN([_LT_LINKER_BOILERPLATE])]) +m4_ifndef([_AC_PROG_LIBTOOL], [AC_DEFUN([_AC_PROG_LIBTOOL])]) +m4_ifndef([AC_LIBTOOL_SETUP], [AC_DEFUN([AC_LIBTOOL_SETUP])]) +m4_ifndef([_LT_AC_CHECK_DLFCN], [AC_DEFUN([_LT_AC_CHECK_DLFCN])]) +m4_ifndef([AC_LIBTOOL_SYS_DYNAMIC_LINKER], [AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER])]) +m4_ifndef([_LT_AC_TAGCONFIG], [AC_DEFUN([_LT_AC_TAGCONFIG])]) +m4_ifndef([AC_DISABLE_FAST_INSTALL], [AC_DEFUN([AC_DISABLE_FAST_INSTALL])]) +m4_ifndef([_LT_AC_LANG_CXX], [AC_DEFUN([_LT_AC_LANG_CXX])]) +m4_ifndef([_LT_AC_LANG_F77], [AC_DEFUN([_LT_AC_LANG_F77])]) +m4_ifndef([_LT_AC_LANG_GCJ], [AC_DEFUN([_LT_AC_LANG_GCJ])]) +m4_ifndef([AC_LIBTOOL_LANG_C_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_C_CONFIG])]) +m4_ifndef([_LT_AC_LANG_C_CONFIG], [AC_DEFUN([_LT_AC_LANG_C_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_CXX_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_CXX_CONFIG])]) +m4_ifndef([_LT_AC_LANG_CXX_CONFIG], [AC_DEFUN([_LT_AC_LANG_CXX_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_F77_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_F77_CONFIG])]) +m4_ifndef([_LT_AC_LANG_F77_CONFIG], [AC_DEFUN([_LT_AC_LANG_F77_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_GCJ_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_GCJ_CONFIG])]) +m4_ifndef([_LT_AC_LANG_GCJ_CONFIG], [AC_DEFUN([_LT_AC_LANG_GCJ_CONFIG])]) +m4_ifndef([AC_LIBTOOL_LANG_RC_CONFIG], [AC_DEFUN([AC_LIBTOOL_LANG_RC_CONFIG])]) +m4_ifndef([_LT_AC_LANG_RC_CONFIG], [AC_DEFUN([_LT_AC_LANG_RC_CONFIG])]) +m4_ifndef([AC_LIBTOOL_CONFIG], [AC_DEFUN([AC_LIBTOOL_CONFIG])]) +m4_ifndef([_LT_AC_FILE_LTDLL_C], [AC_DEFUN([_LT_AC_FILE_LTDLL_C])]) +m4_ifndef([_LT_REQUIRED_DARWIN_CHECKS], [AC_DEFUN([_LT_REQUIRED_DARWIN_CHECKS])]) +m4_ifndef([_LT_AC_PROG_CXXCPP], [AC_DEFUN([_LT_AC_PROG_CXXCPP])]) +m4_ifndef([_LT_PREPARE_SED_QUOTE_VARS], [AC_DEFUN([_LT_PREPARE_SED_QUOTE_VARS])]) +m4_ifndef([_LT_PROG_ECHO_BACKSLASH], [AC_DEFUN([_LT_PROG_ECHO_BACKSLASH])]) +m4_ifndef([_LT_PROG_F77], [AC_DEFUN([_LT_PROG_F77])]) +m4_ifndef([_LT_PROG_FC], [AC_DEFUN([_LT_PROG_FC])]) +m4_ifndef([_LT_PROG_CXX], [AC_DEFUN([_LT_PROG_CXX])]) diff --git a/cpp/third_party/xz-5.8.3/m4/nls.m4 b/cpp/third_party/xz-5.8.3/m4/nls.m4 new file mode 100644 index 0000000000..219cbaa136 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/nls.m4 @@ -0,0 +1,33 @@ +# nls.m4 +# serial 6 (gettext-0.20.2) +dnl Copyright (C) 1995-2003, 2005-2006, 2008-2014, 2016, 2019-2024 Free +dnl Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl +dnl This file can be used in projects which are not available under +dnl the GNU General Public License or the GNU Lesser General Public +dnl License but which still want to provide support for the GNU gettext +dnl functionality. +dnl Please note that the actual code of the GNU gettext library is covered +dnl by the GNU Lesser General Public License, and the rest of the GNU +dnl gettext package is covered by the GNU General Public License. +dnl They are *not* in the public domain. + +dnl Authors: +dnl Ulrich Drepper , 1995-2000. +dnl Bruno Haible , 2000-2003. + +AC_PREREQ([2.50]) + +AC_DEFUN([AM_NLS], +[ + AC_MSG_CHECKING([whether NLS is requested]) + dnl Default is enabled NLS + AC_ARG_ENABLE([nls], + [ --disable-nls do not use Native Language Support], + USE_NLS=$enableval, USE_NLS=yes) + AC_MSG_RESULT([$USE_NLS]) + AC_SUBST([USE_NLS]) +]) diff --git a/cpp/third_party/xz-5.8.3/m4/po.m4 b/cpp/third_party/xz-5.8.3/m4/po.m4 new file mode 100644 index 0000000000..8c0d8602df --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/po.m4 @@ -0,0 +1,456 @@ +# po.m4 +# serial 33 (gettext-0.23) +dnl Copyright (C) 1995-2014, 2016, 2018-2022, 2024 Free Software Foundation, +dnl Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl +dnl This file can be used in projects which are not available under +dnl the GNU General Public License or the GNU Lesser General Public +dnl License but which still want to provide support for the GNU gettext +dnl functionality. +dnl Please note that the actual code of the GNU gettext library is covered +dnl by the GNU Lesser General Public License, and the rest of the GNU +dnl gettext package is covered by the GNU General Public License. +dnl They are *not* in the public domain. + +dnl Authors: +dnl Ulrich Drepper , 1995-2000. +dnl Bruno Haible , 2000-2024. + +AC_PREREQ([2.60]) + +dnl Checks for all prerequisites of the po subdirectory. +AC_DEFUN([AM_PO_SUBDIRS], +[ + AC_REQUIRE([AC_PROG_MAKE_SET])dnl + AC_REQUIRE([AC_PROG_INSTALL])dnl + AC_REQUIRE([AC_PROG_MKDIR_P])dnl + AC_REQUIRE([AC_PROG_SED])dnl + AC_REQUIRE([AM_NLS])dnl + + dnl Release version of the gettext macros. This is used to ensure that + dnl the gettext macros and po/Makefile.in.in are in sync. + AC_SUBST([GETTEXT_MACRO_VERSION], [0.22]) + + dnl Perform the following tests also if --disable-nls has been given, + dnl because they are needed for "make dist" to work. + + dnl Search for GNU msgfmt in the PATH. + dnl The first test excludes Solaris msgfmt and early GNU msgfmt versions. + dnl The second test excludes FreeBSD msgfmt. + AM_PATH_PROG_WITH_TEST(MSGFMT, msgfmt, + [$ac_dir/$ac_word --statistics /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 && + (if $ac_dir/$ac_word --statistics /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], + :) + AC_PATH_PROG([GMSGFMT], [gmsgfmt], [$MSGFMT]) + + dnl Test whether it is GNU msgfmt >= 0.15. +changequote(,)dnl + case `$GMSGFMT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in + '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) GMSGFMT_015=: ;; + *) GMSGFMT_015=$GMSGFMT ;; + esac +changequote([,])dnl + AC_SUBST([GMSGFMT_015]) + + dnl Search for GNU xgettext 0.12 or newer in the PATH. + dnl The first test excludes Solaris xgettext and early GNU xgettext versions. + dnl The second test excludes FreeBSD xgettext. + AM_PATH_PROG_WITH_TEST(XGETTEXT, xgettext, + [$ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1 && + (if $ac_dir/$ac_word --omit-header --copyright-holder= --msgid-bugs-address= /dev/null 2>&1 >/dev/null | grep usage >/dev/null; then exit 1; else exit 0; fi)], + :) + dnl Remove leftover from FreeBSD xgettext call. + rm -f messages.po + + dnl Test whether it is GNU xgettext >= 0.15. +changequote(,)dnl + case `$XGETTEXT --version | sed 1q | sed -e 's,^[^0-9]*,,'` in + '' | 0.[0-9] | 0.[0-9].* | 0.1[0-4] | 0.1[0-4].*) XGETTEXT_015=: ;; + *) XGETTEXT_015=$XGETTEXT ;; + esac +changequote([,])dnl + AC_SUBST([XGETTEXT_015]) + + dnl Search for GNU msgmerge 0.11 or newer in the PATH. + AM_PATH_PROG_WITH_TEST(MSGMERGE, msgmerge, + [$ac_dir/$ac_word --update -q /dev/null /dev/null >&]AS_MESSAGE_LOG_FD[ 2>&1], :) + + dnl Test whether it is GNU msgmerge >= 0.20. + if LC_ALL=C $MSGMERGE --help | grep ' --for-msgfmt ' >/dev/null; then + MSGMERGE_FOR_MSGFMT_OPTION='--for-msgfmt' + else + dnl Test whether it is GNU msgmerge >= 0.12. + if LC_ALL=C $MSGMERGE --help | grep ' --no-fuzzy-matching ' >/dev/null; then + MSGMERGE_FOR_MSGFMT_OPTION='--no-fuzzy-matching --no-location --quiet' + else + dnl With these old versions, $(MSGMERGE) $(MSGMERGE_FOR_MSGFMT_OPTION) is + dnl slow. But this is not a big problem, as such old gettext versions are + dnl hardly in use any more. + MSGMERGE_FOR_MSGFMT_OPTION='--no-location --quiet' + fi + fi + AC_SUBST([MSGMERGE_FOR_MSGFMT_OPTION]) + + dnl Support for AM_XGETTEXT_OPTION. + test -n "${XGETTEXT_EXTRA_OPTIONS+set}" || XGETTEXT_EXTRA_OPTIONS= + AC_SUBST([XGETTEXT_EXTRA_OPTIONS]) + + AC_CONFIG_COMMANDS([po-directories], [[ + for ac_file in $CONFIG_FILES; do + # Support "outfile[:infile[:infile...]]" + case "$ac_file" in + *:*) ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;; + esac + # PO directories have a Makefile.in generated from Makefile.in.in. + case "$ac_file" in */Makefile.in) + # Adjust a relative srcdir. + ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'` + ac_dir_suffix=/`echo "$ac_dir"|sed 's%^\./%%'` + ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'` + # In autoconf-2.13 it is called $ac_given_srcdir. + # In autoconf-2.50 it is called $srcdir. + test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir" + case "$ac_given_srcdir" in + .) top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;; + /*) top_srcdir="$ac_given_srcdir" ;; + *) top_srcdir="$ac_dots$ac_given_srcdir" ;; + esac + # Treat a directory as a PO directory if and only if it has a + # POTFILES.in file. This allows packages to have multiple PO + # directories under different names or in different locations. + if test -f "$ac_given_srcdir/$ac_dir/POTFILES.in"; then + rm -f "$ac_dir/POTFILES" + test -n "$as_me" && echo "$as_me: creating $ac_dir/POTFILES" || echo "creating $ac_dir/POTFILES" + gt_tab=`printf '\t'` + cat "$ac_given_srcdir/$ac_dir/POTFILES.in" | sed -e "/^#/d" -e "/^[ ${gt_tab}]*\$/d" -e "s,.*, $top_srcdir/& \\\\," | sed -e "\$s/\(.*\) \\\\/\1/" > "$ac_dir/POTFILES" + POMAKEFILEDEPS="POTFILES.in" + # ALL_LINGUAS, POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES depend + # on $ac_dir but don't depend on user-specified configuration + # parameters. + if test -f "$ac_given_srcdir/$ac_dir/LINGUAS"; then + # The LINGUAS file contains the set of available languages. + if test -n "$OBSOLETE_ALL_LINGUAS"; then + test -n "$as_me" && echo "$as_me: setting ALL_LINGUAS in configure.in is obsolete" || echo "setting ALL_LINGUAS in configure.in is obsolete" + fi + ALL_LINGUAS=`sed -e "/^#/d" -e "s/#.*//" "$ac_given_srcdir/$ac_dir/LINGUAS"` + POMAKEFILEDEPS="$POMAKEFILEDEPS LINGUAS" + else + # The set of available languages was given in configure.in. + ALL_LINGUAS=$OBSOLETE_ALL_LINGUAS + fi + # Compute POFILES + # as $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).po) + # Compute UPDATEPOFILES + # as $(foreach lang, $(ALL_LINGUAS), $(lang).po-update) + # Compute DUMMYPOFILES + # as $(foreach lang, $(ALL_LINGUAS), $(lang).nop) + # Compute GMOFILES + # as $(foreach lang, $(ALL_LINGUAS), $(srcdir)/$(lang).gmo) + case "$ac_given_srcdir" in + .) srcdirpre= ;; + *) srcdirpre='$(srcdir)/' ;; + esac + POFILES= + UPDATEPOFILES= + DUMMYPOFILES= + GMOFILES= + for lang in $ALL_LINGUAS; do + POFILES="$POFILES $srcdirpre$lang.po" + UPDATEPOFILES="$UPDATEPOFILES $lang.po-update" + DUMMYPOFILES="$DUMMYPOFILES $lang.nop" + GMOFILES="$GMOFILES $srcdirpre$lang.gmo" + done + # CATALOGS depends on both $ac_dir and the user's LINGUAS + # environment variable. + INST_LINGUAS= + if test -n "$ALL_LINGUAS"; then + for presentlang in $ALL_LINGUAS; do + useit=no + if test "%UNSET%" != "$LINGUAS"; then + desiredlanguages="$LINGUAS" + else + desiredlanguages="$ALL_LINGUAS" + fi + for desiredlang in $desiredlanguages; do + # Use the presentlang catalog if desiredlang is + # a. equal to presentlang, or + # b. a variant of presentlang (because in this case, + # presentlang can be used as a fallback for messages + # which are not translated in the desiredlang catalog). + case "$desiredlang" in + "$presentlang" | "$presentlang"_* | "$presentlang".* | "$presentlang"@*) + useit=yes + ;; + esac + done + if test $useit = yes; then + INST_LINGUAS="$INST_LINGUAS $presentlang" + fi + done + fi + CATALOGS= + if test -n "$INST_LINGUAS"; then + for lang in $INST_LINGUAS; do + CATALOGS="$CATALOGS $lang.gmo" + done + fi + test -n "$as_me" && echo "$as_me: creating $ac_dir/Makefile" || echo "creating $ac_dir/Makefile" + sed -e "/^POTFILES =/r $ac_dir/POTFILES" -e "/^# Makevars/r $ac_given_srcdir/$ac_dir/Makevars" -e "s|@POFILES@|$POFILES|g" -e "s|@UPDATEPOFILES@|$UPDATEPOFILES|g" -e "s|@DUMMYPOFILES@|$DUMMYPOFILES|g" -e "s|@GMOFILES@|$GMOFILES|g" -e "s|@CATALOGS@|$CATALOGS|g" -e "s|@POMAKEFILEDEPS@|$POMAKEFILEDEPS|g" "$ac_dir/Makefile.in" > "$ac_dir/Makefile" + for f in "$ac_given_srcdir/$ac_dir"/Rules-*; do + if test -f "$f"; then + case "$f" in + *.orig | *.bak | *~) ;; + *) cat "$f" >> "$ac_dir/Makefile" ;; + esac + fi + done + fi + ;; + esac + done]], + [# Capture the value of obsolete ALL_LINGUAS because we need it to compute + # POFILES, UPDATEPOFILES, DUMMYPOFILES, GMOFILES, CATALOGS. + OBSOLETE_ALL_LINGUAS="$ALL_LINGUAS" + # Capture the value of LINGUAS because we need it to compute CATALOGS. + LINGUAS="${LINGUAS-%UNSET%}" + ]) +]) + +dnl Postprocesses a Makefile in a directory containing PO files. +AC_DEFUN([AM_POSTPROCESS_PO_MAKEFILE], +[ + # When this code is run, in config.status, two variables have already been + # set: + # - OBSOLETE_ALL_LINGUAS is the value of LINGUAS set in configure.in, + # - LINGUAS is the value of the environment variable LINGUAS at configure + # time. + +changequote(,)dnl + # Adjust a relative srcdir. + ac_dir=`echo "$ac_file"|sed 's%/[^/][^/]*$%%'` + ac_dir_suffix=/`echo "$ac_dir"|sed 's%^\./%%'` + ac_dots=`echo "$ac_dir_suffix"|sed 's%/[^/]*%../%g'` + # In autoconf-2.13 it is called $ac_given_srcdir. + # In autoconf-2.50 it is called $srcdir. + test -n "$ac_given_srcdir" || ac_given_srcdir="$srcdir" + case "$ac_given_srcdir" in + .) top_srcdir=`echo $ac_dots|sed 's%/$%%'` ;; + /*) top_srcdir="$ac_given_srcdir" ;; + *) top_srcdir="$ac_dots$ac_given_srcdir" ;; + esac + + # Find a way to echo strings without interpreting backslash. + if test "X`(echo '\t') 2>/dev/null`" = 'X\t'; then + gt_echo='echo' + else + if test "X`(printf '%s\n' '\t') 2>/dev/null`" = 'X\t'; then + gt_echo='printf %s\n' + else + echo_func () { + cat < "$ac_file.tmp" + tab=`printf '\t'` + if grep -l '@TCLCATALOGS@' "$ac_file" > /dev/null; then + # Add dependencies that cannot be formulated as a simple suffix rule. + for lang in $ALL_LINGUAS; do + frobbedlang=`echo $lang | sed -e 's/\..*$//' -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'` + cat >> "$ac_file.tmp" < /dev/null; then + # Add dependencies that cannot be formulated as a simple suffix rule. + for lang in $ALL_LINGUAS; do + frobbedlang=`echo $lang | sed -e 's/_/-/g' -e 's/^sr-CS/sr-SP/' -e 's/@latin$/-Latn/' -e 's/@cyrillic$/-Cyrl/' -e 's/^sr-SP$/sr-SP-Latn/' -e 's/^uz-UZ$/uz-UZ-Latn/'` + cat >> "$ac_file.tmp" <> "$ac_file.tmp" </dev/null \ + && break;; + esac + done]) + + if test "$gl_cv_posix_shell" != no; then + POSIX_SHELL=$gl_cv_posix_shell + PREFERABLY_POSIX_SHELL=$POSIX_SHELL + else + POSIX_SHELL= + PREFERABLY_POSIX_SHELL=/bin/sh + fi + AC_SUBST([POSIX_SHELL]) + AC_SUBST([PREFERABLY_POSIX_SHELL]) +]) diff --git a/cpp/third_party/xz-5.8.3/m4/progtest.m4 b/cpp/third_party/xz-5.8.3/m4/progtest.m4 new file mode 100644 index 0000000000..65ec1942ab --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/progtest.m4 @@ -0,0 +1,92 @@ +# progtest.m4 +# serial 10 (gettext-0.23) +dnl Copyright (C) 1996-2003, 2005, 2008-2024 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. +dnl +dnl This file can be used in projects which are not available under +dnl the GNU General Public License or the GNU Lesser General Public +dnl License but which still want to provide support for the GNU gettext +dnl functionality. +dnl Please note that the actual code of the GNU gettext library is covered +dnl by the GNU Lesser General Public License, and the rest of the GNU +dnl gettext package is covered by the GNU General Public License. +dnl They are *not* in the public domain. + +dnl Authors: +dnl Ulrich Drepper , 1996. + +AC_PREREQ([2.53]) + +# Search path for a program which passes the given test. + +dnl AM_PATH_PROG_WITH_TEST(VARIABLE, PROG-TO-CHECK-FOR, +dnl TEST-PERFORMED-ON-FOUND_PROGRAM [, VALUE-IF-NOT-FOUND [, PATH]]) +AC_DEFUN([AM_PATH_PROG_WITH_TEST], +[ +# Prepare PATH_SEPARATOR. +# The user is always right. +if test "${PATH_SEPARATOR+set}" != set; then + # Determine PATH_SEPARATOR by trying to find /bin/sh in a PATH which + # contains only /bin. Note that ksh looks also at the FPATH variable, + # so we have to set that as well for the test. + PATH_SEPARATOR=: + (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \ + && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \ + || PATH_SEPARATOR=';' + } +fi + +# Find out how to test for executable files. Don't use a zero-byte file, +# as systems may use methods other than mode bits to determine executability. +cat >conf$$.file <<_ASEOF +#! /bin/sh +exit 0 +_ASEOF +chmod +x conf$$.file +if test -x conf$$.file >/dev/null 2>&1; then + ac_executable_p="test -x" +else + ac_executable_p="test -f" +fi +rm -f conf$$.file + +# Extract the first word of "$2", so it can be a program name with args. +set dummy $2; ac_word=[$]2 +AC_MSG_CHECKING([for $ac_word]) +AC_CACHE_VAL([ac_cv_path_$1], +[case "[$]$1" in + [[\\/]]* | ?:[[\\/]]*) + ac_cv_path_$1="[$]$1" # Let the user override the test with a path. + ;; + *) + gt_saved_IFS="$IFS"; IFS=$PATH_SEPARATOR + for ac_dir in m4_if([$5], , $PATH, [$5]); do + IFS="$gt_saved_IFS" + test -z "$ac_dir" && ac_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if $ac_executable_p "$ac_dir/$ac_word$ac_exec_ext"; then + echo "$as_me: trying $ac_dir/$ac_word..." >&AS_MESSAGE_LOG_FD + if [$3]; then + ac_cv_path_$1="$ac_dir/$ac_word$ac_exec_ext" + break 2 + fi + fi + done + done + IFS="$gt_saved_IFS" +dnl If no 4th arg is given, leave the cache variable unset, +dnl so AC_PATH_PROGS will keep looking. +m4_if([$4], , , [ test -z "[$]ac_cv_path_$1" && ac_cv_path_$1="$4" +])dnl + ;; +esac])dnl +$1="$ac_cv_path_$1" +if test m4_if([$4], , [-n "[$]$1"], ["[$]$1" != "$4"]); then + AC_MSG_RESULT([$][$1]) +else + AC_MSG_RESULT([no]) +fi +AC_SUBST([$1])dnl +]) diff --git a/cpp/third_party/xz-5.8.3/m4/tuklib_common.m4 b/cpp/third_party/xz-5.8.3/m4/tuklib_common.m4 new file mode 100644 index 0000000000..c837703406 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/tuklib_common.m4 @@ -0,0 +1,23 @@ +# SPDX-License-Identifier: 0BSD + +############################################################################# +# +# SYNOPSIS +# +# TUKLIB_COMMON +# +# DESCRIPTION +# +# Common checks for tuklib. +# +############################################################################# +# +# Author: Lasse Collin +# +############################################################################# + +AC_DEFUN_ONCE([TUKLIB_COMMON], [ +AC_REQUIRE([AC_CANONICAL_HOST]) +AC_REQUIRE([AC_PROG_CC_C99]) +AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) +])dnl diff --git a/cpp/third_party/xz-5.8.3/m4/tuklib_cpucores.m4 b/cpp/third_party/xz-5.8.3/m4/tuklib_cpucores.m4 new file mode 100644 index 0000000000..928ef3440e --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/tuklib_cpucores.m4 @@ -0,0 +1,181 @@ +# SPDX-License-Identifier: 0BSD + +############################################################################# +# +# SYNOPSIS +# +# TUKLIB_CPUCORES +# +# DESCRIPTION +# +# Check how to find out the number of available CPU cores in the system. +# This information is used by tuklib_cpucores.c. +# +# Supported methods: +# - GetSystemInfo(): Windows (including Cygwin) +# - sched_getaffinity(): glibc (GNU/Linux, GNU/kFreeBSD) +# - cpuset_getaffinity(): FreeBSD +# - sysctl(): BSDs, OS/2 +# - sysconf(): GNU/Linux, Solaris, Tru64, IRIX, AIX, QNX, Cygwin (but +# GetSystemInfo() is used on Cygwin) +# - pstat_getdynamic(): HP-UX +# +############################################################################# +# +# Author: Lasse Collin +# +############################################################################# + +AC_DEFUN_ONCE([TUKLIB_CPUCORES], [ +AC_REQUIRE([TUKLIB_COMMON]) + +# sys/param.h might be needed by sys/sysctl.h. +AC_CHECK_HEADERS([sys/param.h]) + +AC_CACHE_CHECK([how to detect the number of available CPU cores], + [tuklib_cv_cpucores_method], [ + +# Maybe checking $host_os would be enough but this matches what +# tuklib_cpucores.c does. +# +# NOTE: IRIX has a compiler that doesn't error out with #error, so use +# a non-compilable text instead of #error to generate an error. +AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ +#if defined(_WIN32) || defined(__CYGWIN__) +int main(void) { return 0; } +#else +compile error +#endif +]])], [tuklib_cv_cpucores_method=special], [ + +# glibc-based systems (GNU/Linux and GNU/kFreeBSD) have sched_getaffinity(). +# The CPU_COUNT() macro was added in glibc 2.9 so we try to link the +# test program instead of merely compiling it. glibc 2.9 is old enough that +# if someone uses the code on older glibc, the fallback to sysconf() should +# be good enough. +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#include +int +main(void) +{ + cpu_set_t cpu_mask; + sched_getaffinity(0, sizeof(cpu_mask), &cpu_mask); + return CPU_COUNT(&cpu_mask); +} +]])], [tuklib_cv_cpucores_method=sched_getaffinity], [ + +# FreeBSD has both cpuset and sysctl. Look for cpuset first because +# it's a better approach. +# +# This test would match on GNU/kFreeBSD too but it would require +# -lfreebsd-glue when linking and thus in the current form this would +# fail on GNU/kFreeBSD. The above test for sched_getaffinity() matches +# on GNU/kFreeBSD so the test below should never run on that OS. +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#include +#include + +int +main(void) +{ + cpuset_t set; + cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, + sizeof(set), &set); + return 0; +} +]])], [tuklib_cv_cpucores_method=cpuset], [ + +# On OS/2, both sysconf() and sysctl() pass the tests in this file, +# but only sysctl() works. On QNX it's the opposite: only sysconf() works +# (although it assumes that _POSIX_SOURCE, _XOPEN_SOURCE, and _POSIX_C_SOURCE +# are undefined or alternatively _QNX_SOURCE is defined). +# +# We test sysctl() first and intentionally break the sysctl() test on QNX +# so that sysctl() is never used on QNX. +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#ifdef __QNX__ +compile error +#endif +#ifdef HAVE_SYS_PARAM_H +# include +#endif +#include +int +main(void) +{ +#ifdef HW_NCPUONLINE + /* This is preferred on OpenBSD, see tuklib_cpucores.c. */ + int name[2] = { CTL_HW, HW_NCPUONLINE }; +#else + int name[2] = { CTL_HW, HW_NCPU }; +#endif + int cpus; + size_t cpus_size = sizeof(cpus); + sysctl(name, 2, &cpus, &cpus_size, NULL, 0); + return 0; +} +]])], [tuklib_cv_cpucores_method=sysctl], [ + +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#include +int +main(void) +{ + long i; +#ifdef _SC_NPROCESSORS_ONLN + /* Many systems using sysconf() */ + i = sysconf(_SC_NPROCESSORS_ONLN); +#else + /* IRIX */ + i = sysconf(_SC_NPROC_ONLN); +#endif + return 0; +} +]])], [tuklib_cv_cpucores_method=sysconf], [ + +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#include +#include + +int +main(void) +{ + struct pst_dynamic pst; + pstat_getdynamic(&pst, sizeof(pst), 1, 0); + (void)pst.psd_proc_cnt; + return 0; +} +]])], [tuklib_cv_cpucores_method=pstat_getdynamic], [ + + tuklib_cv_cpucores_method=unknown +])])])])])])]) + +case $tuklib_cv_cpucores_method in + sched_getaffinity) + AC_DEFINE([TUKLIB_CPUCORES_SCHED_GETAFFINITY], [1], + [Define to 1 if the number of available CPU cores + can be detected with sched_getaffinity()]) + ;; + cpuset) + AC_DEFINE([TUKLIB_CPUCORES_CPUSET], [1], + [Define to 1 if the number of available CPU cores + can be detected with cpuset(2).]) + ;; + sysctl) + AC_DEFINE([TUKLIB_CPUCORES_SYSCTL], [1], + [Define to 1 if the number of available CPU cores + can be detected with sysctl().]) + ;; + sysconf) + AC_DEFINE([TUKLIB_CPUCORES_SYSCONF], [1], + [Define to 1 if the number of available CPU cores + can be detected with sysconf(_SC_NPROCESSORS_ONLN) + or sysconf(_SC_NPROC_ONLN).]) + ;; + pstat_getdynamic) + AC_DEFINE([TUKLIB_CPUCORES_PSTAT_GETDYNAMIC], [1], + [Define to 1 if the number of available CPU cores + can be detected with pstat_getdynamic().]) + ;; +esac +])dnl diff --git a/cpp/third_party/xz-5.8.3/m4/tuklib_integer.m4 b/cpp/third_party/xz-5.8.3/m4/tuklib_integer.m4 new file mode 100644 index 0000000000..29f2c95f8b --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/tuklib_integer.m4 @@ -0,0 +1,260 @@ +# SPDX-License-Identifier: 0BSD + +############################################################################# +# +# SYNOPSIS +# +# TUKLIB_INTEGER +# +# DESCRIPTION +# +# Checks for tuklib_integer.h: +# - Endianness +# - Does the compiler or the operating system provide byte swapping macros +# - Does the hardware support fast unaligned access to 16-bit, 32-bit, +# and 64-bit integers +# +############################################################################# +# +# Author: Lasse Collin +# +############################################################################# + +AC_DEFUN_ONCE([TUKLIB_INTEGER], [ +AC_REQUIRE([TUKLIB_COMMON]) +AC_REQUIRE([AC_C_BIGENDIAN]) + +AC_MSG_CHECKING([if __builtin_bswap16/32/64 are supported]) +AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], + [[__builtin_bswap16(1); + __builtin_bswap32(1); + __builtin_bswap64(1);]])], +[ + AC_DEFINE([HAVE___BUILTIN_BSWAPXX], [1], + [Define to 1 if the GNU C extensions + __builtin_bswap16/32/64 are supported.]) + AC_MSG_RESULT([yes]) +], [ + AC_MSG_RESULT([no]) + + # Look for other byteswapping methods. + AC_CHECK_HEADERS([byteswap.h sys/endian.h sys/byteorder.h], [break]) + + # Even if we have byteswap.h we may lack the specific macros/functions. + if test x$ac_cv_header_byteswap_h = xyes ; then + m4_foreach([FUNC], [bswap_16,bswap_32,bswap_64], [ + AC_MSG_CHECKING([if FUNC is available]) + AC_LINK_IFELSE([AC_LANG_SOURCE([ +#include +int +main(void) +{ + FUNC[](42); + return 0; +} + ])], [ + AC_DEFINE(HAVE_[]m4_toupper(FUNC), [1], + [Define to 1 if] FUNC [is available.]) + AC_MSG_RESULT([yes]) + ], [AC_MSG_RESULT([no])]) + + ])dnl + 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 + with 16-bit, 32-bit, and 64-bit integers. By default, + this is enabled on x86, x86-64, + 32/64-bit big endian PowerPC, + 64-bit little endian PowerPC, + and some ARM, ARM64, and RISC-V systems.]), + [], [enable_unaligned_access=auto]) +if test "x$enable_unaligned_access" = xauto ; then + # NOTE: There might be other architectures on which unaligned access + # is fast. + case $host_cpu in + i?86|x86_64|powerpc|powerpc64|powerpc64le) + enable_unaligned_access=yes + ;; + 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-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]) + ;; + 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 + ;; + esac +fi +if test "x$enable_unaligned_access" = xyes ; then + AC_DEFINE([TUKLIB_FAST_UNALIGNED_ACCESS], [1], [Define to 1 if + the system supports fast unaligned access to 16-bit, + 32-bit, and 64-bit integers.]) + AC_MSG_RESULT([yes]) +else + AC_MSG_RESULT([no]) +fi + +AC_MSG_CHECKING([if unsafe type punning should be used]) +AC_ARG_ENABLE([unsafe-type-punning], + AS_HELP_STRING([--enable-unsafe-type-punning], + [This introduces strict aliasing violations and may result + in broken code. However, this might improve performance in + some cases, especially with old compilers (e.g. + GCC 3 and early 4.x on x86, GCC < 6 on ARMv6 and ARMv7).]), + [], [enable_unsafe_type_punning=no]) +if test "x$enable_unsafe_type_punning" = xyes ; then + AC_DEFINE([TUKLIB_USE_UNSAFE_TYPE_PUNNING], [1], [Define to 1 to use + unsafe type punning, e.g. char *x = ...; *(int *)x = 123; + which violates strict aliasing rules and thus is + undefined behavior and might result in broken code.]) + AC_MSG_RESULT([yes]) +else + AC_MSG_RESULT([no]) +fi + +AC_MSG_CHECKING([if __builtin_assume_aligned is supported]) +AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[__builtin_assume_aligned("", 1);]])], + [ + AC_DEFINE([HAVE___BUILTIN_ASSUME_ALIGNED], [1], + [Define to 1 if the GNU C extension + __builtin_assume_aligned is supported.]) + AC_MSG_RESULT([yes]) + ], [ + AC_MSG_RESULT([no]) + ]) +])dnl diff --git a/cpp/third_party/xz-5.8.3/m4/tuklib_mbstr.m4 b/cpp/third_party/xz-5.8.3/m4/tuklib_mbstr.m4 new file mode 100644 index 0000000000..98b1d7a3d9 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/tuklib_mbstr.m4 @@ -0,0 +1,31 @@ +# SPDX-License-Identifier: 0BSD + +############################################################################# +# +# SYNOPSIS +# +# TUKLIB_MBSTR +# +# DESCRIPTION +# +# Check if multibyte and wide character functionality is available +# for use by tuklib_mbstr_* functions. If not enough multibyte string +# support is available in the C library, the functions keep working +# with the assumption that all strings are a in single-byte character +# set without combining characters, e.g. US-ASCII or ISO-8859-*. +# +# This .m4 file and tuklib_mbstr.h are common to all tuklib_mbstr_* +# functions, but each function is put into a separate .c file so +# that it is possible to pick only what is strictly needed. +# +############################################################################# +# +# Author: Lasse Collin +# +############################################################################# + +AC_DEFUN_ONCE([TUKLIB_MBSTR], [ +AC_REQUIRE([TUKLIB_COMMON]) +AC_FUNC_MBRTOWC +AC_CHECK_FUNCS([wcwidth vasprintf]) +])dnl diff --git a/cpp/third_party/xz-5.8.3/m4/tuklib_physmem.m4 b/cpp/third_party/xz-5.8.3/m4/tuklib_physmem.m4 new file mode 100644 index 0000000000..4bffe858a9 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/tuklib_physmem.m4 @@ -0,0 +1,217 @@ +# SPDX-License-Identifier: 0BSD + +############################################################################# +# +# SYNOPSIS +# +# TUKLIB_PHYSMEM +# +# DESCRIPTION +# +# Check how to get the amount of physical memory. +# This information is used in tuklib_physmem.c. +# +# Supported methods: +# +# - Windows (including Cygwin), OS/2, DJGPP (DOS), OpenVMS, AROS, +# and QNX have operating-system specific functions. +# +# - AIX has _system_configuration.physmem. +# +# - sysconf() works on GNU/Linux and Solaris, and possibly on +# some BSDs. +# +# - BSDs use sysctl(). +# +# - Tru64 uses getsysinfo(). +# +# - HP-UX uses pstat_getstatic(). +# +# - IRIX has setinvent_r(), getinvent_r(), and endinvent_r(). +# +# - sysinfo() works on Linux/dietlibc and probably on other Linux +# systems whose libc may lack sysconf(). +# +############################################################################# +# +# Author: Lasse Collin +# +############################################################################# + +AC_DEFUN_ONCE([TUKLIB_PHYSMEM], [ +AC_REQUIRE([TUKLIB_COMMON]) + +# sys/param.h might be needed by sys/sysctl.h. +AC_CHECK_HEADERS([sys/param.h]) + +AC_CACHE_CHECK([how to detect the amount of physical memory], + [tuklib_cv_physmem_method], [ + +# Maybe checking $host_os would be enough but this matches what +# tuklib_physmem.c does. +# +# NOTE: IRIX has a compiler that doesn't error out with #error, so use +# a non-compilable text instead of #error to generate an error. +AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ +#if defined(_WIN32) || defined(__CYGWIN__) || defined(__OS2__) \ + || defined(__DJGPP__) || defined(__VMS) \ + || defined(AMIGA) || defined(__AROS__) || defined(__QNX__) +int main(void) { return 0; } +#else +compile error +#endif +]])], [tuklib_cv_physmem_method=special], [ + +# Look for AIX-specific solution before sysconf(), because the test +# for sysconf() will pass on AIX but won't actually work +# (sysconf(_SC_PHYS_PAGES) compiles but always returns -1 on AIX). +# +# NOTE: There is no need to link the check program because it's not calling +# any functions and thus implicit function declarations aren't a problem. +# The unused reference to _system_configuration.physmem might get optimized +# away, and thus the linker might not see that symbol anyway. +AC_COMPILE_IFELSE([AC_LANG_SOURCE([[ +#include + +int +main(void) +{ + (void)_system_configuration.physmem; + return 0; +} +]])], [tuklib_cv_physmem_method=aix], [ + +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#include +int +main(void) +{ + long i; + i = sysconf(_SC_PAGESIZE); + i = sysconf(_SC_PHYS_PAGES); + return 0; +} +]])], [tuklib_cv_physmem_method=sysconf], [ + +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#ifdef HAVE_SYS_PARAM_H +# include +#endif +#include +int +main(void) +{ + int name[2] = { CTL_HW, HW_PHYSMEM }; + unsigned long mem; + size_t mem_ptr_size = sizeof(mem); + sysctl(name, 2, &mem, &mem_ptr_size, NULL, 0); + return 0; +} +]])], [tuklib_cv_physmem_method=sysctl], [ + +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#include +#include + +int +main(void) +{ + int memkb; + int start = 0; + getsysinfo(GSI_PHYSMEM, (caddr_t)&memkb, sizeof(memkb), &start); + return 0; +} +]])], [tuklib_cv_physmem_method=getsysinfo],[ + +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#include +#include + +int +main(void) +{ + struct pst_static pst; + pstat_getstatic(&pst, sizeof(pst), 1, 0); + (void)pst.physical_memory; + (void)pst.page_size; + return 0; +} +]])], [tuklib_cv_physmem_method=pstat_getstatic],[ + +AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#include +int +main(void) +{ + inv_state_t *st = NULL; + setinvent_r(&st); + getinvent_r(st); + endinvent_r(st); + return 0; +} +]])], [tuklib_cv_physmem_method=getinvent_r], [ + +# This version of sysinfo() is Linux-specific. Some non-Linux systems have +# different sysinfo() so we must check $host_os. +case $host_os in + linux*) + AC_LINK_IFELSE([AC_LANG_SOURCE([[ +#include +int +main(void) +{ + struct sysinfo si; + sysinfo(&si); + return 0; +} + ]])], [ + tuklib_cv_physmem_method=sysinfo + ], [ + tuklib_cv_physmem_method=unknown + ]) + ;; + *) + tuklib_cv_physmem_method=unknown + ;; +esac +])])])])])])])]) + +case $tuklib_cv_physmem_method in + aix) + AC_DEFINE([TUKLIB_PHYSMEM_AIX], [1], + [Define to 1 if the amount of physical memory + can be detected with _system_configuration.physmem.]) + ;; + sysconf) + AC_DEFINE([TUKLIB_PHYSMEM_SYSCONF], [1], + [Define to 1 if the amount of physical memory can + be detected with sysconf(_SC_PAGESIZE) and + sysconf(_SC_PHYS_PAGES).]) + ;; + sysctl) + AC_DEFINE([TUKLIB_PHYSMEM_SYSCTL], [1], + [Define to 1 if the amount of physical memory can + be detected with sysctl().]) + ;; + getsysinfo) + AC_DEFINE([TUKLIB_PHYSMEM_GETSYSINFO], [1], + [Define to 1 if the amount of physical memory can + be detected with getsysinfo().]) + ;; + pstat_getstatic) + AC_DEFINE([TUKLIB_PHYSMEM_PSTAT_GETSTATIC], [1], + [Define to 1 if the amount of physical memory can + be detected with pstat_getstatic().]) + ;; + getinvent_r) + AC_DEFINE([TUKLIB_PHYSMEM_GETINVENT_R], [1], + [Define to 1 if the amount of physical memory + can be detected with getinvent_r().]) + ;; + sysinfo) + AC_DEFINE([TUKLIB_PHYSMEM_SYSINFO], [1], + [Define to 1 if the amount of physical memory + can be detected with Linux sysinfo().]) + ;; +esac +])dnl diff --git a/cpp/third_party/xz-5.8.3/m4/tuklib_progname.m4 b/cpp/third_party/xz-5.8.3/m4/tuklib_progname.m4 new file mode 100644 index 0000000000..b70d063ff0 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/tuklib_progname.m4 @@ -0,0 +1,29 @@ +# SPDX-License-Identifier: 0BSD + +############################################################################# +# +# SYNOPSIS +# +# TUKLIB_PROGNAME +# +# DESCRIPTION +# +# Put argv[0] into a global variable progname. On DOS-like systems, +# modify it so that it looks nice (no full path or .exe suffix). +# +# This .m4 file is needed allow this module to use glibc's +# program_invocation_name. +# +############################################################################# +# +# Author: Lasse Collin +# +############################################################################# + +AC_DEFUN_ONCE([TUKLIB_PROGNAME], [ +AC_REQUIRE([TUKLIB_COMMON]) +AC_CHECK_DECL([program_invocation_name], [AC_DEFINE( + [HAVE_PROGRAM_INVOCATION_NAME], [1], + [Define to 1 if 'program_invocation_name' is declared in .])], + [], [#include ]) +])dnl diff --git a/cpp/third_party/xz-5.8.3/m4/visibility.m4 b/cpp/third_party/xz-5.8.3/m4/visibility.m4 new file mode 100644 index 0000000000..4a741c5eab --- /dev/null +++ b/cpp/third_party/xz-5.8.3/m4/visibility.m4 @@ -0,0 +1,85 @@ +dnl SPDX-License-Identifier: FSFULLR + +# visibility.m4 +# serial 9 +dnl Copyright (C) 2005, 2008, 2010-2024 Free Software Foundation, Inc. +dnl This file is free software; the Free Software Foundation +dnl gives unlimited permission to copy and/or distribute it, +dnl with or without modifications, as long as this notice is preserved. + +dnl From Bruno Haible. + +dnl Tests whether the compiler supports the command-line option +dnl -fvisibility=hidden and the function and variable attributes +dnl __attribute__((__visibility__("hidden"))) and +dnl __attribute__((__visibility__("default"))). +dnl Does *not* test for __visibility__("protected") - which has tricky +dnl semantics (see the 'vismain' test in glibc) and does not exist e.g. on +dnl Mac OS X. +dnl Does *not* test for __visibility__("internal") - which has processor +dnl dependent semantics. +dnl Does *not* test for #pragma GCC visibility push(hidden) - which is +dnl "really only recommended for legacy code". +dnl Set the variable CFLAG_VISIBILITY. +dnl Defines and sets the variable HAVE_VISIBILITY. + +AC_DEFUN([gl_VISIBILITY], +[ + AC_REQUIRE([AC_PROG_CC]) + CFLAG_VISIBILITY= + HAVE_VISIBILITY=0 + if test -n "$GCC"; then + dnl First, check whether -Werror can be added to the command line, or + dnl whether it leads to an error because of some other option that the + dnl user has put into $CC $CFLAGS $CPPFLAGS. + AC_CACHE_CHECK([whether the -Werror option is usable], + [gl_cv_cc_vis_werror], + [gl_saved_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -Werror" + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM([[]], [[]])], + [gl_cv_cc_vis_werror=yes], + [gl_cv_cc_vis_werror=no]) + CFLAGS="$gl_saved_CFLAGS" + ]) + dnl Now check whether visibility declarations are supported. + AC_CACHE_CHECK([for simple visibility declarations], + [gl_cv_cc_visibility], + [gl_saved_CFLAGS="$CFLAGS" + CFLAGS="$CFLAGS -fvisibility=hidden" + dnl We use the option -Werror and a function dummyfunc, because on some + dnl platforms (Cygwin 1.7) the use of -fvisibility triggers a warning + dnl "visibility attribute not supported in this configuration; ignored" + dnl at the first function definition in every compilation unit, and we + dnl don't want to use the option in this case. + if test $gl_cv_cc_vis_werror = yes; then + CFLAGS="$CFLAGS -Werror" + fi + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [[extern __attribute__((__visibility__("hidden"))) int hiddenvar; + extern __attribute__((__visibility__("default"))) int exportedvar; + extern __attribute__((__visibility__("hidden"))) int hiddenfunc (void); + extern __attribute__((__visibility__("default"))) int exportedfunc (void); + void dummyfunc (void); + int hiddenvar; + int exportedvar; + int hiddenfunc (void) { return 51; } + int exportedfunc (void) { return 1225736919; } + void dummyfunc (void) {} + ]], + [[]])], + [gl_cv_cc_visibility=yes], + [gl_cv_cc_visibility=no]) + CFLAGS="$gl_saved_CFLAGS" + ]) + if test $gl_cv_cc_visibility = yes; then + CFLAG_VISIBILITY="-fvisibility=hidden" + HAVE_VISIBILITY=1 + fi + fi + AC_SUBST([CFLAG_VISIBILITY]) + AC_SUBST([HAVE_VISIBILITY]) + AC_DEFINE_UNQUOTED([HAVE_VISIBILITY], [$HAVE_VISIBILITY], + [Define to 1 or 0, depending whether the compiler supports simple visibility declarations.]) +]) diff --git a/cpp/third_party/xz-5.8.3/po/LINGUAS b/cpp/third_party/xz-5.8.3/po/LINGUAS new file mode 100644 index 0000000000..67e9a8b9a7 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/LINGUAS @@ -0,0 +1,25 @@ +ca +cs +da +de +eo +es +fi +fr +hr +hu +it +ka +ko +nl +pl +pt +pt_BR +ro +sr +sv +tr +uk +vi +zh_CN +zh_TW diff --git a/cpp/third_party/xz-5.8.3/po/Makefile.in.in b/cpp/third_party/xz-5.8.3/po/Makefile.in.in new file mode 100644 index 0000000000..acff1e1bee --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/Makefile.in.in @@ -0,0 +1,517 @@ +# Makefile for PO directory in any package using GNU gettext. +# Copyright (C) 1995-2000 Ulrich Drepper +# Copyright (C) 2000-2024 Free Software Foundation, Inc. +# +# Copying and distribution of this file, with or without modification, +# are permitted in any medium without royalty provided the copyright +# notice and this notice are preserved. This file is offered as-is, +# without any warranty. +# +# Origin: gettext-0.23 +GETTEXT_MACRO_VERSION = 0.22 + +PACKAGE = @PACKAGE@ +VERSION = @VERSION@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ + +SED = @SED@ +SHELL = /bin/sh +@SET_MAKE@ + +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ +VPATH = @srcdir@ + +prefix = @prefix@ +exec_prefix = @exec_prefix@ +datarootdir = @datarootdir@ +datadir = @datadir@ +localedir = @localedir@ +gettextsrcdir = $(datadir)/gettext/po + +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ + +# We use $(mkdir_p). +# In automake <= 1.9.x, $(mkdir_p) is defined either as "mkdir -p --" or as +# "$(mkinstalldirs)" or as "$(install_sh) -d". For these automake versions, +# @install_sh@ does not start with $(SHELL), so we add it. +# In automake >= 1.10, @mkdir_p@ is derived from ${MKDIR_P}, which is defined +# either as "/path/to/mkdir -p" or ".../install-sh -c -d". For these automake +# versions, $(mkinstalldirs) and $(install_sh) are unused. +mkinstalldirs = $(SHELL) @install_sh@ -d +install_sh = $(SHELL) @install_sh@ +MKDIR_P = @MKDIR_P@ +mkdir_p = @mkdir_p@ + +# When building gettext-tools, we prefer to use the built programs +# rather than installed programs. However, we can't do that when we +# are cross compiling. +CROSS_COMPILING = @CROSS_COMPILING@ + +GMSGFMT_ = @GMSGFMT@ +GMSGFMT_no = @GMSGFMT@ +GMSGFMT_yes = @GMSGFMT_015@ +GMSGFMT = $(GMSGFMT_$(USE_MSGCTXT)) +XGETTEXT_ = @XGETTEXT@ +XGETTEXT_no = @XGETTEXT@ +XGETTEXT_yes = @XGETTEXT_015@ +XGETTEXT = $(XGETTEXT_$(USE_MSGCTXT)) +MSGMERGE = @MSGMERGE@ +MSGMERGE_UPDATE = @MSGMERGE@ --update +MSGMERGE_FOR_MSGFMT_OPTION = @MSGMERGE_FOR_MSGFMT_OPTION@ +MSGINIT = msginit +MSGCONV = msgconv +MSGFILTER = msgfilter + +POFILES = @POFILES@ +GMOFILES = @GMOFILES@ +UPDATEPOFILES = @UPDATEPOFILES@ +DUMMYPOFILES = @DUMMYPOFILES@ +DISTFILES.common = Makefile.in.in remove-potcdate.sed \ +$(DISTFILES.common.extra1) $(DISTFILES.common.extra2) $(DISTFILES.common.extra3) +DISTFILES = $(DISTFILES.common) Makevars POTFILES.in \ +$(POFILES) $(GMOFILES) \ +$(DISTFILES.extra1) $(DISTFILES.extra2) $(DISTFILES.extra3) + +POTFILES = \ + +CATALOGS = @CATALOGS@ + +POFILESDEPS_ = $(srcdir)/$(DOMAIN).pot +POFILESDEPS_yes = $(POFILESDEPS_) +POFILESDEPS_no = +POFILESDEPS = $(POFILESDEPS_$(PO_DEPENDS_ON_POT)) + +DISTFILESDEPS_ = update-po +DISTFILESDEPS_yes = $(DISTFILESDEPS_) +DISTFILESDEPS_no = +DISTFILESDEPS = $(DISTFILESDEPS_$(DIST_DEPENDS_ON_UPDATE_PO)) + +# Makevars gets inserted here. (Don't remove this line!) + +all: all-@USE_NLS@ + + +.SUFFIXES: +.SUFFIXES: .po .gmo .sed .nop .po-create .po-update + +# The .pot file, stamp-po, .po files, and .gmo files appear in release tarballs. +# The GNU Coding Standards say in +# : +# "GNU distributions usually contain some files which are not source files +# ... . Since these files normally appear in the source directory, they +# should always appear in the source directory, not in the build directory. +# So Makefile rules to update them should put the updated files in the +# source directory." +# Therefore we put these files in the source directory, not the build directory. + +# During .po -> .gmo conversion, take into account the most recent changes to +# the .pot file. This eliminates the need to update the .po files when the +# .pot file has changed, which would be troublesome if the .po files are put +# under version control. +$(GMOFILES): $(srcdir)/$(DOMAIN).pot +.po.gmo: + @lang=`echo $* | sed -e 's,.*/,,'`; \ + if test "$(PACKAGE)" = "gettext-tools" && test "$(CROSS_COMPILING)" != "yes"; then PATH=`pwd`/../src:$$PATH; fi; \ + test "$(srcdir)" = . && cdcmd="" || cdcmd="cd $(srcdir) && "; \ + echo "$${cdcmd}rm -f $${lang}.gmo && $(MSGMERGE) $(MSGMERGE_FOR_MSGFMT_OPTION) -o $${lang}.1po $${lang}.po $(DOMAIN).pot && $(GMSGFMT) -c --statistics --verbose -o $${lang}.gmo $${lang}.1po && rm -f $${lang}.1po"; \ + cd $(srcdir) && \ + rm -f $${lang}.gmo && \ + $(MSGMERGE) $(MSGMERGE_FOR_MSGFMT_OPTION) -o $${lang}.1po $${lang}.po $(DOMAIN).pot && \ + $(GMSGFMT) -c --statistics --verbose -o t-$${lang}.gmo $${lang}.1po && \ + mv t-$${lang}.gmo $${lang}.gmo && \ + rm -f $${lang}.1po + + +all-yes: $(srcdir)/stamp-po +all-no: + +# Ensure that the gettext macros and this Makefile.in.in are in sync. +CHECK_MACRO_VERSION = \ + test "$(GETTEXT_MACRO_VERSION)" = "@GETTEXT_MACRO_VERSION@" \ + || { echo "*** error: gettext infrastructure mismatch: using a Makefile.in.in from gettext version $(GETTEXT_MACRO_VERSION) but the autoconf macros are from gettext version @GETTEXT_MACRO_VERSION@" 1>&2; \ + exit 1; \ + } + +# $(srcdir)/$(DOMAIN).pot is only created when needed. When xgettext finds no +# internationalized messages, no $(srcdir)/$(DOMAIN).pot is created (because +# we don't want to bother translators with empty POT files). We assume that +# LINGUAS is empty in this case, i.e. $(POFILES) and $(GMOFILES) are empty. +# In this case, $(srcdir)/stamp-po is a nop (i.e. a phony target). + +# $(srcdir)/stamp-po is a timestamp denoting the last time at which the CATALOGS +# have been loosely updated. Its purpose is that when a developer or translator +# checks out the package from a version control system, and the $(DOMAIN).pot +# file is not under version control, "make" will update the $(DOMAIN).pot and +# the $(CATALOGS), but subsequent invocations of "make" will do nothing. This +# timestamp would not be necessary if updating the $(CATALOGS) would always +# touch them; however, the rule for $(POFILES) has been designed to not touch +# files that don't need to be changed. +$(srcdir)/stamp-po: $(srcdir)/$(DOMAIN).pot + @$(CHECK_MACRO_VERSION) + test ! -f $(srcdir)/$(DOMAIN).pot || \ + test -z "$(GMOFILES)" || $(MAKE) $(GMOFILES) + @test ! -f $(srcdir)/$(DOMAIN).pot || { \ + echo "touch $(srcdir)/stamp-po" && \ + echo timestamp > $(srcdir)/stamp-poT && \ + mv $(srcdir)/stamp-poT $(srcdir)/stamp-po; \ + } + +# Note: Target 'all' must not depend on target '$(DOMAIN).pot-update', +# otherwise packages like GCC can not be built if only parts of the source +# have been downloaded. + +# This target rebuilds $(DOMAIN).pot; it is an expensive operation. +# Note that $(DOMAIN).pot is not touched if it doesn't need to be changed. +# The determination of whether the package xyz is a GNU one is based on the +# heuristic whether some file in the top level directory mentions "GNU xyz". +# If GNU 'find' is available, we avoid grepping through monster files. +$(DOMAIN).pot-update: $(POTFILES) $(srcdir)/POTFILES.in + package_gnu="$(PACKAGE_GNU)"; \ + test -n "$$package_gnu" || { \ + if { if (LC_ALL=C find --version) 2>/dev/null | grep GNU >/dev/null; then \ + LC_ALL=C find -L $(top_srcdir) -maxdepth 1 -type f -size -10000000c -exec grep -i 'GNU @PACKAGE@' /dev/null '{}' ';' 2>/dev/null; \ + else \ + LC_ALL=C grep -i 'GNU @PACKAGE@' $(top_srcdir)/* 2>/dev/null; \ + fi; \ + } | grep -v 'libtool:' >/dev/null; then \ + package_gnu=yes; \ + else \ + package_gnu=no; \ + fi; \ + }; \ + if test "$$package_gnu" = "yes"; then \ + package_prefix='GNU '; \ + else \ + package_prefix=''; \ + fi; \ + if test -n '$(MSGID_BUGS_ADDRESS)' || test '$(PACKAGE_BUGREPORT)' = '@'PACKAGE_BUGREPORT'@'; then \ + msgid_bugs_address='$(MSGID_BUGS_ADDRESS)'; \ + else \ + msgid_bugs_address='$(PACKAGE_BUGREPORT)'; \ + fi; \ + case `$(XGETTEXT) --version | sed 1q | sed -e 's,^[^0-9]*,,'` in \ + '' | 0.[0-9] | 0.[0-9].* | 0.1[0-5] | 0.1[0-5].* | 0.16 | 0.16.[0-1]*) \ + $(XGETTEXT) --default-domain=$(DOMAIN) --directory=$(top_srcdir) \ + --add-comments=TRANSLATORS: \ + --files-from=$(srcdir)/POTFILES.in \ + --copyright-holder='$(COPYRIGHT_HOLDER)' \ + --msgid-bugs-address="$$msgid_bugs_address" \ + $(XGETTEXT_OPTIONS) @XGETTEXT_EXTRA_OPTIONS@ \ + ;; \ + *) \ + $(XGETTEXT) --default-domain=$(DOMAIN) --directory=$(top_srcdir) \ + --add-comments=TRANSLATORS: \ + --files-from=$(srcdir)/POTFILES.in \ + --copyright-holder='$(COPYRIGHT_HOLDER)' \ + --package-name="$${package_prefix}@PACKAGE@" \ + --package-version='@VERSION@' \ + --msgid-bugs-address="$$msgid_bugs_address" \ + $(XGETTEXT_OPTIONS) @XGETTEXT_EXTRA_OPTIONS@ \ + ;; \ + esac + test ! -f $(DOMAIN).po || { \ + if test -f $(srcdir)/$(DOMAIN).pot-header; then \ + sed -e '1,/^#$$/d' < $(DOMAIN).po > $(DOMAIN).1po && \ + cat $(srcdir)/$(DOMAIN).pot-header $(DOMAIN).1po > $(DOMAIN).po && \ + rm -f $(DOMAIN).1po \ + || exit 1; \ + fi; \ + if test -f $(srcdir)/$(DOMAIN).pot; then \ + sed -f $(srcdir)/remove-potcdate.sed < $(srcdir)/$(DOMAIN).pot > $(DOMAIN).1po && \ + sed -f $(srcdir)/remove-potcdate.sed < $(DOMAIN).po > $(DOMAIN).2po && \ + if cmp $(DOMAIN).1po $(DOMAIN).2po >/dev/null 2>&1; then \ + rm -f $(DOMAIN).1po $(DOMAIN).2po $(DOMAIN).po; \ + else \ + rm -f $(DOMAIN).1po $(DOMAIN).2po $(srcdir)/$(DOMAIN).pot && \ + mv $(DOMAIN).po $(srcdir)/$(DOMAIN).pot; \ + fi; \ + else \ + mv $(DOMAIN).po $(srcdir)/$(DOMAIN).pot; \ + fi; \ + } + +# This rule has no dependencies: we don't need to update $(DOMAIN).pot at +# every "make" invocation, only create it when it is missing. +# Only "make $(DOMAIN).pot-update" or "make dist" will force an update. +$(srcdir)/$(DOMAIN).pot: + $(MAKE) $(DOMAIN).pot-update + +# This target rebuilds a PO file if $(DOMAIN).pot has changed. +# Note that a PO file is not touched if it doesn't need to be changed. +$(POFILES): $(POFILESDEPS) + @test -f $(srcdir)/$(DOMAIN).pot || $(MAKE) $(srcdir)/$(DOMAIN).pot + @lang=`echo $@ | sed -e 's,.*/,,' -e 's/\.po$$//'`; \ + if test -f "$(srcdir)/$${lang}.po"; then \ + if test "$(PACKAGE)" = "gettext-tools" && test "$(CROSS_COMPILING)" != "yes"; then PATH=`pwd`/../src:$$PATH; fi; \ + test "$(srcdir)" = . && cdcmd="" || cdcmd="cd $(srcdir) && "; \ + echo "$${cdcmd}$(MSGMERGE_UPDATE) --quiet $(MSGMERGE_OPTIONS) --lang=$${lang} --previous $${lang}.po $(DOMAIN).pot"; \ + cd $(srcdir) \ + && { case `$(MSGMERGE_UPDATE) --version | sed 1q | sed -e 's,^[^0-9]*,,'` in \ + '' | 0.[0-9] | 0.[0-9].* | 0.10 | 0.10.*) \ + $(MSGMERGE_UPDATE) $(MSGMERGE_OPTIONS) $${lang}.po $(DOMAIN).pot;; \ + 0.1[1-5] | 0.1[1-5].*) \ + $(MSGMERGE_UPDATE) --quiet $(MSGMERGE_OPTIONS) $${lang}.po $(DOMAIN).pot;; \ + 0.1[6-7] | 0.1[6-7].*) \ + $(MSGMERGE_UPDATE) --quiet $(MSGMERGE_OPTIONS) --previous $${lang}.po $(DOMAIN).pot;; \ + *) \ + $(MSGMERGE_UPDATE) --quiet $(MSGMERGE_OPTIONS) --lang=$${lang} --previous $${lang}.po $(DOMAIN).pot;; \ + esac; \ + }; \ + else \ + $(MAKE) $${lang}.po-create; \ + fi + + +install: install-exec install-data +install-exec: +install-data: install-data-@USE_NLS@ + if test "$(PACKAGE)" = "gettext-tools"; then \ + $(mkdir_p) $(DESTDIR)$(gettextsrcdir); \ + for file in $(DISTFILES.common) Makevars.template; do \ + $(INSTALL_DATA) $(srcdir)/$$file \ + $(DESTDIR)$(gettextsrcdir)/$$file; \ + done; \ + for file in Makevars; do \ + rm -f $(DESTDIR)$(gettextsrcdir)/$$file; \ + done; \ + else \ + : ; \ + fi +install-data-no: all +install-data-yes: all + @catalogs='$(CATALOGS)'; \ + for cat in $$catalogs; do \ + cat=`basename $$cat`; \ + lang=`echo $$cat | sed -e 's/\.gmo$$//'`; \ + dir=$(localedir)/$$lang/LC_MESSAGES; \ + $(mkdir_p) $(DESTDIR)$$dir; \ + if test -r $$cat; then realcat=$$cat; else realcat=$(srcdir)/$$cat; fi; \ + $(INSTALL_DATA) $$realcat $(DESTDIR)$$dir/$(DOMAIN).mo; \ + echo "installing $$realcat as $(DESTDIR)$$dir/$(DOMAIN).mo"; \ + for lc in '' $(EXTRA_LOCALE_CATEGORIES); do \ + if test -n "$$lc"; then \ + if (cd $(DESTDIR)$(localedir)/$$lang && LC_ALL=C ls -l -d $$lc 2>/dev/null) | grep ' -> ' >/dev/null; then \ + link=`cd $(DESTDIR)$(localedir)/$$lang && LC_ALL=C ls -l -d $$lc | sed -e 's/^.* -> //'`; \ + mv $(DESTDIR)$(localedir)/$$lang/$$lc $(DESTDIR)$(localedir)/$$lang/$$lc.old; \ + mkdir $(DESTDIR)$(localedir)/$$lang/$$lc; \ + (cd $(DESTDIR)$(localedir)/$$lang/$$lc.old && \ + for file in *; do \ + if test -f $$file; then \ + ln -s ../$$link/$$file $(DESTDIR)$(localedir)/$$lang/$$lc/$$file; \ + fi; \ + done); \ + rm -f $(DESTDIR)$(localedir)/$$lang/$$lc.old; \ + else \ + if test -d $(DESTDIR)$(localedir)/$$lang/$$lc; then \ + :; \ + else \ + rm -f $(DESTDIR)$(localedir)/$$lang/$$lc; \ + mkdir $(DESTDIR)$(localedir)/$$lang/$$lc; \ + fi; \ + fi; \ + rm -f $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo; \ + ln -s ../LC_MESSAGES/$(DOMAIN).mo $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo 2>/dev/null || \ + ln $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(DOMAIN).mo $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo 2>/dev/null || \ + cp -p $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(DOMAIN).mo $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo; \ + echo "installing $$realcat link as $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo"; \ + fi; \ + done; \ + done + +install-strip: install + +installdirs: installdirs-exec installdirs-data +installdirs-exec: +installdirs-data: installdirs-data-@USE_NLS@ + if test "$(PACKAGE)" = "gettext-tools"; then \ + $(mkdir_p) $(DESTDIR)$(gettextsrcdir); \ + else \ + : ; \ + fi +installdirs-data-no: +installdirs-data-yes: + @catalogs='$(CATALOGS)'; \ + for cat in $$catalogs; do \ + cat=`basename $$cat`; \ + lang=`echo $$cat | sed -e 's/\.gmo$$//'`; \ + dir=$(localedir)/$$lang/LC_MESSAGES; \ + $(mkdir_p) $(DESTDIR)$$dir; \ + for lc in '' $(EXTRA_LOCALE_CATEGORIES); do \ + if test -n "$$lc"; then \ + if (cd $(DESTDIR)$(localedir)/$$lang && LC_ALL=C ls -l -d $$lc 2>/dev/null) | grep ' -> ' >/dev/null; then \ + link=`cd $(DESTDIR)$(localedir)/$$lang && LC_ALL=C ls -l -d $$lc | sed -e 's/^.* -> //'`; \ + mv $(DESTDIR)$(localedir)/$$lang/$$lc $(DESTDIR)$(localedir)/$$lang/$$lc.old; \ + mkdir $(DESTDIR)$(localedir)/$$lang/$$lc; \ + (cd $(DESTDIR)$(localedir)/$$lang/$$lc.old && \ + for file in *; do \ + if test -f $$file; then \ + ln -s ../$$link/$$file $(DESTDIR)$(localedir)/$$lang/$$lc/$$file; \ + fi; \ + done); \ + rm -f $(DESTDIR)$(localedir)/$$lang/$$lc.old; \ + else \ + if test -d $(DESTDIR)$(localedir)/$$lang/$$lc; then \ + :; \ + else \ + rm -f $(DESTDIR)$(localedir)/$$lang/$$lc; \ + mkdir $(DESTDIR)$(localedir)/$$lang/$$lc; \ + fi; \ + fi; \ + fi; \ + done; \ + done + +# Define this as empty until I found a useful application. +installcheck: + +uninstall: uninstall-exec uninstall-data +uninstall-exec: +uninstall-data: uninstall-data-@USE_NLS@ + if test "$(PACKAGE)" = "gettext-tools"; then \ + for file in $(DISTFILES.common) Makevars.template; do \ + rm -f $(DESTDIR)$(gettextsrcdir)/$$file; \ + done; \ + else \ + : ; \ + fi +uninstall-data-no: +uninstall-data-yes: + catalogs='$(CATALOGS)'; \ + for cat in $$catalogs; do \ + cat=`basename $$cat`; \ + lang=`echo $$cat | sed -e 's/\.gmo$$//'`; \ + for lc in LC_MESSAGES $(EXTRA_LOCALE_CATEGORIES); do \ + rm -f $(DESTDIR)$(localedir)/$$lang/$$lc/$(DOMAIN).mo; \ + done; \ + done + +check: all + +info dvi ps pdf html tags TAGS ctags CTAGS ID: + +install-dvi install-ps install-pdf install-html: + +mostlyclean: + rm -f $(srcdir)/stamp-poT + rm -f core core.* $(DOMAIN).po $(DOMAIN).1po $(DOMAIN).2po *.new.po + rm -fr *.o + +clean: mostlyclean + +distclean: clean + rm -f Makefile Makefile.in POTFILES + +maintainer-clean: distclean + @echo "This command is intended for maintainers to use;" + @echo "it deletes files that may require special tools to rebuild." + rm -f $(srcdir)/$(DOMAIN).pot $(srcdir)/stamp-po $(GMOFILES) + +distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir) +dist distdir: + test -z "$(DISTFILESDEPS)" || $(MAKE) $(DISTFILESDEPS) + @$(MAKE) dist2 +# This is a separate target because 'update-po' must be executed before. +dist2: $(srcdir)/stamp-po $(DISTFILES) + @dists="$(DISTFILES)"; \ + if test "$(PACKAGE)" = "gettext-tools"; then \ + dists="$$dists Makevars.template"; \ + fi; \ + if test -f $(srcdir)/$(DOMAIN).pot; then \ + dists="$$dists $(DOMAIN).pot stamp-po"; \ + else \ + case $(XGETTEXT) in \ + :) echo "Warning: Creating a tarball without '$(DOMAIN).pot', because a suitable 'xgettext' program was not found in PATH." 1>&2;; \ + *) echo "Warning: Creating a tarball without '$(DOMAIN).pot', because 'xgettext' found no strings to extract. Check the contents of the POTFILES.in file and the XGETTEXT_OPTIONS in the Makevars file." 1>&2;; \ + esac; \ + fi; \ + if test -f $(srcdir)/ChangeLog; then \ + dists="$$dists ChangeLog"; \ + fi; \ + for i in 0 1 2 3 4 5 6 7 8 9; do \ + if test -f $(srcdir)/ChangeLog.$$i; then \ + dists="$$dists ChangeLog.$$i"; \ + fi; \ + done; \ + if test -f $(srcdir)/LINGUAS; then dists="$$dists LINGUAS"; fi; \ + for file in $$dists; do \ + if test -f $$file; then \ + cp -p $$file $(distdir) || exit 1; \ + else \ + cp -p $(srcdir)/$$file $(distdir) || exit 1; \ + fi; \ + done + +update-po: Makefile + $(MAKE) $(DOMAIN).pot-update + test -z "$(UPDATEPOFILES)" || $(MAKE) $(UPDATEPOFILES) + $(MAKE) update-gmo + +# General rule for creating PO files. + +.nop.po-create: + @lang=`echo $@ | sed -e 's/\.po-create$$//'`; \ + echo "File $$lang.po does not exist. If you are a translator, you can create it through 'msginit'." 1>&2; \ + exit 1 + +# General rule for updating PO files. + +.nop.po-update: + @lang=`echo $@ | sed -e 's/\.po-update$$//'`; \ + if test "$(PACKAGE)" = "gettext-tools" && test "$(CROSS_COMPILING)" != "yes"; then PATH=`pwd`/../src:$$PATH; fi; \ + tmpdir=`pwd`; \ + echo "$$lang:"; \ + test "$(srcdir)" = . && cdcmd="" || cdcmd="cd $(srcdir) && "; \ + echo "$${cdcmd}$(MSGMERGE) --quiet $(MSGMERGE_OPTIONS) --lang=$$lang --previous $$lang.po $(DOMAIN).pot -o $$lang.new.po"; \ + cd $(srcdir); \ + if { case `$(MSGMERGE) --version | sed 1q | sed -e 's,^[^0-9]*,,'` in \ + '' | 0.[0-9] | 0.[0-9].* | 0.10 | 0.10.*) \ + $(MSGMERGE) $(MSGMERGE_OPTIONS) -o $$tmpdir/$$lang.new.po $$lang.po $(DOMAIN).pot;; \ + 0.1[1-5] | 0.1[1-5].*) \ + $(MSGMERGE) --quiet $(MSGMERGE_OPTIONS) -o $$tmpdir/$$lang.new.po $$lang.po $(DOMAIN).pot;; \ + 0.1[6-7] | 0.1[6-7].*) \ + $(MSGMERGE) --quiet $(MSGMERGE_OPTIONS) --previous -o $$tmpdir/$$lang.new.po $$lang.po $(DOMAIN).pot;; \ + *) \ + $(MSGMERGE) --quiet $(MSGMERGE_OPTIONS) --lang=$$lang --previous -o $$tmpdir/$$lang.new.po $$lang.po $(DOMAIN).pot;; \ + esac; \ + }; then \ + if cmp $$lang.po $$tmpdir/$$lang.new.po >/dev/null 2>&1; then \ + rm -f $$tmpdir/$$lang.new.po; \ + else \ + if mv -f $$tmpdir/$$lang.new.po $$lang.po; then \ + :; \ + else \ + echo "msgmerge for $$lang.po failed: cannot move $$tmpdir/$$lang.new.po to $$lang.po" 1>&2; \ + exit 1; \ + fi; \ + fi; \ + else \ + echo "msgmerge for $$lang.po failed!" 1>&2; \ + rm -f $$tmpdir/$$lang.new.po; \ + fi + +$(DUMMYPOFILES): + +update-gmo: Makefile $(GMOFILES) + @: + +# Recreate Makefile by invoking config.status. Explicitly invoke the shell, +# because execution permission bits may not work on the current file system. +# Use @SHELL@, which is the shell determined by autoconf for the use by its +# scripts, not $(SHELL) which is hardwired to /bin/sh and may be deficient. +Makefile: Makefile.in.in Makevars $(top_builddir)/config.status @POMAKEFILEDEPS@ + cd $(top_builddir) \ + && @SHELL@ ./config.status $(subdir)/$@.in po-directories + +force: + +# Tell versions [3.59,3.63) of GNU make not to export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: + +# This Makefile contains rules which don't work with parallel make, +# namely dist2. +# See . +# So, turn off parallel execution in this Makefile. +.NOTPARALLEL: diff --git a/cpp/third_party/xz-5.8.3/po/Makevars b/cpp/third_party/xz-5.8.3/po/Makevars new file mode 100644 index 0000000000..b2d8a7cfbe --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/Makevars @@ -0,0 +1,91 @@ +# SPDX-License-Identifier: FSFUL + +# Makefile variables for PO directory in any package using GNU gettext. +# +# Copyright (C) 2003-2019 Free Software Foundation, Inc. +# This file is free software; the Free Software Foundation gives +# unlimited permission to use, copy, distribute, and modify it. + +# Usually the message domain is the same as the package name. +DOMAIN = $(PACKAGE) + +# These two variables depend on the location of this directory. +subdir = po +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 interpreted as a zero-width 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 +# package. (Note that the msgstr strings, extracted from the package's +# sources, belong to the copyright holder of the package.) Translators are +# expected to transfer the copyright for their translations to this person +# or entity, or to disclaim their copyright. The empty string stands for +# the public domain; in this case the translators are expected to disclaim +# their copyright. +COPYRIGHT_HOLDER = The XZ Utils authors and contributors + +# This tells whether or not to prepend "GNU " prefix to the package +# name that gets inserted into the header of the $(DOMAIN).pot file. +# Possible values are "yes", "no", or empty. If it is empty, try to +# detect it automatically by scanning the files in $(top_srcdir) for +# "GNU packagename" string. +PACKAGE_GNU = no + +# This is the email address or URL to which the translators shall report +# bugs in the untranslated strings: +# - Strings which are not entire sentences, see the maintainer guidelines +# in the GNU gettext documentation, section 'Preparing Strings'. +# - Strings which use unclear terms or require additional context to be +# understood. +# - Strings which make invalid assumptions about notation of date, time or +# money. +# - Pluralisation problems. +# - Incorrect English spelling. +# - Incorrect formatting. +# It can be your email address, or a mailing list address where translators +# can write to without being subscribed, or the URL of a web page through +# which the translators can contact you. +MSGID_BUGS_ADDRESS = + +# This is the list of locale categories, beyond LC_MESSAGES, for which the +# message catalogs shall be used. It is usually empty. +EXTRA_LOCALE_CATEGORIES = + +# This tells whether the $(DOMAIN).pot file contains messages with an 'msgctxt' +# context. Possible values are "yes" and "no". Set this to yes if the +# package uses functions taking also a message context, like pgettext(), or +# if in $(XGETTEXT_OPTIONS) you define keywords with a context argument. +USE_MSGCTXT = no + +# These options get passed to msgmerge. +# Useful options are in particular: +# --previous to keep previous msgids of translated messages, +# --quiet to reduce the verbosity. +MSGMERGE_OPTIONS = --add-location=file --no-wrap + +# These options get passed to msginit. +# If you want to disable line wrapping when writing PO files, add +# --no-wrap to MSGMERGE_OPTIONS, XGETTEXT_OPTIONS, and +# MSGINIT_OPTIONS. +# +# Although one may need slightly wider terminal than 80 chars, it is +# much nicer to edit the output of --help when --no-wrap is set. +MSGINIT_OPTIONS = --no-wrap + +# This tells whether or not to regenerate a PO file when $(DOMAIN).pot +# has changed. Possible values are "yes" and "no". Set this to no if +# the POT file is checked in the repository and the version control +# program ignores timestamps. +PO_DEPENDS_ON_POT = yes + +# This tells whether or not to forcibly update $(DOMAIN).pot and +# regenerate PO files on "make dist". Possible values are "yes" and +# "no". Set this to no if the POT file and PO files are maintained +# externally. +# +# NOTE: The the custom "mydist" target in ../Makefile.am updates xz.pot. +# An updated xz.pot will cause the .po files to be updated too but +# only when updating would change more than the POT-Creation-Date line. +DIST_DEPENDS_ON_UPDATE_PO = no diff --git a/cpp/third_party/xz-5.8.3/po/POTFILES.in b/cpp/third_party/xz-5.8.3/po/POTFILES.in new file mode 100644 index 0000000000..dead5ed430 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/POTFILES.in @@ -0,0 +1,19 @@ +# SPDX-License-Identifier: 0BSD + +# List of source files which contain translatable strings. +src/xz/args.c +src/xz/coder.c +src/xz/file_io.c +src/xz/hardware.c +src/xz/list.c +src/xz/main.c +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 +src/lzmainfo/lzmainfo.c +src/common/tuklib_exit.c +src/liblzma/common/string_conversion.c diff --git a/cpp/third_party/xz-5.8.3/po/Rules-quot b/cpp/third_party/xz-5.8.3/po/Rules-quot new file mode 100644 index 0000000000..9e13054079 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/Rules-quot @@ -0,0 +1,66 @@ +# Special Makefile rules for English message catalogs with quotation marks. +# +# Copyright (C) 2001-2024 Free Software Foundation, Inc. +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. +# This file is offered as-is, without any warranty. +# +# Written by Bruno Haible , 2001. + +DISTFILES.common.extra1 = quot.sed boldquot.sed en@quot.header en@boldquot.header insert-header.sed Rules-quot + +.SUFFIXES: .insert-header .po-update-en + +en@quot.po-create: + $(MAKE) en@quot.po-update +en@boldquot.po-create: + $(MAKE) en@boldquot.po-update + +en@quot.po-update: en@quot.po-update-en +en@boldquot.po-update: en@boldquot.po-update-en + +.insert-header.po-update-en: + @lang=`echo $@ | sed -e 's/\.po-update-en$$//'`; \ + if test "$(PACKAGE)" = "gettext-tools" && test "$(CROSS_COMPILING)" != "yes"; then PATH=`pwd`/../src:$$PATH; GETTEXTLIBDIR=`cd $(top_srcdir)/src && pwd`; export GETTEXTLIBDIR; fi; \ + tmpdir=`pwd`; \ + echo "$$lang:"; \ + ll=`echo $$lang | sed -e 's/@.*//'`; \ + LC_ALL=C; export LC_ALL; \ + cd $(srcdir); \ + if $(MSGINIT) $(MSGINIT_OPTIONS) -i $(DOMAIN).pot --no-translator -l $$lang -o - 2>/dev/null \ + | $(SED) -f $$tmpdir/$$lang.insert-header | $(SED) -e '/^%%/d' \ + | $(MSGCONV) -t UTF-8 | \ + { case `$(MSGFILTER) --version | sed 1q | sed -e 's,^[^0-9]*,,'` in \ + '' | 0.[0-9] | 0.[0-9].* | 0.1[0-8] | 0.1[0-8].*) \ + $(MSGFILTER) $(SED) -f `echo $$lang | sed -e 's/.*@//'`.sed \ + ;; \ + *) \ + $(MSGFILTER) `echo $$lang | sed -e 's/.*@//'` \ + ;; \ + esac } 2>/dev/null > $$tmpdir/$$lang.new.po \ + ; then \ + if cmp $$lang.po $$tmpdir/$$lang.new.po >/dev/null 2>&1; then \ + rm -f $$tmpdir/$$lang.new.po; \ + else \ + if mv -f $$tmpdir/$$lang.new.po $$lang.po; then \ + :; \ + else \ + echo "creation of $$lang.po failed: cannot move $$tmpdir/$$lang.new.po to $$lang.po" 1>&2; \ + exit 1; \ + fi; \ + fi; \ + else \ + echo "creation of $$lang.po failed!" 1>&2; \ + rm -f $$tmpdir/$$lang.new.po; \ + fi + +en@quot.insert-header: insert-header.sed + sed -e 's/HEADER/en@quot.header/g' $(srcdir)/insert-header.sed > en@quot.insert-header + +en@boldquot.insert-header: insert-header.sed + sed -e 's/HEADER/en@boldquot.header/g' $(srcdir)/insert-header.sed > en@boldquot.insert-header + +mostlyclean: mostlyclean-quot +mostlyclean-quot: + rm -f *.insert-header diff --git a/cpp/third_party/xz-5.8.3/po/boldquot.sed b/cpp/third_party/xz-5.8.3/po/boldquot.sed new file mode 100644 index 0000000000..3c1de54e66 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/boldquot.sed @@ -0,0 +1,21 @@ +# Sed script that converts quotations, by replacing ASCII quotation marks +# with Unicode quotation marks and highlighting the quotations in bold face. +# +# Copyright (C) 2001 Free Software Foundation, Inc. +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. +# This file is offered as-is, without any warranty. +# +# Written by Bruno Haible , 2001. +# +s/"\([^"]*\)"/“\1”/g +s/`\([^`']*\)'/‘\1’/g +s/ '\([^`']*\)' / ‘\1’ /g +s/ '\([^`']*\)'$/ ‘\1’/g +s/^'\([^`']*\)' /‘\1’ /g +s/“”/""/g +s/“/“/g +s/”/”/g +s/‘/‘/g +s/’/’/g diff --git a/cpp/third_party/xz-5.8.3/po/ca.gmo b/cpp/third_party/xz-5.8.3/po/ca.gmo new file mode 100644 index 0000000000..4670cf7d2f Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/ca.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/ca.po b/cpp/third_party/xz-5.8.3/po/ca.po new file mode 100644 index 0000000000..1f22beadda --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/ca.po @@ -0,0 +1,1633 @@ +# SPDX-License-Identifier: 0BSD +# +# XZ Utils Catalan Translation +# Copyright (C) The XZ Utils authors and contributors +# This file is published under the BSD Zero Clause License. +# +# Jordi Mas i Hernàndez , 2022, 2024 +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.6.0-pre2\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: ca\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n==1) ? 0 : 1;\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: argument no vàlid per a --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: massa arguments per a --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "A --block-list, falta la mida del bloc després del número de cadena de filtres «%c:»" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 només es pot utilitzar com a últim element a --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: tipus de format de fitxer desconegut" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: tipus de comprovació d'integritat no admès" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Només es pot especificar un fitxer amb '--files' o '--files0'." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "La variable d'entorn %s conté massa arguments" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "El suport de compressió s'ha desactivat en temps de construcció" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "El suport de descompressió s'ha desactivat en temps de construcció" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "No s'admet la compressió de fitxers lzip (.lz)" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list s'ignora a menys que es comprimeixi al format .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Amb --format=raw, --suffix=.SUF és necessari si no s'escriu a la sortida estàndard" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "El nombre màxim de filtres és de quatre" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Error a l'opció --filters%s=FILTERS:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "El límit d'ús de la memòria és massa baix per a la configuració del filtre indicat." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "cadena de filtres %u utilitzada per --block-list però no especificada amb --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Es desaconsella l'ús d'un predefinit en mode RAW." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Les opcions exactes dels predefinits poden variar entre versions de programari." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "El format .lzma només admet el filtre LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "No es pot usar LZMA1 amb el format .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "La cadena de filtres %u és incompatible amb --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Es canvia al mode d'un sol fil a causa de --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Opcions no admeses a la cadena de filtres %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "S'utilitzen fins a % fils." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Cadena de filtres o opcions de filtre no admeses" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "La descompressió necessitarà %s MiB de memòria." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "S'ha reduït el nombre de fils de %s a %s per a no excedir el límit d'ús de memòria de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "S'ha reduït el nombre de fils de %s a un. El límit d'ús automàtic de memòria de %s MiB encara s'està excedint. Es requereix %s MiB de memòria. Es continua igualment." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "S'està canviant al mode d'un sol fil per a no excedir el límit d'ús de la memòria de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "S'ha ajustat la mida del diccionari LZMA%c de %s MiB a %s MiB per a no excedir el límit d'ús de memòria de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "S'ha ajustat la mida del diccionari LZMA%c per a --filters%u de %s MiB a %s MiBper a no excedir el límit d'ús de memòria de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "S'ha produït un error en canviar a la cadena de filtres %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "S'ha produït un error en crear una canonada: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: ha fallat la funció poll(): %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: sembla que el fitxer s'ha mogut, no s'elimina" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: no es pot eliminar: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: no es pot establir el propietari del fitxer: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: no es pot establir el grup de fitxers: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: no es poden establir els permisos del fitxer: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: ha fallat el tancament del fitxer: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: ha fallat el tancament del fitxer: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "S'ha produït un error en obtenir els indicadors d'estat del fitxer de l'entrada estàndard: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: és un enllaç simbòlic, s'omet" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: és un directori, s'omet" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: no és un fitxer normal, s'omet" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: el fitxer té el bit de setuid o setgid, s'omet" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: el fitxer té un bit enganxós, s'omet" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: el fitxer d'entrada té més d'un enllaç dur, s'omet" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Nom de fitxer buit, s'omet" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "S'ha produït un error en restaurar els indicadors d'estat a l'entrada estàndard: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "S'ha produït un error en obtenir els indicadors d'estat del fitxer de la sortida estàndard: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Opening the directory failed: %s" +msgstr "%s: ha fallat el tancament del fitxer: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Not a regular file, skipping" +msgid "%s: Destination is not a regular file" +msgstr "%s: no és un fitxer normal, s'omet" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "S'ha produït un error en restaurar l'indicador O_APPEND a la sortida estàndard: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: ha fallat el tancament del fitxer: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: ha fallat la cerca en intentar crear un fitxer dispers: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: error de lectura: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: error en cercar el fitxer: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: fi inesperat del fitxer" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: error d'escriptura: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Desactivat" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Quantitat de memòria física (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Nombre de fils del processador:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Compressió:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Descompressió:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Descompressió multifil:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Predeterminat per a -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Informació del maquinari:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Límits d'ús de la memòria:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Fluxos:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blocs:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Mida comprimida:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Mida no comprimida:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Relació:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Comprovació:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Farciment del flux:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Memòria necessària:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Mides a les capçaleres:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Nombre de fitxers:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Flux" + +#: src/xz/list.c +msgid "Block" +msgstr "Bloc" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blocs" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "CompOffset" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "UncompOffset" + +#: src/xz/list.c +msgid "CompSize" +msgstr "CompSize" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "UncompSize" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "TotalSize" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Relació" + +#: src/xz/list.c +msgid "Check" +msgstr "Comprovació" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "CheckVal" + +#: src/xz/list.c +msgid "Padding" +msgstr "Separació" + +#: src/xz/list.c +msgid "Header" +msgstr "Capçalera" + +#: src/xz/list.c +msgid "Flags" +msgstr "Senyals" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "MemUsage" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filtres" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Cap" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "NoConeix2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "NoConeix3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "NoConeix5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "NoConeix6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "NoConeix7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "NoConeix8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "NoConeix9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "NoConeix11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "NoConeix12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "NoConeix13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "NoConeix14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "NoConeix15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: El fitxer està buit" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Massa petit per a ser un fitxer .xz vàlid" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Strms Blocs Comprimit NoComprimit Ràtio Check Nom de fitxer" + +#: src/xz/list.c +msgid "Yes" +msgstr "Sí" + +#: src/xz/list.c +msgid "No" +msgstr "No" + +#: src/xz/list.c +#, fuzzy +#| msgid " Minimum XZ Utils version: %s\n" +msgid "Minimum XZ Utils version:" +msgstr " Versió mínima de XZ Utils: %s\n" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s fitxer\n" +msgstr[1] "%s fitxers\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Totals:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list només funciona en fitxers .xz (--format=xz o --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Proveu «lzmainfo» amb fitxers .lzma." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list no admet la lectura des de l'entrada estàndard" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Error en llegir els noms de fitxer: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Final inesperat de l'entrada en llegir els noms de fitxer" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: S'ha trobat un caràcter nul en llegir els noms de fitxer. Potser volíeu utilitzar «--files0» en comptes de «--files»?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "La compressió i descompressió amb --robot encara no són admesos." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "No es poden llegir les dades de l'entrada estàndard en llegir els noms de fitxer de l'entrada estàndard" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Error intern (error)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "No es poden establir els gestors de senyals" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Sense comprovació d'integritat; no es verifica la integritat del fitxer" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Tipus no admès de comprovació d'integritat; no es verifica la integritat del fitxer" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "S'ha arribat al límit d'ús de la memòria" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "No s'ha reconegut el format del fitxer" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Opcions no admeses" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Les dades comprimides estan malmeses" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Final inesperat de l'entrada" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "Es requereixen %s MiB de memòria. El limitador està desactivat." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "Es requereixen %s MiB de memòria. El límit és %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Cadena de filtres: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Proveu «%s --help» per a més informació." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the 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 "" +#| "Usage: %s [OPTION]... [FILE]...\n" +#| "Compress or decompress FILEs in the .xz format.\n" +#| "\n" +msgid "Compress or decompress FILEs in the .xz format." +msgstr "" +"Ús: %s [OPCIÓ]... [FITXER]...\n" +"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 interpreted as a zero-width space (the 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 "" +"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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Operation modifiers:\n" +msgid "Operation modifiers:" +msgstr "" +"\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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| " --single-stream decompress only the first stream, and silently\n" +#| " ignore possible remaining input data" +msgid "decompress only the first stream, and silently ignore possible remaining input data" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Basic file format and compression options:\n" +msgid "Basic file format and compression options:" +msgstr "" +"\n" +" Opcions bàsiques de format i compressió de fitxers:\n" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " -0 ... -9 compression preset; default is 6; take compressor *and*\n" +#| " decompressor memory usage into account before using 7-9!" +msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!" +msgstr "" +" -0 ... -9 compressió predefinida; per defecte és 6; tingueu en\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " -e, --extreme try to improve compression ratio by using more CPU time;\n" +#| " does not affect decompressor memory requirements" +msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements" +msgstr "" +" -e, --extreme intenta millorar la ràtio de compressió usant més temps\n" +" de CPU; no afecta els requisits de memòria del\n" +" descompressor" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -T, --threads=NUM use at most NUM threads; the default is 0 which uses\n" +#| " as many threads as there are processor cores" +msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores" +msgstr "" +" -T, --threads=NUM usa com a màxim NUM fils; el valor predeterminat és 0;\n" +" que utilitza tants fils com nuclis té el processador" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-size=SIZE\n" +#| " start a new .xz block after every SIZE bytes of input;\n" +#| " use this to set the block size for threaded compression" +msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression" +msgstr "" +" --block-size=MIDA\n" +" inicia un bloc nou .xz després de cada MIDA de bytes\n" +" d'entrada; utilitzeu-ho per a establir la mida del bloc\n" +" per a la compressió amb fils" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-list=BLOCKS\n" +#| " start a new .xz block after the given comma-separated\n" +#| " intervals of uncompressed data; optionally, specify a\n" +#| " filter chain number (0-9) followed by a ':' before the\n" +#| " uncompressed data size" +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 "" +" --block-list=BLOCS\n" +" inicia un bloc .xz nou després de la separació d'intervals\n" +" amb comes donada de dades sense comprimir; opcionalment,\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --flush-timeout=TIMEOUT\n" +#| " when compressing, if more than TIMEOUT milliseconds has\n" +#| " passed since the previous flush and reading more input\n" +#| " would block, all pending data is flushed out" +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 "" +" --flush-timeout=TEMPS\n" +" en comprimir, si han passat més de mil·lisegons de temps\n" +" d'espera des de l'anterior fluix i llegir més entrades\n" +" blocaria, totes les dades pendents es buiden" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --no-adjust if compression settings exceed the memory usage limit,\n" +#| " give an error instead of adjusting the settings downwards" +msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards" +msgstr "" +" --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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Custom filter chain for compression (alternative for using presets):" +msgid "Custom filter chain for compression (an alternative to using presets):" +msgstr "" +"\n" +" Cadena de filtres personalitzada per a la compressió (alternativa per a l'ús\n" +" de predefinits):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| " --filters=FILTERS set the filter chain using the liblzma filter string\n" +#| " syntax; use --filters-help for more information" +msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information" +msgstr "" +"\n" +" --filters=FILTERS estableix la cadena de filtres utilitzant la sintaxi\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --filters1=FILTERS ... --filters9=FILTERS\n" +#| " set additional filter chains using the liblzma filter\n" +#| " string syntax to use with --block-list" +msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list" +msgstr "" +" --filters1=FILTRES ... --filters9=FILTRES\n" +" estableix cadenes de filtres addicionals utilitzant\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --filters-help display more information about the liblzma filter string\n" +#| " syntax and exit." +msgid "display more information about the liblzma filter string syntax and exit" +msgstr "" +" --filters-help mostra més informació sobre la sintaxi de cadena del\n" +" filtre i surt." + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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:" +msgid "number of position bits" +msgstr "Nombre de fils del processador:" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Other options:\n" +msgid "Other options:" +msgstr "" +"\n" +" Altres opcions:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 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 interpreted as a zero-width space (the 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 "" +#| " --info-memory display the total amount of RAM and the currently active\n" +#| " memory usage limits, and exit" +msgid "display the total amount of RAM and the currently active memory usage limits, and exit" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| "With no FILE, or when FILE is -, read standard input.\n" +msgid "With no FILE, or when FILE is -, read standard input." +msgstr "" +"\n" +"Sense FITXER, o quan el FITXER és -, es llegeix l'entrada estàndard.\n" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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" +msgid "Report bugs to <%s> (in English or Finnish)." +msgstr "Informa d'errors a <%s> (en anglès o finès).\n" + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "Filter chains are set using the --filters=FILTERS or\n" +#| "--filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain\n" +#| "can be separated by spaces or '--'. Alternatively a preset <0-9>[e] can be\n" +#| "specified instead of a filter chain.\n" +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 "" +"Les cadenes de filtres s'estableixen utilitzant --filters=FILTERS o les\n" +"opcions --filters1=FILTRES ... --filters9=FILTERS. Cada filtre de la cadena\n" +"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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Options must be 'name=value' pairs separated with commas" +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "%s: les opcions han de ser parelles «name=value» separades per comes" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: nom d'opció no vàlid" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option value" +msgid "Invalid option value" +msgstr "%s: el valor de l'opció no és vàlid" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "No s'admet el LZMA1/LZMA2 predefinit: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "La suma de lc i lp no ha de superar 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: El nom de fitxer té un sufix desconegut, s'omet" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: El fitxer ja té el sufix «%s», s'ometrà" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: El sufix del nom de fitxer no és vàlid" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Value is not a non-negative decimal integer" +msgid "Value is not a non-negative decimal integer" +msgstr "%s: El valor no és un enter decimal no negatiu" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: el sufix multiplicador no és vàlid" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Els sufixos vàlids són «KiB» (2^10), «MiB» (2^20) i «GiB» (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "El valor de l'opció «%s» ha d'estar a l'interval [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Les dades comprimides no es poden llegir des d'un terminal" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Les dades comprimides no es poden escriure en un terminal" + +#: src/lzmainfo/lzmainfo.c +#, fuzzy, c-format +#| msgid "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Usage: %s [--help] [--version] [FILE]...\n" +msgstr "" +"Ú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 interpreted as a zero-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 "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Show information stored in the .lzma file header." +msgstr "" +"Ús: %s [--help] [--version] [FITXER]...\n" +"Mostra la informació emmagatzemada a la capçalera del fitxer .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "El fitxer és massa petit per a ser un fitxer .xz" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "No és un fitxer .lzma" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Ha fallat l'escriptura a la sortida estàndard" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Error desconegut" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported options" +msgid "Unsupported preset" +msgstr "Opcions no admeses" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported filter chain or filter options" +msgid "Unsupported flag in the preset" +msgstr "Cadena de filtres o opcions de filtre no admeses" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option name" +msgid "Unknown option name" +msgstr "%s: nom d'opció no vàlid" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid multiplier suffix" +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "%s: el sufix multiplicador no és vàlid" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Unknown file format type" +msgid "Unknown filter name" +msgstr "%s: tipus de format de fitxer desconegut" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "LZMA1 cannot be used with the .xz format" +msgid "This filter cannot be used in the .xz format" +msgstr "No es pot usar LZMA1 amb el format .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Maximum number of filters is four" +msgid "The maximum number of filters is four" +msgstr "El nombre màxim de filtres és de quatre" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" + +#~ msgid "" +#~ " -z, --compress force compression\n" +#~ " -d, --decompress force decompression\n" +#~ " -t, --test test compressed file integrity\n" +#~ " -l, --list list information about .xz files" +#~ msgstr "" +#~ " -z, --compress força la compressió\n" +#~ " -d, --decompress força la descompressió\n" +#~ " -t, --test comprova la integritat del fitxer comprimit\n" +#~ " -l, --list informació sobre els fitxers .xz" + +#~ msgid "" +#~ " -k, --keep keep (don't delete) input files\n" +#~ " -f, --force force overwrite of output file and (de)compress links\n" +#~ " -c, --stdout write to standard output and don't delete input files" +#~ msgstr "" +#~ " -k, --keep manté (no suprimeixis) els fitxers d'entrada\n" +#~ " -f, --force força la sobreescriptura del fitxer de sortida i\n" +#~ " (des)comprimeix els enllaços\n" +#~ " -c, --stdout escriu a la sortida estàndard i no suprimeixis els\n" +#~ " fitxers d'entrada" + +#~ msgid "" +#~ " --no-sparse do not create sparse files when decompressing\n" +#~ " -S, --suffix=.SUF use the suffix '.SUF' on compressed files\n" +#~ " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~ " omitted, filenames are read from the standard input;\n" +#~ " filenames must be terminated with the newline character\n" +#~ " --files0[=FILE] like --files but use the null character as terminator" +#~ msgstr "" +#~ " --no-sparse no creïs fitxers dispersos en descomprimir\n" +#~ " -S, --suffix=.SUF usa el sufix «.SUF» en fitxers comprimits\n" +#~ " --files[=FILE] llegeix els noms de fitxer a processar des del FITXER;\n" +#~ " si s'omet, els noms de fitxer es llegeixen de l'entrada\n" +#~ " estàndard; els noms de fitxer s'han de finalitzar amb el\n" +#~ " caràcter de línia nova\n" +#~ " --files0[=FILE] com --files però usa el caràcter nul com a terminador" + +#~ msgid "" +#~ " -F, --format=FMT file format to encode or decode; possible values are\n" +#~ " 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'\n" +#~ " -C, --check=CHECK integrity check type: 'none' (use with caution),\n" +#~ " 'crc32', 'crc64' (default), or 'sha256'" +#~ msgstr "" +#~ " -F, --format=FMT fitxer de format per a codificar o descodificar; els\n" +#~ " valors possibles són «auto» (predeterminat), «xz»,\n" +#~ " «lzma», «lzip» i «raw»\n" +#~ " -C, --check=CHECK el tipus de comprovació d'integritat: «none» (useu amb\n" +#~ " precaució), «crc32», «crc64» (predeterminat), o «sha256»" + +#, no-c-format +#~ msgid "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " --memlimit-mt-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " set memory usage limit for compression, decompression,\n" +#~ " threaded decompression, or all of these; LIMIT is in\n" +#~ " bytes, % of RAM, or 0 for defaults" +#~ msgstr "" +#~ " --memlimit-compress=LÍMIT\n" +#~ " --memlimit-decompress=LÍMIT\n" +#~ " --memlimit-mt-decompress=LÍMIT\n" +#~ " -M, --memlimit=LÍMIT\n" +#~ " estableix el límit d'ús de memòria per a la compressió,\n" +#~ " descompressió, descompressió amb fils, o tots ells; el\n" +#~ " LÍMIT és en bytes, % de RAM, o 0 per als predeterminats" + +#~ msgid "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1 or LZMA2; OPTS is a comma-separated list of zero or\n" +#~ " --lzma2[=OPTS] more of the following options (valid values; default):\n" +#~ " preset=PRE reset options to a preset (0-9[e])\n" +#~ " dict=NUM dictionary size (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NUM number of literal context bits (0-4; 3)\n" +#~ " lp=NUM number of literal position bits (0-4; 0)\n" +#~ " pb=NUM number of position bits (0-4; 2)\n" +#~ " mode=MODE compression mode (fast, normal; normal)\n" +#~ " nice=NUM nice length of a match (2-273; 64)\n" +#~ " mf=NAME match finder (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM maximum search depth; 0=automatic (default)" +#~ msgstr "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1 o LZMA2; OPTS és una llista separada per comes de\n" +#~ " --lzma2[=OPTS] zero o més opcions de les següents (valors vàlids;\n" +#~ " predeterminat):\n" +#~ " preset=PRE restableix les opcions a un predefinit\n" +#~ " (0-9[e])\n" +#~ " dict=NUM mida del diccionari (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NUM nombre de bits de context literal (0-4; 3)\n" +#~ " lp=NUM nombre de bits de posició literal (0-4; 0)\n" +#~ " pb=NUM nombre de bits de posició (0-4; 2)\n" +#~ " mode=MODE mode de compressió (ràpid, normal; normal)\n" +#~ " nice=NUM longitud de coincidència (2-273; 64)\n" +#~ " mf=NAME cercador de coincidències (hc3, hc4, bt2,\n" +#~ " bt3, bt4; bt4)\n" +#~ " depth=NUM profunditat màxima de cerca; 0=automàtic\n" +#~ " (predeterminat)" + +#~ msgid "" +#~ "\n" +#~ " --x86[=OPTS] x86 BCJ filter (32-bit and 64-bit)\n" +#~ " --arm[=OPTS] ARM BCJ filter\n" +#~ " --armthumb[=OPTS] ARM-Thumb BCJ filter\n" +#~ " --arm64[=OPTS] ARM64 BCJ filter\n" +#~ " --powerpc[=OPTS] PowerPC BCJ filter (big endian only)\n" +#~ " --ia64[=OPTS] IA-64 (Itanium) BCJ filter\n" +#~ " --sparc[=OPTS] SPARC BCJ filter\n" +#~ " --riscv[=OPTS] RISC-V BCJ filter\n" +#~ " Valid OPTS for all BCJ filters:\n" +#~ " start=NUM start offset for conversions (default=0)" +#~ msgstr "" +#~ "\n" +#~ " --x86[=OPTS] filtre BCJ x86 (32-bit i 64-bit)\n" +#~ " --arm[=OPTS] filtre BCJ ARM\n" +#~ " --armthumb[=OPTS] filtre BCJ ARM-Thumb\n" +#~ " --arm64[=OPTS] filtre ARM64 BCJ\n" +#~ " --powerpc[=OPTS] filtre BCJ PowerPC (només endian gran)\n" +#~ " --ia64[=OPTS] filtre IA-64 (Itanium) BCJ\n" +#~ " --sparc[=OPTS] filtre BCJ SPARC\n" +#~ " --riscv[=OPTS] filtre RISC-V BCJ\n" +#~ " OPTS vàlids per a tots els filtres BCJ:\n" +#~ " start=Núm. decalatge d'inici per a les conversions\n" +#~ " (per defecte=0)" + +#~ msgid "" +#~ "\n" +#~ " --delta[=OPTS] Delta filter; valid OPTS (valid values; default):\n" +#~ " dist=NUM distance between bytes being subtracted\n" +#~ " from each other (1-256; 1)" +#~ msgstr "" +#~ "\n" +#~ " --delta[=OPTS] Filtre delta; OPT (valors vàlids; predeterminat):\n" +#~ " dist=Núm. entre bytes que es resten de\n" +#~ " l'altre (1-256; 1)" + +#~ msgid "" +#~ " -q, --quiet suppress warnings; specify twice to suppress errors too\n" +#~ " -v, --verbose be verbose; specify twice for even more verbose" +#~ msgstr "" +#~ " -q, --quiet suprimeix els avisos; especifiqueu-ho dues vegades per a\n" +#~ " suprimir també els errors\n" +#~ " -v, --verbose sigues detallat; especifiqueu dues vegades per a tenir\n" +#~ " encara més detall" + +#~ msgid "" +#~ " -h, --help display the short help (lists only the basic options)\n" +#~ " -H, --long-help display this long help and exit" +#~ msgstr "" +#~ " -h, --help mostra l'ajuda curta (només mostra les opcions bàsiques)\n" +#~ " -H, --long-help mostra aquesta ajuda llarga i surt" + +#~ msgid "" +#~ " -h, --help display this short help and exit\n" +#~ " -H, --long-help display the long help (lists also the advanced options)" +#~ msgstr "" +#~ " -h, --help mostra aquesta ajuda curta i surt\n" +#~ " -H, --long-help mostra l'ajuda llarga (llista també opcions avançades)" + +#~ msgid "Failed to enable the sandbox" +#~ msgstr "No s'ha pogut habilitar l'espai aïllat" diff --git a/cpp/third_party/xz-5.8.3/po/cs.gmo b/cpp/third_party/xz-5.8.3/po/cs.gmo new file mode 100644 index 0000000000..f9ebe3d90b Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/cs.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/cs.po b/cpp/third_party/xz-5.8.3/po/cs.po new file mode 100644 index 0000000000..57949f7326 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/cs.po @@ -0,0 +1,1679 @@ +# XZ Utils Czech translation +# This file is put in the public domain. +# Marek Černocký , 2010. +# +msgid "" +msgstr "" +"Project-Id-Version: xz-utils\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: cs\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2\n" +"X-Poedit-Language: Czech\n" +"X-Poedit-SourceCharset: utf-8\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Neznámý typ formátu souboru" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Neznámý typ kontroly integrity" + +#: src/xz/args.c +#, fuzzy +#| msgid "Only one file can be specified with `--files' or `--files0'." +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Spolu s přepínači „--files“ nebo „--files0“ může být zadán pouze jeden soubor" + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Proměnná prostředí %s obsahuje příliš mnoho argumentů" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "" + +#: src/xz/args.c +#, fuzzy +#| msgid "%s: With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "%s: S přepínačem --format=raw je vyžadován --sufix=.PRIP, vyjma zápisu do standardního výstupu" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Maximální počet filtrů je čtyři" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Omezení použitelné paměti je příliš malé pro dané nastavení filtru." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Použití přednastavení v režimu raw je nevhodné." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Přesné volby u přednastavení se mohou lišit mezi různými verzemi softwaru." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Formát .lzma podporuje pouze filtr LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 nelze použít s formátem .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Unsupported options" +msgid "Unsupported options in filter chain %u" +msgstr "Nepodporovaná volba" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "" + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Nepodporovaný omezující filtr nebo volby filtru" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Dekomprimace bude vyžadovat %s MiB paměti." + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Přizpůsobit velikost slovníku LZMA%c z %s MiB na %s MiB, tak aby nebylo překročeno omezení použitelné paměti %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Přizpůsobit velikost slovníku LZMA%c z %s MiB na %s MiB, tak aby nebylo překročeno omezení použitelné paměti %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Přizpůsobit velikost slovníku LZMA%c z %s MiB na %s MiB, tak aby nebylo překročeno omezení použitelné paměti %s MiB" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Přizpůsobit velikost slovníku LZMA%c z %s MiB na %s MiB, tak aby nebylo překročeno omezení použitelné paměti %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Vypadá to, že soubor byl přesunut, proto nebude odstraněn" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Nelze odstranit: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Nelze nastavit vlastníka souboru: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Nelze nastavit skupinu souboru: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Nelze nastavit oprávnění souboru: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Selhalo zavření souboru: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Selhalo zavření souboru: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Jedná se o symbolický odkaz, vynechává se" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Jedná se o složku, vynechává se" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Nejedná se o běžný soubor, vynechává se" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Soubor má nastavený bit setuid nebo setgid, vynechává se" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Soubor má nastavený bit sticky, vynechává se" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Vstupní soubor má více než jeden pevný odkaz, vynechává se" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Prázdný název souboru, vynechává se" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Selhalo zavření souboru: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Not a regular file, skipping" +msgid "%s: Destination is not a regular file" +msgstr "%s: Nejedná se o běžný soubor, vynechává se" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Chyba při obnovení příznaku O_APPEND na standardní výstup: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Selhalo zavření souboru: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Selhalo nastavení pozice při pokusu o vytvoření souboru řídké matice: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Chyba čtení: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Chyba při posunu v rámci souboru: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Neočekávaný konec souboru" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Chyba zápisu: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Vypnuto" + +#: src/xz/hardware.c +#, fuzzy +#| msgid "Total amount of physical memory (RAM): " +msgid "Amount of physical memory (RAM):" +msgstr "Celkové množství fyzické paměti (RAM): " + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "" + +#: src/xz/hardware.c +#, fuzzy +#| msgid "Memory usage limit for decompression: " +msgid "Multi-threaded decompression:" +msgstr "Omezení použitelné paměti pro dekomprimaci:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "" + +#: src/xz/hardware.c +#, fuzzy +#| msgid "Memory usage limit reached" +msgid "Memory usage limits:" +msgstr "Dosaženo omezení použitelné paměti" + +#: src/xz/list.c +msgid "Streams:" +msgstr "" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "" + +#: src/xz/list.c +#, fuzzy +#| msgid " Compressed size: %s\n" +msgid "Compressed size:" +msgstr " Komprimovaná velikost: %s\n" + +#: src/xz/list.c +#, fuzzy +#| msgid " Uncompressed size: %s\n" +msgid "Uncompressed size:" +msgstr " Nekomprimovaná velikost: %s\n" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "" + +#: src/xz/list.c +msgid "Check:" +msgstr "" + +#: src/xz/list.c +#, fuzzy +#| msgid " Stream padding: %s\n" +msgid "Stream Padding:" +msgstr " Zarovnání proudu: %s\n" + +#: src/xz/list.c +#, fuzzy +#| msgid " Memory needed: %s MiB\n" +msgid "Memory needed:" +msgstr " Potřebná paměť: %s MiB\n" + +#: src/xz/list.c +#, fuzzy +#| msgid " Sizes in headers: %s\n" +msgid "Sizes in headers:" +msgstr " Velikosti v hlavičkách: %s\n" + +#: src/xz/list.c +#, fuzzy +#| msgid " Number of files: %s\n" +msgid "Number of files:" +msgstr " Počet souborů: %s\n" + +#: src/xz/list.c +msgid "Stream" +msgstr "" + +#: src/xz/list.c +msgid "Block" +msgstr "" + +#: src/xz/list.c +msgid "Blocks" +msgstr "" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "" + +#: src/xz/list.c +msgid "CompSize" +msgstr "" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "" + +#: src/xz/list.c +#, fuzzy +#| msgid "Totals:" +msgid "TotalSize" +msgstr "Celkem:" + +#: src/xz/list.c +msgid "Ratio" +msgstr "" + +#: src/xz/list.c +msgid "Check" +msgstr "" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "" + +#: src/xz/list.c +msgid "Padding" +msgstr "" + +#: src/xz/list.c +msgid "Header" +msgstr "" + +#: src/xz/list.c +msgid "Flags" +msgstr "" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "" + +#: src/xz/list.c +msgid "Filters" +msgstr "" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "žádná" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "neznámá-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "neznámá-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "neznámá-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "neznámá-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "neznámá-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "neznámá-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "neznámá-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "neznámá-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "neznámá-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "neznámá-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "neznámá-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "neznámá-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Soubor je prázdný" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Je příliš malý na to, aby to mohl být platný soubor .xz" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Proud Bloky Komprim Nekomprim Poměr Kontrl Název souboru" + +#: src/xz/list.c +msgid "Yes" +msgstr "Ano" + +#: src/xz/list.c +msgid "No" +msgstr "Ne" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s soubor\n" +msgstr[1] "%s soubory\n" +msgstr[2] "%s souborů\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Celkem:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list pracuje pouze se soubory .xz (--format=xz nebo --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "" + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list nepodporuje čtení ze standardního vstupu" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Chyba při čtení názvů souborů: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Neočekávaný konec vstupu při čtení názvů souborů" + +#: src/xz/main.c +#, fuzzy, c-format +#| msgid "%s: Null character found when reading filenames; maybe you meant to use `--files0' instead of `--files'?" +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Byl nalezen nulový znak při čtení názvů souborů; nechtěli jste náhodou použít „--files0“ místo „--files“?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Komprimace a dekomprimace s přepínačem --robot není zatím podporovaná." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Ze standardního vstupu nelze číst data, když se ze standardního vstupu načítají názvy souborů" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "" + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Interní chyba" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Nelze ustanovit ovladač signálu" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Žádná kontrola integrity; integrita souboru se nebude ověřovat" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Nepodporovaný typ kontroly integrity; integrita souboru se nebude ověřovat" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Dosaženo omezení použitelné paměti" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Formát souboru nebyl rozpoznán" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Nepodporovaná volba" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Komprimovaná data jsou poškozená" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Neočekávaný konec vstupu" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "Je vyžadováno %s MiB paměti. Limit je %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Omezující filtr: %s\n" + +#: src/xz/message.c +#, fuzzy, c-format +#| msgid "Try `%s --help' for more information." +msgid "Try '%s --help' for more information." +msgstr "Zkuste „%s --help“ pro více informací" + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the 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 "" +#| "Usage: %s [OPTION]... [FILE]...\n" +#| "Compress or decompress FILEs in the .xz format.\n" +#| "\n" +msgid "Compress or decompress FILEs in the .xz format." +msgstr "" +"Použití: %s [PŘEPÍNAČ]... [SOUBOR]...\n" +"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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Operation modifiers:\n" +msgid "Operation modifiers:" +msgstr "" +"\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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Basic file format and compression options:\n" +msgid "Basic file format and compression options:" +msgstr "" +"\n" +"Základní přepínače pro formát souboru a komprimaci:\n" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| " -0 ... -9 compression preset; default is 6; take compressor *and*\n" +#| " decompressor memory usage into account before using 7-9!" +msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!" +msgstr "" +" -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 interpreted as a zero-width space (the 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 "" +#| " -e, --extreme try to improve compression ratio by using more CPU time;\n" +#| " does not affect decompressor memory requirements" +msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements" +msgstr "" +" -e, --extreme zkusit zlepšit poměr komprimace využitím více času\n" +" procesoru; nemá vliv na paměťové nároky dekomprimace" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --no-adjust if compression settings exceed the memory usage limit,\n" +#| " give an error instead of adjusting the settings downwards" +msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards" +msgstr "" +" --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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Custom filter chain for compression (alternative for using presets):" +msgid "Custom filter chain for compression (an alternative to using presets):" +msgstr "" +"\n" +"Vlastní omezující filtr pro komprimaci (alternativa k použití přednastavených):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Other options:\n" +msgid "Other options:" +msgstr "" +"\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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 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 interpreted as a zero-width space (the 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 "" +#| " --info-memory display the total amount of RAM and the currently active\n" +#| " memory usage limits, and exit" +msgid "display the total amount of RAM and the currently active memory usage limits, and exit" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| "With no FILE, or when FILE is -, read standard input.\n" +msgid "With no FILE, or when FILE is -, read standard input." +msgstr "" +"\n" +"Pokud SOUBOR není zadán nebo pokud je -, bude se číst ze standardního vstupu.\n" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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" +msgid "Report bugs to <%s> (in English or Finnish)." +msgstr "Chyby hlaste na <%s> (v angličtině nebo finštině).\n" + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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" +msgid "The supported filters and their options are:" +msgstr "Nepodporovaný omezující filtr nebo volby filtru" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Options must be `name=value' pairs separated with commas" +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "%s: Volby musí být páry „název=hodnota“ oddělené čárkami" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Neplatný název volby" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option value" +msgid "Invalid option value" +msgstr "%s: Neplatná hodnota volby" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Nepodporované přednastavení LZMA1/LZMA2: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Součet lc a lp nesmí překročit hodnotu 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Název souboru má neznámou příponu, vynechává se" + +#: src/xz/suffix.c +#, fuzzy, c-format +#| msgid "%s: File already has `%s' suffix, skipping" +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Soubor již má příponu „%s“, vynechává se" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Neplatná přípona názvu souboru" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Value is not a non-negative decimal integer" +msgid "Value is not a non-negative decimal integer" +msgstr "%s: Hodnota není nezáporné desítkové číslo" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Neplatná jednotka s předponou" + +#: src/xz/util.c +#, fuzzy +#| msgid "Valid suffixes are `KiB' (2^10), `MiB' (2^20), and `GiB' (2^30)." +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Platné jednotky s předponami jsou „KiB“ (2^10 B), „MiB“ (2^20 B) a „GiB“ (2^30 B)." + +#: src/xz/util.c +#, fuzzy, c-format +#| msgid "Value of the option `%s' must be in the range [%, %]" +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Hodnota volby „%s“ musí být v rozsahu [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Z terminálu nelze číst komprimovaná data" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Do terminálu nelze zapisovat komprimovaná data" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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 "" + +#: src/lzmainfo/lzmainfo.c +#, fuzzy +#| msgid "%s: Too small to be a valid .xz file" +msgid "File is too small to be a .lzma file" +msgstr "%s: Je příliš malý na to, aby to mohl být platný soubor .xz" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Zápis do standardního výstupu selhal" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Neznámá chyba" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported options" +msgid "Unsupported preset" +msgstr "Nepodporovaná volba" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported filter chain or filter options" +msgid "Unsupported flag in the preset" +msgstr "Nepodporovaný omezující filtr nebo volby filtru" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option name" +msgid "Unknown option name" +msgstr "%s: Neplatný název volby" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid multiplier suffix" +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "%s: Neplatná jednotka s předponou" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Unknown file format type" +msgid "Unknown filter name" +msgstr "%s: Neznámý typ formátu souboru" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "LZMA1 cannot be used with the .xz format" +msgid "This filter cannot be used in the .xz format" +msgstr "LZMA1 nelze použít s formátem .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Maximum number of filters is four" +msgid "The maximum number of filters is four" +msgstr "Maximální počet filtrů je čtyři" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" + +#~ msgid "" +#~ " -z, --compress force compression\n" +#~ " -d, --decompress force decompression\n" +#~ " -t, --test test compressed file integrity\n" +#~ " -l, --list list information about .xz files" +#~ msgstr "" +#~ " -z, --compress provést komprimaci\n" +#~ " -d, --decompress provést dekomprimaci\n" +#~ " -t, --test testovat integritu komprimovaného souboru\n" +#~ " -l, --list vypsat informace o souborech .xz" + +#~ msgid "" +#~ " -k, --keep keep (don't delete) input files\n" +#~ " -f, --force force overwrite of output file and (de)compress links\n" +#~ " -c, --stdout write to standard output and don't delete input files" +#~ msgstr "" +#~ " -k, --keep zachovat (nemazat) vstupní soubory\n" +#~ " -f, --force vynutit přepis výstupního souboru a de/komprimovat odkazy\n" +#~ " -c, --stdout zapisovat na standardní výstup a nemazat vstupní soubory" + +#, fuzzy +#~| msgid "" +#~| " --no-sparse do not create sparse files when decompressing\n" +#~| " -S, --suffix=.SUF use the suffix `.SUF' on compressed files\n" +#~| " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~| " omitted, filenames are read from the standard input;\n" +#~| " filenames must be terminated with the newline character\n" +#~| " --files0[=FILE] like --files but use the null character as terminator" +#~ msgid "" +#~ " --no-sparse do not create sparse files when decompressing\n" +#~ " -S, --suffix=.SUF use the suffix '.SUF' on compressed files\n" +#~ " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~ " omitted, filenames are read from the standard input;\n" +#~ " filenames must be terminated with the newline character\n" +#~ " --files0[=FILE] like --files but use the null character as terminator" +#~ msgstr "" +#~ " --no-sparse nevytvářet při dekomprimaci soubory řídkých matic\n" +#~ " -S, --suffix=.PRIP použít u komprimovaných souborů příponu „.PRIP“\n" +#~ " --files[=SOUBOR] číst názvy souborů, které se mají zpracovat, ze SOUBORu;\n" +#~ " pokud není SOUBOR zadán, čte se ze standardního vstupu;\n" +#~ " názvy souborů musí být zakončeny znakem nového řádku\n" +#~ " --files0[=SOUBOR] stejné jako --files, ale použít k zakončování nulový znak" + +#, fuzzy +#~| msgid "" +#~| " -F, --format=FMT file format to encode or decode; possible values are\n" +#~| " `auto' (default), `xz', `lzma', and `raw'\n" +#~| " -C, --check=CHECK integrity check type: `none' (use with caution),\n" +#~| " `crc32', `crc64' (default), or `sha256'" +#~ msgid "" +#~ " -F, --format=FMT file format to encode or decode; possible values are\n" +#~ " 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'\n" +#~ " -C, --check=CHECK integrity check type: 'none' (use with caution),\n" +#~ " 'crc32', 'crc64' (default), or 'sha256'" +#~ msgstr "" +#~ " -F, --format=FORMÁT formát souboru k zakódování nebo dekódování; možné\n" +#~ " hodnoty jsou „auto“ (výchozí), „xz“, „lzma“ a „raw“\n" +#~ " -C, --check=KONTROLA typ kontroly integrity: „none“ (používejte s rozmyslem),\n" +#~ " „crc32“, „crc64“ (výchozí) nebo „sha256“" + +#, fuzzy, no-c-format +#~| msgid "" +#~| " --memlimit-compress=LIMIT\n" +#~| " --memlimit-decompress=LIMIT\n" +#~| " -M, --memlimit=LIMIT\n" +#~| " set memory usage limit for compression, decompression,\n" +#~| " or both; LIMIT is in bytes, % of RAM, or 0 for defaults" +#~ msgid "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " --memlimit-mt-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " set memory usage limit for compression, decompression,\n" +#~ " threaded decompression, or all of these; LIMIT is in\n" +#~ " bytes, % of RAM, or 0 for defaults" +#~ msgstr "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " nastaví omezení použitelné paměti pro komprimaci,\n" +#~ " dekomprimaci nebo obojí; LIMIT je v bajtech, % z paměti\n" +#~ " RAM nebo 0 pro výchozí" + +#~ msgid "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1 or LZMA2; OPTS is a comma-separated list of zero or\n" +#~ " --lzma2[=OPTS] more of the following options (valid values; default):\n" +#~ " preset=PRE reset options to a preset (0-9[e])\n" +#~ " dict=NUM dictionary size (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NUM number of literal context bits (0-4; 3)\n" +#~ " lp=NUM number of literal position bits (0-4; 0)\n" +#~ " pb=NUM number of position bits (0-4; 2)\n" +#~ " mode=MODE compression mode (fast, normal; normal)\n" +#~ " nice=NUM nice length of a match (2-273; 64)\n" +#~ " mf=NAME match finder (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM maximum search depth; 0=automatic (default)" +#~ msgstr "" +#~ "\n" +#~ " --lzma1[=VOLBY] LZMA1 nebo LZMA2; VOLBY je čárkou oddělovaný seznam žádné\n" +#~ " --lzma2[=VOLBY] nebo více následujících voleb (platné hodnoty; výchozí):\n" +#~ " preset=PŘE změnit volby na PŘEdnastavené (0 – 9[e])\n" +#~ " dict=POČ velikost slovníku (4 KiB – 1536 MiB; 8 MiB)\n" +#~ " lc=POČ počet kontextových bitů literálu (0 – 4; 3)\n" +#~ " lp=POČ počet pozičních bitů literálu (0 – 4; 0)\n" +#~ " pb=POČ počet pozičních bitů (0 – 4; 2)\n" +#~ " mode=REŽIM režim komprimace (fast, normal; normal)\n" +#~ " nice=NUM příznivá délka shody (2 – 273; 64)\n" +#~ " mf=NÁZEV hledání shod (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=POČ maximální hloubka prohledávání;\n" +#~ " 0 = automaticky (výchozí)" + +#, fuzzy +#~| msgid "" +#~| "\n" +#~| " --x86[=OPTS] x86 BCJ filter (32-bit and 64-bit)\n" +#~| " --powerpc[=OPTS] PowerPC BCJ filter (big endian only)\n" +#~| " --ia64[=OPTS] IA-64 (Itanium) BCJ filter\n" +#~| " --arm[=OPTS] ARM BCJ filter (little endian only)\n" +#~| " --armthumb[=OPTS] ARM-Thumb BCJ filter (little endian only)\n" +#~| " --sparc[=OPTS] SPARC BCJ filter\n" +#~| " Valid OPTS for all BCJ filters:\n" +#~| " start=NUM start offset for conversions (default=0)" +#~ msgid "" +#~ "\n" +#~ " --x86[=OPTS] x86 BCJ filter (32-bit and 64-bit)\n" +#~ " --arm[=OPTS] ARM BCJ filter\n" +#~ " --armthumb[=OPTS] ARM-Thumb BCJ filter\n" +#~ " --arm64[=OPTS] ARM64 BCJ filter\n" +#~ " --powerpc[=OPTS] PowerPC BCJ filter (big endian only)\n" +#~ " --ia64[=OPTS] IA-64 (Itanium) BCJ filter\n" +#~ " --sparc[=OPTS] SPARC BCJ filter\n" +#~ " --riscv[=OPTS] RISC-V BCJ filter\n" +#~ " Valid OPTS for all BCJ filters:\n" +#~ " start=NUM start offset for conversions (default=0)" +#~ msgstr "" +#~ "\n" +#~ " --x86[=VOLBY] Filtr x86 BCJ (32bitový a 64bitový)\n" +#~ " --powerpc[=VOLBY] Filtr PowerPC BCJ (pouze big endian)\n" +#~ " --ia64[=VOLBY] Filtr IA64 (Itanium) BCJ\n" +#~ " --arm[=VOLBY] Filtr ARM BCJ (pouze little endian)\n" +#~ " --armthumb[=VOLBY] Filtr ARM-Thumb BCJ (pouze little endian)\n" +#~ " --sparc[=VOLBY] Filtr SPARC BCJ\n" +#~ " Platné volby pro všechny filtry BCJ:\n" +#~ " start=POČ počáteční posun pro převody (výchozí=0)" + +#~ msgid "" +#~ "\n" +#~ " --delta[=OPTS] Delta filter; valid OPTS (valid values; default):\n" +#~ " dist=NUM distance between bytes being subtracted\n" +#~ " from each other (1-256; 1)" +#~ msgstr "" +#~ "\n" +#~ " --delta[=VOLBY] Filtr Delta; platné VOLBY (platné hodnoty; výchozí):\n" +#~ " dist=POČ vzdálenost mezi bajty, které jsou odečítány\n" +#~ " jeden od druhého (1 – 256; 1)" + +#~ msgid "" +#~ " -q, --quiet suppress warnings; specify twice to suppress errors too\n" +#~ " -v, --verbose be verbose; specify twice for even more verbose" +#~ msgstr "" +#~ " -q, --quiet potlačit varování; zadáním dvakrát, potlačíte i chyby\n" +#~ " -v, --verbose podrobnější zprávy; zadáním dvakrát, budou ještě\n" +#~ " podrobnější" + +#~ msgid "" +#~ " -h, --help display the short help (lists only the basic options)\n" +#~ " -H, --long-help display this long help and exit" +#~ msgstr "" +#~ " -h, --help zobrazit krátkou nápovědu (vypíše jen základní přepínače)\n" +#~ " -H, --long-help zobrazit tuto úplnou nápovědu a skončit" + +#~ msgid "" +#~ " -h, --help display this short help and exit\n" +#~ " -H, --long-help display the long help (lists also the advanced options)" +#~ msgstr "" +#~ " -h, --help zobrazit tuto zkrácenou nápovědu a skončit\n" +#~ " -H, --long-help zobrazit úplnou nápovědu (vypíše i pokročilé přepínače)" + +#~ msgid "Memory usage limit for compression: " +#~ msgstr "Omezení použitelné paměti pro komprimaci: " + +#, c-format +#~ msgid " Streams: %s\n" +#~ msgstr " Proudů: %s\n" + +#, c-format +#~ msgid " Blocks: %s\n" +#~ msgstr " Bloků: %s\n" + +#, c-format +#~ msgid " Ratio: %s\n" +#~ msgstr " Poměr komprimace: %s\n" + +#, c-format +#~ msgid " Check: %s\n" +#~ msgstr " Typ kontroly: %s\n" + +#~ msgid "" +#~ " Streams:\n" +#~ " Stream Blocks CompOffset UncompOffset CompSize UncompSize Ratio Check Padding" +#~ msgstr "" +#~ " Proudy:\n" +#~ " Proud Bloky KomprPozice NekomprPozice KomprVelikost NekomprVelikost Poměr Kontrola Zarovnání" + +#, c-format +#~ msgid "" +#~ " Blocks:\n" +#~ " Stream Block CompOffset UncompOffset TotalSize UncompSize Ratio Check" +#~ msgstr "" +#~ " Bloky:\n" +#~ " Proud Blok KomprPozice NekomprPozice CelkVelikost NekomprVelikost Poměr Kontrola" + +#, c-format +#~ msgid " CheckVal %*s Header Flags CompSize MemUsage Filters" +#~ msgstr " KontrHod %*s Hlavič Příznaky KomprVel PoužiPam Filtry" + +#, c-format +#~ msgid "The selected match finder requires at least nice=%" +#~ msgstr "Vybraný vyhledávač shod vyžaduje minimálně nice=%" + +#~ msgid "Limit was %s MiB, but %s MiB would have been needed" +#~ msgstr "Limit byl %s MiB, ale bylo by zapotřebí %s MiB" + +#~ msgid "%s MiB (%s bytes)\n" +#~ msgstr "%s MiB (%s bajtů)\n" + +#~ msgid "" +#~ " -e, --extreme use more CPU time when encoding to increase compression\n" +#~ " ratio without increasing memory usage of the decoder" +#~ msgstr "" +#~ " -e, --extreme využít více procesorového času pro kódování, čímž se\n" +#~ " zvýší kompresní poměr bez zvýšení paměti použité kodérem" + +#~ msgid "" +#~ " -M, --memory=NUM use roughly NUM bytes of memory at maximum; 0 indicates\n" +#~ " the default setting, which is 40 % of total RAM" +#~ msgstr "" +#~ " -M, --memory=POČ použít zhruba POČ bajtů paměti jako maximum; 0 znamená\n" +#~ " výchozí nastavení, což je 40% celkového množství paměti" + +#~ msgid "" +#~ "\n" +#~ " --subblock[=OPTS] Subblock filter; valid OPTS (valid values; default):\n" +#~ " size=NUM number of bytes of data per subblock\n" +#~ " (1 - 256Mi; 4Ki)\n" +#~ " rle=NUM run-length encoder chunk size (0-256; 0)" +#~ msgstr "" +#~ "\n" +#~ " --subblock[=VOLBY] Subblokový filtr; platné VOLBY (platné hodnoty; výchozí):\n" +#~ " size=POČ počet bajtů dat na subblok\n" +#~ " (1 - 256 Mi; 4 Ki)\n" +#~ " rle=POČ velikost dávky pro kodér run-length (0-256; 0)" + +#~ msgid "" +#~ "On this system and configuration, this program will use a maximum of roughly\n" +#~ "%s MiB RAM and " +#~ msgstr "" +#~ "Na tomto systému a s tímto nastavením použije tento program maximum ze zhruba\n" +#~ "%s MiB RAM a " + +#~ msgid "" +#~ "one thread.\n" +#~ "\n" +#~ msgstr "" +#~ "jedno vlákno.\n" +#~ "\n" + +#~ msgid "%s: Invalid multiplier suffix. Valid suffixes:" +#~ msgstr "%s: Neplatná přípona. Platné přípony jsou:" diff --git a/cpp/third_party/xz-5.8.3/po/da.gmo b/cpp/third_party/xz-5.8.3/po/da.gmo new file mode 100644 index 0000000000..460dae3cf0 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/da.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/da.po b/cpp/third_party/xz-5.8.3/po/da.po new file mode 100644 index 0000000000..bea97ac0f5 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/da.po @@ -0,0 +1,1436 @@ +# Danish translation xz. +# This file is put in the public domain. +# Joe Hansen , 2019. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.2.4\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: da\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Ugyldigt parameter til --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: For mange argumenter til --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 kan kun bruges som det sidste element i --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Ukendt filformattype" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Typen for integritetkontrol er ikke understøttet" + +#: src/xz/args.c +#, fuzzy +#| msgid "Only one file can be specified with `--files' or `--files0'." +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Kun en fil kan angives med »--files« eller »--files0«." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, fuzzy, c-format +#| msgid "%s: " +msgid "%s: %s" +msgstr "%s: " + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Miljøvariablen %s indeholder for mange argumenter" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Komprimeringsunderstøttelse blev deaktiveret på byggetidspunktet" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Dekomprimeringsunderstøttelse blev deaktiveret på byggetidspunktet" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "" + +#: src/xz/args.c +#, fuzzy +#| msgid "%s: With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "%s: med --format=raw, --suffix=.SUF er krævet med mindre der skrives til standardud" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Maksimalt antal filtre er fire" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Begræsningen for brug af hukommelse er for lav for den givne filteropsætning." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Det frarådes at bruge en forhåndskonfiguration i rå tilstand (raw mode)." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "De præcise indstillinger for forhåndskonfigurationerne kan variere mellem programversioner." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Formatet .lzma understøtter kun LZMA1-filteret" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 kan ikke bruges med .xz-formatet" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "The filter chain is incompatible with --flush-timeout" +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Filterkæden er ikke kompatibel med --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Skifter til enkelt trådet tilstand på grund af --flush-timeout" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Unsupported options" +msgid "Unsupported options in filter chain %u" +msgstr "Tilvalg er ikke understøttede" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Bruger op til % tråde." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Filterkæde eller filterindstillinger er ikke understøttet" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Dekomprimering vil kræve %s MiB hukommelse." + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Adjusted the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Justerede antallet af tråde fra %s til %s for ikke at overskride begræsningen på brug af hukommelse på %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Adjusted the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Justerede antallet af tråde fra %s til %s for ikke at overskride begræsningen på brug af hukommelse på %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Justerede LZMA%c-ordbogsstørrelsen fra %s MiB til %s MiB for ikke at overskride begrænsningen på brug af hukommelse på %s MiB" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Justerede LZMA%c-ordbogsstørrelsen fra %s MiB til %s MiB for ikke at overskride begrænsningen på brug af hukommelse på %s MiB" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Error creating a pipe: %s" +msgid "Error changing to filter chain %u: %s" +msgstr "Det opstod en fejl under oprettelse af en datakanal: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Det opstod en fejl under oprettelse af en datakanal: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() mislykkedes: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Filen er vist blevet flyttet, sletter ikke" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Kan ikke fjerne: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Kan ikke angive filejeren: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Kan ikke angive filgruppen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Kan ikke angive filtilladelser: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Lukning af filen fejlede: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Lukning af filen fejlede: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Der opstod en fejl under indhentelse af filstatusflag fra standardind: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Er en symbolsk henvisning, udelader" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Er en mappe, udelader" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Er ikke en normal fil, udelader" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Filen har setuid- eller setgid-bitsæt, udelader" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Fil har klæbende bitsæt, udelader" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Inddatafil har mere end en hård henvisning, udelader" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Tomt filnavn, udelader" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Der opstod en fejl under gendannelse af statusflagene til standardind: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Der opstod en fejl under indhentelse af filstatusflag fra standardud: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Lukning af filen fejlede: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Not a regular file, skipping" +msgid "%s: Destination is not a regular file" +msgstr "%s: Er ikke en normal fil, udelader" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Der opstod en fejl under gendannelse af flaget O_APPEND til standardud: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Lukning af filen fejlede: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Søgning fejlede under forsøg på at oprette en tynd fil: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Læsefejl: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Der opstod en fejl under søgning efter filen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Uventet filafslutning" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Skrivefejl: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Deaktiveret" + +#: src/xz/hardware.c +#, fuzzy +#| msgid "Total amount of physical memory (RAM): " +msgid "Amount of physical memory (RAM):" +msgstr "Samlet mængde fysisk hukommelse (RAM): " + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "" + +#: src/xz/hardware.c +#, fuzzy +#| msgid "Memory usage limit for decompression: " +msgid "Multi-threaded decompression:" +msgstr "Grænse for hukommelsesforbug til dekomprimering: " + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "" + +#: src/xz/hardware.c +#, fuzzy +#| msgid "Memory usage limit reached" +msgid "Memory usage limits:" +msgstr "Begrænsning på brug af hukommelse er nået" + +#: src/xz/list.c +msgid "Streams:" +msgstr "" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "" + +#: src/xz/list.c +#, fuzzy +#| msgid " Compressed size: %s\n" +msgid "Compressed size:" +msgstr " Komprimeret str.: %s\n" + +#: src/xz/list.c +#, fuzzy +#| msgid " Uncompressed size: %s\n" +msgid "Uncompressed size:" +msgstr " Ukomprimeret str.: %s\n" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "" + +#: src/xz/list.c +msgid "Check:" +msgstr "" + +#: src/xz/list.c +#, fuzzy +#| msgid " Stream padding: %s\n" +msgid "Stream Padding:" +msgstr " Strømfyld: %s\n" + +#: src/xz/list.c +#, fuzzy +#| msgid " Memory needed: %s MiB\n" +msgid "Memory needed:" +msgstr " Hukommelse krævet: %s MiB\n" + +#: src/xz/list.c +#, fuzzy +#| msgid " Sizes in headers: %s\n" +msgid "Sizes in headers:" +msgstr " Størrelser i teksthoveder: %s\n" + +#: src/xz/list.c +#, fuzzy +#| msgid " Number of files: %s\n" +msgid "Number of files:" +msgstr " Antal filer: %s\n" + +#: src/xz/list.c +msgid "Stream" +msgstr "" + +#: src/xz/list.c +msgid "Block" +msgstr "" + +#: src/xz/list.c +msgid "Blocks" +msgstr "" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "" + +#: src/xz/list.c +msgid "CompSize" +msgstr "" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "" + +#: src/xz/list.c +#, fuzzy +#| msgid "Totals:" +msgid "TotalSize" +msgstr "I alt:" + +#: src/xz/list.c +msgid "Ratio" +msgstr "" + +#: src/xz/list.c +msgid "Check" +msgstr "" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "" + +#: src/xz/list.c +msgid "Padding" +msgstr "" + +#: src/xz/list.c +msgid "Header" +msgstr "" + +#: src/xz/list.c +msgid "Flags" +msgstr "" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "" + +#: src/xz/list.c +msgid "Filters" +msgstr "" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Ingen" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Ukendt-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Ukendt-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Ukendt-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Ukendt-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Ukendt-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Ukendt-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Ukendt-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Ukendt-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Ukendt-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Ukendt-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Ukendt-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Ukendt-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Filen er tom" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: For lille til at være en gyldig .xz-fil" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "" + +#: src/xz/list.c +msgid "Yes" +msgstr "Ja" + +#: src/xz/list.c +msgid "No" +msgstr "Nej" + +#: src/xz/list.c +#, fuzzy +#| msgid " Minimum XZ Utils version: %s\n" +msgid "Minimum XZ Utils version:" +msgstr " Minimum for XZ Utils-version: %s\n" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s fil\n" +msgstr[1] "%s filer\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "I alt:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "" + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list understøtter ikke læsning fra standardind" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Der opstod en fejl under forsøg på læsning af filnavne: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Uventet afslutning på inddata under forsøg på læsning af filnavne" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Komprimering og dekomprimering med --robot er endnu ikke understøttet." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Intern fejl (fejl)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Kan ikke etbalere signalhåndteringer" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Ingen integritetkontrol; verificerer ikke filintegritet" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Begrænsning på brug af hukommelse er nået" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Filformatet blev ikke genkendt" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Tilvalg er ikke understøttede" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Komprimerede data er ødelagte" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Uventet afslutning på inddata" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB hukommelse er krævet. Begrænseren er deaktiveret." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB hukommelse er krævet. Begrænsningen er %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Filterkæde: %s\n" + +#: src/xz/message.c +#, fuzzy, c-format +#| msgid "Try `%s --help' for more information." +msgid "Try '%s --help' for more information." +msgstr "Prøv »%s --help« for yderligere information." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +"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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Operation modifiers:\n" +msgid "Operation modifiers:" +msgstr "" +"\n" +"Operationsændrere:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Other options:\n" +msgid "Other options:" +msgstr "" +"\n" +"Andre tilvalg:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| "With no FILE, or when FILE is -, read standard input.\n" +msgid "With no FILE, or when FILE is -, read standard input." +msgstr "" +"\n" +"Med ingen FIL, eller når FIL er -, læs standardind.\n" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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" +msgid "Report bugs to <%s> (in English or Finnish)." +msgstr "" +"Rapporter fejl til <%s> (på engelsk eller finsk).\n" +"Rapporter oversættelsesfejl til .\n" + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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" +msgid "The supported filters and their options are:" +msgstr "Filterkæde eller filterindstillinger er ikke understøttet" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Options must be `name=value' pairs separated with commas" +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "%s: Tilvalg skal være »navne=værdi«-par adskilt med kommaer" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Ugyldigt tilvalgsnavn" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option value" +msgid "Invalid option value" +msgstr "%s: Ugyldigt tilvalgsværdi" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "LZMA1/LZMA2-forhåndskonfiguration er ikke understøttet: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Summen af lc og lp må ikke være højere end 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Filnavn har ukendt endelse, udelader" + +#: src/xz/suffix.c +#, fuzzy, c-format +#| msgid "%s: File already has `%s' suffix, skipping" +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Filen har allrede endelsen »%s«, udelader." + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Ugyldig filnavnendelse" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Value is not a non-negative decimal integer" +msgid "Value is not a non-negative decimal integer" +msgstr "%s: Værdi er ikke et positivt decimalheltal" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Ugyldig multiplikatorendelse" + +#: src/xz/util.c +#, fuzzy +#| msgid "Valid suffixes are `KiB' (2^10), `MiB' (2^20), and `GiB' (2^30)." +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Gyldige endelser er »KiB« (2^10), »MiB« (2^20) og »GiB« (2^30)." + +#: src/xz/util.c +#, fuzzy, c-format +#| msgid "Value of the option `%s' must be in the range [%, %]" +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Værdien for tilvalget »%s« skal være i intervallet [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Komprimerede data kan ikke læses fra en terminal" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Komprimerede data kan ikke skrives til en terminal" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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 "" + +#: src/lzmainfo/lzmainfo.c +#, fuzzy +#| msgid "%s: Too small to be a valid .xz file" +msgid "File is too small to be a .lzma file" +msgstr "%s: For lille til at være en gyldig .xz-fil" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Skrivning til standardud mislykkedes" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Ukendt fejl" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported options" +msgid "Unsupported preset" +msgstr "Tilvalg er ikke understøttede" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported filter chain or filter options" +msgid "Unsupported flag in the preset" +msgstr "Filterkæde eller filterindstillinger er ikke understøttet" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option name" +msgid "Unknown option name" +msgstr "%s: Ugyldigt tilvalgsnavn" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid multiplier suffix" +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "%s: Ugyldig multiplikatorendelse" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Unknown file format type" +msgid "Unknown filter name" +msgstr "%s: Ukendt filformattype" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "LZMA1 cannot be used with the .xz format" +msgid "This filter cannot be used in the .xz format" +msgstr "LZMA1 kan ikke bruges med .xz-formatet" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Maximum number of filters is four" +msgid "The maximum number of filters is four" +msgstr "Maksimalt antal filtre er fire" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" + +#~ msgid "" +#~ " -h, --help display the short help (lists only the basic options)\n" +#~ " -H, --long-help display this long help and exit" +#~ msgstr "" +#~ " -h, --help vis den korte hjælpetekst (viser kun grundlæggende\n" +#~ " tilvalg)\n" +#~ " -H, --long-help vis den lange hjælpetekst og afslut" + +#~ msgid "" +#~ " -h, --help display this short help and exit\n" +#~ " -H, --long-help display the long help (lists also the advanced options)" +#~ msgstr "" +#~ " -h, --help vis den korte hjælpetekst og afslut\n" +#~ " -H, --long-help vis den lange hjælpetekst (viser også de avancerede\n" +#~ " tilvalg)" + +#~ msgid "Sandbox is disabled due to incompatible command line arguments" +#~ msgstr "Sandkassen er deaktiveret på grund af inkompatible kommandolinjeargumenter" + +#~ msgid "Sandbox was successfully enabled" +#~ msgstr "Sandkassen blev aktiveret" + +#~ msgid "Failed to enable the sandbox" +#~ msgstr "Kunne ikke aktivere sandkassen" + +#~ msgid "Memory usage limit for compression: " +#~ msgstr "Grænse for hukommelsesforbrug til komprimering: " + +#, c-format +#~ msgid " Streams: %s\n" +#~ msgstr " Strømme: %s\n" + +#, c-format +#~ msgid " Blocks: %s\n" +#~ msgstr " Blokke: %s\n" + +#, c-format +#~ msgid " Ratio: %s\n" +#~ msgstr " Pakkeforhold: %s\n" + +#, c-format +#~ msgid " Check: %s\n" +#~ msgstr " Kontrol: %s\n" + +#~ msgid "" +#~ " Streams:\n" +#~ " Stream Blocks CompOffset UncompOffset CompSize UncompSize Ratio Check Padding" +#~ msgstr "" +#~ " Strømme:\n" +#~ " Strøm Blokke KompForsk. DekompForsk. KompStr. DekompStr. Forh. Kontrol Fyld" + +#, c-format +#~ msgid "" +#~ " Blocks:\n" +#~ " Stream Block CompOffset UncompOffset TotalSize UncompSize Ratio Check" +#~ msgstr "" +#~ " Blokke:\n" +#~ " Strøm Blok KompForsk. DekompForsk. Ialtstr. DekompStr. Forh. Kontrol" + +#, c-format +#~ msgid " CheckVal %*s Header Flags CompSize MemUsage Filters" +#~ msgstr " KontrolVær %*sTeksth Flag Kompstr. HukForb. Filtre" + +#, c-format +#~ msgid "The selected match finder requires at least nice=%" +#~ msgstr "Den valgte matchfinder kræver mindst nice=%" diff --git a/cpp/third_party/xz-5.8.3/po/de.gmo b/cpp/third_party/xz-5.8.3/po/de.gmo new file mode 100644 index 0000000000..b1880f4e73 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/de.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/de.po b/cpp/third_party/xz-5.8.3/po/de.po new file mode 100644 index 0000000000..ab7d433b70 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/de.po @@ -0,0 +1,1267 @@ +# SPDX-License-Identifier: 0BSD +# +# German translation for xz. +# This file is published under the BSD Zero Clause License. +# André Noll , 2010. +# Anna Henningsen , 2015. +# Mario Blättermann , 2019, 2022-2025. +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: de\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"X-Generator: Lokalize 24.12.1\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Ungültiges Argument für --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Zu viele Argumente für --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "In --block-list fehlt die Blockgröße nach der Filterkettennummer »%c:«" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 kann nur das letzte Element in --block-list sein" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Unbekanntes Dateiformat" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Integritätsprüfungstyp nicht unterstützt" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Nur eine Datei kann als Argument für »--files« oder »--files0« angegeben werden." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Die Umgebungsvariable %s enthält zu viele Argumente" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Die Unterstützung für Kompression wurde zum Zeitpunkt der Erstellung deaktiviert" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Die Unterstützung für Dekompression wurde zum Zeitpunkt der Erstellung deaktiviert" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Kompression von lzip-Dateien (.lz) wird nicht unterstützt" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list wird ignoriert, außer wenn in das .xz-Format komprimiert wird" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Mit --format=raw ist --suffix=.SUF notwendig, falls nicht in die Standardausgabe geschrieben wird" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Maximal vier Filter möglich" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Fehler in der Option --filters%s=FILTER:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Die Speicherbedarfsbegrenzung ist für die gegebene Filter-Konfiguration zu niedrig." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "Filterkette %u wird von --block-list verwendet, wurde aber nicht mit --filters%u= angegeben" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Verwendung einer Voreinstellung im Roh-Modus wird nicht empfohlen." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Die genauen Optionen der Voreinstellung können zwischen Softwareversionen variieren." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Das .lzma-Format unterstützt nur den LZMA1-Filter" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 kann nicht mit dem .xz-Format verwendet werden" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Die Filterkette %u ist inkompatibel zu --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Wegen --flush-timeout wird auf den Einzelthread-Modus umgeschaltet" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Nicht unterstützte Optionen in Filterkette %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Bis zu % Threads werden benutzt." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Filterkette oder Filteroptionen werden nicht unterstützt" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Dekompression wird %s MiB Speicher brauchen." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Anzahl der Threads wurde von %s auf %s reduziert, um die Speicherbedarfsbegrenzung von %s MiB nicht zu übersteigen" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Anzahl der Threads wurde von %s auf einen reduziert. Die automatische Begrenzung des Speicherverbrauchs auf %s MiB wird immer noch überschritten. %s MiB an Speicher sind erforderlich. Es wird dennoch fortgesetzt." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Es wurde in den Einzelthread-Modus gewechselt, um die Speicherbedarfsbegrenzung von %s MiB nicht zu übersteigen" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Die LZMA%c-Wörterbuchgröße wurde von %s MiB auf %s MiB angepasst, um die Speicherbedarfsbegrenzung von %s MiB nicht zu übersteigen" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Die LZMA%c-Wörterbuchgröße für --filters%u wurde von %s MiB auf %s MiB angepasst, um die Speicherbedarfsbegrenzung von %s MiB nicht zu übersteigen" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Fehler beim Wechsel zur Filterkette %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Fehler beim Erzeugen der Pipeline: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() ist fehlgeschlagen: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Datei scheint verschoben worden zu sein, daher wird sie nicht gelöscht" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Löschen nicht möglich: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Dateieigentümer kann nicht gesetzt werden: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Dateigruppe kann nicht gesetzt werden: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Zugriffsrechte können nicht gesetzt werden: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Fehler beim Synchronisieren der Datei: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Fehler beim Synchronisieren des Verzeichnisses der Datei: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Dateistatus-Markierungen können nicht aus der Standardeingabe ermittelt werden: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Ist ein symbolischer Link, wird übersprungen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Ist ein Verzeichnis, wird übersprungen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Keine reguläre Datei, wird übersprungen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Datei hat das setuid- oder setgid-Bit gesetzt, wird übersprungen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Datei hat sticky-Bit gesetzt, wird übersprungen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Eingabedatei hat mehr als einen harten Link, wird übersprungen" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Leerer Dateiname, wird übersprungen" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Fehler beim Wiederherstellen der Status-Markierungen für die Standardeingabe: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Status-Markierungen der Standardausgabe können nicht ermittelt werden: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Fehler beim Öffnen des Verzeichnisses: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: Ziel ist keine reguläre Datei" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Fehler beim Wiederherstellen der O_APPEND-Markierungen für die Standardausgabe: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Fehler beim Schließen der Datei: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Positionierungsfehler beim Versuch, eine Sparse-Datei (dünnbesetzte Datei) zu erzeugen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Lesefehler: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Fehler beim Durchsuchen der Datei: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Unerwartetes Ende der Datei" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Schreibfehler: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Deaktiviert" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Gesamtmenge physischer Speicher (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Anzahl der Prozessor-Threads:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Kompression:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Dekompression:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Multithread-Dekompression:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Vorgabe für -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Hardware-Information:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Speicherbedarfsbegrenzung:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Datenströme:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blöcke:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Größe komprimiert:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Größe unkomprimiert:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Verhältnis:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Prüfung:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Datenstromauffüllung:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Benötigter Speicher:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Größe in Köpfen:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Anzahl Dateien:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Datenstrom" + +#: src/xz/list.c +msgid "Block" +msgstr "Block" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blöcke" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "KompVers" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "UnkompVers" + +#: src/xz/list.c +msgid "CompSize" +msgstr "KompGröße" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "UnkompGröße" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "Gesamt" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Verhältnis" + +#: src/xz/list.c +msgid "Check" +msgstr "Prüfung" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "Prüfwert" + +#: src/xz/list.c +msgid "Padding" +msgstr "Auffüllung" + +#: src/xz/list.c +msgid "Header" +msgstr "Kopf" + +#: src/xz/list.c +msgid "Flags" +msgstr "Flags" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "SpeichVerb" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filter" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Keine" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Unbek.2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Unbek.3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Unbek.5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Unbek.6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Unbek.7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Unbek.8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Unbek.9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Unbek.11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Unbek.12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Unbek.13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Unbek.14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Unbek.15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Datei ist leer" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Zu klein, um eine gültige .xz-Datei zu sein" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr " Str. Blöcke Kompr. Unkompr. Verh. Check Dateiname" + +#: src/xz/list.c +msgid "Yes" +msgstr "Ja" + +#: src/xz/list.c +msgid "No" +msgstr "Nein" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Minimal erforderliche XZ Utils-Version:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s Datei\n" +msgstr[1] "%s Dateien\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Gesamt:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list funktioniert nur mit .xz-Dateien (--format=xz oder --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Versuchen Sie »lzmainfo« mit .lzma-Dateien." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list unterstützt kein Lesen aus der Standardeingabe" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Fehler beim Lesen der Dateinamen: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Unerwartetes Ende der Eingabe beim Lesen der Dateinamen" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Null-Zeichen beim Lesen der Dateinamen gefunden; meinten Sie »--files0« statt »--files«?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Kompression und Dekompression mit --robot wird noch nicht unterstützt." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Lesen der Daten aus der Standardeingabe ist nicht möglich, wenn die Dateinamen auch aus der Standardeingabe gelesen werden" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Interner Fehler (Bug)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Signalroutine kann nicht gesetzt werden" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Keine Integritätsprüfung; Integrität der Datei wird nicht überprüft" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Typ der Integritätsprüfung wird nicht unterstützt; Integrität der Datei wird nicht überprüft" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Speicherbedarfsbegrenzung erreicht" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Dateiformat nicht erkannt" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Optionen nicht unterstützt" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Komprimierte Daten sind beschädigt" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Unerwartetes Ende der Eingabe" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB Speicher wird benötigt. Die Begrenzung ist deaktiviert." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB Speicher wird benötigt. Die Begrenzung ist %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Filterkette: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Versuchen Sie »%s --help« für mehr Informationen." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Fehler bei der Ausgabe des Hilfetextes (Fehlercode %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".END" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "FILE" +msgstr "DATEI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "FORMAT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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«" + +#: src/xz/message.c +msgid "NAME" +msgstr "NAME" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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." + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "ANZAHL" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "BEGRENZUNG" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTER" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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." + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "OPTIONEN" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "ZAHL" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "MODE" +msgstr "MODUS" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "Melden Sie Fehler an <%s> (auf Englisch oder Finnisch)." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Optionen müssen in der Form »Name=Wert« gegeben werden, getrennt durch Kommata" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Ungültiger Optionsname" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Ungültiger Optionswert" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "LZMA1/LZMA2-Voreinstellung wird nicht unterstützt: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Die Summe aus lc und lp darf höchstens 4 sein" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Dateiname hat unbekanntes Suffix, wird übersprungen" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Datei hat bereits das Suffix »%s«, wird übersprungen" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Ungültige Dateiendung" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Wert ist keine nicht-negative dezimale Ganzzahl" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Ungültige Einheit" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Gültige Einheiten sind »KiB« (2^10), »MiB« (2^20) und »GiB« (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Wert der Option »%s« muss im Bereich [%, %] sein" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Komprimierte Daten können nicht vom Terminal gelesen werden" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Komprimierte Daten können nicht auf das Terminal geschrieben werden" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Die Datei ist zu klein, um eine .lzma-Datei zu sein" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Keine .lzma-Datei" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Schreiben in die Standardausgabe fehlgeschlagen" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Unbekannter Fehler" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Voreinstellung wird nicht unterstützt" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Nicht unterstützter Schalter in der Voreinstellung" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Unbekannter Optionsname" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Optionswert darf nicht leer sein" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Wert ist außerhalb des zulässigen Bereichs" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Diese Option unterstützt keine Einheiten-Endungen" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Ungültige Einheit (KiB, MiB oder GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Unbekannter Filtername" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Dieser Filter kann nicht im .xz-Format verwendet werden" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Speicherzuweisung ist fehlgeschlagen" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Leere Zeichenkette ist nicht erlaubt; versuchen Sie »6«, wenn der Vorgabewert erwünscht ist" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Maximal vier Filter sind möglich" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Filtername fehlt" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Unzulässige Filterkette (»lzma2« fehlt am Ende?)" diff --git a/cpp/third_party/xz-5.8.3/po/en@boldquot.header b/cpp/third_party/xz-5.8.3/po/en@boldquot.header new file mode 100644 index 0000000000..ac96ad9f36 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/en@boldquot.header @@ -0,0 +1,35 @@ +%% A header that gets inserted into message catalogs named en@boldquot.po. +%% +%% Copyright (C) 2001 Free Software Foundation, Inc. +%% This file is free software; the Free Software Foundation +%% gives unlimited permission to copy and/or distribute it, +%% with or without modifications, as long as this notice is preserved. +%% This file is offered as-is, without any warranty. +%% +%% Written by Bruno Haible , 2001. +%% +# All this catalog "translates" are quotation characters. +# The msgids must be ASCII and therefore cannot contain real quotation +# characters, only substitutes like grave accent (0x60), apostrophe (0x27) +# and double quote (0x22). These substitutes look strange; see +# https://www.cl.cam.ac.uk/~mgk25/ucs/quotes.html +# +# This catalog translates grave accent (0x60) and apostrophe (0x27) to +# left single quotation mark (U+2018) and right single quotation mark (U+2019). +# It also translates pairs of apostrophe (0x27) to +# left single quotation mark (U+2018) and right single quotation mark (U+2019) +# and pairs of quotation mark (0x22) to +# left double quotation mark (U+201C) and right double quotation mark (U+201D). +# +# When output to an UTF-8 terminal, the quotation characters appear perfectly. +# When output to an ISO-8859-1 terminal, the single quotation marks are +# transliterated to apostrophes (by iconv in glibc 2.2 or newer) or to +# grave/acute accent (by libiconv), and the double quotation marks are +# transliterated to 0x22. +# When output to an ASCII terminal, the single quotation marks are +# transliterated to apostrophes, and the double quotation marks are +# transliterated to 0x22. +# +# This catalog furthermore displays the text between the quotation marks in +# bold face, assuming the VT100/XTerm escape sequences. +# diff --git a/cpp/third_party/xz-5.8.3/po/en@quot.header b/cpp/third_party/xz-5.8.3/po/en@quot.header new file mode 100644 index 0000000000..287e2e735b --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/en@quot.header @@ -0,0 +1,32 @@ +%% A header that gets inserted into message catalogs named en@quot.po. +%% +%% Copyright (C) 2001 Free Software Foundation, Inc. +%% This file is free software; the Free Software Foundation +%% gives unlimited permission to copy and/or distribute it, +%% with or without modifications, as long as this notice is preserved. +%% This file is offered as-is, without any warranty. +%% +%% Written by Bruno Haible , 2001. +%% +# All this catalog "translates" are quotation characters. +# The msgids must be ASCII and therefore cannot contain real quotation +# characters, only substitutes like grave accent (0x60), apostrophe (0x27) +# and double quote (0x22). These substitutes look strange; see +# https://www.cl.cam.ac.uk/~mgk25/ucs/quotes.html +# +# This catalog translates grave accent (0x60) and apostrophe (0x27) to +# left single quotation mark (U+2018) and right single quotation mark (U+2019). +# It also translates pairs of apostrophe (0x27) to +# left single quotation mark (U+2018) and right single quotation mark (U+2019) +# and pairs of quotation mark (0x22) to +# left double quotation mark (U+201C) and right double quotation mark (U+201D). +# +# When output to an UTF-8 terminal, the quotation characters appear perfectly. +# When output to an ISO-8859-1 terminal, the single quotation marks are +# transliterated to apostrophes (by iconv in glibc 2.2 or newer) or to +# grave/acute accent (by libiconv), and the double quotation marks are +# transliterated to 0x22. +# When output to an ASCII terminal, the single quotation marks are +# transliterated to apostrophes, and the double quotation marks are +# transliterated to 0x22. +# diff --git a/cpp/third_party/xz-5.8.3/po/eo.gmo b/cpp/third_party/xz-5.8.3/po/eo.gmo new file mode 100644 index 0000000000..7839b5360b Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/eo.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/eo.po b/cpp/third_party/xz-5.8.3/po/eo.po new file mode 100644 index 0000000000..e30cd86205 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/eo.po @@ -0,0 +1,1627 @@ +# SPDX-License-Identifier: 0BSD +# +# Esperanto translations for xz package. +# This file is published under the BSD Zero Clause License. +# Keith Bowes , 2019, 2023–2024. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.6.0-pre2\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: eo\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Nevalida parametro por --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Tro da argumentoj por --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "En --block-list, la blokgrando mankas post numero de la filtrila ĉeno '%c:'" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 povas nur esti uzata kiel la lasta elemento en --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Nekonata dosierformata tipo" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Nekomprenata tipo de integra kontrolo" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Nur unu dosiero estas specifebla per '--files' aŭ '--files0'." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "La medivariablo %s enhavas troajn argumentojn" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Rego de kunpremado estas malaktivigita dum muntotempo" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Rego de malkunpremado estas malaktivigita dum muntotempo" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Ne povas kunpremi lzip-dosierojn (.lz)" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list estas ignorata se ne kunpremas al la formato .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Kun --format=raw, --suffix=.SUF estas postulata se ne skribi al la ĉefeligujo" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Maksimuma nombra da filtriloj estas kvar" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Erora en la --filters%s=FILTRILOJ elekto:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Memoruzada limigo estas tro malgranda por la donita filtrila elekto." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "filtrila ĉeno %u uzata de --block-list sed ne specifita per --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Uzi aprioraĵon en kruda reĝimo estas malkonsilinda." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "La ĝustaj elektoj de la aprioraĵoj povas varii inter programoj eldonoj." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "La .lzma-formato komprenas sole la filtrilon LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA ne estas uzebla por la .xz-formato" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "La filtrila ĉeno %u estas nekongrua kun --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Ŝanĝas al unufadena reĝimo pro --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Nekomprenataj elektoj en filtrila ĉeno %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Uzas ĝis % fadenoj" + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Nekomprenata filtrila ĉeno aŭ filtrilaj elektoj" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Malkunpremado postulos %s megabajtojn da memoro." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Malpliigis la nombron da fadenoj de %s ĝis %s por ne superi la memoruzadan limigo de %s megabajtoj" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Malpliigis la nombron da fadenoj de %s ĝis unu. La aŭtomata memoruzada limigo de %s megabajtoj ankoraŭ estas superata. %s megabajtoj da memoro estas postulata. Senkonsidere daŭrigas." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Ŝanĝas al unufadena reĝimo por ne superi la memoruzadan limigon de %s megabajtoj" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Alĝŭstigis vortara grando de LZMA%c de %s megabajtoj ĝis %s megabajtoj por ne superi la memoruzadan limigon de %s megabajtoj" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Alĝustigis vortara grando de LZMA%c por --filters%u de %s megabajtoj ĝis %s megabajtoj por ne superi la memoruzadan limigon de %s megabajtoj" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Eraro dum ŝanĝiĝo al filtrila ĉeno %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Eraro dum krei dukton: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() malsukcesis: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Dosiero ŝajne estis movita, ne forigos" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Ne eblas forigi: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Ne eblas agordi la dosieran estron: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Ne eblas agordi la dosieran grupon: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Ne eblas agordi la dosierajn atingopermesojn: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Fermo de la dosiero malsukcesis: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Fermo de la dosiero malsukcesis: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Eraro dum atingi la dosierstatajn flagojn de ĉefenigujon: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Estas simbola ligilo, preterpasas" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Estas dosierujo, preterpasas" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Ne regula dosiero, preterpasas" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Dosiero havas setuid- aŭ setgid-biton, preterpasas" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Dosiero havas glueman biton, preterpasas" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Enmeta dosiero havas pli ol rektan ligilon, preterpasas" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Malplena dosiero, preterpasas" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Eraro dum restarigi la statajn flagojn de la ĉefenigujo: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Eraro dum atingi la dosierstatajn flagojn el la ĉefenigujo: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Fermo de la dosiero malsukcesis: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Not a regular file, skipping" +msgid "%s: Destination is not a regular file" +msgstr "%s: Ne regula dosiero, preterpasas" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Eraro dum restarigi la flagon O_APPEND de la ĉefenigujo: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Fermo de la dosiero malsukcesis: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Serĉado malsukcesis dum provi krei maldensan dosieron: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Legeraro: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Eraro dum serĉi la dosieron: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Neatendita dosierfino" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Skriberaro: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Malaktiva" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Kiomo da efektiva memoro (ĉefmemoro)" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Nombro da procesoraj fadenoj:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Kunpremo:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Malkunmpreno:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Plurfadena malkunpremado:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Aprioraĵo por -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Aparataro-informoj:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Memoruzada limigoj:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Fluoj:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blokoj:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Kunpremita grando:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Nekunpremita grando:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Proporcio:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Kontrolo:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Fluo-remburo:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Memoro postulata:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Grandoj en ĉapoj:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Nombro da dosieroj:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Fluo" + +#: src/xz/list.c +msgid "Block" +msgstr "Bloko" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blokoj" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "KunpMsam" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "MKunMSam" + +#: src/xz/list.c +msgid "CompSize" +msgstr "Kunpgrando" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "Mkunpgrando" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "KiomGrando" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Proporcio" + +#: src/xz/list.c +msgid "Check" +msgstr "Kontrolo" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "KontVal" + +#: src/xz/list.c +msgid "Padding" +msgstr "Remburo" + +#: src/xz/list.c +msgid "Header" +msgstr "Ĉapo" + +#: src/xz/list.c +msgid "Flags" +msgstr "Flago" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "Memuzado" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filtriloj" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Nenio" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Nekonata-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Nekonata-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Nekonata-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Nekonata-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Nekonata-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Nekonata-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Nekonata-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Nekonata-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Nekonata-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Nekonata-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Nekonata-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Nekonata-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Dosiero malplenas" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Tro malgranda por esti valida .xz-dosiero" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Fluoj Blokoj Kunpremita Nekunpremita Propor Kontrol Dosiernomo" + +#: src/xz/list.c +msgid "Yes" +msgstr "Jes" + +#: src/xz/list.c +msgid "No" +msgstr "Ne" + +#: src/xz/list.c +#, fuzzy +#| msgid " Minimum XZ Utils version: %s\n" +msgid "Minimum XZ Utils version:" +msgstr " Minimuma eldono de XZ Utils: %s\n" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s dosiero\n" +msgstr[1] "%s dosieroj\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Sumoj:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list funkcias nur por .xz-dosierojn (--format=xz aŭ --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Provi la programon 'lzmainfo' por .lzma-dosieroj." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list ne regas legadon el la ĉefenigujo" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Eraro dum legi dosiernomojn: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Neatendita fino de enigo dum legi dosiernomojn" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Nula signo trovita dum legi dosiernomojn; eble vi celis uzi la parametron '--files0' anstataŭ '--files'" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Kunpremo kaj malkunmpremo per --robot ankoraŭ ne estas regataj." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Ne eblas legi datumojn el la ĉefenigujo dum legi dosiernomojn el la ĉefenigujo" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Interna programeraro" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Ne eblas establi signalajn traktilojn" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Neniu integra kontrolo; ne certigos dosieran integron" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Nekomprenata tipo de integra kontrolo; ne certigos dosieran integron" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Memoruzada limigo atingita" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Dosierformato ne rekonata" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Nekomprenataj elektoj" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Kunpremitaj datumoj estas koruptaj" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Neatendita fino de enigo" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s megabajtoj da memoro estas postulataj. La limigilo estas malaktiva." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s megabajtoj da memoro estas postulata. La limigo estas %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Filtrila ĉeno: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "'%s --help' por pliaj informaj." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the 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 "" +#| "Usage: %s [OPTION]... [FILE]...\n" +#| "Compress or decompress FILEs in the .xz format.\n" +#| "\n" +msgid "Compress or decompress FILEs in the .xz format." +msgstr "" +"Uzmaniero: %s [ELEKTO].. [DOSIERO]...\n" +"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 interpreted as a zero-width space (the 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 "" +"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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Operation modifiers:\n" +msgid "Operation modifiers:" +msgstr "" +"\n" +" Operacia modifiloj:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| " --single-stream decompress only the first stream, and silently\n" +#| " ignore possible remaining input data" +msgid "decompress only the first stream, and silently ignore possible remaining input data" +msgstr "" +" --single-stream\n" +" 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Basic file format and compression options:\n" +msgid "Basic file format and compression options:" +msgstr "" +"\n" +" Bazaj dosierformataj kaj kunpremaj elektoj:\n" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " -0 ... -9 compression preset; default is 6; take compressor *and*\n" +#| " decompressor memory usage into account before using 7-9!" +msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!" +msgstr "" +" -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 interpreted as a zero-width space (the 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 "" +#| " -e, --extreme try to improve compression ratio by using more CPU time;\n" +#| " does not affect decompressor memory requirements" +msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements" +msgstr "" +" -e, --extreme provi plibonigi kunpreman proporcion per uzado de\n" +" ĉefprocesoran tempon; ne influas la memorajn postulojn\n" +" de malkunpremo" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -T, --threads=NUM use at most NUM threads; the default is 0 which uses\n" +#| " as many threads as there are processor cores" +msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores" +msgstr "" +" -T, --threads=NOMBRO\n" +" uzi maksimume NOMBRO da fadenoj; apriore 0, kiu\n" +" uzas fadenojn samnombrajn kiel procesorajn kernojn" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-size=SIZE\n" +#| " start a new .xz block after every SIZE bytes of input;\n" +#| " use this to set the block size for threaded compression" +msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression" +msgstr "" +" --block-size=GRANDO\n" +" komenci novan .xz-blokon post ĉiu GRANDO bajtoj da enigo;\n" +" uzi por agordi la blokan grandon por kunfadena kunpremo" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-list=BLOCKS\n" +#| " start a new .xz block after the given comma-separated\n" +#| " intervals of uncompressed data; optionally, specify a\n" +#| " filter chain number (0-9) followed by a ':' before the\n" +#| " uncompressed data size" +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 "" +" --block-list=BLOKOJ\n" +" komenci novan .xz-blokon post la donitajn intertempojn de\n" +" nekunpremitaj datumoj, apartigataj de komoj. Laŭvole\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --flush-timeout=TIMEOUT\n" +#| " when compressing, if more than TIMEOUT milliseconds has\n" +#| " passed since the previous flush and reading more input\n" +#| " would block, all pending data is flushed out" +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 "" +" --flush-timeout=TEMPOLIMO\n" +" dum kunpremo se pli ol TEMPOLIMO milisekundoj\n" +" okazis post la antaŭan elbufrigo kaj legi pliajn enigojn\n" +" paŭzigus, ĉiuj atendataj datumoj estas elbufrigataj" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --no-adjust if compression settings exceed the memory usage limit,\n" +#| " give an error instead of adjusting the settings downwards" +msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards" +msgstr "" +" --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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Custom filter chain for compression (alternative for using presets):" +msgid "Custom filter chain for compression (an alternative to using presets):" +msgstr "" +"\n" +" Propra filtrila ĉeno por kunpremo (alternativaj por uzi antaŭagordaĵon):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| " --filters=FILTERS set the filter chain using the liblzma filter string\n" +#| " syntax; use --filters-help for more information" +msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information" +msgstr "" +"\n" +" --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 interpreted as a zero-width space (the 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 "" +#| " --filters1=FILTERS ... --filters9=FILTERS\n" +#| " set additional filter chains using the liblzma filter\n" +#| " string syntax to use with --block-list" +msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list" +msgstr "" +" --filters=FILTRILOJ ... --filters9=FILTRILOJ\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --filters-help display more information about the liblzma filter string\n" +#| " syntax and exit." +msgid "display more information about the liblzma filter string syntax and exit" +msgstr "" +" --filters-help montri pliajn informojn pri la sintakso de la\n" +" liblzma-filtrila ĉeno kaj poste eliri." + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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:" +msgid "number of position bits" +msgstr "Nombro da procesoraj fadenoj:" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Other options:\n" +msgid "Other options:" +msgstr "" +"\n" +" Aliaj elektoj:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --info-memory display the total amount of RAM and the currently active\n" +#| " memory usage limits, and exit" +msgid "display the total amount of RAM and the currently active memory usage limits, and exit" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| "With no FILE, or when FILE is -, read standard input.\n" +msgid "With no FILE, or when FILE is -, read standard input." +msgstr "" +"\n" +"Kun neniu DOSIERO aŭ kiam DOSIERO estas -, legi el la ĉefenigujo.\n" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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" +msgid "Report bugs to <%s> (in English or Finnish)." +msgstr "Raporti programerarojn al <%s> (en la angla aŭ la suoma).\n" + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "Filter chains are set using the --filters=FILTERS or\n" +#| "--filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain\n" +#| "can be separated by spaces or '--'. Alternatively a preset <0-9>[e] can be\n" +#| "specified instead of a filter chain.\n" +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 "" +"Filtrilaj ĉenoj estas agorditaj per la elektoj --filters=FIILTRILOJ aŭ\n" +"--filters1=FILTRILOJ ... --filters9=FILTRILOJ. Ĉiu filtrilo en la ĉeno\n" +"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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Options must be 'name=value' pairs separated with commas" +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "%s: Elektoj devas esti paroj de 'name=value', apartigitaj per komoj" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Nevalida elekto-nomo" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option value" +msgid "Invalid option value" +msgstr "%s: Nevalida elekto-valoro" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Nevalida LZMA1/LZMA2 antaŭagordaĵo: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "La sumo de lc kaj lp devas ne esti pli ol 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Dosiernomo havas nekonatan sufikson, preterpasas" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Dosiero jam havas la sufikson '%s', preterpasas" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Nevalida dosiernoma sufikso" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Value is not a non-negative decimal integer" +msgid "Value is not a non-negative decimal integer" +msgstr "%s: Valoro ne estas nenegativa dekuma entjero" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Nevalida multiplika sufikso" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Validaj sufiksoj estas 'KiB' (2^10), 'MiB' (2^20) kaj 'GiB' (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Valoro de la elekto '%s' devas esti inkluzive inter % kaj %" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Kunpremitaj datumoj ne povas esti ligataj de terminalo" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Kunpremitaj datumoj ne povas esti skribataj al terminalo" + +#: src/lzmainfo/lzmainfo.c +#, fuzzy, c-format +#| msgid "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Usage: %s [--help] [--version] [FILE]...\n" +msgstr "" +"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 interpreted as a zero-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 "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Show information stored in the .lzma file header." +msgstr "" +"Uzmaniero: %s [--help] [--version] [DOSIERO]...\n" +"Montri informojn konservitaj en la .lzma-dosiera ĉapo" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Dosiero malgrandas por esti .lzma-dosiero" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Ne .lzma-dosiero" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Skribi al la ĉefeligujo malsukcesis" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Nekonata eraro" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported options" +msgid "Unsupported preset" +msgstr "Nekomprenataj elektoj" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported filter chain or filter options" +msgid "Unsupported flag in the preset" +msgstr "Nekomprenata filtrila ĉeno aŭ filtrilaj elektoj" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option name" +msgid "Unknown option name" +msgstr "%s: Nevalida elekto-nomo" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid multiplier suffix" +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "%s: Nevalida multiplika sufikso" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Unknown file format type" +msgid "Unknown filter name" +msgstr "%s: Nekonata dosierformata tipo" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "LZMA1 cannot be used with the .xz format" +msgid "This filter cannot be used in the .xz format" +msgstr "LZMA ne estas uzebla por la .xz-formato" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Maximum number of filters is four" +msgid "The maximum number of filters is four" +msgstr "Maksimuma nombra da filtriloj estas kvar" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" + +#~ msgid "" +#~ " -z, --compress force compression\n" +#~ " -d, --decompress force decompression\n" +#~ " -t, --test test compressed file integrity\n" +#~ " -l, --list list information about .xz files" +#~ msgstr "" +#~ " -z, --compress eldevigi kunpremon\n" +#~ " -d, --decompress eldevigi malkunpremon\n" +#~ " -t, --test certigi la integron de kunpremitan dosieron\n" +#~ " -l, --list listigi informojn pri .xz-dosierojn" + +#~ msgid "" +#~ " -k, --keep keep (don't delete) input files\n" +#~ " -f, --force force overwrite of output file and (de)compress links\n" +#~ " -c, --stdout write to standard output and don't delete input files" +#~ msgstr "" +#~ " -k, --keep ne forigi enigajn dosierojn\n" +#~ " -f, --force eldevigi anstataŭigi eligajn dosierojn kaj\n" +#~ " (mal)kunpmremajn ligilojn \n" +#~ " -c, --stdout skribi al la ĉefeligujo kaj ne forigi enigajn dosierojn" + +#~ msgid "" +#~ " --no-sparse do not create sparse files when decompressing\n" +#~ " -S, --suffix=.SUF use the suffix '.SUF' on compressed files\n" +#~ " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~ " omitted, filenames are read from the standard input;\n" +#~ " filenames must be terminated with the newline character\n" +#~ " --files0[=FILE] like --files but use the null character as terminator" +#~ msgstr "" +#~ " --no-sparse ne krei maldensajn dosierojn dum malkunpremiĝo\n" +#~ " -S, --suffix=.SUF uzi la sufikson '.SUF' ĉe kunpremataj dosieroj\n" +#~ " --files[=DOSIERO]\n" +#~ " legi dosiernomojn traktotajn el DOSIERO; se DOSIERO estas\n" +#~ " forlasita, dosiernomoj estas legataj el la ĉefenigujo;\n" +#~ " dosiernomojn devas finigi novlinia signo\n" +#~ " --files0[=DOSIERO]\n" +#~ " kiel --files sed uzi la nulan signon por finigi" + +#~ msgid "" +#~ " -F, --format=FMT file format to encode or decode; possible values are\n" +#~ " 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'\n" +#~ " -C, --check=CHECK integrity check type: 'none' (use with caution),\n" +#~ " 'crc32', 'crc64' (default), or 'sha256'" +#~ msgstr "" +#~ "h -F, --format=FMT dosierformato kodota aŭ malkodata; validaj valoroj estas\n" +#~ " 'auto' (apriora), 'xz', 'lzma', 'lzip' kaj 'raw'\n" +#~ " -C, --check=KONT tipo de integra kontrolo: 'none' (estu atentema),\n" +#~ " 'crc32', 'crc64' (apriora) aŭ 'sha256'" + +#, no-c-format +#~ msgid "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " --memlimit-mt-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " set memory usage limit for compression, decompression,\n" +#~ " threaded decompression, or all of these; LIMIT is in\n" +#~ " bytes, % of RAM, or 0 for defaults" +#~ msgstr "" +#~ " --memlimit-compress=LIMIGO\n" +#~ " --memlimit-decompress=LIMIGO\n" +#~ " --memlimit-mt-decompress=LIMIGO\n" +#~ " -M, --memlimit=LIMO\n" +#~ " agordi memoruzadon por kunpremo, malkunpremo,\n" +#~ " kunfadena kunpmero aŭ ĉiuj el tiuj; LIMIGO estas\n" +#~ " laŭ bajtoj, % da ĉefmemoro, aŭ 0 por aprioraĵoj" + +#~ msgid "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1 or LZMA2; OPTS is a comma-separated list of zero or\n" +#~ " --lzma2[=OPTS] more of the following options (valid values; default):\n" +#~ " preset=PRE reset options to a preset (0-9[e])\n" +#~ " dict=NUM dictionary size (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NUM number of literal context bits (0-4; 3)\n" +#~ " lp=NUM number of literal position bits (0-4; 0)\n" +#~ " pb=NUM number of position bits (0-4; 2)\n" +#~ " mode=MODE compression mode (fast, normal; normal)\n" +#~ " nice=NUM nice length of a match (2-273; 64)\n" +#~ " mf=NAME match finder (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM maximum search depth; 0=automatic (default)" +#~ msgstr "" +#~ "\n" +#~ " --lzma1[=ELEKTOJ] LZMA1 aŭ LZMA2; OPTS estas listo de nul aŭ pliaj\n" +#~ " --lzma2[=ELEKTOJ] de la jenaj elektoj (validaj valoroj; apriora),\n" +#~ " apartigataj de komoj:\n" +#~ " preset=ANT restarigi agordon al antaŭagordaĵon (0-9[e])\n" +#~ " dict=NOM vortara grando (4 kilobajtoj - 1536\n" +#~ " megabajtoj; 8 megabajtoj)\n" +#~ " lc=NOM nombro da laŭvortaj kuntekstaj bitoj\n" +#~ " (0-4; 3)\n" +#~ " lp=NOM nombro da laŭvortaj poziciaj bitoj (0-4; 0)\n" +#~ " pb=NOM nombro da poziciaj bitoj (0-4; 2)\n" +#~ " mode=REĜI kunprema reĝimo (fast, normal; normal)\n" +#~ " nice=NOM bona longo de kongruaĵo (2-273; 64)\n" +#~ " mf=NOMO kongruaĵa trovilo (hc3, hc4, bt2, bt3, bt4;\n" +#~ " bt4)\n" +#~ " depth=NUM maksimuma profundo de serĉo; 0=aŭtomata\n" +#~ " (apriore)" + +#~ msgid "" +#~ "\n" +#~ " --x86[=OPTS] x86 BCJ filter (32-bit and 64-bit)\n" +#~ " --arm[=OPTS] ARM BCJ filter\n" +#~ " --armthumb[=OPTS] ARM-Thumb BCJ filter\n" +#~ " --arm64[=OPTS] ARM64 BCJ filter\n" +#~ " --powerpc[=OPTS] PowerPC BCJ filter (big endian only)\n" +#~ " --ia64[=OPTS] IA-64 (Itanium) BCJ filter\n" +#~ " --sparc[=OPTS] SPARC BCJ filter\n" +#~ " --riscv[=OPTS] RISC-V BCJ filter\n" +#~ " Valid OPTS for all BCJ filters:\n" +#~ " start=NUM start offset for conversions (default=0)" +#~ msgstr "" +#~ "\n" +#~ " --x86[=ELEKTOJ] x86-BCJ-filtrilo (32-bita kaj 64-bita)\n" +#~ " --arm[=ELEKTOJ] ARM-BCJ-filtrilo\n" +#~ " --armthumb[=ELEKTOJ]\n" +#~ " ARM-Thumb-BCJ-filtrilo\n" +#~ " --arm64[=OPTS] ARM64-BCJ-filtrilo\n" +#~ " --powerpc[=ELEKTOJ] PowerPC-BCJ-filtrilo (nur pezkomenca)\n" +#~ " --ia64[=ELEKTOJ] IA-64 (Itanium)-BCJ-filtrilo\n" +#~ " --sparc[=ELEKTOJ] SPARC-BCJ-filtrilo\n" +#~ " --riscv[=ELEKTOJ] RISC-V_BCJ-filtrilo\n" +#~ " Validaj ELEKTOJ por ĉiuj BCJ-filters:\n" +#~ " start=NOMBRO komenca deŝovo por konvertoj (apriore 0)" + +#~ msgid "" +#~ "\n" +#~ " --delta[=OPTS] Delta filter; valid OPTS (valid values; default):\n" +#~ " dist=NUM distance between bytes being subtracted\n" +#~ " from each other (1-256; 1)" +#~ msgstr "" +#~ "\n" +#~ " --delta[=ELEKTOJ] Delta filtriloj; validaj valoroj:\n" +#~ " dist=NOMBRO distanco inter bajtoj subtrahataj de unu\n" +#~ " la alia (1-256; 1)" + +#~ msgid "" +#~ " -q, --quiet suppress warnings; specify twice to suppress errors too\n" +#~ " -v, --verbose be verbose; specify twice for even more verbose" +#~ msgstr "" +#~ " -q, --quiet silentigi avertojn; uzu dufoje por ankaŭ silentigi erarojn\n" +#~ " -v, --verbose eligi superfluajn informojn; uzu dufoje por pliigi la\n" +#~ " superfluecon" + +#~ msgid "" +#~ " -h, --help display the short help (lists only the basic options)\n" +#~ " -H, --long-help display this long help and exit" +#~ msgstr "" +#~ " -h, --help montri la mallongan helpon (listigas nur la bazajn\n" +#~ " elektojn)\n" +#~ " -H, --long-help montri la longan helpon kaj finiĝi" + +#~ msgid "" +#~ " -h, --help display this short help and exit\n" +#~ " -H, --long-help display the long help (lists also the advanced options)" +#~ msgstr "" +#~ " -h, --help montri ĉi tiun mallongan helpon kaj finiĝi\n" +#~ " -H, --long-help montri la longan helpon (listigas ankaŭ la altnivelajn\n" +#~ " elektojn)" + +#~ msgid "Failed to enable the sandbox" +#~ msgstr "Malsukcesis aktivigi la sablujon" diff --git a/cpp/third_party/xz-5.8.3/po/es.gmo b/cpp/third_party/xz-5.8.3/po/es.gmo new file mode 100644 index 0000000000..abc29a1e59 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/es.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/es.po b/cpp/third_party/xz-5.8.3/po/es.po new file mode 100644 index 0000000000..4517d19574 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/es.po @@ -0,0 +1,1266 @@ +# SPDX-License-Identifier: 0BSD +# +# 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.8.0-pre1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Argumento inválido para --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Demasiados argumentos para --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "En --block-list, falta el tamaño de bloque después del número de cadena de filtros '%c:'" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 solo se puede usar como el último elemento en --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Tipo de formato de fichero desconocido" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: No se admite el tipo de verificación de integridad" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Solo se puede especificar un fichero con '--files' o '--files0'." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "La variable de ambiente %s contiene demasiados argumentos" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Se desactivó el soporte para compresión en el momento de compilación" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Se desactivó el soporte para descompresión en el momento de compilación" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "No se admite la compresión de ficheros lzip (.lz)" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list se descarta a menos que se comprima con el formato .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Con --format=raw, se requiere --suffix=.SUF a menos que se escriba a la salida estándar" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "El número máximo de filtros es cuatro" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Error en la opción --filters%s=FILTROS:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "El límite de uso de memoria es demasiado bajo para la configuración de filtros dada." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "la cadena de filtros %u es usada por --block-list pero no se especifica con --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "No se recomienda un modo predeterminado en modo crudo." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "El número exacto de las opciones predeterminadas puede variar entre versiones del software." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "El formato .lzma solamente admite el filtro LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "No se puede usar LZMA1 con el formato .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "La cadena de filtros %u es incompatible con --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Se cambia al modo de un solo hilo debido a --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Opciones sin soporte en la cadena de filtros %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Se usan hasta % hilos." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "No se admiten las opciones de cadena de filtros o de filtro" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "La descompresión necesitará %s MiB de memoria." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Se reduce el número de hilos de %s a %s para no exceder el límite de uso de memoria de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Se reduce el número de hilos de %s a uno. Aún se está excediendo el límite automático de uso de memoria de %s MiB. Se requieren %s MiB de memoria. Continúa de cualquier manera." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Se ajusta al modo de un solo hilo para no exceder el límite de uso de memoria de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Se ajusta el tamaño del diccionario LZMA%c de %s MiB a %s MiB para no exceder el límite de uso de memoria de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Se ajusta el tamaño del diccionario LZMA%c para --filters%u de %s MiB a %s MiB para no exceder el límite de uso de memoria de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Error al cambiar a la cadena de filtros %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Error al crear una tubería: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: falló poll(): %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Al parecer se movió el fichero, no se borra" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: No se puede borrar: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: No se puede establecer el propietario del fichero: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: No se puede establecer el grupo del fichero: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: No se pueden establecer los permisos del fichero: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Falló al sincronizar el fichero: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Falló al sincronizar el directorio del fichero: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Error al obtener la opciones de estado de fichero de la entrada estándar: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Es un enlace simbólico, se salta" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Es un directorio, se salta" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: No es un fichero regular, se salta" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: El fichero tiene el bit setuid o setgid activo, se salta" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: El fichero tiene el bit sticky activo, se salta" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: El fichero de entrada tiene más de un enlace duro, se salta" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Nombre de fichero vacío, se salta" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Error al restaurar las opciones de estado en la entrada estándar: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Error al obtener las opciones de estado de fichero de la entrada estándar: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Falló al abrir el directorio: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: El destino no es un fichero regular" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Error al restaurar la opción O_APPEND a la salida estándar: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Falló al cerrar el fichero: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Falló la búsqueda al tratar de crear un fichero disperso: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Error de lectura: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Error al buscar en el fichero: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Fin de fichero inesperado" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Error de escritura: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Desactivado" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Cantidad total de memoria física (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Número de hilos de procesador:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Compresión" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Descompresión:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Descompresión multihilos:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Por omisión para -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Información de hardware:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Límites de uso de memoria:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Flujos:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Bloques:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Tamaño comprimido:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Tamaño sin comprimir:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Tasa:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Verificación:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Relleno de flujo:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Memoria requerida:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Tamaños en cabeceras:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Número de ficheros:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Flujo" + +#: src/xz/list.c +msgid "Block" +msgstr "Bloque" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Bloques" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "DesplComp" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "DesplDescomp" + +#: src/xz/list.c +msgid "CompSize" +msgstr "TamComp" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "TamDescomp" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "TamTotal" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Tasa" + +#: src/xz/list.c +msgid "Check" +msgstr "Verif" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "ValVerif" + +#: src/xz/list.c +msgid "Padding" +msgstr "Relleno" + +#: src/xz/list.c +msgid "Header" +msgstr "Cabecera" + +#: src/xz/list.c +msgid "Flags" +msgstr "Opciones" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "UsoMem" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filtros" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Ninguno" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Descon-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Descon-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Descon-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Descon-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Descon-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Descon-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Descon-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Descon-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Descon-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Descon-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Descon-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Descon-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: El fichero está vacío" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Demasiado pequeño para ser un fichero .xz válido" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Flujos Bloques Comprimido Sin-Comprimir Tasa Verif Nombre-Fichero" + +#: src/xz/list.c +msgid "Yes" +msgstr "Sí" + +#: src/xz/list.c +msgid "No" +msgstr "No" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Versión mínima de Herramientas XZ:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s fichero\n" +msgstr[1] "%s ficheros\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Totales:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list solo funciona con ficheros .xz (--format=xz o --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Pruebe 'lzmainfo' con ficheros .lzma." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list no admite leer de la entrada estándar" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Error al leer nombres de fichero: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Fin de entrada inesperada al leer nombres de fichero" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Se encontraron caracteres nulos al leer nombres de ficheros. ¿Tal vez quería usar '--files0' en lugar de '--files'?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Aún no se admite la compresión y descompresión con --robot." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "No se pueden leer datos de la entrada estándar cuando se leen nombres de fichero de la entrada estándar" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Error interno (bug)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "No se pueden establecer los manejadores de señales" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "No hay revisión de integridad; no se verifica la integridad del fichero" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "No se admite el tipo de revisión de integridad; no se verifica la integridad del fichero" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Se alcanzó el límite de uso de memoria" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "No se reconoce el formato del fichero" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Opciones sin soporte" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Los datos comprimidos están corruptos" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Fin de entrada inesperado" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "Se requieren %s MiB de memoria. Se desactiva el limitador." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "Se requieren %s MiB de memoria. El límite es %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Cadena de filtro: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Pruebe '%s --help' para obtener más información." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Error al mostrar el texto de ayuda (código de error %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".SUF" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "FILE" +msgstr "FICHERO" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "FORMATO" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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'" + +#: src/xz/message.c +msgid "NAME" +msgstr "NOMBRE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOQUES" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTROS" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "OPCS" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "PRE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "MODE" +msgstr "MODO" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "" +"Reporte errores a <%s> (en inglés o finlandés).\n" +"Reporte errores de traducción al español a ." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Las opciones deben ser pares 'nombre=valor' separadas por comas" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Nombre de opción inválido" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Valor de opción inválido" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "No se admite el valor predefinido LZMA1/LZMA2: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "La suma de lc y lp no debe exceder 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: El nombre de fichero tiene un sufijo desconocido, se salta" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: El fichero ya tiene un sufijo '%s', se salta" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Sufijo de nombre de fichero inválido" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "El valor no es un entero decimal no-negativo" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Sufijo multiplicador inválido" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Los sufijos válidos son 'KiB' (2^10), 'MiB' (2^20), y 'GiB' (2^30)." + +#: 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 intervalo [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "No se pueden leer datos comprimidos de una terminal" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "No se pueden escribir datos comprimidos a una terminal" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "El fichero es demasiado pequeño para ser un fichero .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "No es un fichero .lzma" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Falló la escritura a la salida estándar" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Error desconocido" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Opción sin soporte" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Opción sin soporte en el valor predefinido" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Nombre de opción inválido" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "El valor de la opción no puede estar vacío" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Valor fuera de intervalo" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Esta opción no admite ningún sufijo multiplicador" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Sufijo multiplicador inválido (KiB, MiB, o GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Nombre de filtro desconocido" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Este filtro no se puede usar en el formato .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Falló el alojamiento de memoria" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "No se permite una cadena vacía, pruebe con '6' si se requiere un valor por defecto" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "El número máximo de filtros es cuatro" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Falta el nombre del filtro" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Cadena de filtro inválida (¿falta 'lzma2' al final?)" diff --git a/cpp/third_party/xz-5.8.3/po/fi.gmo b/cpp/third_party/xz-5.8.3/po/fi.gmo new file mode 100644 index 0000000000..a850488589 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/fi.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/fi.po b/cpp/third_party/xz-5.8.3/po/fi.po new file mode 100644 index 0000000000..d5c2d1c196 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/fi.po @@ -0,0 +1,1266 @@ +# SPDX-License-Identifier: 0BSD +# +# Finnish translations for xz package +# Suomenkielinen käännös xz-paketille. +# This file is published under the BSD Zero Clause License. +# Lauri Nurmi , 2019, 2020, 2022, 2025. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: fi\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.5\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Virheellinen argumentti valitsimelle --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Liian monta argumenttia valitsimelle --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "Valitsimen --block-list yhteydessä lohkon koko puuttuu suodinketjun numeron '%c:' jälkeen" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 kelpaa vain viimeiseksi alkioksi valitsimen --block-list kanssa" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Tuntematon tiedostomuototyyppi" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Eheystarkistuksen tyyppiä ei tueta" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Vain yksi tiedosto voidaan antaa valitsimille ”--files” ja ”--files0”." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Ympäristömuuttuja %s sisältää liian monta argumenttia" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Tiivistämistuki on poistettu käytöstä käännösaikana" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Purkutuki on poistettu käytöstä käännösaikana" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Lzip-tiedostojen (.lz) tiivistämistä ei tueta" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list jätetään huomiotta, ellei olla tiivistämässä .xz-muotoon" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "--format=raw vaatii, että --suffix=.PÄÄTE on annettu, ellei kirjoiteta vakiotulosteeseen" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Suodattimien enimmäismäärä on neljä" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Virhe --filters%s=SUOTIMET-asetuksessa:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Muistinkäytön raja on liian matala valituille suotimille." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "--block-list käyttää suodinketjua %u, jota ei ole määritelty --filters%u=:lla" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Esiasetusten käyttö raw-tilassa ei ole suositeltavaa." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Esiasetusten tarkat asetukset saattavat vaihdella ohjelmistoversioiden välillä." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr ".lzma-muoto tukee vain LZMA1-suodinta" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1:tä ei voi käyttää .xz-muodon kanssa" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Suodinketju %u on yhteensopimaton valitsimen --flush-timeout kanssa" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Vaihdetaan yksisäikeiseen tilaan valitsimen --flush-timeout vuoksi" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Ei-tuettuja asetuksia suodinketjussa %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Käytetään enintään % säiettä." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Ei-tuetut suodinketjun tai suotimen asetukset" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Purkaminen vaatii %s MiB muistia." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Pudotettiin säikeiden määrä %s säikeestä %s:een, jottei ylitettäisi %s MiB:n rajaa muistinkäytölle" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Pudotettiin säikeiden määrä %s säikeestä yhteen. Automaattinen %s MiB:n raja muistinkäytölle ylittyy silti. Vaaditaan %s MiB muistia. Jatketaan kaikesta huolimatta." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Siirrytään yhden säikeen tilaan, jottei ylitettäisi %s MiB:n rajaa muistinkäytölle" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Pudotettiin LZMA%c-sanaston koko %s MiB:stä %s MiB:hen, jottei ylitettäisi %s MiB:n rajaa muistinkäytölle" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Pudotettiin LZMA%c-sanaston koko --filter%u:lle %s MiB:stä %s MiB:hen, jottei ylitettäisi %s MiB:n rajaa muistinkäytölle" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Virhe vaihdettaessa suodinketjuun %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Virhe putkea luodessa: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll()-kutsu epäonnistui: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Tiedosto on nähtävästi siirretty, ei poisteta" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Ei voi poistaa: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Tiedoston omistajaa ei voi asettaa: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Tiedoston ryhmää ei voi asettaa: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Tiedoston oikeuksia ei voi asettaa: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Tiedoston synkronointi epäonnistui: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Tiedoston hakemiston synkronointi epäonnistui: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Virhe tiedoston tilalippujen noutamisessa vakiosyötteelle: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: On symbolinen linkki, ohitetaan" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: On hakemisto, ohitetaan" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Ei ole tavallinen tiedosto, ohitetaan" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Tiedostolla on setuid- tai setgid-bitti, ohitetaan" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Tiedostolla on sticky-bitti, ohitetaan" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Syötetiedostoon on yli yksi kova linkki, ohitetaan" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Tyhjä tiedostonimi, ohitetaan" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Virhe tilalippujen palauttamisessa vakiosyötteelle: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Virhe tiedoston tilalippujen noutamisessa vakiotulosteelle: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Hakemiston avaaminen epäonnistui: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: Kohde ei ole tavallinen tiedosto" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Virhe O_APPEND-lipun palauttamisessa vakiosyötteelle: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Tiedoston sulkeminen epäonnistui: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Siirtyminen epäonnistui yritettäessä luoda hajanaista tiedostoa: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Lukuvirhe: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Virhe tiedostossa siirtymisessä: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Odottamaton tiedoston loppu" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Kirjoitusvirhe: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Pois käytöstä" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Fyysisen muistin kokonaismäärä (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Suoritinsäikeiden määrä:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Tiivistys:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Purku:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Monisäikeinen purku:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "-T0:n oletusarvo:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Laitteiston tiedot:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Muistinkäytön rajat:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Virrat:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Lohkot:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Tiivistetty koko:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Tiivistämätön koko:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Suhde:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Tarkistus:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Virran tasaus:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Tarvittava muisti:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Koot otsakkeissa:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Tiedostojen määrä:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Virta" + +#: src/xz/list.c +msgid "Block" +msgstr "Lohko" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Lohkot" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "TiivSiirr." + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "Tv:tönSiirr." + +#: src/xz/list.c +msgid "CompSize" +msgstr "TiivKoko" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "Tv:tönKoko" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "Yht.Koko" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Suhde" + +#: src/xz/list.c +msgid "Check" +msgstr "Tark." + +#: src/xz/list.c +msgid "CheckVal" +msgstr "Tark.arvo" + +#: src/xz/list.c +msgid "Padding" +msgstr "Tasaus" + +#: src/xz/list.c +msgid "Header" +msgstr "Otsake" + +#: src/xz/list.c +msgid "Flags" +msgstr "Liput" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "Muist.käyt." + +#: src/xz/list.c +msgid "Filters" +msgstr "Suodattimet" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Ei mitään" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Tuntematon-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Tuntematon-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Tuntematon-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Tuntematon-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Tuntematon-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Tuntematon-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Tuntematon-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Tuntematon-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Tuntematon-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Tuntematon-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Tuntematon-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Tuntematon-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Tiedosto on tyhjä" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Liian pieni kelvolliseksi .xz-tiedostoksi" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Virrat Lohkot Tiivist. Tiivistämätön Suhde Tark. Tiedostonimi" + +#: src/xz/list.c +msgid "Yes" +msgstr "Kyllä" + +#: src/xz/list.c +msgid "No" +msgstr "Ei" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "XZ Utilsin vähimmäisversio:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s tiedosto\n" +msgstr[1] "%s tiedostoa\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Yhteensä:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list toimii vain .xz-tiedostoille (--format=xz tai --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Kokeile ”lzmainfo”-komento .lzma-tiedostoille." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list ei tue lukemista vakiosyötteestä" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Virhe luettaessa tiedostonimiä: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Odottamaton syötteen loppu tiedostonimiä luettaessa" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Nul-merkki kohdattiin tiedostonimiä lukiessa; oliko tarkoitus antaa valitsin ”--files0” eikä ”--files”?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Tiivistys ja purku --robot -valitsimen kanssa eivät ole vielä tuettuja." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Dataa ei voi lukea vakiosyötteestä kun tiedostonimiä luetaan vakiosyötteestä" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Sisäinen virhe (ohjelmistovika)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Signaalinkäsittelimiä ei voi muodostaa" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Ei eheystarkastusta; ei varmenneta tiedoston eheyttä" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Ei-tuettu eheystarkastuksen tyyppi; ei varmenneta tiedoston eheyttä" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Muistinkäytön raja saavutettu" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Tiedostomuotoa ei tunnistettu" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Ei-tuetut asetukset" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Tiivistetty data on turmeltunut" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Odottamaton syötteen loppu" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB muistia vaaditaan. Rajoitin on poistettu käytöstä." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB muistia vaaditaan. Raja on %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Suodinketju: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Komento ”%s --help” antaa lisää tietoa." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Virhe tulostettaessa ohjetekstiä (virhekoodi %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "FILE" +msgstr "TIED" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "MUOTO" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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”" + +#: src/xz/message.c +msgid "NAME" +msgstr "NIMI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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ä" + +#: src/xz/message.c +msgid "SIZE" +msgstr "KOKO" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "LOHKOT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "RAJA" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "SUOTIMET" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "ASET" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "ESI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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ä" + +#: src/xz/message.c +msgid "MODE" +msgstr "TILA" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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ä." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "Ilmoita ohjelmistovioista (suomeksi) osoitteeseen <%s>." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Valitsinten on oltava pilkuilla eroteltuja ”nimi=arvo”-pareja" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Virheellinen asetuksen nimi" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Virheellinen asetuksen arvo" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Ei-tuettu LZMA1/LZMA2-esiasetus: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "lc:n ja lp:n summa ei saa olla yli 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Tiedostonimen pääte on tuntematon, ohitetaan" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Tiedostolla on jo ”%s”-pääte, ohitetaan" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Virheellinen tiedostonimen pääte" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Arvo ei ole ei ole epänegatiivinen kymmenkantainen kokonaisluku" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Tuntematon kerroin" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Kelvolliset kertoimet ovat ”KiB” (2¹⁰), ”MiB” (2²⁰) ja ”GiB” (2³⁰)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Valitsimen ”%s” arvon on oltava välillä [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Tiivistettyä dataa ei voi lukea päätteestä" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Tiivistettyä dataa ei voi kirjoittaa päätteeseen" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Liian pieni kelvolliseksi .xz-tiedostoksi" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Ei .lzma-tiedosto" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Vakiotulosteeseen kirjoitus epäonnistui" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Tuntematon virhe" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Ei-tuettu esiasetus" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Ei-tuettu lippu esiasetuksessa" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Tuntematon asetuksen nimi" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Valitsimen arvo ei voi olla tyhjä" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Arvo sallitun välin ulkopuolella" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Tämä asetus ei tue kertoimia" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Virheellinen kerroin (KiB, MiB tai GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Tuntematon suotimen nimi" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Tätä suodinta ei voi käyttää .xz-muodon kanssa" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Muistinvaraus epäonnistui" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Tyhjä merkkijono ei ole sallittu, kokeile arvoa ”6”, jos oletusarvoa tarvitaan" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Suodattimien enimmäismäärä on neljä" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Suotimen nimi puuttuu" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Virheellinen suodinketju (puuttuuko ”lzma2” lopusta?)" diff --git a/cpp/third_party/xz-5.8.3/po/fr.gmo b/cpp/third_party/xz-5.8.3/po/fr.gmo new file mode 100644 index 0000000000..6b7b53ba26 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/fr.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/fr.po b/cpp/third_party/xz-5.8.3/po/fr.po new file mode 100644 index 0000000000..78b90de94f --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/fr.po @@ -0,0 +1,1668 @@ +# XZ Utils French Translation +# This file is put in the public domain. +# Adrien Nader , 2011-2014. +# Stéphane Aulery , 2019-2023. +# +msgid "" +msgstr "" +"Project-Id-Version: xz-5.4.4-pre1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: fr\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=2; plural=(n==1) ? 0 : 1;\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s : argument de l'option --block-list invalide" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s : trop d'arguments pour l'option --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 peut seulement être utilisé en dernier élément de --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s : Format de fichier inconnu" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s : Type de vérification d'intégrité inconnu" + +#: src/xz/args.c +#, fuzzy +#| msgid "Only one file can be specified with `--files' or `--files0'." +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Un seul fichier peut être spécifié avec `--files' ou `--files0'." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, fuzzy, c-format +#| msgid "%s: " +msgid "%s: %s" +msgstr "%s : " + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "La variable d'environnement %s contient trop d'arguments" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Le support de la compression à était désactivé lors de la compilaton" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Le support de la décompression a été désactivé lors de la compilation" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "" + +#: src/xz/args.c +#, fuzzy +#| msgid "%s: With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "%s : Avec --format=raw, --suffix=.SUF est nécessaire sauf lors de l'écriture vers stdout" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Le nombre maximal de filtres est quatre" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "La limite d'utilisation mémoire est trop basse pour la configuration de filtres donnée." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Utiliser un préréglage en mode `raw' est déconseillé." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Le détail des préréglages peut varier entre différentes versions du logiciel." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Le format .lzma ne prend en charge que le filtre LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "Le filtre LZMA1 ne peut être utilisé avec le format .xz" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "The filter chain is incompatible with --flush-timeout" +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "La Chaine de filtre est incompatible avec --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Bascule en mode mono-processus à cause de --flush-timeout" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Unsupported options" +msgid "Unsupported options in filter chain %u" +msgstr "Options non prises en charge" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Jusqu'à % threads seront utilisés." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Enchaînement ou options de filtres non pris en charge" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "La décompression nécessitera %s MiB de mémoire." + +#: src/xz/coder.c +#, fuzzy, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Nombre de threads réduit de %s à %s pour ne pas dépasser la limite d'utilisation mémoire de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "" + +#: src/xz/coder.c +#, fuzzy, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Nombre de threads réduit de %s à %s pour ne pas dépasser la limite d'utilisation mémoire de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Taille du dictionnaire LZMA%c réduite de %s MiB à %s MiB pour ne pas dépasser la limite d'utilisation mémoire de %s MiB" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Taille du dictionnaire LZMA%c réduite de %s MiB à %s MiB pour ne pas dépasser la limite d'utilisation mémoire de %s MiB" + +#: src/xz/coder.c +#, fuzzy, c-format +#| msgid "Error creating a pipe: %s" +msgid "Error changing to filter chain %u: %s" +msgstr "Impossible de créer un tube anonyme (pipe) : %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Impossible de créer un tube anonyme (pipe) : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s : L'appel à la fonction poll() a échoué : %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s : Le fichier a apparemment été déplacé, suppression annulée" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s : Impossible de supprimer : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s : Impossible de modifier le propriétaire du fichier : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s : Impossible de modifier le groupe propriétaire du fichier : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s : Impossible de modifier les permissions du fichier : %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s : Impossible de fermer le fichier : %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s : Impossible de fermer le fichier : %s" + +# Note from translator on "file status flags". +# The following entry is kept un-translated on purpose. It is difficult to +# translate and should only happen in exceptional circumstances which means +# that translating would: +# - lose some of the meaning +# - make it more difficult to look up in search engines; it might happen one in +# a million times, if we dilute the error message in 20 languages, it will be +# almost impossible to find an explanation and support for the error. +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Echec de la lecture du drapeau d'état du fichier depuis la sortie standard : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s est un lien symbolique : ignoré" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s est un répertoire : ignoré" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s n'est pas un fichier régulier : ignoré" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s : Le fichier possède les bits `setuid' ou `setgid' : ignoré" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s : Le fichier possède le bit `sticky' : ignoré" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s : Le fichier d'entrée a plus d'un lien matériel : ignoré" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Nom de fichier vide, ignoré" + +# See note from translator above titled "file status flags". +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Erreur de restauration du drapeau d'état de l'entrée standard : %s" + +# See note from translator above titled "file status flags". +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Erreur de lecture du drapeau d'état du fichier depuis la sortie standard : %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Opening the directory failed: %s" +msgstr "%s : Impossible de fermer le fichier : %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Not a regular file, skipping" +msgid "%s: Destination is not a regular file" +msgstr "%s n'est pas un fichier régulier : ignoré" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Impossible de rétablir le drapeau O_APPEND sur la sortie standard : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s : Impossible de fermer le fichier : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s : Impossible de se déplacer dans le fichier pour créer un 'sparse file' : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s : Erreur d'écriture : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s : Impossible de se déplacer dans le fichier : %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s : Fin de fichier inattendue" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s : Erreur d'écriture : %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Désactivé" + +#: src/xz/hardware.c +#, fuzzy +msgid "Amount of physical memory (RAM):" +msgstr "Quantité totale de mémoire physique (RAM) : " + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "" + +#: src/xz/hardware.c +#, fuzzy +msgid "Multi-threaded decompression:" +msgstr "Limite d'utilisation pour la décompression : " + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "" + +#: src/xz/hardware.c +#, fuzzy +msgid "Memory usage limits:" +msgstr "Limite d'utilisation mémoire atteinte" + +#: src/xz/list.c +msgid "Streams:" +msgstr "" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "" + +#: src/xz/list.c +#, fuzzy +msgid "Compressed size:" +msgstr " Taille données avec compression : %s\n" + +#: src/xz/list.c +#, fuzzy +msgid "Uncompressed size:" +msgstr " Taille données sans compression : %s\n" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "" + +#: src/xz/list.c +msgid "Check:" +msgstr "" + +#: src/xz/list.c +#, fuzzy +msgid "Stream Padding:" +msgstr " Octets de rembourrage du flux : %s\n" + +#: src/xz/list.c +#, fuzzy +msgid "Memory needed:" +msgstr " Mémoire nécessaire : %s MiB\n" + +#: src/xz/list.c +#, fuzzy +msgid "Sizes in headers:" +msgstr " Tailles stockées dans l'en-tête : %s\n" + +#: src/xz/list.c +#, fuzzy +msgid "Number of files:" +msgstr " Nombre de fichiers : %s\n" + +#: src/xz/list.c +msgid "Stream" +msgstr "" + +#: src/xz/list.c +msgid "Block" +msgstr "" + +#: src/xz/list.c +msgid "Blocks" +msgstr "" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "" + +#: src/xz/list.c +msgid "CompSize" +msgstr "" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "" + +#: src/xz/list.c +#, fuzzy +msgid "TotalSize" +msgstr "Totaux :" + +#: src/xz/list.c +msgid "Ratio" +msgstr "" + +#: src/xz/list.c +msgid "Check" +msgstr "" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "" + +#: src/xz/list.c +msgid "Padding" +msgstr "" + +#: src/xz/list.c +msgid "Header" +msgstr "" + +#: src/xz/list.c +msgid "Flags" +msgstr "" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "" + +#: src/xz/list.c +msgid "Filters" +msgstr "" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Aucune" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Inconnue-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Inconnue-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Inconnue-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Inconnue-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Inconnue-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Inconnue-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Inconnue-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Inconnue-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Inconnue-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Inconnue-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Inconnue-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Inconnue-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s : Le fichier est vide" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s : Trop petit pour être un fichier xz valide." + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Flux Blocs Compressé Décompressé Ratio Vérif. Nom de fichier" + +#: src/xz/list.c +msgid "Yes" +msgstr "Oui" + +#: src/xz/list.c +msgid "No" +msgstr "Non" + +#: src/xz/list.c +#, fuzzy +#| msgid " Minimum XZ Utils version: %s\n" +msgid "Minimum XZ Utils version:" +msgstr " Version minimale de XZ Utils : %s\n" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s fichier\n" +msgstr[1] "%s fichiers\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Totaux :" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list ne marche que sur les fichiers .xz (--format=xz ou --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "" + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list est incompatible avec la lecture sur l'entrée standard" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s : Erreur lors de la lecture des noms de fichiers : %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s : Fin des données inattendue lors de la lecture des noms de fichiers" + +#: src/xz/main.c +#, fuzzy, c-format +#| msgid "%s: Null character found when reading filenames; maybe you meant to use `--files0' instead of `--files'?" +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s : Caractère NULL détecté lors de la lecture des noms de fichiers ; peut-être pensiez-vous à `--files0' plutot qu'a `--files' ?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "La compression et la décompression ne marchent pas encore avec --robot." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Impossible de lire à la fois les données et les noms de fichiers depuis l'entrée standard" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s : " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Erreur interne (bug)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Impossible d'installer le gestionnaire de signaux" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Pas de données de vérification d'intégrité ; vérification non effectuée" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Méthode de vérification d'intégrité non prise en charge ; vérification non effectuée" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Limite d'utilisation mémoire atteinte" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Format de fichier inconnu" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Options non prises en charge" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Les données compressées sont corrompues" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Fin des données inattendue " + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB de mémoire sont nécessaires. La limite est désactivée." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB de mémoire sont nécessaires, la limite étant %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s : Enchaînement de filtres : %s\n" + +#: src/xz/message.c +#, fuzzy, c-format +#| msgid "Try `%s --help' for more information." +msgid "Try '%s --help' for more information." +msgstr "Éxécutez `%s --help' pour obtenir davantage d'informations." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the 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 "" +#| "Usage: %s [OPTION]... [FILE]...\n" +#| "Compress or decompress FILEs in the .xz format.\n" +#| "\n" +msgid "Compress or decompress FILEs in the .xz format." +msgstr "" +"Utilisation : %s [OPTION]... [FICHIER]...\n" +"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 interpreted as a zero-width space (the 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 "" +"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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Operation modifiers:\n" +msgid "Operation modifiers:" +msgstr "" +"\n" +" Modificateurs :\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| " --single-stream decompress only the first stream, and silently\n" +#| " ignore possible remaining input data" +msgid "decompress only the first stream, and silently ignore possible remaining input data" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Basic file format and compression options:\n" +msgid "Basic file format and compression options:" +msgstr "" +"\n" +" Options basiques de format de fichier et de compression :\n" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 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 interpreted as a zero-width space (the 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 "" +#| " -0 ... -9 compression preset; default is 6; take compressor *and*\n" +#| " decompressor memory usage into account before using 7-9!" +msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!" +msgstr "" +" -0 ... -9 préréglage de compression : 6 par défaut ; pensez à\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " -e, --extreme try to improve compression ratio by using more CPU time;\n" +#| " does not affect decompressor memory requirements" +msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements" +msgstr "" +" -e, --extreme essayer d'améliorer la compression en utilisant davantage\n" +" de temps processeur ;\n" +" n'affecte pas les besoins mémoire du décompresseur" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -T, --threads=NUM use at most NUM threads; the default is 1; set to 0\n" +#| " to use as many threads as there are processor cores" +msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores" +msgstr "" +" -T, --threads=NB créer au plus NB fils de compression (1 par défault) ; la\n" +" valeur 0 est spéciale et équivaut au nombre de processeurs\n" +" de la machine" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-size=SIZE\n" +#| " start a new .xz block after every SIZE bytes of input;\n" +#| " use this to set the block size for threaded compression" +msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression" +msgstr "" +" --block-size=TAILLE\n" +" débuter un bloc XZ après chaque TAILLE octets de données\n" +" d'entrée ; ce réglage sert pour la compression paralléle" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-list=SIZES\n" +#| " start a new .xz block after the given comma-separated\n" +#| " intervals of uncompressed data" +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 "" +" --block-list=TAILLES\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --flush-timeout=TIMEOUT\n" +#| " when compressing, if more than TIMEOUT milliseconds has\n" +#| " passed since the previous flush and reading more input\n" +#| " would block, all pending data is flushed out" +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 "" +" --flush-timeout=TIMEOUT\n" +" pendant la compression, si plus de TIMEOUT ms ont passées\n" +" depuis le dernier flush et que la lecture est bloquée,\n" +" toutes les données en attente sont écrites" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --no-adjust if compression settings exceed the memory usage limit,\n" +#| " give an error instead of adjusting the settings downwards" +msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards" +msgstr "" +" --no-adjust si les réglages de compression dépassent la limite\n" +" 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Custom filter chain for compression (alternative for using presets):" +msgid "Custom filter chain for compression (an alternative to using presets):" +msgstr "" +"\n" +" Chaîne de filtres de compression personnalisée (en lieu des préréglages) :" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Other options:\n" +msgid "Other options:" +msgstr "" +"\n" +" Autres options :\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 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 interpreted as a zero-width space (the 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 "" +#| " --info-memory display the total amount of RAM and the currently active\n" +#| " memory usage limits, and exit" +msgid "display the total amount of RAM and the currently active memory usage limits, and exit" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| "With no FILE, or when FILE is -, read standard input.\n" +msgid "With no FILE, or when FILE is -, read standard input." +msgstr "" +"\n" +"Sans FILE ou quand FILE est -, lire l'entrée standard.\n" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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" +msgid "Report bugs to <%s> (in English or Finnish)." +msgstr "" +"Signaler les bogues à <%s> (en anglais ou en finnois).\n" +"Signaler les bogues de traduction à .\n" + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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" +msgid "The supported filters and their options are:" +msgstr "Enchaînement ou options de filtres non pris en charge" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Options must be `name=value' pairs separated with commas" +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "%s: Les options doivent être des paires `nom=valeur' séparées par des virgules" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s : Nom d'option invalide" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option value" +msgid "Invalid option value" +msgstr "%s : Valeur d'option invalide" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Préréglage LZMA1/LZMA2 non reconnu : %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "La somme de lc et lp ne doit pas dépasser 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s : Le fichier a un suffixe inconnu, ignoré" + +#: src/xz/suffix.c +#, fuzzy, c-format +#| msgid "%s: File already has `%s' suffix, skipping" +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s : Le fichier a déjà le suffixe '%s', ignoré" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Suffixe de nom de fichier invalide" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Value is not a non-negative decimal integer" +msgid "Value is not a non-negative decimal integer" +msgstr "%s : La valeur n'est pas un entier décimal non négatif" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s : Suffixe multiplicateur invalide" + +#: src/xz/util.c +#, fuzzy +#| msgid "Valid suffixes are `KiB' (2^10), `MiB' (2^20), and `GiB' (2^30)." +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Les suffixes valides sont 'KiB' (2^10), 'MiB' (2^20) et 'GiB' (2^30)." + +#: src/xz/util.c +#, fuzzy, c-format +#| msgid "Value of the option `%s' must be in the range [%, %]" +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "La valeur de l'option '%s' doit être inclue entre % et %" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Les données compressées ne peuvent pas être lues depuis un terminal" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Les données compressées ne peuvent pas être écrites dans un terminal" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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 "" + +#: src/lzmainfo/lzmainfo.c +#, fuzzy +#| msgid "%s: Too small to be a valid .xz file" +msgid "File is too small to be a .lzma file" +msgstr "%s : Trop petit pour être un fichier xz valide." + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Impossible d'écrire vers la sortie standard" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Erreur inconnue" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported options" +msgid "Unsupported preset" +msgstr "Options non prises en charge" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported filter chain or filter options" +msgid "Unsupported flag in the preset" +msgstr "Enchaînement ou options de filtres non pris en charge" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option name" +msgid "Unknown option name" +msgstr "%s : Nom d'option invalide" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid multiplier suffix" +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "%s : Suffixe multiplicateur invalide" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Unknown file format type" +msgid "Unknown filter name" +msgstr "%s : Format de fichier inconnu" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "LZMA1 cannot be used with the .xz format" +msgid "This filter cannot be used in the .xz format" +msgstr "Le filtre LZMA1 ne peut être utilisé avec le format .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Maximum number of filters is four" +msgid "The maximum number of filters is four" +msgstr "Le nombre maximal de filtres est quatre" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" + +#~ msgid "" +#~ " -z, --compress force compression\n" +#~ " -d, --decompress force decompression\n" +#~ " -t, --test test compressed file integrity\n" +#~ " -l, --list list information about .xz files" +#~ msgstr "" +#~ " -z, --compress forcer le mode compression\n" +#~ " -d, --decompress forcer le mode décompression\n" +#~ " -t, --test tester l'intégrité du fichier compressé\n" +#~ " -l, --list lister les informations sur les fichiers .xz" + +#~ msgid "" +#~ " -k, --keep keep (don't delete) input files\n" +#~ " -f, --force force overwrite of output file and (de)compress links\n" +#~ " -c, --stdout write to standard output and don't delete input files" +#~ msgstr "" +#~ " -k, --keep ne pas supprimer les fichiers d'entrée\n" +#~ " -f, --force forcer l'écrasement éventuel du fichier de sortie et\n" +#~ " (dé)compresser les liens symboliques\n" +#~ " -c, --stdout écrire sur la sortie standard et ne pas supprimer les\n" +#~ " fichiers d'entrée" + +#, fuzzy +#~| msgid "" +#~| " --no-sparse do not create sparse files when decompressing\n" +#~| " -S, --suffix=.SUF use the suffix `.SUF' on compressed files\n" +#~| " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~| " omitted, filenames are read from the standard input;\n" +#~| " filenames must be terminated with the newline character\n" +#~| " --files0[=FILE] like --files but use the null character as terminator" +#~ msgid "" +#~ " --no-sparse do not create sparse files when decompressing\n" +#~ " -S, --suffix=.SUF use the suffix '.SUF' on compressed files\n" +#~ " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~ " omitted, filenames are read from the standard input;\n" +#~ " filenames must be terminated with the newline character\n" +#~ " --files0[=FILE] like --files but use the null character as terminator" +#~ msgstr "" +#~ " --no-sparse ne pas créer de 'sparse file' lors de la décompression\n" +#~ " -S, --suffix=.SUF utiliser le suffixe `.SUF' pour les fichiers compressés\n" +#~ " --files[=FILE] lire les fichiers sur lesquels opérer depuis FILE ; si\n" +#~ " FILE est omis, ceux-ci sont lus depuis l'entrée standard\n" +#~ " et doivent être suivis d'un caractère retour à la ligne\n" +#~ " --files0[=FILE] comme --files mais avec un caractère null comme séparateur" + +#, fuzzy +#~ msgid "" +#~ " -F, --format=FMT file format to encode or decode; possible values are\n" +#~ " 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'\n" +#~ " -C, --check=CHECK integrity check type: 'none' (use with caution),\n" +#~ " 'crc32', 'crc64' (default), or 'sha256'" +#~ msgstr "" +#~ " -F, --format=FMT format du fichier à encoder ou décoder ; sont acceptés :\n" +#~ " `auto' (par défaut), `xz', `lzma' et `raw'\n" +#~ " -C, --check=CHECK type de vérification d'intégrité : `none' (à utiliser avec\n" +#~ " précaution), `crc32', `crc64' (par défaut) ou `sha256'" + +#, fuzzy, no-c-format +#~ msgid "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " --memlimit-mt-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " set memory usage limit for compression, decompression,\n" +#~ " threaded decompression, or all of these; LIMIT is in\n" +#~ " bytes, % of RAM, or 0 for defaults" +#~ msgstr "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " règle la limite d'utilisation mémoire pour la compression,\n" +#~ " décompression ou les deux ; LIMIT est en octets,\n" +#~ " pourcentage de RAM, ou 0 pour la valeur par défaut" + +#~ msgid "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1 or LZMA2; OPTS is a comma-separated list of zero or\n" +#~ " --lzma2[=OPTS] more of the following options (valid values; default):\n" +#~ " preset=PRE reset options to a preset (0-9[e])\n" +#~ " dict=NUM dictionary size (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NUM number of literal context bits (0-4; 3)\n" +#~ " lp=NUM number of literal position bits (0-4; 0)\n" +#~ " pb=NUM number of position bits (0-4; 2)\n" +#~ " mode=MODE compression mode (fast, normal; normal)\n" +#~ " nice=NUM nice length of a match (2-273; 64)\n" +#~ " mf=NAME match finder (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM maximum search depth; 0=automatic (default)" +#~ msgstr "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1/2 ; OPTS est une liste d'options parmi les suivantes\n" +#~ " --lzma2[=OPTS] (entre parenthèses : valeurs valides et par défaut) :\n" +#~ " preset=PRE remettre les options à un préréglage (0-9[e])\n" +#~ " dict=NUM taille dictionnaire (4KiB - 1536MiB ; 8MiB)\n" +#~ " lc=NUM nombre de 'literal context bits' (0-4 ; 3)\n" +#~ " lp=NUM nombre de 'literal position bits' (0-4 ; 0)\n" +#~ " pb=NUM nombre de 'position bits' (0-4 ; 2)\n" +#~ " mode=MODE mode de compression (fast, normal ; normal)\n" +#~ " nice=NUM nice length of a match (2-273; 64)\n" +#~ " mf=NAME 'match finder' (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM profondeur de recherche maximale ;\n" +#~ " 0=automatique (par défaut)" + +#, fuzzy +#~ msgid "" +#~ "\n" +#~ " --x86[=OPTS] x86 BCJ filter (32-bit and 64-bit)\n" +#~ " --arm[=OPTS] ARM BCJ filter\n" +#~ " --armthumb[=OPTS] ARM-Thumb BCJ filter\n" +#~ " --arm64[=OPTS] ARM64 BCJ filter\n" +#~ " --powerpc[=OPTS] PowerPC BCJ filter (big endian only)\n" +#~ " --ia64[=OPTS] IA-64 (Itanium) BCJ filter\n" +#~ " --sparc[=OPTS] SPARC BCJ filter\n" +#~ " --riscv[=OPTS] RISC-V BCJ filter\n" +#~ " Valid OPTS for all BCJ filters:\n" +#~ " start=NUM start offset for conversions (default=0)" +#~ msgstr "" +#~ "\n" +#~ " --x86[=OPTS] filtre BCJ x86 (32-bit et 64-bit)\n" +#~ " --powerpc[=OPTS] filtre BCJ PowerPC ('big endian' uniquement)\n" +#~ " --ia64[=OPTS] filtre BCJ IA-64 (Itanium)\n" +#~ " --arm[=OPTS] filtre BCJ ARM ('little endian' uniquement)\n" +#~ " --armthumb[=OPTS] filtre BCJ ARM-Thumb ('little endian' uniquement)\n" +#~ " --sparc[=OPTS] filtre BCJ SPARC\n" +#~ " OPTS valides pour tous les filtres BCJ :\n" +#~ " start=NUM position de début de la conversion (défaut=0)" + +#~ msgid "" +#~ "\n" +#~ " --delta[=OPTS] Delta filter; valid OPTS (valid values; default):\n" +#~ " dist=NUM distance between bytes being subtracted\n" +#~ " from each other (1-256; 1)" +#~ msgstr "" +#~ "\n" +#~ " --delta[=OPTS] Filtre delta ; OPTS valides (vals. valides ; par défaut) :\n" +#~ " dist=NUM distance entre les octets soustraits les\n" +#~ " uns aux autres (1-256 ; 1)" + +#~ msgid "" +#~ " -q, --quiet suppress warnings; specify twice to suppress errors too\n" +#~ " -v, --verbose be verbose; specify twice for even more verbose" +#~ msgstr "" +#~ " -q, --quiet masquer les avertissements ; spécifier deux fois pour\n" +#~ " aussi masquer les erreurs\n" +#~ " -v, --verbose être bavard ; spécifier deux fois pour l'être davantage" + +#~ msgid "" +#~ " -h, --help display the short help (lists only the basic options)\n" +#~ " -H, --long-help display this long help and exit" +#~ msgstr "" +#~ " -h, --help afficher l'aide courte (ne liste que les options de base)\n" +#~ " -H, --long-help afficher l'aide longue (ceci) puis quitter" + +#~ msgid "" +#~ " -h, --help display this short help and exit\n" +#~ " -H, --long-help display the long help (lists also the advanced options)" +#~ msgstr "" +#~ " -h, --help afficher l'aide courte (ceci) puis quitter\n" +#~ " -H, --long-help afficher l'aide longue (liste aussi les options avancées)" + +#~ msgid "Failed to enable the sandbox" +#~ msgstr "Echec de l'activation de la sandboxe" + +#~ msgid "The selected match finder requires at least nice=%" +#~ msgstr "Le `match finder' choisi nécessite au moins nice=%" + +#~ msgid "Sandbox is disabled due to incompatible command line arguments" +#~ msgstr "La sandbox est désactivée car elle est incompatible avec les arguments passés" + +#~ msgid "Sandbox was successfully enabled" +#~ msgstr "La sandboxe a été activée avec succès" + +#~ msgid "Memory usage limit for compression: " +#~ msgstr "Limite d'utilisation pour la compression : " + +#~ msgid " Streams: %s\n" +#~ msgstr " Flux : %s\n" + +#~ msgid " Blocks: %s\n" +#~ msgstr " Blocs : %s\n" + +#~ msgid " Ratio: %s\n" +#~ msgstr " Ratio : %s\n" + +#~ msgid " Check: %s\n" +#~ msgstr " Vérification : %s\n" + +#~ msgid "" +#~ " Streams:\n" +#~ " Stream Blocks CompOffset UncompOffset CompSize UncompSize Ratio Check Padding" +#~ msgstr "" +#~ " Flux :\n" +#~ " Flux Blocs PositionComp PositionDécomp TailleComp TailleDécomp Ratio Vérif. Bourrage" + +#~ msgid "" +#~ " Blocks:\n" +#~ " Stream Block CompOffset UncompOffset TotalSize UncompSize Ratio Check" +#~ msgstr "" +#~ " Blocs :\n" +#~ " Flux Bloc PositionComp PositionDécomp TailleTot TailleDécomp Ratio Vérif." + +#~ msgid " CheckVal %*s Header Flags CompSize MemUsage Filters" +#~ msgstr " ValVérif %*sEn-tête Drapeaux TailleComp UtilMém Filtres" + +#~ msgid "Error setting O_NONBLOCK on standard input: %s" +#~ msgstr "Impossible d'établir le drapeau O_NONBLOCK sur la sortie standard : %s" + +#~ msgid "Error setting O_NONBLOCK on standard output: %s" +#~ msgstr "Impossible d'activer le drapeau O_NONBLOCK sur la sortie standard : %s" diff --git a/cpp/third_party/xz-5.8.3/po/hr.gmo b/cpp/third_party/xz-5.8.3/po/hr.gmo new file mode 100644 index 0000000000..e43f132de5 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/hr.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/hr.po b/cpp/third_party/xz-5.8.3/po/hr.po new file mode 100644 index 0000000000..85f53b09df --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/hr.po @@ -0,0 +1,1271 @@ +# SPDX-License-Identifier: 0BSD +# +# Croatian messages for xz. +# Hrvatski prijevod poruka XZ paketa +# This file is published under the BSD Zero Clause License. +# Copyright (C) The XZ Utils authors and contributors +# +# Božidar Putanec , 2020-2025. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: xz 5.8.0-pre1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: hr\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: vim9.1\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: nevaljani argument za --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Previše argumenata za --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "Uz '--block-list' nedostaje veličina bloka iza broja lanca filtra '%c:'" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "za '--block-list' može se koristiti '0' samo kao posljednji element" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Nepoznata vrsta formata datoteke" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Nepodržani način (tip) provjere integriteta" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Samo jedna datoteka može biti specificirana s '--files' ili '--files0'." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Varijabla okruženja '%s' sadrži previše argumenata" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Podrška za kompresiju bila je onemogućena tijekom kompilacije" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Podrška za dekompresiju bila je onemogućena tijekom kompilacije" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Kompresija LZIP datoteka (.lz) nije podržana" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "'--block-list' je zanemaren (vrijedi samo za komprimiranje u .xz format)" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Uz opciju '--format=raw', '--suffix=.EXT' je nužan (osim ako ne piše na standardni izlaz)" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Maksimalni broj filtara je četiri" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Greška u opciji '--filters%s=FILTRI':" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Za danu postavku filtara treba više memorije (granica upotrebe memorije je preniska)" + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "lanac filtra %u koristi se za '--block-list', ali nije naveden s '--filters%u='" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Ne preporučuje se koristiti početne (preset) postavke u sirovom načinu rada." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Točne opcije početnih (preset) postavki mogu se razlikovati ovisno od verzije do verzije softvera." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Samo LZMA1 filtar podržava format .lzma" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "Ne može se koristi LZMA1 s .xz formatom" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Lanac filtra %u nije kompatibilan s '--flush-timeout'" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Prelazimo na način rada s jednom dretvom zbog '--flush-timeout'" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Nepodržane opcije u lancu filtra %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Koristimo do % dretvi." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Nepodržani lanac filtara ili opcija filtara" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Za dekompresiju će trebati %s MiB memorije." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Smanjen je broj dretvi od %s na %s da ne prekorači granicu upotrebe memorije od %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Smanjen je broj od %s na jednu dretvu, ali granica od %s MiB automatske upotrebe memorije još uvijek je prekoračena. Potrebno je %s MiB memorije. Ipak nastavljamo dalje." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Prelazimo na način rada s jednom dretvom da ne prekoračimo granicu upotrebe memorije od %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Veličina LZMA%c rječnika prilagođena je od %s na %s da se ne prekorači granica upotrebe memorije od %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Veličina LZMA%c rječnika prilagođena je za '--filters%u' od %s na %s da ne prekorači granicu upotrebe memorije od %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Greška pri prebacivanju na lanac filtra %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Greška pri stvaranju cijevi: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() nije uspjela: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Izgleda da je datoteka premještena -- nije izbrisana" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "Brisanje %s nije moguće: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Nije moguće promijeniti vlasnika datoteke: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Nije moguće promijeniti grupu datoteke: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Nije moguće postaviti prava dostupa datoteci: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Nije uspjelo sinkronizirati datoteku: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Nije uspjelo sinkronizirati direktorij datoteke: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Greška pri pokušaju dobivanja oznaka statusa datoteke iz standardnog ulaza: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: To je simbolična poveznica -- preskočeno" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: To je direktorij -- preskočeno" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: To nije regularna datoteka -- preskočeno" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Datoteka ima postavljen SETUID- ili SETGID bit -- preskočeno" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Datoteka ima postavljen ljepljivi bit -- preskočeno" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Ulazna datoteka ima više od jednog tvrdog linka -- preskočeno" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Prazna datoteka -- preskočeno" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Greška pri vraćanju statusnih flags na standardni ulaz: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Greška pri dobivanju oznaka statusa datoteke iz standardnog izlaza: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Nije uspjelo otvoriti direktorij: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: Odredište nije obična datoteka" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Greška pri vraćanju 'O_APPEND' oznaka na standardni izlaz: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Nije uspjelo zatvoriti datoteku: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: 'Seeking' (traženje) nije uspjelo pri pokušaju stvaranja raštrkane datoteke: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Greška pri čitanju: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Greška pri 'seeking' (traženju) datoteke: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Neočekivani kraj datoteke" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Greška pri pisanju: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Onemogućeno" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Količina fizičke memorije (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Broj dretvi procesora:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Kompresija:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Dekompresija:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Dekompresija s više dretvi:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Zadano za -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Informacije o hardveru:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Granica za korištenje memorije:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Tokovi:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blokovi:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Komprimirana veličina:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Dekomprimirana veličina:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Omjer:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Kontrola:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Dopuna toka:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Potrebna memorija:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Veličine u zaglavljima:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Količina datoteka:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Tok" + +#: src/xz/list.c +msgid "Block" +msgstr "Blok" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blokovi" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "KomprOdmak" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "DekomprOdmak" + +#: src/xz/list.c +msgid "CompSize" +msgstr "KomprVeličina" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "DekomprVeličina" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "TotalVeličina" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Omjer" + +#: src/xz/list.c +msgid "Check" +msgstr "Kontrola" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "KontrVrijedn" + +#: src/xz/list.c +msgid "Padding" +msgstr "Dopuna" + +#: src/xz/list.c +msgid "Header" +msgstr "Zaglavlje" + +#: src/xz/list.c +msgid "Flags" +msgstr "Flags" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "MemUpotreba" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filtri" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Nijedan" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Nepoznat-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Nepoznat-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Nepoznat-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Nepoznat-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Nepoznat-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Nepoznat-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Nepoznat-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Nepoznat-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Nepoznat-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Nepoznat-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Nepoznat-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Nepoznat-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Datoteka je prazna" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Datoteka je premala da bude valjana .xz datoteka" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr " Tok Blok Komprimirano Dekomprimir Omjer Kontr Datoteka" + +#: src/xz/list.c +msgid "Yes" +msgstr "Da" + +#: src/xz/list.c +msgid "No" +msgstr "Ne" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Minimalna verzija programa XZ:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s datoteka\n" +msgstr[1] "%s datoteke\n" +msgstr[2] "%s datoteka\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Ukupno:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "'--list' radi samo sa .xz datoteke (--format=xz ili --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Pokušajte s ‘lzmainfo’ s .lzma datotekama." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "'--list' ne podržava čitanje iz standardnog izlaza" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Greška pri čitanju datoteka: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Neočekivani kraj ulaznih podataka tijekom čitanja imena datoteka" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Prazni NULA-znak pronađen pri čitanju imena datoteka; možda ste mislili koristiti '--files0' umjesto '--files'?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Komprimiranje i dekomprimiranje s '--robot' još nije podržano." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Nije moguće čitati podatke iz standardnog ulaza dok se čitaju imena datoteka iz standardnog ulaza" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Interna greška (bug)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Nije moguće uspostaviti rukovatelje signala" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Nema provjere integriteta -- ne provjeravamo integritet datoteke" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Nepodržani tip provjere integriteta -- ne provjeravamo integritet datoteke" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Dostignuta je granica za upotrebu memorije" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Format datoteke nije prepoznat" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Nepodržane opcije" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Komprimirani podaci su oštećeni" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Neočekivani kraj ulaznih podataka" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s Potrebno je MiB memorije. Ograničenja su onemogućena." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s Potrebno je MiB memorije. Ograničenje je %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Lanac filtara: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Pokušajte s '%s --help’ za pomoć i više informacija." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Greška prilikom ispisa teksta pomoći (kod greške %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".EXT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "FILE" +msgstr "DATOTEKA" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "FORMAT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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'" + +#: src/xz/message.c +msgid "NAME" +msgstr "IME" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "BROJ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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)" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOKOVI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTRI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "OPCIJE" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "" +"Greške prijavite na <%s> (na engleskom ili finskom).\n" +"Prijavite greške u prijevodu na ." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Opcije moraju biti parovi 'name=value' odvojeni zarezima" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Nevaljano ime opcije" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Nevaljana vrijednost opcije" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Nepodržana LZMA1/LZMA2 početna postavka: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Zbroj lc i lp ne smije biti veći od 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Ime datoteke nema poznatu ekstenziju, preskačemo" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Datoteka već ima '%s' ekstenziju, preskačemo" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Nevaljana ekstenzija u imenu datoteke" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Vrijednost nije nula ili pozitivni dekadski cijeli broj" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Nevaljani sufiks-množitelj" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Valjani sufiks-množitelji su 'KiB' (2^10), 'MiB' (2^20), i 'GiB' (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Vrijednost opcije '%s' mora biti u rasponu [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Nije moguće čitati komprimirane podatke iz terminala" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Nije moguće pisati komprimirane podatke na terminal" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Datoteka je premala da bude .lzma datoteka" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "To nije .lzma datoteka" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Pisanje na standardni izlaz nije uspjelo" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Nepoznata greška" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Nepodržane početne opcije" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Nepodržani flag u početnoj opciji" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Nevaljano ime opcije" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Vrijednost opcije ne može biti prazna" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Vrijednost je izvan granica" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Ova opcija ne podržava upotrebu sufiks-množitelja" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Nevaljani sufiks-množitelj (KiB, MiB, or GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Nepoznato ime filtra" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Ovaj filtar ne može se koristi u .xz formatu" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Dodjela memorije nije uspjela" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Prazan string nije dopušten, pokušajte s '6' ako je potrebna zadana vrijednost" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Maksimalni broj filtara je četiri" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Nema imena filtra" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Nevaljani lanac filtra (nema 'lzma2’ na kraju)?" diff --git a/cpp/third_party/xz-5.8.3/po/hu.gmo b/cpp/third_party/xz-5.8.3/po/hu.gmo new file mode 100644 index 0000000000..800f812947 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/hu.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/hu.po b/cpp/third_party/xz-5.8.3/po/hu.po new file mode 100644 index 0000000000..de9ef3301b --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/hu.po @@ -0,0 +1,1673 @@ +# SPDX-License-Identifier: 0BSD +# +# Hungarian translation for xz. +# This file is published under the BSD Zero Clause License. +# +# Meskó Balázs , 2019, 2022, 2024. +msgid "" +msgstr "" +"Project-Id-Version: xz 5.6.0-pre2\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: hu\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"plural-forms: nplurals=2; plural=(n != 1);\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.4\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Érvénytelen argumentum a --block-list kapcsolóhoz" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Túl sok argumentum a --block-list kapcsolóhoz" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "A --block-list kapcsolónál hiányzik a blokkméret a(z) „%c:” szűrőláncszám után" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "A 0 csak utolsó elemként használható a --block-list kapcsolónál" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Ismeretlen fájlformátumtípus" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Nem támogatott integritás-ellenőrzési típus" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Csak egy fájl adható meg a „--files” vagy „--files0” kapcsolóknál." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "A(z) %s környezeti változó túl sok argumentumot tartalmaz" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "A tömörítési támogatás ki lett kapcsolva fordítási időben" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "A kibontási támogatás ki lett kapcsolva fordítási időben" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Az lzip-fájlok (.lz) tömörítése nem támogatott" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "A --block-list kapcsoló csak .xz formátum esetén van figyelembe véve" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "A --format=raw esetén a --suffix=.SUF szükséges, hacsak nem a szabványosra kimenetre ír" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "A szűrők legnagyobb száma négy" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Hiba a --filters%s=SZŰRŐK kapcsolóban:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "A memóriahasználat túl alacsony a megadott szűrőbeállításokhoz." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "A --block-list használja a(z) %u. szűrőláncot, de az nincs megadva a --filters%u= kapcsolóval" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Az előbeállítások használata nyers módban nem javasolt." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Az előbeállítások pontos beállításai különbözhetnek a szoftververziók között." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Az .lzma formátum csak az LZMA1 szűrőt támogatja" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "Az LZMA1 nem használható az .xz formátummal" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "A(z) %u. szűrőlánc nem kompatibilis a --flush-timeout kapcsolóval" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Egyszálú módra váltás a --flush-timeout kapcsoló miatt" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Nem támogatott kapcsolók a(z) %u szűrőláncban" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Legfeljebb % szál használata." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Nem támogatott szűrőlánc vagy szűrőkapcsolók" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "A kibontáshoz %s MiB memória szükséges." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "A szálak számának csökkentése erről: %s, erre: %s, hogy ne lépje túl a(z) %s MiB-os korlátot" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "A szálak számának csökkentése erről: %s, egyre. A(z) %s MiB-os automatikus memóriahasználati korlát így is túl lett lépve. %s MiB memória szükséges. Ennek ellenére folytatás mindenképpen." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Egyszálú módra váltás, hogy ne lépje túl a(z) %s MiB-os memóriahasználati korlátot" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Az LZMA%c szótár méretének módosítása erről: %s MiB, erre: %s MiB, hogy ne lépje túl a(z) %s MiB-os korlátot" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "A --filters%2$u szűrőhöz tartozó LZMA%1$c szótár méretének módosítása %3$s MiB-ról %4$s MiB-ra, hogy ne lépje túl a(z) %5$s MiB-os korlátot" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Hiba a(z) %u. szűrőlánc létrehozásakor: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Hiba a csővezeték létrehozásakor: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() sikertelen: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Úgy tűnik, hogy a fájl át lett helyezve, nincs eltávolítás" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Nem távolítható el: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: A fájl tulajdonosa nem adható meg: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: A fájl csoportja nem adható meg: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: A fájl jogosultságai nem adhatók meg: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: A fájl lezárása sikertelen: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: A fájl lezárása sikertelen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Hiba a fájl állapotjelzőinek lekérdezésekor a szabványos bemenetről: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Szimbolikus link, kihagyás" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Könyvtár, kihagyás" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Nem szabályos fájl, kihagyás" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: A fájlon setuid vagy setgid bit van beállítva, kihagyás" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: A fájlon sticky bit van beállítva, kihagyás" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: A bemeneti fájlhoz több mint egy hard link tartozik, kihagyás" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Üres fájlnév, kihagyás" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Hiba a fájl állapotjelzőinek visszaállításakor a szabványos bemenetre: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Hiba a fájl állapotjelzőinek lekérdezésekor a szabványos kimenetről: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Opening the directory failed: %s" +msgstr "%s: A fájl lezárása sikertelen: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Not a regular file, skipping" +msgid "%s: Destination is not a regular file" +msgstr "%s: Nem szabályos fájl, kihagyás" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Hiba az O_APPEND visszaállításakor a szabványos kimenetre: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: A fájl lezárása sikertelen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: A pozícionálás sikertelen a ritka fájl létrehozásának kísérletekor: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Olvasási hiba: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Hiba a fájlban pozícionáláskor: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Váratlan fájlvég" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Írási hiba: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Letiltva" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Fizikai memória (RAM) mennyisége:" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Processzorszálak száma:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Tömörítés:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Kibontás:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Többszálás kibontás:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "A -T0 alapértelmezése:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Hardverjellemzők:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Memóriahasználat korlátja:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Adatfolyamok:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blokkok:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Tömörített méret:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Kibontott méret:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Arány:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Ellenőrzés:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Adatfolyam kerete:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Szükséges memória:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Méretek a fejlécekben:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Fájlok száma:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Adatfolyam" + +#: src/xz/list.c +msgid "Block" +msgstr "Blokk" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blokkok" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "Tömörített eltolás" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "Kibontott eltolás" + +#: src/xz/list.c +msgid "CompSize" +msgstr "Tömörített méret" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "Kibontott méret" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "Teljes méret" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Arány" + +#: src/xz/list.c +msgid "Check" +msgstr "Ellenőrzés" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "Ellenőrzőérték" + +#: src/xz/list.c +msgid "Padding" +msgstr "Keret" + +#: src/xz/list.c +msgid "Header" +msgstr "Fejléc" + +#: src/xz/list.c +msgid "Flags" +msgstr "Jelzők" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "Memóriahasználat" + +#: src/xz/list.c +msgid "Filters" +msgstr "Szűrők" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Nincs" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Névtelen-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Névtelen-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Névtelen-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Névtelen-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Névtelen-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Névtelen-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Névtelen-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Névtelen-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Névtelen-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Névtelen-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Névtelen-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Névtelen-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: A fájl üres" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Túl kicsi, hogy érvényes .xz fájl legyen" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Folyam Blokkok Tömörített Kibontott Arány Ellenőrzés Fájlnév" + +#: src/xz/list.c +msgid "Yes" +msgstr "Igen" + +#: src/xz/list.c +msgid "No" +msgstr "Nem" + +#: src/xz/list.c +#, fuzzy +#| msgid " Minimum XZ Utils version: %s\n" +msgid "Minimum XZ Utils version:" +msgstr " Legkisebb XZ Utils verzió: %s\n" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s fájl\n" +msgstr[1] "%s fájl\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Összesen:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "A --list csak .xz fájlokkal működik (--format=xz vagy --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Az „lzmainfo” kipróbálása az .lzma fájlok esetén." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "A --list nem támogatja a szabványos bemenetről beolvasást" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Hiba a fájlnevek olvasásakor: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: A bemenet váratlanul véget ért a fájlnevek olvasásakor" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Null karakter található a fájlnevek olvasásakor; talán a „--files0” kapcsolóra gondolt a „--files” helyett?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "A tömörítés és kibontás még nem támogatott a --robot kapcsolóval." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Az adatok nem olvashatók be a szabványos bemenetről a fájlnevek olvasásakor" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Belső hiba (bug)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "A szignálkezelők nem hozhatók létre" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Nincs integritás-ellenőrzés; a fájl épsége nem lesz ellenőrizve" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Nem támogatott integritás-ellenőrzési típus; a fájl épsége nem lesz ellenőrizve" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Memóriahasználat korlátja elérve" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "A fájlformátum nem felismert" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Nem támogatott kapcsolók" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "A tömörített adatok megsérültek" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "A bemenet váratlanul véget ért" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB memória szükséges. A korlátozás letiltva." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB memória szükséges. A korlát %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Szűrőlánc: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "További információkért adja ki a következő parancsot: „%s --help”." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the 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 "" +#| "Usage: %s [OPTION]... [FILE]...\n" +#| "Compress or decompress FILEs in the .xz format.\n" +#| "\n" +msgid "Compress or decompress FILEs in the .xz format." +msgstr "" +"Használat: %s [KAPCSOLÓ]... [FÁJL]...\n" +".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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Operation modifiers:\n" +msgid "Operation modifiers:" +msgstr "" +"\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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| " --single-stream decompress only the first stream, and silently\n" +#| " ignore possible remaining input data" +msgid "decompress only the first stream, and silently ignore possible remaining input data" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Basic file format and compression options:\n" +msgid "Basic file format and compression options:" +msgstr "" +"\n" +" Alapvető fájlformátum és tömörítési beállítások:\n" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " -0 ... -9 compression preset; default is 6; take compressor *and*\n" +#| " decompressor memory usage into account before using 7-9!" +msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!" +msgstr "" +" -0 ... -9 tömörítési előbeállítás; alapértelmezett a 6;\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " -e, --extreme try to improve compression ratio by using more CPU time;\n" +#| " does not affect decompressor memory requirements" +msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements" +msgstr "" +" -e, --extreme a tömörítési arány javítási kísérlete több CPU-idő\n" +" használatával; nincs hatással a kibontó memóriaigényére" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -T, --threads=NUM use at most NUM threads; the default is 0 which uses\n" +#| " as many threads as there are processor cores" +msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores" +msgstr "" +" -T, --threads=SZÁM legfeljebb ennyi szál használata; alapértelmezett a 0,\n" +" amely annyi szálat használ, amennyi processzormag áll\n" +" rendelkezésre" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-size=SIZE\n" +#| " start a new .xz block after every SIZE bytes of input;\n" +#| " use this to set the block size for threaded compression" +msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression" +msgstr "" +" --block-size=MÉRET\n" +" új .xz blokk indítása minden MÉRETnyi bájt bemenet után;\n" +" a többszálas tömörítés blokkméretének megadásához" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-list=BLOCKS\n" +#| " start a new .xz block after the given comma-separated\n" +#| " intervals of uncompressed data; optionally, specify a\n" +#| " filter chain number (0-9) followed by a ':' before the\n" +#| " uncompressed data size" +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 "" +" --block-list=BLOKKOK\n" +" új .xz blokk indítása a vesszőkkel felsorolva megadott\n" +" méretű tömörítetlen adatszakaszok után; a tömörítetlen\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --flush-timeout=TIMEOUT\n" +#| " when compressing, if more than TIMEOUT milliseconds has\n" +#| " passed since the previous flush and reading more input\n" +#| " would block, all pending data is flushed out" +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 "" +" --flush-timeout=IDŐTÚLLÉPÉS\n" +" tömörítéskor, ha több mint IDŐTÚLLÉPÉS ezredmásodperc\n" +" telt el az előző kiírástól, és a bemenetolvasás\n" +" blokkolna, akkor minden adat ki lesz írva" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --no-adjust if compression settings exceed the memory usage limit,\n" +#| " give an error instead of adjusting the settings downwards" +msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards" +msgstr "" +" --no-adjust ha a tömörítési beállítások túllépik a memóriahasználati\n" +" 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Custom filter chain for compression (alternative for using presets):" +msgid "Custom filter chain for compression (an alternative to using presets):" +msgstr "" +"\n" +" Egyéni szűrőlánc a tömörítéshez (alternatíva az előbeállításokra):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| " --filters=FILTERS set the filter chain using the liblzma filter string\n" +#| " syntax; use --filters-help for more information" +msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information" +msgstr "" +"\n" +" --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 interpreted as a zero-width space (the 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 "" +#| " --filters1=FILTERS ... --filters9=FILTERS\n" +#| " set additional filter chains using the liblzma filter\n" +#| " string syntax to use with --block-list" +msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list" +msgstr "" +" --filters1=SZŰRŐK ... --filters9=SZŰRŐK\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --filters-help display more information about the liblzma filter string\n" +#| " syntax and exit." +msgid "display more information about the liblzma filter string syntax and exit" +msgstr "" +" --filters-help további információk megjelenítése a libzma\n" +" szűrőformátumról, majd kilépés." + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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:" +msgid "number of position bits" +msgstr "Processzorszálak száma:" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Other options:\n" +msgid "Other options:" +msgstr "" +"\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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 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 interpreted as a zero-width space (the 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 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 interpreted as a zero-width space (the 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 "" +#| " --info-memory display the total amount of RAM and the currently active\n" +#| " memory usage limits, and exit" +msgid "display the total amount of RAM and the currently active memory usage limits, and exit" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| "With no FILE, or when FILE is -, read standard input.\n" +msgid "With no FILE, or when FILE is -, read standard input." +msgstr "" +"\n" +"FÁJL nélkül, vagy ha a FÁJL -, olvasás a szabványos bemenetről.\n" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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" +msgid "Report bugs to <%s> (in English or Finnish)." +msgstr "Ide jelentse a hibákat: <%s> (angolul vagy finnül).\n" + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "Filter chains are set using the --filters=FILTERS or\n" +#| "--filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain\n" +#| "can be separated by spaces or '--'. Alternatively a preset <0-9>[e] can be\n" +#| "specified instead of a filter chain.\n" +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 szűrőláncokat a --filters=SZŰRŐK vagy a\n" +"--filters1=SZŰRŐK ... --filters9=SZŰRŐK kapcsolókkal lehet megadni. A láncban\n" +"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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Options must be 'name=value' pairs separated with commas" +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "%s: A kapcsolóknak vesszőkkel elválasztott „név=érték” pároknak kell lenniük" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Érvénytelen kapcsolónév" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option value" +msgid "Invalid option value" +msgstr "%s: Érvénytelen kapcsolóérték" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Nem támogatott LZMA1/LZMA2 előbeállítás: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Az lc és lp összege nem haladhatja meg a 4-et" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: A fájlnév utótagja ismeretlen, kihagyás" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: A fájlnak már van „%s” utótagja, kihagyás" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Érvénytelen fájlnév utótag" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Value is not a non-negative decimal integer" +msgid "Value is not a non-negative decimal integer" +msgstr "%s: Az érték nem nemnegatív decimális egész szám" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Érvénytelen szorzó utótag" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Az érvényes utótagok: „KiB” (2^10), „MiB” (2^20) és „GiB” (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "A(z) „%s” kapcsoló értékének a(z) [%, %] tartományban kell lennie" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "A tömörített adatokat nem lehet beolvasni a terminálból" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "A tömörített adatokat nem lehet kiírni a terminálba" + +#: src/lzmainfo/lzmainfo.c +#, fuzzy, c-format +#| msgid "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Usage: %s [--help] [--version] [FILE]...\n" +msgstr "" +"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 interpreted as a zero-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 "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Show information stored in the .lzma file header." +msgstr "" +"Használat: %s [--help] [--version] [FÁJL]…\n" +"Az .lzma fájl fejlécében tárolt információk megjelenítése" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "A fájl túl kicsi, hogy érvényes .lzma fájl legyen" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Nem .lzma fájl" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "A szabványos kimenetre írás sikertelen" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Ismeretlen hiba" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported options" +msgid "Unsupported preset" +msgstr "Nem támogatott kapcsolók" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported filter chain or filter options" +msgid "Unsupported flag in the preset" +msgstr "Nem támogatott szűrőlánc vagy szűrőkapcsolók" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option name" +msgid "Unknown option name" +msgstr "%s: Érvénytelen kapcsolónév" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid multiplier suffix" +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "%s: Érvénytelen szorzó utótag" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Unknown file format type" +msgid "Unknown filter name" +msgstr "%s: Ismeretlen fájlformátumtípus" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "LZMA1 cannot be used with the .xz format" +msgid "This filter cannot be used in the .xz format" +msgstr "Az LZMA1 nem használható az .xz formátummal" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Maximum number of filters is four" +msgid "The maximum number of filters is four" +msgstr "A szűrők legnagyobb száma négy" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" + +#~ msgid "" +#~ " -z, --compress force compression\n" +#~ " -d, --decompress force decompression\n" +#~ " -t, --test test compressed file integrity\n" +#~ " -l, --list list information about .xz files" +#~ msgstr "" +#~ " -z, --compress kényszerített tömörítés\n" +#~ " -d, --decompress kényszerített kibontás\n" +#~ " -t, --test tömörített fájl épségének tesztelése\n" +#~ " -l, --list információk kiírása az .xz fájlokról" + +#~ msgid "" +#~ " -k, --keep keep (don't delete) input files\n" +#~ " -f, --force force overwrite of output file and (de)compress links\n" +#~ " -c, --stdout write to standard output and don't delete input files" +#~ msgstr "" +#~ " -k, --keep bemeneti fájlok megtartása (ne törölje)\n" +#~ " -f, --force kimeneti fájl kényszerített felülírása,\n" +#~ " és a linkek tömörítése/kibontása\n" +#~ " -c, --stdout írás a szabványos kimenetre írás, és nem törli a\n" +#~ " bemeneti fájlokat" + +#~ msgid "" +#~ " --no-sparse do not create sparse files when decompressing\n" +#~ " -S, --suffix=.SUF use the suffix '.SUF' on compressed files\n" +#~ " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~ " omitted, filenames are read from the standard input;\n" +#~ " filenames must be terminated with the newline character\n" +#~ " --files0[=FILE] like --files but use the null character as terminator" +#~ msgstr "" +#~ " --no-sparse ne hozzon létre ritka fájlokat kibontáskor\n" +#~ " -S, --suffix=.SUF a „.SUF” utótag használata a tömörített fájlokon\n" +#~ " --files[=FÁJL] fájlnevek beolvasása a FÁJLból; ha a FÁJL nincs\n" +#~ " megadva, akkor a fájlnevek a szabványos bemenetről\n" +#~ " lesznek beolvasva; a fájlneveket újsor karakterrel\n" +#~ " kell zárni\n" +#~ " --files0[=FÁJL] mint a --files, de a null karaktert használja\n" +#~ " használja elválasztóként" + +#~ msgid "" +#~ " -F, --format=FMT file format to encode or decode; possible values are\n" +#~ " 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'\n" +#~ " -C, --check=CHECK integrity check type: 'none' (use with caution),\n" +#~ " 'crc32', 'crc64' (default), or 'sha256'" +#~ msgstr "" +#~ " -F, --format=FMT a kódoláshoz vagy dekódoláshoz használt fájlformátum;\n" +#~ " lehetséges értékek „auto” (alapértelmezett), „xz”,\n" +#~ " „lzma”, „lzip” és „raw”\n" +#~ " -C, --check=ELL integritás-ellenőrzés típusa: „none” (óvatosan használja),\n" +#~ " „crc32”, „crc64” (alapértelmezett) vagy „sha256”" + +#, no-c-format +#~ msgid "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " --memlimit-mt-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " set memory usage limit for compression, decompression,\n" +#~ " threaded decompression, or all of these; LIMIT is in\n" +#~ " bytes, % of RAM, or 0 for defaults" +#~ msgstr "" +#~ " --memlimit-compress=KORLÁT\n" +#~ " --memlimit-decompress=KORLÁT\n" +#~ " --memlimit-mt-decompress=KORLÁT\n" +#~ " -M, --memlimit=KORLÁT\n" +#~ " a memóriahasználati korlát megadása tömörítéshez,\n" +#~ " kibontáshoz, többszálú kibontású vagy mindháromhoz; a\n" +#~ " KORLÁT bájtokban van megadva, a RAM %-ában, vagy 0 az\n" +#~ " alapértelmezéshez" + +#~ msgid "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1 or LZMA2; OPTS is a comma-separated list of zero or\n" +#~ " --lzma2[=OPTS] more of the following options (valid values; default):\n" +#~ " preset=PRE reset options to a preset (0-9[e])\n" +#~ " dict=NUM dictionary size (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NUM number of literal context bits (0-4; 3)\n" +#~ " lp=NUM number of literal position bits (0-4; 0)\n" +#~ " pb=NUM number of position bits (0-4; 2)\n" +#~ " mode=MODE compression mode (fast, normal; normal)\n" +#~ " nice=NUM nice length of a match (2-273; 64)\n" +#~ " mf=NAME match finder (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM maximum search depth; 0=automatic (default)" +#~ msgstr "" +#~ "\n" +#~ " --lzma1[=KAPCS] LZMA1 vagy LZMA2; a KAPCS nulla vagy több vesszővel\n" +#~ " --lzma2[=KAPCS] elválasztott kapcsoló az alábbiak közül\n" +#~ " (érvényes érték; alapértelmezett):\n" +#~ " preset=ELŐ visszaállítás egy előbeállításra (0-9[e])\n" +#~ " dict=SZÁM szótárméret (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=SZÁM literál környezeti bitek száma (0-4; 3)\n" +#~ " lp=SZÁM literál pozícióbitek száma (0-4; 0)\n" +#~ " pb=SZÁM pozícióbitek száma (0-4; 2)\n" +#~ " mode=MÓD tömörítési mód (fast, normal; normal)\n" +#~ " nice=SZÁM az egyezés „nice” hossza (2-273; 64)\n" +#~ " mf=NÉV egyezéskereső (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=SZÁM legnagyobb keresési mélység; 0=automatikus\n" +#~ " (alapértelmezett)" + +#~ msgid "" +#~ "\n" +#~ " --x86[=OPTS] x86 BCJ filter (32-bit and 64-bit)\n" +#~ " --arm[=OPTS] ARM BCJ filter\n" +#~ " --armthumb[=OPTS] ARM-Thumb BCJ filter\n" +#~ " --arm64[=OPTS] ARM64 BCJ filter\n" +#~ " --powerpc[=OPTS] PowerPC BCJ filter (big endian only)\n" +#~ " --ia64[=OPTS] IA-64 (Itanium) BCJ filter\n" +#~ " --sparc[=OPTS] SPARC BCJ filter\n" +#~ " --riscv[=OPTS] RISC-V BCJ filter\n" +#~ " Valid OPTS for all BCJ filters:\n" +#~ " start=NUM start offset for conversions (default=0)" +#~ msgstr "" +#~ "\n" +#~ " --x86[=KAPCS] x86 BCJ szűrő (32 bites és 64 bites)\n" +#~ " --arm[=KAPCS] ARM BCJ szűrő\n" +#~ " --armthumb[=KAPCS] ARM-Thumb BCJ szűrő\n" +#~ " --arm64[=KAPCS] ARM64 BCJ szűrő\n" +#~ " --powerpc[=KAPCS] PowerPC BCJ szűrő (csak big endian esetén)\n" +#~ " --ia64[=KAPCS] IA-64 (Itanium) BCJ szűrő\n" +#~ " --sparc[=KAPCS] SPARC BCJ szűrő\n" +#~ " --riscv[=KAPCS] RISC-V BCJ szűrő\n" +#~ " Érvényes KAPCS az összes BCJ szűrőhöz:\n" +#~ " start=SZÁM kezdési eltolás az átalakításokhoz\n" +#~ " (alapértelmezett=0)" + +#~ msgid "" +#~ "\n" +#~ " --delta[=OPTS] Delta filter; valid OPTS (valid values; default):\n" +#~ " dist=NUM distance between bytes being subtracted\n" +#~ " from each other (1-256; 1)" +#~ msgstr "" +#~ "\n" +#~ " --delta[=OPTS] Delta szűrő; érvényes KAPCSOLÓK\n" +#~ " (érvényes értékek; alapértelmezett default):\n" +#~ " dist=SZÁM az egymásból kivont bájtok közti\n" +#~ " távolság (1-256; 1)" + +#~ msgid "" +#~ " -q, --quiet suppress warnings; specify twice to suppress errors too\n" +#~ " -v, --verbose be verbose; specify twice for even more verbose" +#~ msgstr "" +#~ " -q, --quiet figyelmeztetések elrejtése; adja meg kétszer, hogy a\n" +#~ " hibákat is elrejtse\n" +#~ " -v, --verbose legyen bőbeszédű; adja meg kétszer, hogy még bőbeszédűbb\n" +#~ " legyen" + +#~ msgid "" +#~ " -h, --help display the short help (lists only the basic options)\n" +#~ " -H, --long-help display this long help and exit" +#~ msgstr "" +#~ " -h, --help a rövid súgó megjelenítése (csak az alapvető kapcsolók)\n" +#~ " -H, --long-help ezen hosszú súgó megjelenítése, és kilépés" + +#~ msgid "" +#~ " -h, --help display this short help and exit\n" +#~ " -H, --long-help display the long help (lists also the advanced options)" +#~ msgstr "" +#~ " -h, --help ezen rövid súgó megjelenítése, és kilépés\n" +#~ " -H, --long-help a hosszú súgó megjelenítése (speciális kapcsolókhoz)" + +#~ msgid "Failed to enable the sandbox" +#~ msgstr "A homokozó engedélyezése sikertelen" + +#, c-format +#~ msgid "The selected match finder requires at least nice=%" +#~ msgstr "A kiválasztott egyezéskeresőhöz legalább nice=% szükséges" + +#~ msgid "Sandbox is disabled due to incompatible command line arguments" +#~ msgstr "A homokozó ki lett kapcsolva a nem kompatibilis parancssori argumentumok miatt" + +#~ msgid "Sandbox was successfully enabled" +#~ msgstr "A homokozó sikeresen engedélyezve" + +#~ msgid "Memory usage limit for compression: " +#~ msgstr "Memóriahasználat korlátja tömörítéskor: " + +#~ msgid " Streams: %s\n" +#~ msgstr " Adatfolyamok: %s\n" + +#~ msgid " Blocks: %s\n" +#~ msgstr " Blokkok: %s\n" + +#~ msgid " Ratio: %s\n" +#~ msgstr " Arány: %s\n" + +#~ msgid " Check: %s\n" +#~ msgstr " Ellenőrzés: %s\n" + +#~ msgid "" +#~ " Streams:\n" +#~ " Stream Blocks CompOffset UncompOffset CompSize UncompSize Ratio Check Padding" +#~ msgstr "" +#~ " Adatfolyamok:\n" +#~ " Folyam Blokkok TömEltolás KibEltolás TömMéret KibMéret Arány Ellenőrzés Keret" + +#~ msgid "" +#~ " Blocks:\n" +#~ " Stream Block CompOffset UncompOffset TotalSize UncompSize Ratio Check" +#~ msgstr "" +#~ " Blokkok:\n" +#~ " Folyam Blokkok TömEltolás KibEltolás TömMéret KibMéret Arány Ellenőrzés" + +#~ msgid " CheckVal %*s Header Flags CompSize MemUsage Filters" +#~ msgstr " ÉrtékEll %*s Fejléc Jelzők TömMéret MemHasználat Szűrők" diff --git a/cpp/third_party/xz-5.8.3/po/insert-header.sed b/cpp/third_party/xz-5.8.3/po/insert-header.sed new file mode 100644 index 0000000000..f9534e7edf --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/insert-header.sed @@ -0,0 +1,31 @@ +# Sed script that inserts the file called HEADER before the header entry. +# +# Copyright (C) 2001 Free Software Foundation, Inc. +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. +# This file is offered as-is, without any warranty. +# +# Written by Bruno Haible , 2001. +# +# At each occurrence of a line starting with "msgid ", we execute the following +# commands. At the first occurrence, insert the file. At the following +# occurrences, do nothing. The distinction between the first and the following +# occurrences is achieved by looking at the hold space. +/^msgid /{ +x +# Test if the hold space is empty. +s/m/m/ +ta +# Yes it was empty. First occurrence. Read the file. +r HEADER +# Output the file's contents by reading the next line. But don't lose the +# current line while doing this. +g +N +bb +:a +# The hold space was nonempty. Following occurrences. Do nothing. +x +:b +} diff --git a/cpp/third_party/xz-5.8.3/po/it.gmo b/cpp/third_party/xz-5.8.3/po/it.gmo new file mode 100644 index 0000000000..910262b2de Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/it.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/it.po b/cpp/third_party/xz-5.8.3/po/it.po new file mode 100644 index 0000000000..a8cce1559c --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/it.po @@ -0,0 +1,1270 @@ +# SPDX-License-Identifier: 0BSD +# +# Italian translation for xz +# This file is published under the BSD Zero Clause License. +# Gruppo traduzione italiano di Ubuntu-it , 2009, 2010 +# Lorenzo De Liso , 2010. +# Milo Casagrande , 2009, 2010, 2011, 2014, 2019. +# Luca Vercelli 2025. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.8.0-pre1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: it\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Launchpad-Export-Date: 2010-08-16 19:16+0000\n" +"X-Generator: Poedit 2.2.1\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: argomento non valido per --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: troppi argomenti per --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "In --block-list, la dimensione del blocco è mancante, dopo il numero di catena di filtri \"%c:\"" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 può essere usato solo come ultimo elemento in --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: tipo di formato del file sconosciuto" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: tipo di controllo integrità non supportato" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Solo un file può essere specificato con \"--files\" o \"--files0\"." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "La variabile d'ambiente %s contiene troppi argomenti" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Il supporto alla compressione è stato disabilitato in fase di compilazione" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Il supporto alla decompressione è stato disabilitato in fase di compilazione" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "La compressione di file lzip (.lz) non è supportata" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list viene ignorato a meno che si stia comprimendo in formato .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Con --format=raw è richiesto --suffix=.SUF a meno che non si scriva sullo standard output" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Il numero massimo di filtri è quattro" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Errore nell'opzione --filters%s=FILTRI:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Il limite dell'uso della memoria è troppo basso per l'impostazione del filtro dato." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "catena di filtri %u usata da --block-list ma non specificata con --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Non è consigliato usare un preset nella modalità raw." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Le opzioni esatte per i preset possono variare tra le versioni del software." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Il formato .lzma supporta solo il filtro LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 non può essere usato con il formato .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "La catena di filtri %u non è compatibile con --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Passaggio a modalità singolo thread poiché viene usato --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Opzioni non supportate nella catena di filtri %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Vengono usati fino a % thread." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Catena di filtri od opzioni del filtro non supportata" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "La decompressione necessita di %s MiB di memoria." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Ridotto il numero di thread da %s a %s per non eccedere il limite di utilizzo della memoria di %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Ridotto il numero di thread da %s a uno. Il limite automatico di uso di memoria di %s MiB è ancora superato. Necessari %s MiB di memoria. Si procede comunque." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Si è commutato alla modalità a thread singola per non eccedere il limite di utilizzo della memoria di %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Regolata la dimensione del dizionario LZMA%c da %s MiB a %s MiB per non superare il limite dell'uso della memoria di %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Regolata la dimensione del dizionario LZMA%c per --filters%u da %s MiB a %s MiB per non superare il limite dell'uso della memoria di %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Errore nel concatenare alla catena di filtri %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Errore nel creare una pipe: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() non riuscita: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: sembra che il file sia stato spostato, non viene rimosso" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: impossibile rimuovere: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: impossibile impostare il proprietario del file: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: impossibile impostare il gruppo del file: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: impossibile impostare i permessi del file: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: sincronizzazione del file non riuscita: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: sincronizzazione della cartella del file non riuscita: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Errore nel recuperare le flag di stato del file dallo standard input: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: è un collegamento simbolico, viene saltato" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: è una cartella, viene saltata" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: non è un file regolare, viene saltato" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: il file ha il bit setuid o setgid impostato, viene saltato" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: il file ha lo sticky bit impostato, viene saltato" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: il file di input ha più di un collegamento fisico, viene saltato" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Nome file vuoto, viene saltato" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Errore nel ripristinare le flag di stato sullo standard input: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Errore nel recuperare le flag di stato del file dallo standard output: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: apertura della cartella non riuscita: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: la destinazione non è un file regolare" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Errore nel ripristinare la flag O_APPEND sullo standard output: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: chiusura del file non riuscita: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: posizionamento non riuscito nel tentativo di creare un file sparso: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: errore di lettura: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: errore nel cercare nel file: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: fine del file inaspettata" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: errore di scrittura: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Disabilitata" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Quantità di memoria fisica (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Numero di thread del processore:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Compressione:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Decompressione:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Decompressione multi-thread:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Valori predefiniti per -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Informazioni hardware:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Limiti di utilizzo della memoria:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Stream:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blocchi:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Dimensione compressa:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Dimensione non compressa:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Rapporto:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Controllo:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Padding dello stream:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Memoria necessaria:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Dim. negli header:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Numero di file:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Stream" + +#: src/xz/list.c +msgid "Block" +msgstr "Blocco" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blocchi" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "" + +#: src/xz/list.c +msgid "CompSize" +msgstr "" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "TotalSize" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Rapporto" + +#: src/xz/list.c +msgid "Check" +msgstr "Controllo" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "" + +#: src/xz/list.c +msgid "Padding" +msgstr "Padding" + +#: src/xz/list.c +msgid "Header" +msgstr "Header" + +#: src/xz/list.c +msgid "Flags" +msgstr "Flag" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filtri" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Nessuno" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Sconosc2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Sconosc3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Sconosc5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Sconosc6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Sconosc7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Sconosc8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Sconosc9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Sconosc11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Sconosc12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Sconosc13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Sconosc14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Sconosc15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: il file è vuoto" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: troppo piccolo per essere un file .xz valido" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr " Strm Blocc. Compresso Estratto Rapp. Contr Nome file" + +#: src/xz/list.c +msgid "Yes" +msgstr "Sì" + +#: src/xz/list.c +msgid "No" +msgstr "No" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Versione \"XZ Utils\" minima:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s file\n" +msgstr[1] "%s file\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Totali:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list funziona solamente con file .xz (--format=xz o --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Provare \"lzmainfo\" con i file .lzma." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list non è in grado di leggere dallo standard input" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: errore nel leggere i nomi dei file: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: fine dell'input durante la lettura dei nomi dei file non attesa" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: trovato carattere null durante la lettura dei nomi dei file; forse si intendeva usare \"--files0\" invece di \"--files\"?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "La compressione e la decompressione con --robot non sono ancora supportate." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Impossibile leggere i dati dallo standard input durante la lettura dei nomi dei file dallo standard input" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Errore interno (bug)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Impossibile stabilire i gestori dei segnali" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Nessun controllo d'integrità; l'integrità del file non viene verificata" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Tipo di controllo di integrità non supportato; l'integrità del file non viene verificata" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Limite di utilizzo della memoria raggiunto" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Formato di file non riconosciuto" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Opzioni non supportate" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "I dati compressi sono danneggiati" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Fine dell'input non attesa" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB di memoria sono richiesti. Il limite è disabilitato." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB di memoria sono richiesti. Il limite è %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: catena di filtri: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Provare \"%s --help\" per maggiori informazioni." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Errore nello stampare il testo di aiuto (codice di errore %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "FILE" +msgstr "FILE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "FORMATO" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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\"" + +#: src/xz/message.c +msgid "NAME" +msgstr "NOME" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "NUM" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "SIZE" +msgstr "DIM" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOCCHI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "LIMITE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTRI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "OPZIONI" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the 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):" +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; OPZIONI è una lista separata da virgole di zero o più delle seguenti opzioni (valori validi; predefinito):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "PRESET" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "MODE" +msgstr "MODALITÀ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "Segnalare i bug a <%s> (in inglese o finlandese). Segnalare i bug di traduzione a ." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Le opzioni devono essere coppie \"nome=valore\" separate da virgole" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: nome opzione non valido" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "valore dell'opzione non valido" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Preset LZMA/LZMA2 non supportato: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "La somma di lc e lp non deve superare 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: il nome del file ha un suffisso sconosciuto, viene saltato" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: il file ha il suffisso \"%s\", viene saltato" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: suffisso del nome del file non valido" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Il valore non è un numero intero decimale non-negativo" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: suffisso del moltiplicatore non valido" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "I suffissi validi sono \"KiB\" (2^10), \"MiB\" (2^20), e \"GiB\" (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Il valore dell'opzione \"%s\" deve essere nell'intervallo [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "I dati compressi non possono essere letti da un terminale" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "I dati compressi non possono essere scritti su un terminale" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Il file è troppo piccolo per essere un file .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Non è un file .lzma" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Scrittura sullo standard output non riuscita" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Errore sconosciuto" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Preset non supportato" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Flag nel preset non supportato" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Nome di opzione non valido" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Il valore dell'opzione non può essere vuoto" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Valore fuori scala" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Questa opzione non supporta alcun suffisso moltiplicatore" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Suffisso del moltiplicatore non valido (KiB, MiB, o GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Nome di filtro non valido" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Questo filtro non può essere usato nel formato .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Allocazione di memoria fallita" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Stringa vuota non ammessa, provare '6' se è necessario un valore predefinito" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Il numero massimo di filtri è quattro" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Nome del filtro mancante" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Catena di filtro non valida (manca \"lzma2\" al fondo?)" diff --git a/cpp/third_party/xz-5.8.3/po/ka.gmo b/cpp/third_party/xz-5.8.3/po/ka.gmo new file mode 100644 index 0000000000..a3573a11d7 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/ka.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/ka.po b/cpp/third_party/xz-5.8.3/po/ka.po new file mode 100644 index 0000000000..748bf695a6 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/ka.po @@ -0,0 +1,1264 @@ +# SPDX-License-Identifier: 0BSD +# +# xz translation to Georgian. +# This file is published under the BSD Zero Clause License. +# Temuri Doghonadze , 2024. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: ka\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.5\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: --block-list -ის არასწორი არგუმენტი" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: --block-list -ის მეტისმეტად ბევრი არგუმენტი" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "პარამეტრი --block-list ფილტრის ჯაჭვის ნომრის '%c' შემდეგ ბლოკის ზომა აკლია" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "ნული --block-list -ის მხოლოდ ბოლო ელემენტი შეიძლება იყოს" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: ფაილის ფორმატის უცნობი ტიპი" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: სიმრთელის შემოწმების მხარდაუჭერელი ტიპი" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "'--files' ან '--files0' -თან ერთად, მხოლოდ, ერთი ფაილის მითითება შეიძლება." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "გარემოს ცვლადი %s მეტისმეტად ბევრ არგუმენტს შეიცავს" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "შეკუმშვის მხარდაჭერა გამორთულია აგების დროს" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "გაშლის მხარდაჭერა გამორთულია აგების დროს" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "შეკუმშვა lzip (.lz) ფაილებისთვის მხარდაჭერილი არაა" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "პარამეტრი --block-list გამოტოვებულია იმ შემთხვევის გარდა, თუ .xz ფორმატს იყენებთ" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "--format=raw -თან ერთად --suffix=.SUF -ის მითითება აუცილებელია, თუ stdout-ზე არ წერთ" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "ფილტრების მაქსიმალური რაოდენობა ოთხის ტოლია" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Error პარამეტრში --filters%s=FILTERS:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "მითითებული ფილტრის გამოსაყენებლად მეხსიერების გამოყენების ლიმიტი მეტისმეტად დაბალია." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "ფილტრების ჯაჭვი %u გამოიყენება პარამეტრით --block-list, მაგრამ არაა მითითებული პარამეტრით --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "პრესეტის დაუმუშავებელ რეჟიმში გამოყენება რეკომენდებული არაა." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "პრესეტების ზუსტი პარამეტრები ვერსიებს შორის იცვლება." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr ".lzma ფორმატს მხოლოდ LZMA1 ფილტრს მხარდაჭერა გააჩნია" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1-ის გამოყენება .შეუძლებელია xz ფორმატით" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "ფილტრების ჯაჭვი %u შეუთავსებელია პარამეტრთან --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "ერთნაკადიან რეჟიმზე გადართვა --flush-timeout -ის გამო" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "მხარდაუჭერელი პარამეტრები ფილტრის ჯაჭვში %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "გამოიყენება მაქსიმუმ % ნაკადი." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "მხარდაუჭერელი ფილტრების ჯაჭვი ან ფილტრის პარამეტრები" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "გაშლისთვის საჭიროა %s მიბ მეხსიერება." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "ნაკადების რაოდენობა შემცირდა %s-დან %s-ზე, რომ არ გადავაცილო მეხსიერების შეზღუდვას %s მიბ" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "ნაკადების რაოდენობა შემცირდა %s-დან ერთამდე. ავტომატური მეხსიერების გამოყენების შეზღუდვა %s მბ-ზე გადაცილებულია. საჭიროა %s მიბ მეხსიერება. მაინც გავაგრძელებ." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "გადავერთე ერთნაკადიან რეჟიმში, რომ არ გადავაცილო მეხსიერების ზღვარს %s მიბ" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "LZMA%c-ის ლექსიკონის ზომა შესწორდა %s მიბ-დან %s მიბ-ზე, რომ არ გადავაჭარბო მეხსიერების ლიმიტს, რომელიც %s მიბ-ის ტოლია" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "LZMA%c-ის ლექსიკონის ზომა შესწორდა --filters%u-სთვის %s მიბ-დან %s მიბ-ზე, რომ არ გადავაჭარბო მეხსიერების ლიმიტს, რომელიც %s მიბ-ის ტოლია" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "ფილტრების ჯაჭვზე %u შეცვლის შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "ფაიფის შექმნის შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() -ის შეცდომა: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: როგორც ჩანს, ფაილი გადატანილია. არ წავშლი" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: წაშლა შეუძლებელია: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: ფაილის მფლობელის დაყენების შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: ფაილის ჯგუფის დაყენების შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: ფაილის წვდომების დაყენების შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: ფაილის სინქრონიზაციის შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: ფაილის საქაღალდის სინქრონიზაციის შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "ფაილის სტატუსის ალმები მიღების შეცდომა სტანდარტული შეყვანიდან: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: სიმბმულია. გამოტოვება" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: საქაღალდეა, გამოტოვება" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: ჩვეულებრივი ფაილი არაა. გამოტოვება" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: ფაილს setuid ან setgit ბიტი აქვს დაყენებული. გამოტოვება" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: ფაილს წებოვანი ბიტი აქვს. გამოტოვება" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: შეყვანილ ფაილს ერთზე მეტი მყარი ბმული გააჩნია. გამოტოვება" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "ცარიელი ფაილის სახელი. გამოტოვება" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "სტატუსის ალმების აღდგენის შეცდომა სტანდარტულ შეყვანაზე: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "ფაილის სტატუსის ალმების მიღების შეცდომა სტანრარტული გამოტანიდან: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: საქაღალდის გახსნის შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: სამიზნე ჩვეულებრივი ფაილი არაა" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "O_APPEND ალმის აღდგენის შეცდომა სტანდარტულ გამოტანაზე: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: ფაილის დახურვის შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: გადახვევის შეცდომა დამატებითი ფაილის შექმნის მცდელობისას: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: წაკითხვის შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: ფაილის გადახვევის შეცდომა: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: ფაილის მოულოდნელი დასასრული" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: ჩაწერის შეცდომა: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "გამორთულია" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "ფიზიკური მეხსიერების (RAM) რაოდენობა:" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "პროცესორის ნაკადების რაოდენობა:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "შეკუმშვა:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "გაშლა:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "მრავალნაკადიანი გაშლა:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "ნაგულისხმევი პარამეტრისთვის -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "ინფორმაცია აპარატურის შესახებ:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "მეხსიერების გამოყენების შეზღუდვები:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "ნაკადები:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "ბლოკები:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "შეკუმშული ზომა:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "შეუკუმშავი ზომა:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "პროპორციები:" + +#: src/xz/list.c +msgid "Check:" +msgstr "შემოწმება:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "ნაკადის შევსება:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "საჭიროა მეხსიერება:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "ზომა თავსართებში:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "ფაილების რაოდენობა:" + +#: src/xz/list.c +msgid "Stream" +msgstr "ნაკადი" + +#: src/xz/list.c +msgid "Block" +msgstr "ბლოკი" + +#: src/xz/list.c +msgid "Blocks" +msgstr "ბლოკები" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "შეკუმშწანაცვლ" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "შეუკუმშწანაცვლ" + +#: src/xz/list.c +msgid "CompSize" +msgstr "შეკუმშზომა" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "შეუკუმშზომა" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "ზომასულ" + +#: src/xz/list.c +msgid "Ratio" +msgstr "პროპორციები" + +#: src/xz/list.c +msgid "Check" +msgstr "შემოწმება" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "მნიშვნშემოწმ" + +#: src/xz/list.c +msgid "Padding" +msgstr "შევსება" + +#: src/xz/list.c +msgid "Header" +msgstr "ზედა კოლონტიტული" + +#: src/xz/list.c +msgid "Flags" +msgstr "დროშები" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "მეხსგამოყ" + +#: src/xz/list.c +msgid "Filters" +msgstr "ფილტრები" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "არაფერი" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "უცნობი-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "უცნობი-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "უცნობი-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "უცნობი-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "უცნობი-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "უცნობი-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "უცნობი-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "უცნობი-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "უცნობი-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "უცნობი-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "უცნობი-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "უცნობი-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: ფაილი ცარიელია" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: მეტისმეტად პატარაა, რომ სწორ .xz ფაილს წარმოადგენდეს" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "ნაკადები ბლოკები შეკუმშული შეუკუმშავი ფარდობა შემოწმება ფაილს სახელი" + +#: src/xz/list.c +msgid "Yes" +msgstr "დიახ" + +#: src/xz/list.c +msgid "No" +msgstr "არა" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "მინიმალური XZ Utils ვერსია:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s ფაილი\n" +msgstr[1] "%s ფაილი\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "ჯამები:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list მხოლოდ .xz ფაილებზე მუშაობს (--format=xz ან --format=auto (ავტომატური))" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "სცადეთ 'lzmainfo' .lzma ფაილებისთვის." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list -ს სტანდარტული შეყვანიდან წაკითხვის მხარდაჭერა არ გააჩნია" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: ფაილის სახელების წაკითხვის შეცდომა: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: შეყვანის მოულოდნელი დასასრული ფაილის სახელების კითხვისას" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: ფაილის სახელების კითხვისა აღმოჩენილია ნულოვანი სიმბოლო. შეიძლება, '--files'-ის მაგიერ '--files0'-ის გამოყენება გნებავდათ?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "--robot -ან ერთად შეკუმშვა და გაშლა ჯერჯერობით მხარდაუჭერელია." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "მონაცემების სტანდარტული შეყვანიდან წაკითხვა მაშინ, როცა ფაილების სახელებიც სტანდარტული შეყვანიდან იკითხება, შეუძლებელია" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "შიდა შეცდომა (პროგრამა გასამართია)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "სიგნალების დამმუშავებლების დამყარების შეცდომა" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "სიმრთელის შემოწმების გარეშე. ფაილის სიმრთელე არ შემოწმდება" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "ფაილის სიმრთელის შემოწმების ხარდაუჭერელი ტიპი. ფაილის სიმრთელე არ შემოწმდება" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "მეხსიერების გამოყენების ლიმიტი მიღწეულია" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "ფაილის ფორმატი უცნობია" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "მხარდაუწერელი პარამეტრები" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "შეკუმშული მონაცემები დაზიანებულია" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "შეყვანის მოულოდნელი დასასრული" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "საჭიროა %s მბ მეხსიერება. მსაზღვრელი გამორთულია." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "საჭიროა %s მბ მეხსიერება. ზღვარია: %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: ფილტრის ჯაჭვი: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "მეტი ინფორმაციისთვის სცადეთ '%s --help'." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "დახმარების ტექსტის გამოტანის შეცდომა (შეცდომის კოდია %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "გაშლისას დამატებითი ფაილები არ შეიქმნება" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".SUF" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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' სუფიქსის გამოყენება" + +#: src/xz/message.c +msgid "FILE" +msgstr "FILE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "ფაილის ფორმატისა და შეკუმშვის ძირითადი პარამეტრები:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "ფორმატი" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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'" + +#: src/xz/message.c +msgid "NAME" +msgstr "სახელი" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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-ის მეტი დატვირთვის ხარჯზე შეკუმშვის დონის აწევის ცდა. არქივის გაშლისას მეხსიერების მოთხოვნები არ შეიცვლება" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "NUM" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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, რაც იყენებს იმდენ ნაკადს, რამდენი ბირთვიც აქვს პროცესორს" + +#: src/xz/message.c +msgid "SIZE" +msgstr "ზომა" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 ბლოკის დაწყება ყოველი მითითებული ზომის მიღწევისას. გამოიყენეთ ეს, რომ დააყენოთ ბლოკის ზომა მრავალნაკადიანი შეკუმშვისას" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "ბლოკები" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 მილიწამზე მეტი გავიდა მას შემდეგ, რაც წინა ფლეში და მეტი შეყვანის წაკითხვა დაბლოკავს, ყველა მომლოდინე მონაცემი ამოიწურა" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "ლიმიტი" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "მომხმარებლის ფილტრის ჯაჭვი შეკუმშვისთვის (პრესეტების გამოყენების ალტერნატივა):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "ფილტრები" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 ფილტრის სტრიქონის სინტაქის შესახებ და გასვლა" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "პარამ-ები" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 მძიმით გამოყოფილი სიაა ნული ან მეტი შემდეგი პარამეტრებიდან (სწორი მნიშვნელობა. ნაგულიხმევი):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "პრე" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "ლექსიკონის ზომა" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "მდებარეობის ბიტების რაოდენობა" + +#: src/xz/message.c +msgid "MODE" +msgstr "რეჟიმი" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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-დან მოხდება." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "შეცდომების შესახებ მიწერეთ <%s> (ინგლისურად, ან ფინურად)." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 "მხარდაჭერელი ფილტრები და მათ პარამეტრებია:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "პარამეტრები უნდა წარმოადგენდეს \"სახელი=მნიშვნელობა\" ტიპის წყვილებს, მძიმეებით გამოყოფილს" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: არასწორი პარამეტრის სახელი" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "არასწორი პარამეტრის მნიშვნელობა" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "მხარდაუჭერელი LZMA1/LZMA2 პრესეტი: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "\"lc\" და \"lp\"-ის ჯამი 4-ზე მეტი არ უნდა იყო" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: ფაილის სახელის უცნობი სუფიქსი. გამოტოვება" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: ფაილს სუფიქსი `%s' უკვე გააჩნა. გამოტოვება" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: ფაილის სახელის არასწორი სუფიქსი" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "მნიშვნელობა არაუარყოფით მთელ რიცხვს არ წარმოადგენს" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: არასწორი მამრავლის სუფიქსი" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "სწორი სუფიქსებია `KiB' (2^10), `MiB' (2^20) და `GiB' (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "პარამეტრის (%s) მნიშვნელობის დასაშვები დიაპაზონია [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "შეკუმშული მონაცემების ტერმინალიდან წაკითხვა შეუძლებელია" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "შეკუმშული მონაცემების ტერმინალში ჩაწერა შეუძლებელია" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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 ფაილის თავსართში შენახული ინფორმაციის ჩვენება." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "%s: მეტისმეტად პატარაა, რომ სწორ .xz ფაილს წარმოადგენდეს" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "არ წარმოადგენს .lzma ფაილს" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "სტანდარტული გამოტანაში ჩაწერის შეცდომა" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "უცნობი შეცდომა" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "მხარდაუჭერელი პრესეტი" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "მხარდაუჭერელი ალამი პრესეტში" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "უცნობი პარამეტრის სახელი" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "პარამეტრი ცარიელი ვერ იქნება" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "მნიშვნელობა დიაპაზონს გარეთაა" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "ამ პარამეტრს გამამრავლებელი სუფიქსების მხარდაჭერა არ გააჩნია" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "არასწორი მულტიპლიკატორის სუფიქსი (KiB, MiB ან GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "ფილტრის უცნობი სახელი" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "ამ ფილტრს .xz ფორმატში ვერ გამოიყენებთ" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "მეხსიერების გამოყოფის შეცდომა" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "ცარიელი სტრიქონი დაუშვებელია. სცადეთ '6', თუ ნაგულისხმევი მნიშვნელობა გჭირდებათ" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "ფილტრების მაქსიმალური რაოდენობა ოთხის ტოლია" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "ფილტრის სახელი მითითებული არაა" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "არასწორი ფილტრის ჯაჭვი (ბოლოში აკლია 'lzma2'?)" diff --git a/cpp/third_party/xz-5.8.3/po/ko.gmo b/cpp/third_party/xz-5.8.3/po/ko.gmo new file mode 100644 index 0000000000..4d7123e36a Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/ko.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/ko.po b/cpp/third_party/xz-5.8.3/po/ko.po new file mode 100644 index 0000000000..a3271d7734 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/ko.po @@ -0,0 +1,1266 @@ +# SPDX-License-Identifier: 0BSD +# Korean translation for the xz. +# This file is published under the BSD Zero Clause License. +# Seong-ho Cho , 2019, 2022, 2023, 2024, 2025. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: ko\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.5\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: --block-list의 인자값이 잘못됨" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: --block-list 인자 갯수가 너무 많음" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "--block-list에서 필터 체인 번호 '%c:' 다음 블록 크기가 빠졌습니다." + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 값은 --block-list의 마지막 원소로만 사용할 수 있습니다" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: 알 수 없는 파일 형식" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: 지원하지 않는 무결성 검사 형식" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "'--files' 또는 '--files0' 옵션에는 하나의 파일만 지정할 수 있습니다." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "%s 환경 변수에 너무 많은 인자 값이 들어있습니다" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "빌드 시점에 압축 기능을 비활성했습니다" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "빌드 시점에 압축 해제 기능을 비활성했습니다" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "lzip 파일 (.lz) 압축은 지원하지 않습니다" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr ".xz 형식으로 압축하지 않으면 --block-list 옵션은 무시합니다" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "표준 출력으로 기록하지 않는 한 --format=raw, --suffix=.<확장자> 옵션이 필요합니다" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "최대 필터 갯수는 4 입니다" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "--filters%s=<필터> 옵션 오류:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "주어진 필터 설정으로는 메모리 사용 제한 값이 너무 적습니다." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "--block-lisk에서 필터 체인 %u번을 사용하고 있지만 --filters%u= 옵션으로 지정하지 않았습니다" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "RAW 모드에서의 프리셋 사용은 권장하지 않습니다." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "프리셋의 정확한 옵션 값은 프로그램 버전에 따라 다릅니다." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr ".lzma 형식은 LZMA1 필터만 지원합니다" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr ".xz 형식에는 LZMA1 필터를 사용할 수 없습니다" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "필터 체인 %u번이 --flush-timeout 옵션과 맞지 않습니다" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "--flush-timeout 옵션을 지정하였으므로 단일 스레드 모드로 전환합니다" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "필터 체인 %u번에서 지원하지 않는 옵션" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "최대 스레드 %개를 사용합니다." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "지원하지 않는 필터 체인 또는 필터 옵션" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "압축 해제시 %s MiB 메모리 용량이 필요합니다." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "메모리 사용량 %s MiB 제한을 넘지 않으려 스레드 수를 %s(에)서 %s(으)로 줄였습니다" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "스레드 수가 %s(에)서 하나로 줄었습니다. 메모리 사용 자동 제한량 %sMiB를 여전히 초과합니다. 메모리 공간 %sMiB가 필요합니다. 어쨌든 계속합니다." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "메모리 사용 제한량 %sMiB를 넘지 않으려 단일 스레드 모드로 전환합니다" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "메모리 사용 제한량 %4$sMiB를 넘지 않으려 %2$sMiB에서 %3$sMiB로 LZMA%1$c 딕셔너리 크기를 조정했습니다" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "메모리 사용 제한량 %5$sMiB를 넘지 않으려 %3$sMiB에서 %4$sMiB로 --filters%2$u의 LZMA%1$c 딕셔너리 크기를 조정했습니다" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "필터 체인 %u번 전환 오류: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "파이프 생성 오류: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() 실패: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: 파일을 이동한 것 같음, 제거 안함" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: 제거할 수 없음: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: 파일 소유자를 설정할 수 없음: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: 파일 소유 그룹을 설정할 수 없음: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: 파일 권한을 설정할 수 없음: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: 파일 동기화 실패: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: 파일의 디렉터리 동기화 실패: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "표준 입력에서 파일 상태 플래그 가져오기 오류: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: 심볼릭 링크, 건너뜀" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: 디렉터리입니다, 건너뜀" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: 일반 파일 아님, 건너뜀" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: setuid 또는 setgid 비트 설정 있음, 건너뜀" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: 끈적이 비트 설정이 있는 파일, 건너뜀" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: 입력 파일에 하나 이상의 하드링크가 있습니다, 건너뜀" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "파일 이름 없음, 건너뜀" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "표준 입력으로의 상태 플래그 복원 오류: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "표준 출력에서 파일 상태 플래그 가져오기 오류: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: 디렉터리 열기 실패: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: 대상이 일반 파일이 아닙니다" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "표준 출력으로의 O_APPEND 플래그 복원 오류: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: 파일 닫기 실패: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: 분할 파일 생성 시도시 탐색 실패: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: 읽기 오류: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: 파일 탐색 오류: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: 예상치 못한 파일의 끝" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: 쓰기 오류: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "사용 안함" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "물리 메모리 양 (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "프로세서 스레드 수:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "압축:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "압축해제:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "멀티 스레드 압축 해제:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "-T0 기본값:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "하드웨어 정보:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "메모리 사용 제한량:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "스트림:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "블록 수:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "압축 용량:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "압축해제 용량:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "압축율:" + +#: src/xz/list.c +msgid "Check:" +msgstr "검사:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "스트림 패딩:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "요구 메모리:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "헤더 길이:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "파일 갯수:" + +#: src/xz/list.c +msgid "Stream" +msgstr "스트림" + +#: src/xz/list.c +msgid "Block" +msgstr "블록" + +#: src/xz/list.c +msgid "Blocks" +msgstr "블록" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "압축오프셋" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "압축해제오프셋" + +#: src/xz/list.c +msgid "CompSize" +msgstr "압축크기" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "압축해제크기" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "총크기" + +#: src/xz/list.c +msgid "Ratio" +msgstr "압축율" + +#: src/xz/list.c +msgid "Check" +msgstr "검사" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "검사값" + +#: src/xz/list.c +msgid "Padding" +msgstr "패딩" + +#: src/xz/list.c +msgid "Header" +msgstr "헤더" + +#: src/xz/list.c +msgid "Flags" +msgstr "플래그" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "메모리사용" + +#: src/xz/list.c +msgid "Filters" +msgstr "필터" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "없음" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "알 수 없음-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "알 수 없음-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "알 수 없음-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "알 수 없음-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "알 수 없음-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "알 수 없음-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "알 수 없음-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "알 수 없음-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "알 수 없음-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "알 수 없음-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "알 수 없음-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "알 수 없음-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: 파일 내용 없음" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: 유효한 .xz 파일로 보기에는 너무 작습니다" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "스트림 블록 압축 압축해제 압축율 검사 파일 이름" + +#: src/xz/list.c +msgid "Yes" +msgstr "예" + +# 주: 아니오가 아니라 아니요가 맞는 표현 +#: src/xz/list.c +msgid "No" +msgstr "아니요" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "최소 XZ 유틸리티 버전:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "파일 %s개\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "총:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list 옵션은 .xz 파일에만 동작합니다(--format=xz 또는 --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "'lzmainfo' 명령에 .lzma 파일 이름을 붙여 실행해보십시오." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list 옵션은 표준 입력 읽기를 지원하지 않습니다" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: 파일 이름 읽기 오류: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: 파일 이름 읽는 중 예상치 못한 입력 끝" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: 파일 이름을 읽는 도중 NULL 문자 발견. '--files' 옵션 대신 '--files0' 옵션을 사용하시려는게 아닙니까?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "아직 압축 동작과 압축 해제 동작에 --robot 옵션을 지원하지 않습니다." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "표준 출력에서 파일 이름을 읽을 때 표준 입력에서 데이터를 읽을 수 없습니다" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "내부 오류 (버그)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "시그널 처리자를 준비할 수 없습니다" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "무결성 검사 안함. 파일 무결성을 검증하지 않습니다" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "지원하지 않는 무결성 검사 형식. 파일 무결성을 검증하지 않습니다" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "메모리 사용량 한계에 도달했습니다" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "파일 형식을 인식할 수 없음" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "지원하지 않는 옵션" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "압축 데이터 깨짐" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "예상치 못한 입력 끝" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB 메모리 용량이 필요합니다. 제한을 비활성합니다." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB 메모리 용량이 필요합니다. 제한 용량은 %s 입니다." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: 필터 체인: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "자세한 사용법은 '%s --help'를 입력하십시오." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "도움말 텍스트 출력 오류(오류 코드 %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "압축 해제시 희소 처리 파일을 만들지 않습니다" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".SUF" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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'로 사용합니다" + +#: src/xz/message.c +msgid "FILE" +msgstr "<파일>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "기본 파일 형식 및 압축 옵션:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "<형식>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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'가 있습니다" + +#: src/xz/message.c +msgid "NAME" +msgstr "<이름>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 점유 시간을 더 확보하여 압축률을 개선합니다. 압축 해제시 메모리 요구 용량에는 영향을 주지 않습니다" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "<숫자>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 값입니다" + +#: src/xz/message.c +msgid "SIZE" +msgstr "<크기>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 블록을 시작합니다. 스레드 압축의 블록 크기를 지정할 때 사용합니다" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "<블록>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "압축하는 동안, 이전 데이터를 플러싱한 후 더 많은 블록 입력을 읽어들일 때 <숫자> 만큼의 밀리초단위 제한시간을 넘기면 모든 대기 데이터를 소거합니다" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "<제한>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "압축용 개별 필터 체인 설정 (사전 설정 사용을 대신함):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "<필터>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 필터 문자열 문법 추가 정보를 나타낸 후 빠져나갑니다" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "<옵션>" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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개 이상의 쉼표 구분 값입니다 (유효한 값. 기본값):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "<사전설정>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "딕셔너리 크기" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "위치 비트 수" + +#: src/xz/message.c +msgid "MODE" +msgstr "<모드>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "<파일> 값이 없거나, <파일> 값이 - 문자이면, 표준 입력을 읽어들입니다." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "<%s> (영문 또는 핀란드어)에 버그를 보고하십시오." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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=<필터> 옵션으로\n" +"필터 체인을 지정합니다. 체인의 각 필터는 공백 문자 또는 '--'으로 구분할 수 있습니다.\n" +"필터 체인 대신 %s 사전 설정 값을 지정할 수 있습니다." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "지원하는 필터와 옵션은 다음과 같습니다:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "옵션은 쉼표로 구분한 '이름=값' 쌍이어야합니다" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: 잘못된 옵션 이름" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "잘못된 옵션 값" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "지원하지 않는 LZMA1/LZMA2 사전 설정: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "lc값과 lp값의 합이 4를 초과하면 안됩니다" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: 파일 이름에 알 수 없는 확장자 붙음, 건너뜀" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: 파일에 이미 '%s' 확장자가 붙음, 건너뜀" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: 잘못된 파일 이름 확장자" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "값이 10진 양의 정수가 아닙니다" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: 잘못된 승수 단위" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "사용할 수 있는 단위는 'KiB' (2^10), 'MiB' (2^20), 'GiB' (2^30) 입니다." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "'%s' 옵션 값은 [%, %] 범위 안에 있어야 합니다" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "압축 데이터를 터미널에서 읽을 수 없습니다" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "압축 데이터를 터미널에 기록할 수 없습니다" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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 파일 헤더에 저장한 정보를 보여줍니다." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr ".lzma 파일이기에는 너무 작습니다" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr ".lzma 파일이 아닙니다" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "표준 출력 기록 실패" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "알 수 없는 오류" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "지원하지 않는 사전 설정" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "지원하지 않는 사전 설정 플래그" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "알 수 없는 옵션 이름" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "옵션 값을 비워둘 수 없습니다" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "값 범위 벗어남" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "이 옵션은 배수 단위 접미사를 지원하지 않습니다" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "잘못된 배수 단위 (KiB, MiB, 또는 GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "알 수 없는 파일 형식" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr ".xz 형식에 이 필터를 사용할 수 없습니다" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "메모리 할당 실패" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "빈 문자열을 허용하지 않습니다. 기본값이 필요하다면 '6'을 넣으십시오" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "최대 필터 갯수는 4 입니다" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "필터 이름이 빠졌습니다" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "부적절한 필터 체인 ('lzma2'를 뺐습니까?)" diff --git a/cpp/third_party/xz-5.8.3/po/nl.gmo b/cpp/third_party/xz-5.8.3/po/nl.gmo new file mode 100644 index 0000000000..6f2c6756bb Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/nl.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/nl.po b/cpp/third_party/xz-5.8.3/po/nl.po new file mode 100644 index 0000000000..4dc897f5e2 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/nl.po @@ -0,0 +1,1269 @@ +# SPDX-License-Identifier: 0BSD +# +# Dutch translation for xz-utils. +# This file is published under the BSD Zero Clause License. +# +# "Wie soll ich wissen was ich meine bevor ich höre was ich sage." +# +# Benno Schulenberg , 2019, 2024, 2025. +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: nl\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=n != 1;\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Ongeldig argument bij --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Te veel argumenten bij --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "Bij '--block-list' ontbreekt blokgrootte na filterketennummer '%c':" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "Bij '--block-list' kan '0' alleen het laatste element zijn" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Onbekend soort bestandsindeling" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Niet-ondersteund soort integriteitscontrole" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Slechts één bestand kan opgegeven worden met '--files' of '--files0'." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Omgevingsvariabele '%s' bevat te veel argumenten" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Compressie werd uitgeschakeld tijdens compilatie" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Decompressie werd uitgeschakeld tijdens compilatie" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Compressie van LZIP-bestanden (.lz) wordt niet ondersteund" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "'--block-list' wordt genegeerd (alleen geldig bij comprimeren naar .xz-indeling)" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Met '--format=raw' is optie '--suffix=.EXT' vereist (tenzij naar standaarduitvoer geschreven wordt)" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Het maximum aantal filters is vier" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Fout in optie '--filters%s=FILTERS':" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Geheugengebruiksgrens is te laag voor de gegeven filterconfiguratie." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "filterketen %u is gebruikt bij '--block-list' maar niet gegeven met '--filters%u='" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Gebruik van een voorinstelling in rauwe modus wordt ontraden." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "De precieze opties van de voorinstellingen kunnen variëren tussen programmaversies." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "De .lzma-indeling ondersteunt alleen het LZMA1-filter" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 kan niet gebruikt worden met de .xz-indeling" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Filterketen %u is niet compatibel met '--flush-timeout'" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Overgeschakeld naar enkeldraads modus wegens '--flush-timeout'" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Niet-ondersteunde opties in filterketen %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Tot % threads worden gebruikt." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Niet-ondersteunde filterketen of filteropties" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Decompressie heeft %s MiB aan geheugen nodig." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Aantal threads is gereduceerd van %s naar %s om de geheugengebruiksgrens van %s MiB niet te overschrijden" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Het aantal threads is gereduceerd van %s naar 1, maar de automatische geheugengebruiksgrens van %s MiB wordt alsnog overschreden. %s MiB aan geheugen is nodig. Toch doorgegaan." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Overgeschakeld naar enkeldraads modus, om de geheugengebruiksgrens van %s MiB niet te overschrijden" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Grootte van LZMA%c-woordenboek is aangepast van %s MiB naar %s MiB om de geheugengebruiksgrens van %s MiB niet te overschrijden" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Grootte van LZMA%c-woordenboek voor '--filters%u' is aangepast van %s MiB naar %s MiB om de geheugengebruiksgrens van %s MiB niet te overschrijden" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Fout bij overgaan naar filterketen %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Fout bij aanmaken van pijp: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() is mislukt: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "Bestand '%s' schijnt verplaatst te zijn -- niet verwijderd" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "Kan '%s' niet verwijderen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Kan bestandseigenaar niet instellen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Kan bestandsgroep niet instellen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Kan de toegangsrechten niet instellen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Synchroniseren van bestand is mislukt: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Synchroniseren van bestandsmap is mislukt: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Fout bij verkrijgen van de bestandstoestandsvlaggen van standaardinvoer: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Is een symbolische koppeling -- overgeslagen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Is een map -- overgeslagen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Is geen gewoon bestand -- overgeslagen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Bestand heeft SETUID- of SETGID-bit gezet -- overgeslagen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Bestand heeft 'sticky'-bit gezet -- overgeslagen" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Invoerbestand heeft meer dan één harde koppeling -- overgeslagen" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Lege bestandsnaam -- overgeslagen" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Fout bij herstellen van de bestandstoestandsvlaggen naar standaardinvoer: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Fout bij verkrijgen van de bestandstoestandsvlaggen van standaarduitvoer: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Openen van map is mislukt: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: Doel is geen gewoon bestand" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Fout bij herstellen van de 'O_APPEND'-vlag naar standaardinvoer: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Sluiten van bestand is mislukt: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: 'Seeken' is mislukt bij aanmaken van een bestand met gaten: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Leesfout: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Fout bij 'seeken': %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Onverwacht einde van bestand" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Schrijffout: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Uitgeschakeld" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Hoeveelheid fysiek geheugen (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Aantal processor-threads:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Compressie:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Decompressie:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Multi-threaded decompressie:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Default voor -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Hardware-informatie:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Geheugengebruiksgrenzen:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Streams:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blokken:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Gecomprimeerde grootte:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Ongecomprimeerde grootte:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Ratio:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Controle:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Stream-opvulling:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Benodigd geheugen:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Groottes in koppen:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Aantal bestanden:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Stream" + +#: src/xz/list.c +msgid "Block" +msgstr "Blok" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blokken" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "Gecomp.Start" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "Ongecomp.Start" + +#: src/xz/list.c +msgid "CompSize" +msgstr "Gecomp.Grootte" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "Ongecomp.Grootte" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "TotaleGrootte" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Ratio" + +#: src/xz/list.c +msgid "Check" +msgstr "Controle" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "Cont.waarde" + +#: src/xz/list.c +msgid "Padding" +msgstr "Vulling" + +#: src/xz/list.c +msgid "Header" +msgstr "Kop" + +#: src/xz/list.c +msgid "Flags" +msgstr "Vlaggen" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "Geh.geb." + +#: src/xz/list.c +msgid "Filters" +msgstr "Filters" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Geen" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Onbekend-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Onbekend-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Onbekend-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Onbekend-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Onbekend-8" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Onbekend-9" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Onbekend-10" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Onbekend-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Onbekend-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Onbekend-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Onbekend-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Onbekend-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Bestand is leeg" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Te klein om een geldig .xz-bestand te zijn" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Strms Blokkn Gecomprim. Ongecomprim. Ratio Contrle Bestandsnaam" + +#: src/xz/list.c +msgid "Yes" +msgstr "Ja" + +#: src/xz/list.c +msgid "No" +msgstr "Nee" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Minimale XZ-Utils-versie:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s bestand\n" +msgstr[1] "%s bestanden\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Totalen:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "'--list' werkt alleen voor .xz-bestanden (--format=xz of --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Probeer 'lzmainfo' met .lzma-bestanden." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "'--list' is niet mogelijk bij lezen van standaardinvoer" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Fout bij lezen van bestandsnamen: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Onverwacht einde van invoer tijdens lezen van bestandsnamen" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: NUL-teken gevonden bij lezen van bestandsnamen; misschien bedoelde u '--files0' i.p.v. '--files'?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Compressie en decompressie met '--robot' worden nog niet ondersteund." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Kan geen gegevens van standaardinvoer lezen wanneer bestandsnamen daarvan gelezen worden" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "** Interne fout (bug) **" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Kan signaalverwerkers niet instellen" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Geen integriteitscontrole -- bestandsintegriteit wordt niet gecontroleerd" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Niet-ondersteunde integriteitscontrole -- bestandsintegriteit wordt niet gecontroleerd" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Geheugengebruiksgrens is bereikt" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Bestandsindeling niet herkend" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Niet-ondersteunde opties" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Gecomprimeerde gegevens zijn beschadigd" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Onverwacht einde van invoer" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB aan geheugen is nodig. De begrenzer is uitgeschakeld." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB aan geheugen is nodig. De grens is %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Filterketen: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Typ '%s --help' voor meer informatie." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Fout bij tonen van hulptekst (foutcode %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".EXT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "FILE" +msgstr "BESTAND" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "INDELING" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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'" + +#: src/xz/message.c +msgid "NAME" +msgstr "NAAM" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "GETAL" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" +"maximaal dit aantal threads gebruiken; standaard is 0,\n" +"wat zoveel threads als er processorkernen zijn betekent" + +#: src/xz/message.c +msgid "SIZE" +msgstr "GROOTTE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOKKEN" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "GRENS" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTERS" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "INSTEL" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "GRAAD" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "MODE" +msgstr "MODUS" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "" +"Rapporteer programmagebreken aan <%s> (in het Engels);\n" +"meld fouten in de vertaling aan ." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Opties moeten 'naam=waarde'-paren zijn, gescheiden door komma's" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Ongeldige optienaam" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Ongeldige optiewaarde" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Niet-ondersteunde LZMA1/LZMA2-voorinstelling: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "De som van lc en lp mag niet groter zijn dan 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Bestand heeft onbekende extensie -- overgeslagen" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Bestand heeft al '%s'-extensie -- overgeslagen" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Ongeldige bestandsnaamextensie" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Waarde is geen niet-negatief tientallig geheel getal" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Ongeldig vermenigvuldigingsachtervoegsel" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Geldige achtervoegsels zijn 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Waarde van optie '%s' moet in het bereik [%, %] liggen" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Gecomprimeerde gegevens kunnen niet van een terminal gelezen worden" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Gecomprimeerde gegevens kunnen niet naar een terminal geschreven worden" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Bestand is te klein om een .lzma-bestand te zijn" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Geen .lzma-bestand" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Schrijven naar standaarduitvoer is mislukt" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Onbekende fout" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Niet-ondersteunde voorinstelling" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Niet-ondersteunde vlag in voorinstelling" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Ongeldige optienaam" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Optiewaarde mag niet leeg zijn" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Waarde ligt buiten bereik" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Deze optie accepteert geen vermenigvuldigingsachtervoegsels" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Ongeldig vermenigvuldigingsachtervoegsel (KiB, MiB, of GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Onbekende filternaam" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Dit filter kan niet gebruikt worden met de .xz-indeling" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Onvoldoende geheugen beschikbaar" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Lege tekenreeks is niet toegestaan; probeer '6' als een standaardwaarde nodig is" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Het maximum aantal filters is vier" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Ontbrekende filternaam" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Ongeldige filterketen (ontbreekt 'lzma2' aan het eind?)" diff --git a/cpp/third_party/xz-5.8.3/po/pl.gmo b/cpp/third_party/xz-5.8.3/po/pl.gmo new file mode 100644 index 0000000000..93864523d4 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/pl.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/pl.po b/cpp/third_party/xz-5.8.3/po/pl.po new file mode 100644 index 0000000000..4a74b938c7 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/pl.po @@ -0,0 +1,1266 @@ +# SPDX-License-Identifier: 0BSD +# +# Polish translation for xz. +# This file is published under the BSD Zero Clause License. +# Jakub Bogusz , 2011-2025. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: pl\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=3; plural=n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Błędny argument dla --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Zbyt dużo argumentów dla --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "W --block-list brakuje rozmiaru bloku po numerze łańcucha filtrów „%c:”" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 w --block-list może być użyte wyłącznie jako ostatni element" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Nieznany typ formatu pliku" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Nieobsługiwany typ kontroli spójności" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Wraz z opcją „--files” lub „--files0” można podać tylko jeden plik." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Zmienna środowiskowa %s zawiera zbyt dużo argumentów" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Obsługa kompresji została wyłączona na etapie budowania" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Obsługa dekompresji została wyłączona na etapie budowania" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Kompresja plików lzip (.lz) nie jest obsługiwana" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list jest ignorowane poza kompresją do formatu .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Przy użyciu --format=raw i zapisie do pliku wymagana jest opcja --suffix=.ROZ" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Maksymalna liczba filtrów to cztery" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Błąd w opcji --filters%s=FILTRY:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Limit użycia pamięci jest zbyt mały dla podanej konfiguracji filtra." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "łańcuch filtrów %u użyty w --block-list, ale nie podany przez --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Używanie ustawień predefiniowanych w trybie surowym jest odradzane." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Dokładne opcje ustawień predefiniowanych mogą różnić się między wersjami oprogramowania." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Format .lzma obsługuje tylko filtr LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 nie może być używany z formatem .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Łańcuch filtrów %u jest niezgodny z --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Przełączanie w tryb jednowątkowy z powodu --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Nieobsługiwane opcje w łańcuchu filtrów %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Maksymalna liczba używanych wątków: %." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Nieobsługiwany łańcuch filtrów lub opcje filtra" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Dekompresja będzie wymagała %s MiB pamięci." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Zmniejszono liczbę wątków z %s do %s, aby nie przekroczyć limitu użycia pamięci %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Zmniejszono liczbę wątków z %s do jednego. Automatyczny limit użycia pamięci %s MiB jest nadal przekroczony - wymagane jest %s MiB. Kontynuacja mimo to." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Przełączenie w tryb jednowątkowy, aby nie przekroczyć limitu użycia pamięci %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Skorygowano rozmiar słownika LZMA%c z %s MiB do %s MiB aby nie przekroczyć limitu użycia pamięci %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Skorygowano rozmiar słownika LZMA%c dla --filters%u z %s MiB do %s MiB, aby nie przekroczyć limitu użycia pamięci %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Błąd podczas zmiany w łańcuchu filtrów %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Błąd tworzenia potoku: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() nie powiodło się: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Plik wygląda na przeniesiony, nie zostanie usunięty" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Nie można usunąć: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Nie można ustawić właściciela pliku: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Nie można ustawić grupy pliku: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Nie można ustawić uprawnień pliku: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Synchronizacja pliku nie powiodła się: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Synchronizacja katalogu z plikiem nie powiodła się: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Błąd podczas pobierania flag stanu pliku ze standardowego wejścia: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Jest dowiązaniem symbolicznym, pominięto" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Jest katalogiem, pominięto" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Nie jest zwykłym plikiem, pominięto" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Plik ma ustawiony bit setuid lub setgid, pominięto" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Plik ma ustawiony bit sticky, pominięto" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Plik wejściowy ma więcej niż jedno dowiązanie zwykłe, pominięto" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Pusta nazwa pliku, pominięto" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Błąd podczas odtwarzania flag stanu dla standardowego wejścia: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Błąd podczas pobierania flag stanu pliku ze standardowego wyjścia: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Otwarcie katalogu nie powiodło się: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: Cel nie jest zwykłym plikiem" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Błąd podczas odtwarzania flagi O_APPEND dla standardowego wyjścia: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Zamknięcie pliku nie powiodło się: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Zmiana pozycji nie powiodła się podczas próby utworzenia pliku rzadkiego: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Błąd odczytu: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Błąd podczas zmiany pozycji w pliku: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Nieoczekiwany koniec pliku" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Błąd zapisu: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Wyłączony" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Rozmiar pamięci fizycznej (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Liczba wątków procesora:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Kompresja:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Dekompresja:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Dekompresja wielowątkowa:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Domyślnie dla -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Informacje o sprzęcie:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Limity użycia pamięci" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Strumienie:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Bloki:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Rozmiar spakowany:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Rozmiar rozpakowany:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Współczynnik:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Kontrola spójności:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Wyrównanie strumienia:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Wymagana pamięć:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Rozmiar w nagłówkach:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Liczba plików:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Strumień" + +#: src/xz/list.c +msgid "Block" +msgstr "Blok" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Bloki" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "Offset spak." + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "Offset rozp." + +#: src/xz/list.c +msgid "CompSize" +msgstr "Rozm.spak." + +#: src/xz/list.c +msgid "UncompSize" +msgstr "Rozm.rozp." + +#: src/xz/list.c +msgid "TotalSize" +msgstr "Rozm.całk." + +#: src/xz/list.c +msgid "Ratio" +msgstr "Wsp." + +#: src/xz/list.c +msgid "Check" +msgstr "Kontrola" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "S.kontr." + +#: src/xz/list.c +msgid "Padding" +msgstr "Wyrównanie" + +#: src/xz/list.c +msgid "Header" +msgstr "Nagłówek" + +#: src/xz/list.c +msgid "Flags" +msgstr "Flagi" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "Uż.pamięci" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filtry" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Brak" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Nieznany-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Nieznany-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Nieznany-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Nieznany-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Nieznany-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Nieznany-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Nieznany-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Nieznany11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Nieznany12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Nieznany13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Nieznany14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Nieznany15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Plik jest pusty" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Za mały na poprawny plik .xz" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Strum. Bloki Spakowany Rozpakowany Wsp. Kontrola Nazwa pliku" + +#: src/xz/list.c +msgid "Yes" +msgstr "Tak" + +#: src/xz/list.c +msgid "No" +msgstr "Nie" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Minimalna wersja XZ Utils:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s plik\n" +msgstr[1] "%s pliki\n" +msgstr[2] "%s plików\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Sumarycznie:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list działa tylko z plikami .xz (--format=xz lub --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Proszę spróbować „lzmainfo” z plikami .lzma." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list nie obsługuje odczytu ze standardowego wejścia" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Błąd odczytu nazw plików: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Nieoczekiwany koniec wejścia podczas odczytu nazw plików" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Napotkano znak NUL podczas odczytu nazw plików; może miało być „--files0” zamiast „--files”?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Kompresja i dekompresja z opcją --robot nie jest jeszcze obsługiwana." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Nie można odczytać danych ze standardowego wejścia przy czytaniu nazw plików ze standardowego wejścia" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Błąd wewnętrzny" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Nie można ustawić obsługi sygnałów" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Brak kontroli spójności; poprawność plików nie będzie weryfikowana" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Nieobsługiwany typ kontroli spójności; poprawność plików nie będzie weryfikowana" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Osiągnięto limit użycia pamięci" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Nie rozpoznany format pliku" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Nieobsługiwane opcje" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Dane skompresowane są uszkodzone" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Nieoczekiwany koniec wejścia" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "Wymagane jest %s MiB pamięci. Limit jest wyłączony." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "Wymagane jest %s MiB pamięci. Limit to %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Łańcuch filtrów: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Polecenie „%s --help” pokaże więcej informacji." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Błąd podczas wypisywania tekstu pomocy (kod błędu %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".ROZ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "FILE" +msgstr "PLIK" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "FORMAT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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”" + +#: src/xz/message.c +msgid "NAME" +msgstr "NAZWA" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "ILE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "SIZE" +msgstr "ROZMIAR" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOKI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "LIMIT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTRY" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "OPCJE" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "PRE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "MODE" +msgstr "TRYB" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "" +"Błędy prosimy zgłaszać na adres <%s> (w języku angielskim lub fińskim).\n" +"Błędy w tłumaczeniu prosimy zgłaszać na adres ." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Opcje muszą być parami „nazwa=wartość” rozdzielonymi przecinkami" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Błędna nazwa opcji" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Błędna wartość opcji" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Nieobsługiwane ustawienie predefiniowane LZMA1/LZMA2: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Suma lc i lp nie może przekroczyć 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Nazwa pliku ma nieznane rozszerzenie, pominięto" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Plik już ma rozszerzenie „%s”, pominięto" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Błędne rozszerzenie nazwy pliku" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Wartość nie jest nieujemną liczbą całkowitą" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Błędny przyrostek mnożnika" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Poprawne przyrostki to „KiB” (2^10), „MiB” (2^20) i „GiB” (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Wartość opcji „%s” musi być w przedziale [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Dane skompresowane nie mogą być czytane z terminala" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Dane skompresowane nie mogą być zapisywane na terminal" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Plik jest za mały, aby był plikiem .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "To nie jest plik .lzma" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Zapis na standardowe wyjście nie powiódł się" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Nieznany błąd" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Nieobsługiwane ustawienie predefiniowane" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Nieobsługiwana flaga w ustawieniu predefiniowanym" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Nieznana nazwa opcji" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Wartość opcji nie może być pusta" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Wartość spoza zakresu" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Ta opcja nie obsługuje żadnych przyrostków mnożników" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Błędny przyrostek mnożnika (KiB, MiB lub GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Nieznana nazwa filtra" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Ten filtr nie może być używany w formacie .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Nie udało się przydzielić pamięci" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Łańcuch pusty nie jest dozwolony, jeśli potrzebna jest wartość domyślna, proszę spróbować „6”" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Maksymalna liczba filtrów to cztery" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Brak nazwy filtra" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Błędny łańcuch filtrów (brak „lzma2” na końcu?)" diff --git a/cpp/third_party/xz-5.8.3/po/pt.gmo b/cpp/third_party/xz-5.8.3/po/pt.gmo new file mode 100644 index 0000000000..506bb96120 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/pt.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/pt.po b/cpp/third_party/xz-5.8.3/po/pt.po new file mode 100644 index 0000000000..44cbd47088 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/pt.po @@ -0,0 +1,1278 @@ +# SPDX-License-Identifier: 0BSD +# +# Portuguese (Portugal) Translation for the xz Package +# This file is published under the BSD Zero Clause License. +# Pedro Albuquerque , 2025. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.8.0-pre1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: pt\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.5\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: argumento inválido para --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: demasiados argumentos para --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "Em --block-list, falta o tamanho do bloco após filtrar o número da cadeia \"%c:\"" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 só pode ser usado como o último elemento em --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: tipo de formato de ficheiro desconhecido" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: tipo de verificação de integridade não suportado" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Só pode especificar um ficheiro com \"--files\" ou \"--files0\"." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "A variável de ambiente %s contém demasiados argumentos" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "O suporte a compressão foi desactivado ao compilar" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "O suporte a descompressão foi desactivado ao compilar" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "A compressão de ficheiros lzip (.lz) não é suportada" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list é ignorado a não ser que comprima para formato .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Com --format=raw, --suffix=.SUF é requerido, a menos que seja escrito em stdout" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "O número máximo de filtros é quatro" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Erro na opção --filters%s=FILTERS:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "O limite de uso de memória é baixo demais para a configuração de filtro dada." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "cadeia de filtro %u usada por --block-list mas não especificada com --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "O uso de uma predefinição em modo bruto é desencorajado." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "As opções exactas de predefinições podem variar entre versões do programa." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "O formato .lzma tem só suporta o filtro LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "Impossível utilizar LZMA1 com o formato .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "A cadeia de filtragem %u é incompatível com --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "A mudar para o modo de linha única devido a --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Opções não suportadas na cadeia de filtragem %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "A usar até % linhas." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Opções de filtro ou cadeia de filtros não suportadas" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "A descompressão precisará de %s MiB de memória." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Número de linhas reduzido de %s de %s para não exceder o limite de uso de memória de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Número de linhas reduzido de %s para uma. O limite automático de utilização de memória de %s MiB ainda continua excedido. Necessita de %s MiB. A continuar mesmo assim." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "A mudar para o modo de linha única para não exceder o limite de uso de memória de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Ajustado o tamanho de dicionário de LZMA%c de %s MiB para %s MiB para não exceder o limite de uso de memória de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Ajustado o tamanho de dicionário de LZMA%c para --filters%u de %s MiB para %s MiB para não exceder o limite de uso de memória de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Erro ao mudar para a cadeia de filtragem %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Erro ao criar um túnel: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() falhou: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: o ficheiro parece ter sido movido, não será eliminado" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: impossível remover: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: impossível definir o proprietário do ficheiro: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: impossível definir o grupo do ficheiro: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: impossível definir as permissões do ficheiro: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: falha ao sincronizar o ficheiro: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: falha ao sincronizar a pasta do ficheiro: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Erro ao obter as bandeiras de estado da entrada padrão: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: é uma ligação simbólica, a ignorar" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: é uma pasta, a ignorar" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: não é um ficheiro normal, a ignorar" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: o ficheiro tem o bit setuid ou setgid definido, a ignorar" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: o ficheiro tem o bit sticky definido, a ignorar" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: o ficheiro de entrada tem mais de uma ligação absoluta, a ignorar" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Nome de ficheiro vazio, a ignorar" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Erro ao restaurar as bandeiras de estado para a entrada padrão: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Erro ao obter as bandeiras de estado do ficheiro da saída padrão: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: falha ao abrir a pasta: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: o destino não é um ficheiro normal" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Erro ao restaurar a bandeira O_APPEND para a saída padrão: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: falha ao fechar o ficheiro: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: falha na procura ao tentar criar um ficheiro escasso: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: erro de leitura: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: erro ao procurar o ficheiro: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: fim de ficheiro inesperado" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: erro de escrita: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Desactivado" + +# Espaços adicionados para manter alinhamento com mensagens adjacentes -- Rafael +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Total de memória física (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Número de linhas do processador:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Compressão:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Descompressão:" + +# Espaços reduzidos para manter alinhamento com mensagens adjacentes -- Rafael +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Descompressão multi-linha:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Pré-definição para -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Informação do equipamento:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Limites de uso de memória:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Fluxos:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blocos:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Tamanho comprimido:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Tamanho descomprimido:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Proporção:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Verificar:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Espaço do fluxo:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Memória requerida:" + +# Espaço adicionado para promover alinhamento, vide "xz -lvv foo.xz" +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Tamanho em cabeçalhos:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Número de ficheiros:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Fluxo" + +#: src/xz/list.c +msgid "Block" +msgstr "Bloco" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blocos" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "DesvComp" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "DesvDescomp" + +#: src/xz/list.c +msgid "CompSize" +msgstr "TamComp" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "TamDescomp" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "Total" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Proporção" + +#: src/xz/list.c +msgid "Check" +msgstr "Verificar" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "ValVerif" + +#: src/xz/list.c +msgid "Padding" +msgstr "Espaço" + +#: src/xz/list.c +msgid "Header" +msgstr "Cabeçalho" + +#: src/xz/list.c +msgid "Flags" +msgstr "Bandeiras" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "UsoMem" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filtros" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Nenhum" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "SemNome-2" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-3" +msgstr "SemNome-3" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-5" +msgstr "SemNome-5" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-6" +msgstr "SemNome-6" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-7" +msgstr "SemNome-7" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-8" +msgstr "SemNome-8" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-9" +msgstr "SemNome-9" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-11" +msgstr "SemNome-11" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-12" +msgstr "SemNome-12" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-13" +msgstr "SemNome-13" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-14" +msgstr "SemNome-14" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-15" +msgstr "SemNome-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: o ficheiro está vazio" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: muito pequeno para um ficheiro .xz válido" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Fluxos Blocos Comprimido Descomprimido Rácio Verif. Nome de ficheiro" + +#: src/xz/list.c +msgid "Yes" +msgstr "Sim" + +#: src/xz/list.c +msgid "No" +msgstr "Não" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Versão mínima do XZ Utils:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s ficheiro\n" +msgstr[1] "%s ficheiros\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Totais:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list só funciona em ficheiros .xz (--format=xz ou --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Tentar \"lzmainfo\" com ficheiros .lzma." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list não suporta a leitura da entrada padrão" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: erro ao ler nomes de ficheiro: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: fim de entrada inesperado ao ler nomes de ficheiros" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: encontrado carácter nulo ao ler nomes de ficheiro; talvez queira usar \"--files0\" em vez de \"--files\"?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Compressão e descompressão com --robot ainda não são suportadas." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Impossível ler dados da entrada padrão ao ler nomes de ficheiro da entrada padrão" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Erro interno (erro)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Impossível estabelecer gestores de sinais" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Sem teste de integridade; a integridade do ficheiro não será verificada" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Tipo de verificação de integridade não suportada; a integridade do ficheiro não será verificada" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Limite de uso de memória alcançado" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Formato de ficheiro não reconhecido" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Opções não suportadas" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Os dados comprimidos estão corrompidos" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Fim de entrada inesperado" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "São necessários %s MiB de memória. O limitador está desactivado." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "São necessários %s MiB de memória. O limite é %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: cadeia de filtros: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Tente \"%s --help\" para mais informações." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Erro ao imprimir o texto de ajuda (erro: %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".SUF" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "FILE" +msgstr "FICH" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "FORMATO" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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\"" + +#: src/xz/message.c +msgid "NAME" +msgstr "NOME" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "SIZE" +msgstr "TAMANHO" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOCOS" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "LIMITE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTROS" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "OPÇS" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "PRE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "MODE" +msgstr "MODO" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "Relatar erros em <%s> (em inglês ou finlandês)." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "As opções devem ser pares \"nome=valor\" separados por vírgulas" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: nome de opção inválido" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Valor de opção inválido" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Predefinição LZMA1/LZMA2 não suportada: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "A soma de lc e lp não deve exceder 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: nome de ficheiro com sufixo desconhecido, a ignorar" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: o ficheiro já tem o sufixo \"%s\", a ignorar" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: sufixo de nome de ficheiro inválido" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "O valor não é um inteiro decimal não-negativo" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: sufixo multiplicador inválido" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Sufixos válidos são \"KiB\" (2^10), \"MiB\" (2^20) e \"GiB\" (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "O valor da opção \"%s\" deve estar no intervalo [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Dados comprimidos não podem ser lidos de um terminal" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Dados comprimidos não podem ser escritos num terminal" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "O ficheiro é muito pequeno para um ficheiro .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Não é um ficheiro .lzma" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "A escrita para a saída padrão falhou" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Erro desconhecido" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Pré-definição não suportada" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Bandeira não suportada na pré-definição" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Nome de opção desconhecido" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "O valor da opção não pode estar vazio" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Valor fora do intervalo" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Esta opção não suporta sufixos de multiplicação" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Sufixo multiplicador inválido (KiB, MiB, ou GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Nome de filtro desconhecido" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Impossível utilizar este filtro com o formato .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Falha ao alocar memória" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Não são permitidas cadeias vazias, tente \"6\" se precisa de uma pré-definição" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "O número máximo de filtros é quatro" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Nome de filtro em falta" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Cadeia de filtragem inválida ('lzma2' em falta no fim?)" diff --git a/cpp/third_party/xz-5.8.3/po/pt_BR.gmo b/cpp/third_party/xz-5.8.3/po/pt_BR.gmo new file mode 100644 index 0000000000..82858f7617 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/pt_BR.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/pt_BR.po b/cpp/third_party/xz-5.8.3/po/pt_BR.po new file mode 100644 index 0000000000..07b3d73adc --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/pt_BR.po @@ -0,0 +1,1683 @@ +# SPDX-License-Identifier: 0BSD +# +# Brazilian Portuguese translations for xz package +# Traduções em português brasileiro para o pacote xz. +# This file is published under the BSD Zero Clause License. +# Rafael Fontenelle , 2019-2024. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.6.0-pre2\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: pt_BR\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=2; plural=(n > 1)\n" +"X-Generator: Gtranslator 46.1\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Argumento inválido para --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Argumentos demais para --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "Em --block-list, está faltando o tamanho do bloco após o número da cadeia de filtros \"%c:\"" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 só pode ser usado como o último elemento em --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Tipo de formato de arquivo desconhecido" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Tipo de verificação de integridade sem suporte" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Somente um arquivo pode ser especificado com \"--files\" ou \"--files0\"." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "A variável de ambiente %s contém argumentos demais" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Suporte a compressão foi desabilitado em tempo de compilação" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Suporte a descompressão foi desabilitado em tempo de compilação" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "A compactação de arquivos lzip (.lz) não é suportada" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list é ignorado a menos que seja compactado para o formato .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Com --format=raw, --suffix=.SUF é exigido, a menos que esteja escrevendo para stdout" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "O número máximo de filtros é quatro" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Erro na opção --filters%s=FILTROS:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "O limite de uso de memória é baixo demais para a configuração de filtro dada." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "cadeia de filtros %u usada por --block-list, mas não especificada com --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "O uso de uma predefinição em modo bruto é desencorajado." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "As opções exatas de predefinições podem variar entre versões do software." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "O formato .lzma possui suporte apenas ao filtro LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 não pode ser usado com o formato .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "A cadeia de filtros %u é incompatível com --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Alternando para o modo de thread única por causa de --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Opções sem suporte na cadeia de filtros %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Usando até % threads." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Opções de filtro ou cadeia de filtros sem suporte" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "A descompressão precisará de %s MiB de memória." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Reduzido o número de threads de %s para %s para não exceder o limite de uso de memória de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Reduzido o número de threads de %s para um. O limite de uso de memória automática de %s MiB ainda está sendo excedido. %s MiB de memória é necessário. Continuando de qualquer maneira." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Alternando para o modo de thread única para não exceder o limite de uso de memória de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Ajustado o tamanho de dicionário de LZMA%c de %s MiB para %s MiB para não exceder o limite de uso de memória de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Tamanho do dicionário LZMA%c ajustado para --filters%u de %s MiB para %s MiB para não exceder o limite de uso de memória de %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Erro ao alterar para a cadeia de filtros %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Erro ao criar um pipe: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() falhou: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: O arquivo parece ter sido movido, não será removido" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Não foi possível remover: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Não foi possível definir o dono do arquivo: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Não foi possível definir o grupo do arquivo: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Não foi possível definir as permissões do arquivo: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Fechamento do arquivo falhou: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Fechamento do arquivo falhou: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Erro ao obter os sinalizadores de status da entrada padrão: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: É um link simbólico, ignorando" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: É um diretório, ignorando" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Não é um arquivo comum, ignorando" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: O arquivo possui o bit setuid ou setgid definido, ignorando" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: O arquivo possui o bit sticky definido, ignorando" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: O arquivo de entrada possui mais de um link físico, ignorando" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Nome de arquivo vazio, ignorando" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Erro ao restaurar os sinalizadores de status para entrada padrão: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Erro ao obter os sinalizadores de status de arquivo da saída padrão: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Fechamento do arquivo falhou: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Not a regular file, skipping" +msgid "%s: Destination is not a regular file" +msgstr "%s: Não é um arquivo comum, ignorando" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Erro ao restaurar o sinalizador O_APPEND para a saída padrão: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Fechamento do arquivo falhou: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Busca falhou ao tentar criar um arquivo esparso: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Erro de leitura: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Erro ao buscar o arquivo: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Fim de arquivo inesperado" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Erro de escrita: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Desabilitado" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Quantidade total de memória física (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Número de threads de processador:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Compactação:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Descompactação:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Descompactação com várias threads:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Padrão para -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Informações de hardware:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Memory usage limits:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Fluxos:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blocos:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Tamanho compactado:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Tamanho não compactado:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Proporção:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Verificação:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Ajuste do fluxo:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Memória exigida:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Tamanhos nos cabeçalhos:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Número de arquivos:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Fluxo" + +#: src/xz/list.c +msgid "Block" +msgstr "Bloco" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blocos" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "DeslocComp" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "DeslocDescomp" + +#: src/xz/list.c +msgid "CompSize" +msgstr "TamComp" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "TamDescomp" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "TamTotal" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Proporção" + +#: src/xz/list.c +msgid "Check" +msgstr "Verificação" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "ValorVerific." + +#: src/xz/list.c +msgid "Padding" +msgstr "Preench." + +#: src/xz/list.c +msgid "Header" +msgstr "Cabeçalho" + +#: src/xz/list.c +msgid "Flags" +msgstr "Sinalizadores" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "UsoMem" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filtros" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Nenhuma" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Incógnito2" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Incógnito3" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Incógnito5" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Incógnito6" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Incógnito7" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Incógnito8" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Incógnito9" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Incógnito11" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Incógnito12" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Incógnito13" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Incógnito14" + +# Não exceder 10 caracteres e espaços não são permitidos -- Rafael +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Incógnito15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: O arquivo está vazio" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Pequeno demais para ser um arquivo .xz válido" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Fluxos Blocos Comprimido Descomprimid Propo Verif Nome de Arquivo" + +#: src/xz/list.c +msgid "Yes" +msgstr "Sim" + +#: src/xz/list.c +msgid "No" +msgstr "Não" + +#: src/xz/list.c +#, fuzzy +#| msgid " Minimum XZ Utils version: %s\n" +msgid "Minimum XZ Utils version:" +msgstr " Versão mínima do XZ Utils: %s\n" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s arquivo\n" +msgstr[1] "%s arquivos\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Totais:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list funciona apenas em arquivos .xz (--format=xz ou --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Tente 'lzmainfo' com arquivos .lzma." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list não possui suporte a leitura da entrada padrão" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Erro ao ler nomes de arquivo: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Fim da entrada inesperado ao ler nomes de arquivos" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Caractere nulo encontrado ao ler nomes de arquivos; talvez você queria usar \"--files0\" em vez de \"--files\"?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Ainda não há suporte a compressão e descompressão com --robot." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Não é possível ler dados da entrada padrão ao ler nomes de arquivos da entrada padrão" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Erro interno (bug)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Não foi possível estabelecer manipuladores de sinais" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Sem verificação de integridade; não será verificada a integridade do arquivo" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Tipo de verificação de integridade sem suporte; não será verificada a integridade do arquivo" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Limite de uso de memória alcançado" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Formato de arquivo não reconhecido" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Opções sem suporte" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Os dados comprimidos estão corrompidos" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Fim da entrada inesperado" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB de memória é necessário. O limitador está desabilitado." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB de memória é necessário. O limite é %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Cadeia de filtros: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Tente \"%s --help\" para mais informações." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the 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 "" +#| "Usage: %s [OPTION]... [FILE]...\n" +#| "Compress or decompress FILEs in the .xz format.\n" +#| "\n" +msgid "Compress or decompress FILEs in the .xz format." +msgstr "" +"Uso: %s [OPÇÕES]... [ARQUIVO]...\n" +"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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Operation modifiers:\n" +msgid "Operation modifiers:" +msgstr "" +"\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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| " --single-stream decompress only the first stream, and silently\n" +#| " ignore possible remaining input data" +msgid "decompress only the first stream, and silently ignore possible remaining input data" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Basic file format and compression options:\n" +msgid "Basic file format and compression options:" +msgstr "" +"\n" +" Opções básicas de formato de arquivo e compressão:\n" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " -0 ... -9 compression preset; default is 6; take compressor *and*\n" +#| " decompressor memory usage into account before using 7-9!" +msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!" +msgstr "" +" -0 ... -9 predefinição de compressão; padrão é 6; leve o uso de\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " -e, --extreme try to improve compression ratio by using more CPU time;\n" +#| " does not affect decompressor memory requirements" +msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements" +msgstr "" +" -e, --extreme tenta melhorar a proporção de compressão usando mais\n" +" tempo de CPU; não afeta os requisitos de memória do\n" +" descompressor" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -T, --threads=NUM use at most NUM threads; the default is 0 which uses\n" +#| " as many threads as there are processor cores" +msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores" +msgstr "" +" -T, --threads=NÚM usa no máximo NÚM threads; o padrão é 0 que usa\n" +" o máximo de threads que há de núcleos de processador" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-size=SIZE\n" +#| " start a new .xz block after every SIZE bytes of input;\n" +#| " use this to set the block size for threaded compression" +msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression" +msgstr "" +" --block-size=TAM\n" +" inicia novo bloco .xz após cada TAM bytes de entrada;\n" +" use isso para definido o tamanho de bloco para\n" +" compressão com threads" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-list=BLOCKS\n" +#| " start a new .xz block after the given comma-separated\n" +#| " intervals of uncompressed data; optionally, specify a\n" +#| " filter chain number (0-9) followed by a ':' before the\n" +#| " uncompressed data size" +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 "" +" --block-list=BLOCOS\n" +" inicia um novo bloco .xz após os intervalos dados,\n" +" separados por vírgula, de dados descomprimidos;\n" +" opcionalmente, especifique um número de cadeia de\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --flush-timeout=TIMEOUT\n" +#| " when compressing, if more than TIMEOUT milliseconds has\n" +#| " passed since the previous flush and reading more input\n" +#| " would block, all pending data is flushed out" +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 "" +" --flush-timeout=TEMPO-LIMITE\n" +" ao comprimir, se mais de TEMPO-LIMITE milissegundos\n" +" tiverem passado desde a liberação anterior e a leitura\n" +" de mais entrada bloquearia, todos os dados pendentes\n" +" serão liberados" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --no-adjust if compression settings exceed the memory usage limit,\n" +#| " give an error instead of adjusting the settings downwards" +msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards" +msgstr "" +" --no-adjust se configurações de compressão exceder o limite\n" +" 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Custom filter chain for compression (alternative for using presets):" +msgid "Custom filter chain for compression (an alternative to using presets):" +msgstr "" +"\n" +" Cadeia de filtros personalizada para compressão (alternativa à predefinição):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| " --filters=FILTERS set the filter chain using the liblzma filter string\n" +#| " syntax; use --filters-help for more information" +msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information" +msgstr "" +"\n" +" --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 interpreted as a zero-width space (the 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 "" +#| " --filters1=FILTERS ... --filters9=FILTERS\n" +#| " set additional filter chains using the liblzma filter\n" +#| " string syntax to use with --block-list" +msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list" +msgstr "" +"--filters1=FILTROS ... --filters9=FILTROS\n" +" 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 interpreted as a zero-width space (the 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 "" +#| " --filters-help display more information about the liblzma filter string\n" +#| " syntax and exit." +msgid "display more information about the liblzma filter string syntax and exit" +msgstr "" +" --filters-help exibe mais informações sobre a sintaxe de filtro liblzma\n" +" e sai." + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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:" +msgid "number of position bits" +msgstr "Número de threads de processador:" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Other options:\n" +msgid "Other options:" +msgstr "" +"\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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --info-memory display the total amount of RAM and the currently active\n" +#| " memory usage limits, and exit" +msgid "display the total amount of RAM and the currently active memory usage limits, and exit" +msgstr "" +" --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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| "With no FILE, or when FILE is -, read standard input.\n" +msgid "With no FILE, or when FILE is -, read standard input." +msgstr "" +"\n" +"Sem ARQUIVO, ou quando ARQUIVO é -, lê da entrada padrão.\n" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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" +msgid "Report bugs to <%s> (in English or Finnish)." +msgstr "" +"Relate erros para <%s> (em inglês ou finlandês).\n" +"Relate erros de tradução para .\n" + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "Filter chains are set using the --filters=FILTERS or\n" +#| "--filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain\n" +#| "can be separated by spaces or '--'. Alternatively a preset <0-9>[e] can be\n" +#| "specified instead of a filter chain.\n" +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 filtros são definidas usando as opções --filters=FILTROS ou\n" +"--filters1=FILTROS ... --filters9=FILTROS. Cada filtro na cadeia pode ser\n" +"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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Options must be 'name=value' pairs separated with commas" +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "%s: As opções devem ser pares \"nome=valor\" separados por vírgulas" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Nome de opção inválido" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option value" +msgid "Invalid option value" +msgstr "%s: Valor de opção inválido" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Predefinição LZMA1/LZMA2 sem suporte: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "A soma de lc e lp não deve exceder 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: O nome de arquivo tem um sufixo desconhecido, ignorando" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: O arquivo já tem o sufixo \"%s\", ignorando" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Sufixo de nome de arquivo inválido" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Value is not a non-negative decimal integer" +msgid "Value is not a non-negative decimal integer" +msgstr "%s: O valor não é um inteiro integral decimal" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Sufixo multiplicador inválido" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Sufixos válidos são \"KiB\" (2^10), \"MiB\" (2^20) e \"GiB\" (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "O valor da opção \"%s\" deve estar no intervalo [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Dados comprimidos não podem ser lidos de um terminal" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Dados comprimidos não podem ser escrito para um terminal" + +#: src/lzmainfo/lzmainfo.c +#, fuzzy, c-format +#| msgid "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Usage: %s [--help] [--version] [FILE]...\n" +msgstr "" +"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 interpreted as a zero-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 "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Show information stored in the .lzma file header." +msgstr "" +"Uso: %s [--help] [--version] [ARQUIVO]...\n" +"Mostra informações armazenadas no cabeçalho do arquivo .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Arquivo é pequeno demais para ser um arquivo .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Não é um arquivo .lzma" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "A escrita para a saída padrão falhou" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Erro desconhecido" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported options" +msgid "Unsupported preset" +msgstr "Opções sem suporte" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported filter chain or filter options" +msgid "Unsupported flag in the preset" +msgstr "Opções de filtro ou cadeia de filtros sem suporte" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option name" +msgid "Unknown option name" +msgstr "%s: Nome de opção inválido" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid multiplier suffix" +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "%s: Sufixo multiplicador inválido" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Unknown file format type" +msgid "Unknown filter name" +msgstr "%s: Tipo de formato de arquivo desconhecido" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "LZMA1 cannot be used with the .xz format" +msgid "This filter cannot be used in the .xz format" +msgstr "LZMA1 não pode ser usado com o formato .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Maximum number of filters is four" +msgid "The maximum number of filters is four" +msgstr "O número máximo de filtros é quatro" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" + +#~ msgid "" +#~ " -z, --compress force compression\n" +#~ " -d, --decompress force decompression\n" +#~ " -t, --test test compressed file integrity\n" +#~ " -l, --list list information about .xz files" +#~ msgstr "" +#~ " -z, --compress força a compressão\n" +#~ " -d, --decompress força a descompressão\n" +#~ " -t, --test testa a integridade do arquivo comprimido\n" +#~ " -l, --list lista informações sobre arquivos .xz" + +#~ msgid "" +#~ " -k, --keep keep (don't delete) input files\n" +#~ " -f, --force force overwrite of output file and (de)compress links\n" +#~ " -c, --stdout write to standard output and don't delete input files" +#~ msgstr "" +#~ " -k, --keep mantém (não exclui) os arquivos de entrada\n" +#~ " -f, --force força a sobrescrita do arquivo de entrada e a \n" +#~ " (des)compressão de links\n" +#~ " -c, --stdout escreve a entrada padrão e não exclui os arquivos\n" +#~ " de entrada" + +#~ msgid "" +#~ " --no-sparse do not create sparse files when decompressing\n" +#~ " -S, --suffix=.SUF use the suffix '.SUF' on compressed files\n" +#~ " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~ " omitted, filenames are read from the standard input;\n" +#~ " filenames must be terminated with the newline character\n" +#~ " --files0[=FILE] like --files but use the null character as terminator" +#~ msgstr "" +#~ " --no-sparse não cria arquivos esparsos ao descomprimir\n" +#~ " -S, --suffix=.SUF usa o sufixo \".SUF\" em arquivos comprimidos\n" +#~ " --files[=ARQUIVO]\n" +#~ " lê nomes de arquivos para processar de ARQUIVO;\n" +#~ " se ARQUIVO for omitido, nomes de arquivos são\n" +#~ " lidos da entrada padrão; nomes de arquivos devem\n" +#~ " terminar com o caractere de nova linha\n" +#~ " --files0[=ARQUIVO]\n" +#~ " similar a --files, mas usa o caractere nulo como\n" +#~ " terminador" + +#~ msgid "" +#~ " -F, --format=FMT file format to encode or decode; possible values are\n" +#~ " 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'\n" +#~ " -C, --check=CHECK integrity check type: 'none' (use with caution),\n" +#~ " 'crc32', 'crc64' (default), or 'sha256'" +#~ msgstr "" +#~ " -F, --format=FMT formato de arquivo para codificar ou decodificar;\n" +#~ " valores possíveis são\n" +#~ " \"auto\" (padrão), \"xz\", \"lzma\", \"lzip\" e \"raw\"\n" +#~ " -C, --check=VERIF tipo de verificação de integridade: \"none\" (cuidado!),\n" +#~ " \"crc32\", \"crc64\" (padrão) ou \"sha256\"" + +#, no-c-format +#~ msgid "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " --memlimit-mt-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " set memory usage limit for compression, decompression,\n" +#~ " threaded decompression, or all of these; LIMIT is in\n" +#~ " bytes, % of RAM, or 0 for defaults" +#~ msgstr "" +#~ " --memlimit-compress=LIMITE\n" +#~ " --memlimit-decompress=LIMITE\n" +#~ " --memlimit-mt-decompress=LIMITE\n" +#~ " -M, --memlimit=LIMITE\n" +#~ " define o limite de uso de memória para compressão,\n" +#~ " descompressão, compactação em threads ou todas essas;\n" +#~ " LIMITE é em bytes, % de RAM ou 0 para padrões" + +#~ msgid "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1 or LZMA2; OPTS is a comma-separated list of zero or\n" +#~ " --lzma2[=OPTS] more of the following options (valid values; default):\n" +#~ " preset=PRE reset options to a preset (0-9[e])\n" +#~ " dict=NUM dictionary size (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NUM number of literal context bits (0-4; 3)\n" +#~ " lp=NUM number of literal position bits (0-4; 0)\n" +#~ " pb=NUM number of position bits (0-4; 2)\n" +#~ " mode=MODE compression mode (fast, normal; normal)\n" +#~ " nice=NUM nice length of a match (2-273; 64)\n" +#~ " mf=NAME match finder (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM maximum search depth; 0=automatic (default)" +#~ msgstr "" +#~ "\n" +#~ "--lzma1[=OPÇÕES] LZMA1/LZMA2; OPÇÕES é uma lista separada por vírgula de\n" +#~ "--lzma2[=OPÇÕES] zero ou + das opções abaixo (valores válidos, padrão):\n" +#~ " preset=PRE redefine opções para predefinição (0-9[e])\n" +#~ " dict=NÚM tam. de dicionário (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NÚM núm. de bits de contexto literal (0-4; 3)\n" +#~ " lp=NÚM núm. de bits de posição literal (0-4; 0)\n" +#~ " pb=NÚM núm. de bits de posição (0-4; 2)\n" +#~ " mode=MODO modo de compressão (fast, normal; normal)\n" +#~ " nice=NÚM tam. de nice de correspondência (2-273; 64)\n" +#~ " mf=NOME localizador de correspondência\n" +#~ " (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM máximo de profundidade de pesquisa;\n" +#~ " 0=automatic (padrão)" + +#~ msgid "" +#~ "\n" +#~ " --x86[=OPTS] x86 BCJ filter (32-bit and 64-bit)\n" +#~ " --arm[=OPTS] ARM BCJ filter\n" +#~ " --armthumb[=OPTS] ARM-Thumb BCJ filter\n" +#~ " --arm64[=OPTS] ARM64 BCJ filter\n" +#~ " --powerpc[=OPTS] PowerPC BCJ filter (big endian only)\n" +#~ " --ia64[=OPTS] IA-64 (Itanium) BCJ filter\n" +#~ " --sparc[=OPTS] SPARC BCJ filter\n" +#~ " --riscv[=OPTS] RISC-V BCJ filter\n" +#~ " Valid OPTS for all BCJ filters:\n" +#~ " start=NUM start offset for conversions (default=0)" +#~ msgstr "" +#~ "\n" +#~ " --x86[=OPÇÕES] filtro BCJ x86 (32 bits e 64 bits)\n" +#~ " --arm[=OPÇÕES] filtro BCJ ARM\n" +#~ " --armthumb[=OPÇÕES] filtro BCJ ARM-Thumb\n" +#~ " --arm64[=OPÇÕES] filtro BCJ ARM64\n" +#~ " --powerpc[=OPÇÕES] filtro BCJ PowerPC (big endian apenas)\n" +#~ " --ia64[=OPÇÕES] filtro BCJ IA-64 (Itanium)\n" +#~ " --sparc[=OPÇÕES] filtro BCJ SPARC\n" +#~ " --riscv[=OPÇÕES] filtro BCJ RISC-V\n" +#~ " OPÇÕES válidas para todos os filtros BCJ:\n" +#~ " start=NUM deslocamento inicial para conversões\n" +#~ " (padrão=0)" + +#~ msgid "" +#~ "\n" +#~ " --delta[=OPTS] Delta filter; valid OPTS (valid values; default):\n" +#~ " dist=NUM distance between bytes being subtracted\n" +#~ " from each other (1-256; 1)" +#~ msgstr "" +#~ "\n" +#~ " --delta[=OPÇÕES] filtro delta; OPÇÕES válidas (valores válidos, padrão):\n" +#~ " dist=NÚM distância entre bytes sendo subtraído\n" +#~ " de cada um (1-256; 1)" + +#~ msgid "" +#~ " -q, --quiet suppress warnings; specify twice to suppress errors too\n" +#~ " -v, --verbose be verbose; specify twice for even more verbose" +#~ msgstr "" +#~ " -q, --quiet suprime avisos, use duas vezes para suprimir erros também\n" +#~ " -v, --verbose ser detalhado; use duas vezes para ainda mais detalhes" + +#~ msgid "" +#~ " -h, --help display the short help (lists only the basic options)\n" +#~ " -H, --long-help display this long help and exit" +#~ msgstr "" +#~ " -h, --help exibe a ajuda curto (lista apenas as opções básicas)\n" +#~ " -H, --long-help exibe essa ajuda longa e sai" + +#~ msgid "" +#~ " -h, --help display this short help and exit\n" +#~ " -H, --long-help display the long help (lists also the advanced options)" +#~ msgstr "" +#~ " -h, --help exibe essa ajuda curta e sai\n" +#~ " -H, --long-help exibe a ajuda longa (lista também as opções avançadas)" + +#~ msgid "Failed to enable the sandbox" +#~ msgstr "Falha ao habilitar o sandbox" + +#~ msgid "Sandbox is disabled due to incompatible command line arguments" +#~ msgstr "Sandbox está desabilitado em razão de argumentos de linha de comando incompatíveis" + +#~ msgid "Sandbox was successfully enabled" +#~ msgstr "Sandbox foi habilitado com sucesso" + +# Espaços adicionados para manter alinhamento com mensagens adjacentes -- Rafael +#~ msgid "Memory usage limit for compression: " +#~ msgstr "Limite de uso de memória para compressão: " + +#~ msgid " Streams: %s\n" +#~ msgstr " Fluxos: %s\n" + +#~ msgid " Blocks: %s\n" +#~ msgstr " Blocos: %s\n" + +#~ msgid " Ratio: %s\n" +#~ msgstr " Proporção: %s\n" + +#~ msgid " Check: %s\n" +#~ msgstr " Verificação: %s\n" + +#~ msgid "" +#~ " Streams:\n" +#~ " Stream Blocks CompOffset UncompOffset CompSize UncompSize Ratio Check Padding" +#~ msgstr "" +#~ " Fluxos:\n" +#~ " Fluxo Blocos DeslocComp DeslocDescomp TamanhoComp TamanhoDescomp Propo Verif Ajuste" + +#~ msgid "" +#~ " Blocks:\n" +#~ " Stream Block CompOffset UncompOffset TotalSize UncompSize Ratio Check" +#~ msgstr "" +#~ " Blocos:\n" +#~ " Fluxo Bloco DeslocComp DeslocDescomp TamanhoTotal TamanhoDecomp Propo Verif" + +#~ msgid " CheckVal %*s Header Flags CompSize MemUsage Filters" +#~ msgstr " ValVerif %*s Cabeç Sinaliz TamComp UsoMem Filtros" + +#~ msgid "The selected match finder requires at least nice=%" +#~ msgstr "O localizador de correspondência selecionado requer pelo menos nice=%" diff --git a/cpp/third_party/xz-5.8.3/po/quot.sed b/cpp/third_party/xz-5.8.3/po/quot.sed new file mode 100644 index 0000000000..eb0e08dad0 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/quot.sed @@ -0,0 +1,17 @@ +# Sed script that converts quotations, by replacing ASCII quotation marks +# with Unicode quotation marks. +# +# Copyright (C) 2001 Free Software Foundation, Inc. +# This file is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. +# This file is offered as-is, without any warranty. +# +# Written by Bruno Haible , 2001. +# +s/"\([^"]*\)"/“\1”/g +s/`\([^`']*\)'/‘\1’/g +s/ '\([^`']*\)' / ‘\1’ /g +s/ '\([^`']*\)'$/ ‘\1’/g +s/^'\([^`']*\)' /‘\1’ /g +s/“”/""/g diff --git a/cpp/third_party/xz-5.8.3/po/remove-potcdate.sed b/cpp/third_party/xz-5.8.3/po/remove-potcdate.sed new file mode 100644 index 0000000000..8c70dfbf14 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/remove-potcdate.sed @@ -0,0 +1,25 @@ +# Sed script that removes the POT-Creation-Date line in the header entry +# from a POT file. +# +# Copyright (C) 2002 Free Software Foundation, Inc. +# Copying and distribution of this file, with or without modification, +# are permitted in any medium without royalty provided the copyright +# notice and this notice are preserved. This file is offered as-is, +# without any warranty. +# +# The distinction between the first and the following occurrences of the +# pattern is achieved by looking at the hold space. +/^"POT-Creation-Date: .*"$/{ +x +# Test if the hold space is empty. +s/P/P/ +ta +# Yes it was empty. First occurrence. Remove the line. +g +d +bb +:a +# The hold space was nonempty. Following occurrences. Do nothing. +x +:b +} diff --git a/cpp/third_party/xz-5.8.3/po/ro.gmo b/cpp/third_party/xz-5.8.3/po/ro.gmo new file mode 100644 index 0000000000..0c8bdccbe1 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/ro.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/ro.po b/cpp/third_party/xz-5.8.3/po/ro.po new file mode 100644 index 0000000000..732e7ecbe6 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/ro.po @@ -0,0 +1,1311 @@ +# SPDX-License-Identifier: 0BSD +# +# Romanian translation for XZ Utils package. +# Mesajele în limba română pentru pachetul XZ Utils. +# This file is published under the BSD Zero Clause License. +# +# Remus-Gabriel Chelu , 2022 - 2025. +# +# Cronologia traducerii fișierului „xz”: +# Traducerea inițială, făcută de R-GC, pentru versiunea xz 5.2.5. +# Actualizare a traducerii pentru versiunea 5.2.6 (nepublicată în TP), făcută de R-GC, 2022. +# Actualizare a algoritmului formelor de plural (de la „trei” la „patru” experimental). +# Actualizare a traducerii pentru versiunea 5.4.0-pre1, făcută de R-GC, noi-2022. +# Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +# Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +# Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +# Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +# Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +# Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +# Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +# Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.8.0-pre1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: ro\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=4; plural=((n==1) ? 0 : (n==2) ? 1 : (n==0 || (n%100 > 0 && n%100 < 20)) ? 2 : 3);\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.5\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Argument nevalid pentru opțiunea „--block-list”" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Prea multe argumente pentru opțiunea „--block-list”" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "În „--block-list”, dimensiunea blocului lipsește după numărul lanțului de filtrare „%c”:" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 poate fi folosit doar ca ultimul element din opțiunea „--block-list”" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Tip de format de fișier necunoscut" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Tip de verificare a integrității neacceptat" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Numai un fișier poate fi specificat cu „--files” sau „--files0”." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Variabila de mediu „%s” conține prea multe argumente" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Suportul de comprimare a fost dezactivat în timpul construirii" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Suportul de decomprimare a fost dezactivat în timpul construirii" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Comprimarea fișierelor lzip (.lz) nu este acceptată" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "opțiunea „--block-list” este ignorată dacă nu se comprimă în formatul .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Cu opțiunea „--format=raw”, este necesară opțiunea „--suffix=.SUF”, cu excepția cazului în care se scrie la ieșirea standard" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Numărul maxim de filtre este patru" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Eroare în opțiunea „--filters%s=FILTRE”:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Limita de utilizare a memoriei este prea mică pentru configurarea dată filtrului." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "lanțul de filtre %u este utilizat de „--block-list”, dar nu este specificat cu „--filters%u=”" + +# Notă: +# cu toate că sunt împotriva americanismelor, am preferat folosirea cuvîntului american, „românizat”, pentru a avea o traducere fluidă, fără construcții încărcate și inecesare... +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Utilizarea unei presetări în modul brut este descurajată." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Opțiunile exacte ale presetărilor pot varia între versiunile de software." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Formatul .lzma acceptă numai filtrul LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 nu poate fi utilizat cu formatul .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Lanțul de filtre %u este incompatibil cu opțiunea „--flush-timeout”" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Se trece la modul cu un singur fir de execuție datorită opțiunii „--flush-timeout”" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Opțiuni neacceptate în lanțul de filtre %u" + +# NOTĂ: +# - să intru în contact cu dezvoltatorii, pentru ai ruga să introducă a doua formă de plural +# (necesară cel puțin pentru limba română): +# „Se utilizează până la % de fire.” +# **** +# construcție necesară pentru mașini cu +# procesoare/nuclee > 10 +# === +# cred că deja au apărut astfel de „monștrii” +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Se utilizează până la % fire de execuție." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Lanț de filtre sau opțiuni de filtrare neacceptate" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Decomprimarea va avea nevoie de %sMio de memorie." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Numărul de fire de execuție a fost redus de la %s la %s pentru a nu se depăși limita de utilizare a memoriei de %sMio" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "S-a redus numărul de fire de execuție de la %s la unul. Limita automată de utilizare a memoriei de %sMio este încă depășită. Sunt necesari %sMio de memorie. Se continuă în ciuda acestui lucru." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "S-a trecut la modul cu un singur-fir de execuție pentru a nu se depăși limita de utilizare a memoriei de %sMio" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "S-a ajustat dimensiunea dicționarului LZMA%c de la %sMio la %sMio pentru a nu se depăși limita de utilizare a memoriei de %sMio" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "S-a ajustat dimensiunea dicționarului LZMA%c pentru „--filters%u” de la %sMio la %sMio pentru a nu depăși limita de utilizare a memoriei de %sMio" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Eroare la schimbarea lanțului de filtrare %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Eroare la crearea unei conducte: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() a eșuat: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Fișierul pare să fi fost mutat, nu eliminat" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Nu se poate elimina: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Nu se poate configura proprietarul fișierului: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Nu se poate configura grupul proprietar al fișierului: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Nu se pot configura permisiunile fișierului: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Sincronizarea fișierului a eșuat: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Sincronizarea directorului fișierului a eșuat: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Eroare la obținerea indicatorilor de stare a fișierului de la intrarea standard: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Este o legătură simbolică, se omite" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Este un director, se omite" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Nu este un fișier obișnuit, se omite" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Fișierul are activați biții «setuid» sau «setgid», se omite" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Fișierul are activat bitul lipicios(sticky), se omite" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Fișierul de intrare are mai mult de o legătură dură, se omite" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Numele fișierului este gol, se omite" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Eroare la restabilirea indicatorilor de stare la intrarea standard: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Eroare la obținerea indicatorilor de stare a fișierului de la ieșirea standard: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Deschiderea directorului a eșuat: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: Destinația nu este un fișier obișnuit" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Eroare la restabilirea indicatorului O_APPEND la ieșirea standard: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Închiderea fișierului a eșuat: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Căutarea a eșuat când se încerca crearea unui fișier dispers(sparse): %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Eroare de citire: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Eroare la explorarea fișierului: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Sfârșit neașteptat al fișierului" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Eroare de scriere: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Dezactivat" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Cantitatea totală de memorie fizică (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Numărul de fire de execuție ale procesorului:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Comprimare:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Decomprimare:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Decomprimare cu multiple-fire de execuție:" + +# R-GC, scrie: +# ATENȚIE: +# este vorba de: +# T0 = momentul 0, și nu de: +# TO = la, către. pe, în... +# **** +# probabil tipul de literă folosit de mine în Poedit, să +# nu diferențieze prea mult O de 0... +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Implicit pentru -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Informații despre componentele mașinii:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Limitele de utilizare a memoriei:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Fluxuri:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Blocuri:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Dimensiune comprimată:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Dimensiune decomprimată:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Raport:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Verificare:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Completare flux:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Memorie necesară:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Dim. în antete:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Numărul de fișiere:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Flux" + +#: src/xz/list.c +msgid "Block" +msgstr "Bloc" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Blocuri" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "PozițieComprim" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "PozițieDecomprim" + +#: src/xz/list.c +msgid "CompSize" +msgstr "DimComp" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "DimDecomp" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "DimTotală" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Raport" + +#: src/xz/list.c +msgid "Check" +msgstr "Verificare" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "ValVerificare" + +#: src/xz/list.c +msgid "Padding" +msgstr "Completare" + +#: src/xz/list.c +msgid "Header" +msgstr "Antet" + +#: src/xz/list.c +msgid "Flags" +msgstr "Indicatori" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "UtilizareMem" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filtre" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Nici una" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Necunos-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Necunos-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Necunos-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Necunos-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Necunos-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Necunos-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Necunos-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Necunos-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Necunos-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Necunos-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Necunos-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Necunos-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Fișierul este gol" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Prea mic pentru a fi un fișier .xz valid" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Fluxuri Blocuri Comprimare Decomprimare Raport Verificare Nume fișier" + +#: src/xz/list.c +msgid "Yes" +msgstr "Da" + +#: src/xz/list.c +msgid "No" +msgstr "Nu" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Versiunea minimă XZ Utils:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "un fișier\n" +msgstr[1] "două fișiere\n" +msgstr[2] "%s fișiere\n" +msgstr[3] "%s de fișiere\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Totaluri:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "„--list” funcționează numai pe fișierele .xz („--format=xz” sau „--format=auto”)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Încercați «lzmainfo» cu fișiere .lzma ." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "„--list” nu acceptă citirea de la intrarea standard" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Eroare la citirea numelor de fișiere: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Sfârșit neașteptat al intrării la citirea numelor de fișiere" + +# Adaptînd sugestia făcută de Daniel Șerbănescu asupra traducerii cuvîntului „null”, am modificat +# traducerea de la:„Caracter nul găsit...”, la: +# „Caracter nul(null) găsit...” +# Sugestia făcută de el în baza obiecției că în pagina web, «dexonline» definiția cuvîntului nul, este un pic ambiguă; nu are o bază prea solidă, +# din următoarele motive: +# - pagina în cauză e construită, alimentată și menținută de persoane voluntare, precum noi ca traducători de software. +# - intrările pentru definiția cuvîntului „nul”, sînt extrase din dicționare de uz general; niciuna dintre ele, nu a ieșit dintr-un dicționar tehnic, cu atît mai puțin unul de informatică. +# - utilizatorul software-ului «xz», direct de la linia de comandă, mă îndoiesc că va fi un utilizator ce nu este familiarizat cu nomenclatura din informatică (pentru restul utilizatorilor, acest mesaj nu va fi vizibil, pentru că-l vor utiliza din spatele unui software „IGU” «InterfațăGrafică(de)Utilizator» +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Caracter nul(null) găsit la citirea numelor de fișiere; poate ați vrut să utilizați „--files0” în loc de „--files”?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Comprimarea și decomprimarea cu „--robot” nu sunt încă acceptate." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Nu se pot citi date de la intrarea standard atunci când se citesc numele de fișiere de la intrarea standard" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Eroare internă (bug)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Nu se pot stabili gestionarii de semnal" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Fără verificare a integrității; nu se verifică integritatea fișierului" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Tip neacceptat de verificare a integrității; nu se verifică integritatea fișierului" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Limita de utilizare a memoriei a fost atinsă" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Formatul fișierului nu este recunoscut" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Opțiuni neacceptate" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Datele comprimate sunt corupte" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Sfârșit neașteptat al intrării" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "Se necesită %sMio de memorie. Limitarea este dezactivată." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "Se necesită %sMio de memorie. Limita este de %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Lanț de filtre: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Încercați «%s --help» pentru mai multe informații." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Eroare la afișarea textului de ajutor (cod de eroare %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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ă" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".SUF" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "FORMAT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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”" + +#: src/xz/message.c +msgid "NAME" +msgstr "NUME" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "SIZE" +msgstr "DIM" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOCURI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "LIMITA" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTRE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "OPȚI" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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)" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "PRE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "MODE" +msgstr "MOD" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "" +"Raportați erorile la <%s> (în engleză sau finlandeză).\n" +"Raportați erorile de traducere la " + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Opțiunile trebuie să fie perechi „nume=valoare” separate prin virgule" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Nume de opțiune nevalid" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Valoare nevalidă a opțiunii" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Presetare LZMA1/LZMA2 neacceptată: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Suma de lc și lp nu trebuie să depășească 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Numele fișierului are un sufix necunoscut, se omite" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Fișierul are deja sufixul „%s”, se omite" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Sufixul numelui de fișier nu este valid" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Valoarea nu este un număr întreg zecimal nenegativ" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Sufix multiplicator nevalid" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Sufixele valide sunt „KiB” (2^10), „MiB” (2^20) și „GiB” (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Valoarea opțiunii „%s” trebuie să fie în intervalul [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Datele comprimate nu pot fi citite de pe un terminal" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Datele comprimate nu pot fi scrise pe un terminal" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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 ." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Prea mic pentru a fi un fișier .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Nu este un fișier .lzma" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Scrierea la ieșirea standard a eșuat" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Eroare necunoscută" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Presetare neacceptată" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Fanion neadmis în presetare" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Nume de opțiune necunoscut" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Valoarea opțiunii nu poate fi vidă" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Valoare în afara intervalului" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Această opțiune nu acceptă sufixe de multiplicare" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Sufix multiplicator nevalid (KiB, MiB, sau GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Nume de filtru necunoscut" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Acest filtru nu poate fi utilizat în formatul .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Alocarea memoriei a eșuat" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Șirul vid nu este permis, încercați „6” dacă este necesară o valoare implicită" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Numărul maxim de filtre este patru" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Lipsește numele filtrului" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Lanț de filtre nevalid (lipsește, „lzma2”, la sfârșit?)" diff --git a/cpp/third_party/xz-5.8.3/po/sr.gmo b/cpp/third_party/xz-5.8.3/po/sr.gmo new file mode 100644 index 0000000000..979a12df0c Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/sr.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/sr.po b/cpp/third_party/xz-5.8.3/po/sr.po new file mode 100644 index 0000000000..8c4d98726f --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/sr.po @@ -0,0 +1,1264 @@ +# SPDX-License-Identifier: 0BSD +# +# Serbian translation of xz. +# This file is published under the BSD Zero Clause License. +# Мирослав Николић , 2020-2025. +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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" +"Language: sr\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.5\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Неисправан аргумент за „--block-list“" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Превише аргумената за „--block-list“" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "У „--block-list“, величина блока недостаје након ланца филтера број „%c:“" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 се може користити само као последњи елемент у „--block-list“-у" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Непозната врста формата датотеке" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Неподржана врста провере целовитости" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Само једну датотеку можете навести са „--files“ или „--files0“." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Променљива окружења „%s“ садржи превише аргумената" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Подршка запакивања је искључена у време изградње" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Подршка распакивања је искључена у време изградње" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Запакивање „lzip“ датотека (.lz) није подржано" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "„--block-list“ се занемарује осим ако се пакује у „.xz“ формат" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Са „--format=raw“, „--suffix=.SUF“ је потребно осим ако се пише на стандардни излаз" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Највећи број филтера је четири" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Грешка у опцији „--filters%s=ФИЛТЕРИ“:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Ограничење коришћења меморије је премало за дато подешавање филтера." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "ланац филтера „%u“ је коришћен од „--block-list“ али није наведен са „--filters%u=“" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Коришћење претподешавања у сировом режиму је обесхрабрујуће." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Тачне опције претподешавања се могу разликовати од издања до издања софтвера." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Формат „.lzma“ подржава само „LZMA1“ филтер" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "Не можете користити „LZMA1“ са „.xz“ форматом" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Ланац филтера „%u“ није сагласан са „--flush-timeout“" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Пребацујем се на режим једне нити због „--flush-timeout“" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Неподржане опције у ланцу филтера %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Користим до % нити." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Неподржан ланац филтера или опције филтера" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "За распакивање ће бити потребно %s MiB меморије." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Број нити је смањен са %s на %s да се не би прекорачило ограничење коришћења меморије од %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Број нити је смањен са %s на једну. Аутоматско ограничење коришћења меморије од %s MiB је ипак премашено. %s MiB меморије је потребно. Ипак настављам." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Прелазим на режим једне нити да се не би прекорачило ограничење коришћења меморије од %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Величина „LZMA%c“ речника је промењена са %s на %s да се неби прекорачило ограничење коришћења меморије од %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Величина „LZMA%c“ речника је промењена за „--filters%u“ са %s MiB на %s MiB да се не прекорачи ограничење коришћења меморије од %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Грешка промене на ланац филтера „%u“: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Грешка стварања спојке: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: „poll()“ није успело: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Изгледа да је датотека премештена, не уклањам" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Не могу да уклоним: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Не могу да поставим власника датотеке: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Не могу да поставим групу датотеке: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Не могу да поставим овлашћења датотеке: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Усклађивање датотеке није успело: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Усклађивање директоријума датотеке није успело: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Грешка добављања заставица стања датотеке са стандардног улаза: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Јесте симболичка веза прескачем" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Јесте директоријум, прескачем" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Није обична датотека, прескачем" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Датотека има постављен „setuid“ или „setgid“ бит, прескачем" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Датотека има постављен лепљиви бит, прескачем" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Улазна датотека има више од једне чврсте везе, прескачем" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Празан назив датотеке, прескачем" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Грешка повраћаја заставица стања на стандардни улаз: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Грешка добављања заставица стања датотеке са стандардног излаза: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Отварање директоријума није успело: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: Одредиште није обична датотека" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Грешка повраћаја заставице „O_APPEND“ на стандардни излаз: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Затварање датотеке није успело: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Премотавање није успело приликом покушаја прављења оскудне датотеке: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Грешка читања: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Грешка приликом претраге датотеке: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Неочекиван крај датотеке" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Грешка писања: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Искључено" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Укупна количина физичке меморије (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Број нити процесора:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Запакивање:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Распакивање:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Вишенитно распакивање:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Основно за „-T0“:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "О хардверу:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Ограничење коришћења меморије:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Токови:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Блокови:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Величина сажетог:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Величина несажетог:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Однос:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Провери:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Попуна тока:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Потребна меморија:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Величине у заглављима:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Број датотека:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Ток" + +#: src/xz/list.c +msgid "Block" +msgstr "Блок" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Блокови" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "ПомерЗапак" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "ПомерНсжтог" + +#: src/xz/list.c +msgid "CompSize" +msgstr "ВлчнаЗапак" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "ВлчнаНсжтог" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "УкупнаВлчна" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Однос" + +#: src/xz/list.c +msgid "Check" +msgstr "Провери" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "ПровериВредн" + +#: src/xz/list.c +msgid "Padding" +msgstr "Попуна" + +#: src/xz/list.c +msgid "Header" +msgstr "Заглавље" + +#: src/xz/list.c +msgid "Flags" +msgstr "Заставице" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "КоришћМемор" + +#: src/xz/list.c +msgid "Filters" +msgstr "Филтери" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Ништа" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Незнано-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Незнано-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Незнано-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Незнано-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Незнано-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Незнано-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Незнано-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Незнано-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Незнано-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Незнано-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Незнано-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Незнано-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Датотека је празна" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Премало је да би било исправна „.xz“ датотека" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Токови Блокови Запаковано Распаковано Однос Провера Датотека" + +#: src/xz/list.c +msgid "Yes" +msgstr "Да" + +#: src/xz/list.c +msgid "No" +msgstr "Не" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Најмање издање XZ помагала:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s датотека\n" +msgstr[1] "%s датотеке\n" +msgstr[2] "%s датотека\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Укупно:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "„--list“ ради само над „.xz“ датотекама (--format=xz или --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Пробајте „lzmainfo“ са „.lzma“ датотекама." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "„--list“ не подржава читање са стандардног улаза" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Грешка читања назива датотека: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Неочекивани крај улаза приликом читања назива датотека" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Нађох ништаван знак приликом читања назива датотека; можда сте хтели да користите „--files0“ уместо „--files“?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Запакивање и распакивање са „--robot“ није још подржано." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Не могу да читам податке са стандардног улаза приликом читања назива датотека са стандардног улаза" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Унутрашња грешка (бубица)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Не могу да успоставим руковаоце сигналом" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Нема провере целовитости; не проверавам целовитост датотеке" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Неподржана врста провере целовитости; не проверавам целовитост датотеке" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Ограничење коришћења меморије је достигнуто" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Није препознат формат датотеке" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Неподржане опције" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Запаковани подаци су оштећени" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Неочекиван крај улаза" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB меморије је потребно. Ограничавач је онемогућен." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB меморије је потребно. Ограничење је %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Ланац филтера: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Пробајте „%s --help“ за више података." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Грешка исписивања текста помоћи (код грешке %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "не ствара привидне датотеке када распакује" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".SUF" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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“ на запакованим датотекама" + +#: src/xz/message.c +msgid "FILE" +msgstr "ДАТОТЕКА" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "Основне опције формата датотеке и запакивања:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "ФОРМАТ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "NAME" +msgstr "НАЗИВ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "покушава да побољша однос запакивања користећи више времена процесора; не утиче на потребе меморије распакивача" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "БРОЈ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 за коришћење онолико нити колико има језгара процесора" + +#: src/xz/message.c +msgid "SIZE" +msgstr "ВЕЛИЧИНА" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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“ блок након свака ВЕЛИЧИНА бајта улаза; користите ово да поставите величину блока за нитирано запакивање" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "БЛОКОВИ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "приликом запакивања, ако је прошло више од ВРЕМЕ_ИСТЕКА милисекунди до претходног убацивања и читања још улаза блокираће, сви подаци на чекању се истискују ван" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "ОГРАНИЧЕЊЕ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "Произвољни ланац филтера за запакивање (алтернатива за коришћење предподешавања):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "ФИЛТЕРИ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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“ филтера и излази" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "ОПЦИЈЕ" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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; ОПЦИЈЕ је зарезом раздвојен списак нула или више следећих опција (исправне вредности; основно):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "ПРЕ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "величина речника" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "број битова положаја" + +#: src/xz/message.c +msgid "MODE" +msgstr "РЕЖИМ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "Без ДАТОТЕКЕ, или када је ДАТОТЕКА -, чита стандардни улаз." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "Грешке пријавите на <%s> (на енглеском или финском)." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 "Подржани филтери и њихове опције су:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Опције морају бити парови „назив=вредност“ раздвојени зарезима" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Неисправан назив опције" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Неисправна вредност опције" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Неподржано претподешавање „LZMA1/LZMA2“: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Збир „lc“ и „lp“ не сме премашити 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Назив датотеке има непознат суфикс, прескачем" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Датотека већ има суфикс „%s“, прескачем" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Неисправан суфикс назива датотеке" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Вредност није не-негативан децимални цео број" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Неисправан суфикс умножавача" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Исправни суфикси су KiB (2^10), MiB (2^20), и GiB (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Вредност опције „%s“ мора бити у опсегу [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Запаковани подаци се не могу читати из терминала" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Запаковани подаци се не могу писати на терминал" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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“ датотеке." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Датотека је премала да би била „.lzma“ датотека" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Није „.lzma“ датотека" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Писање на стандардни излаз није успело" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Непозната грешка" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Неподржано предподешавање" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Неподржана заставица у предподешавању" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Непознат назив опције" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Вредност опције не може бити празна" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Вредност је ван опсега" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Ова опција не подржава никакве суфиксе умножавача" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Неисправан суфикс умножавача (KiB, MiB, или GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Непознат назив филтера" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Филтер се не може користити у „.xz“ формату" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Додела меморије није успела" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Празна ниска није дозвољена, пробајте 6 ако је основна вредност потребна" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Највећи број филтера је четири" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Недостаје назив филтера" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Неисправан ланац филтера („lzma2“ недостаје на крају?)" diff --git a/cpp/third_party/xz-5.8.3/po/stamp-po b/cpp/third_party/xz-5.8.3/po/stamp-po new file mode 100644 index 0000000000..9788f70238 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/stamp-po @@ -0,0 +1 @@ +timestamp diff --git a/cpp/third_party/xz-5.8.3/po/sv.gmo b/cpp/third_party/xz-5.8.3/po/sv.gmo new file mode 100644 index 0000000000..93c65cb07b Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/sv.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/sv.po b/cpp/third_party/xz-5.8.3/po/sv.po new file mode 100644 index 0000000000..9dc9da13b6 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/sv.po @@ -0,0 +1,1271 @@ +# SPDX-License-Identifier: 0BSD +# +# Swedish translation for xz. +# Copyright (C) The XZ Utils authors and contributors +# This file is published under the BSD Zero Clause License. +# +# Sebastian Rasmussen , 2019. +# Anders Jonsson , 2024. +# Luna Jernberg , 2022, 2023, 2024, 2025. +# # +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\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 \n" +"Language: sv\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.5\n" +"X-Poedit-Bookmarks: -1,10,-1,-1,-1,-1,-1,-1,-1,-1\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Ogiltigt argument till --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: För många argument till --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "I --block-list saknas blockstorlek efter filterkedjenummer ”%c:”" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 kan endast användas som det sista elementet i --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Okänd filformatstyp" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Integritetskontrolltyp stöds inte" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Endast en fil kan anges med ”--files” eller ”--files0”." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Miljövariabeln %s innehåller för många argument" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Komprimeringsstöd inaktiverades vid byggtid" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Dekomprimeringsstöd inaktiverades vid byggtid" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Komprimering av lzip-filer (.lz) stöds inte" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list ignoreras såvida du inte komprimerar till .xz-formatet" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Med --format=raw krävs --suffix=.SUF om data inte skrivs till standard ut" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Maximalt antal filter är fyra" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Fel i flagga för --filters%s=FILTER:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Begränsning av minnesanvändning är allt för låg för den angivna filteruppsättningen." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "filterkedja %u används av --block-list men inte specificerad med --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Det avråds från att använda en förinställning i rått läge." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "De exakta flaggorna för förinställningar kan variera mellan programversioner." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Formatet .lzma har endast stöd för LZMA1-filtret" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 kan inte användas tillsammans med .xz-formatet" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Filterkedja %u är inkompatibel med --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Växlar till entrådsläge på grund av --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Flaggor som inte stöds i filterkedjan %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Använder upp till % trådar." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Filterkedja eller filterflaggor stöds inte" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Dekomprimering kommer att kräva %s MiB minne." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Reducerade antalet trådar från %s till %s för att inte överstiga begränsningen av minnesanvändning på %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Reducerade antalet trådar från %s till en. Den automatiska minnesanvändningsgränsen på %s MiB överskrids fortfarande. %s MiB minne krävs. Fortsätter i alla fall." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Ändrar till enkeltrådat läge för att inte överskrida minnesanvändningsgränsen på %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Justerade storlek för LZMA%c-lexikon från %s MiB till %s MiB för att inte överstiga begränsningen av minnesanvändning på %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Justerade storlek för LZMA%c-lexikon för --filters%u från %s MiB till %s MiB för att inte överskrida minnesanvändningsgränsen på %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Fel vid ändring till filterkedja %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Fel vid skapande av rörledning: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() misslyckades: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Filen verkar ha flyttats, tar inte bort" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Kan inte ta bort: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Kan inte sätta filägaren: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Kan inte sätta filgruppen: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Kan inte sätta filrättigheterna: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Synkroniseringen av filen misslyckades: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s:Synkroniseringen av filens katalog misslyckades:: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Fel vid hämtning av filstatusflaggor från standard in: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Är en symbolisk länk, hoppar över" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Är en katalog, hoppar över" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Är inte en vanlig fil, hoppar över" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Filen har setuid- eller setgid-biten satt, hoppar över" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Filen har stickybiten satt, hoppar över" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Indatafilen har mer än en hårdlänk, hoppar över" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Tomt filnamn, hoppar över" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Fel vid återställning av statusflaggorna för standard in: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Fel vid hämtning av filstatusflaggorna från standard ut: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Att öppna katalogen misslyckades: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: Destinationen är inte en vanlig fil" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Fel vid återställning av O_APPEND-flaggan till standard ut: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Stängning av filen misslyckades: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Sökning misslyckades vid skapande av gles fil: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Läsfel: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Fel vid sökning i fil: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Oväntat filslut" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Skrivfel: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Inaktiverad" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Totalt mängd fysiskt minne (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Antal processortrådar:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Komprimering:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Dekomprimering:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Flertrådad dekomprimering:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Standard för -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Hårdvaruinformation:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Minnesanvändningsgränser:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Strömmar:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Block:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Komprimerad storlek:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Okomprimerad storlek:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Förhållande:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Kontroll:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Strömfyllnad:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Minne som behövs:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Storlek i huvuden:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Antal filer:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Ström" + +#: src/xz/list.c +msgid "Block" +msgstr "Block" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Block" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "Komprimerad position" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "Okomprimerad position" + +#: src/xz/list.c +msgid "CompSize" +msgstr "Komprimerad storlek" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "Okomprimerad storlek" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "Total storlek" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Förhållande" + +#: src/xz/list.c +msgid "Check" +msgstr "Kontroll" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "Kontrollvärde" + +#: src/xz/list.c +msgid "Padding" +msgstr "Fyllnad" + +#: src/xz/list.c +msgid "Header" +msgstr "Huvud" + +#: src/xz/list.c +msgid "Flags" +msgstr "Flaggor" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "Minnesanvändning" + +#: src/xz/list.c +msgid "Filters" +msgstr "Filters" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Ingen" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Okänd-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Okänd-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Okänd-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Okänd-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Okänd-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Okänd-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Okänd-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Okänd-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Okänd-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Okänd-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Okänd-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Okänd-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Fil är tom" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: För liten för att vara en giltig .xz-fil" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Strmr Block Komprimerd Okomprimerd Förh. Kntrll Filnamn" + +#: src/xz/list.c +msgid "Yes" +msgstr "Ja" + +#: src/xz/list.c +msgid "No" +msgstr "Nej" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Minsta XZ Utils version:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s fil\n" +msgstr[1] "%s filer\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Total:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list fungerar endast med .xz-filer (--format=xz eller --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Pröva ”lzmainfo” med .lzma-filer." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list saknar stöd för att läsa från standard in" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Fel vid läsning av filnamn: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Oväntat slut av indata vid läsning av filnamn" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Nulltecken hittades vid läsning av filnamn; kanske du menade att använda ”--files0” istället för ”--files”?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Komprimering och dekomprimering med --robot stöds inte än." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Kan inte läsa data från standard in när filnamn läses från standard in" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Internt fel" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Kan inte etablera signalhanterare" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Ingen integritetskontroll; kan inte verifiera filintegritet" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Typ av integritetskontroll stöds inte; verifierar inte filintegritet" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Begränsning av minnesanvändning uppnådd" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Filformat okänt" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Flaggor stöds inte" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Komprimerad data är korrupt" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Oväntat avslut av indata" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB minne krävs. Begränsaren inaktiverad." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB minne krävs. Begränsningen är %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Filterkedja: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Testa ”%s --help” för mer information." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Fel vid utskrift av hjälptexten (felkod %d)" + +#: src/xz/message.c +#, c-format +msgid "Usage: %s [OPTION]... [FILE]...\n" +msgstr "Användning: %s [ALTERNATIV]... [FIL]...\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Komprimera eller dekomprimera FILER i formatet .xz." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Obligatoriska argument för långa alternativ är också obligatoriska för korta alternativ." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Operationsläge:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "tvinga komprimering" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "tvinga dekomprimering" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 den komprimerade filens integritet" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "lista information om .xz-filer" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Operationsmodifierare:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "behåll (ta inte bort) indatafiler" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "tvinga överskrift av utdatafilen och (av)komprimera länkar" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "skriv till standardutdata och ta inte bort indatafiler" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "synkronisera inte utdatafilen till lagringsenheten innan du tar bort indatafilen" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "dekomprimera endast den första strömmen och ignorera eventuellt kvarvarande indata i tysthet" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "skapa inte glesa filer vid dekomprimering" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".SUF" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "använd suffixet '.SUF' på komprimerade filer" + +#: src/xz/message.c +msgid "FILE" +msgstr "FIL" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "läs filnamn att bearbeta från FIL; om FIL utelämnas läses filnamnen från standardinmatningen; filnamn måste avslutas med nyradstecknet" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "som --filer men använd null-tecknet som terminator" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Grundläggande filformat och komprimeringsalternativ:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "FORMAT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "filformat för kodning eller avkodning; möjliga värden är 'auto' (standard), 'xz', 'lzma', 'lzip' och 'raw'" + +#: src/xz/message.c +msgid "NAME" +msgstr "NAMN" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "integritetskontrolltyp: 'ingen' (använd med försiktighet), 'crc32', 'crc64' (standard) eller 'sha256'" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "verifiera inte integritetskontrollen vid dekomprimering" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "förinställd komprimering; standard är 6; ta hänsyn till användningen av kompressor *och* dekomprimeringsminne innan du använder 7-9!" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "försök att förbättra kompressionsförhållandet genom att använda mer CPU-tid; påverkar inte dekomprimeringsminneskraven" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "NUM" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "använd som mest NUM trådar; standard är 0 som använder lika många trådar som det finns processorkärnor" + +#: src/xz/message.c +msgid "SIZE" +msgstr "STORLEK" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "starta ett nytt .xz-block efter varje STORLEK-byte med inmatning; använd detta för att ställa in blockstorleken för flertrådad kompression" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOCK" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "starta ett nytt .xz-block efter de givna kommaseparerade intervallen av okomprimerad data; ange eventuellt ett filterkedjenummer (0-9) följt av ett ':' före den okomprimerade datastorleken" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "vid komprimering, om mer än NUM millisekunder har gått sedan föregående tömning och läsning av mer indata skulle blockeras, rensas all väntande data ut" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "GRÄNSVÄRDE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "ställ in minnesanvändningsgräns för komprimering, dekompression, flertrådad dekompression eller alla dessa; GRÄNSVÄRDE är i byte, % av RAM-minnet eller 0 för standardinställningar" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "om komprimeringsinställningarna överskrider minnesanvändningsgränsen, ge ett felmeddelande istället för att justera inställningarna nedåt" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Anpassad filterkedja för komprimering (ett alternativ till förinställningar):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTER" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "ställ in filterkedjan med hjälp av liblzma-filtersträngsyntaxen; använd --filters-help för mer information" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "ställ in ytterligare filterkedjor med hjälp av liblzma-filtersträngsyntaxen att använda med --block-list" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "visa mer information om liblzma filtersträngsyntax och avsluta" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "ALTERNATIV" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 eller LZMA2; OPTS är en kommaseparerad lista med noll eller fler av följande alternativ (giltiga värden; standard):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "FÖRINSTÄLLNING" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "återställ alternativ till en förinställning" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "ordboksstorlek" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 "antal bokstavliga kontextbitar" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "antal bokstavliga positionsbitar" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "antal positionsbitar" + +#: src/xz/message.c +msgid "MODE" +msgstr "LÄGE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "komprimeringsläge" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "fin längd på en match" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "träffsökare" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "maximalt sökdjup; 0=automatisk (standard)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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-bitars och 64-bitars)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 (endast big endian)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "Giltiga ALTERNATIV för alla BCJ-filter:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "startoffset för omvandlingar (standard=0)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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; giltiga ALTERNATIV (giltiga värden; standard):" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "avståndet mellan byte som subtraheras från varandra" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Andra alternativ:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "dämpa varningar; ange två gånger för att dämpa fel också" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "var utförlig; specificera två gånger för ännu mer utförlighet" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "åt inte varningar påverka avslutningsstatus" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "använd maskintolkningsbara meddelanden (användbara för skript)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "visa den totala mängden RAM och de för närvarande aktiva minnesanvändningsgränserna och avsluta" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "visa den korta hjälpen (visar endast de grundläggande alternativen)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "visa den långa hjälpen och avsluta" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "visa den korta hjälpen och avsluta" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "visa den långa hjälpen (visar även de avancerade alternativen)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "visa versionsnumret och avsluta" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "Med FIL, eller när FIL är -, läs standard in." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "" +"Rapportera fel till <%s> (på engelska eller finska).\n" +"Rapportera översättningsfel till " + +#. 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 interpreted as a zero-width space (the 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 hemsida: <%s>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "DETTA ÄR EN UTVECKLINGSVERSION SOM INTE ÄR AVSEDD FÖR PRODUKTIONSANVÄNDNING." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "Filterkedjor ställs in med alternativen --filters=FILTERS eller --filters1=FILTER ... --filters9=FILTER. Varje filter i kedjan kan separeras med mellanslag eller '--'. Alternativt kan en förinställd %s specificeras istället för en filterkedja." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Filtren som stöds och flaggorna för dem är:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Alternativ måste vara ”namn=värde”-par separerade med kommatecken" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Ogiltigt flaggnamn" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Ogiltigt alternativvärde" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "LZMA1/LZMA2-förinställning stöds inte: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Summan av lc och lp får inte överstiga 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Filnamn har okänd filändelse, hoppar över" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Filen har redan ändelsen ”%s”, hoppar över" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Ogiltig filnamnsändelse" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Värdet är inte ett icke-negativt, decimalt heltal" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Ogiltig multipeländelse" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Giltiga suffix är ”KiB” (2^10), ”MiB” (2^20) och ”GiB” (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Värdet för flaggan ”%s” måste vara inom intervallet [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Komprimerad data kan inte läsas från en terminal" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Komprimerad data kan inte skrivas till en terminal" + +#: src/lzmainfo/lzmainfo.c +#, c-format +msgid "Usage: %s [--help] [--version] [FILE]...\n" +msgstr "Användning: %s [--help] [--version] [FIL]…\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-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 "Visa information som lagrats i .lzma-filhuvudet" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Filen är för liten för att vara en giltig .lzma-fil" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Inte en .lzma-fil" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Skrivning till standard ut misslyckades" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Okänt fel" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Förinställning stöds inte" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Flagga som inte stöds i förinställningen" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Okänt alternativnamn" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Alternativvärdet får inte vara tomt" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Värde utanför intervallet" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Det här alternativet stöder inte några multiplikatorsuffix" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Ogiltigt multiplikatorsuffix (KiB, MiB eller GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Okänt filternamn" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Detta filter kan inte användas med .xz-formatet" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Minnesallokering misslyckades" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Tom sträng är inte tillåten, försök '6' om ett standardvärde behövs" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Det maximala antalet filter är fyra" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Filternamn saknas" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Ogiltig filterkedja ('lzma2' saknas på slutet?)" diff --git a/cpp/third_party/xz-5.8.3/po/tr.gmo b/cpp/third_party/xz-5.8.3/po/tr.gmo new file mode 100644 index 0000000000..80e3501997 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/tr.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/tr.po b/cpp/third_party/xz-5.8.3/po/tr.po new file mode 100644 index 0000000000..f6d0a7639d --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/tr.po @@ -0,0 +1,1264 @@ +# SPDX-License-Identifier: 0BSD +# +# Turkish translation for xz. +# This file is published under the BSD Zero Clause License. +# +# Emir SARI , 2022-2025. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\n" +"POT-Creation-Date: 2026-03-30 17:13+0300\n" +"PO-Revision-Date: 2025-01-25 17:00+0300\n" +"Last-Translator: Emir SARI \n" +"Language-Team: Turkish \n" +"Language: tr\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=2; plural=(n > 1);\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: --block-list için geçersiz argüman" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: --block-list için çok fazla argüman" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "--block-list içinde, süzgeç zinciri numarası '%c' sonrası blok boyutu eksik:" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0, yalnızca --block-list içindeki son öge olarak kullanılabilir" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Bilinmeyen dosya biçimi türü" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Desteklenmeyen bütünlük denetimi türü" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "'--files' veya '--files0' ile yalnızca bir dosya belirtilebilir." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Çevre değişkeni %s, pek fazla argüman içeriyor" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Sıkıştırma desteği, yapım sırasında devre dışı bırakıldı" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Sıkıştırma açma desteği, yapım sırasında devre dışı bırakıldı" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "lzip dosyalarının (.lz) sıkıştırılması desteklenmiyor" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr ".xz biçimine sıkıştırılmadığı durumlarda --block-list yok sayılır" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "stdout'a yazılmıyorsa --format-raw ile --suffix=.SUF gereklidir" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Olabilecek en çok süzgeç sayısı dörttür" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "--filters%s=SÜZGEÇLER seçeneğinde hata:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Verilen süzgeç ayarı için bellek kullanım sınırı pek düşük." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "Süzgeç zinciri %u --block-list tarafından kullanılıyor; ancak --filters%u= ile belirtilmemiş." + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Ham kipte bir önayar kullanımı önerilmez." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Önayarların kesin seçenekleri yazılım sürümleri arasında ayrım gösterebilir." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr ".lzma biçimi, yalnızca LZMA1 süzgecini destekler" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1, .xz biçimi ile birlikte kullanılamaz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Süzgeç zinciri %u, --flush-timeout ile uyumsuz" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "--flush-timeout nedeniyle tek iş parçacıklı kipe geçiliyor" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Süzgeç zinciri %u ile desteklenmeyen seçenekler" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "En çok % iş parçacığı kullanılıyor." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Desteklenmeyen süzgeç zinciri veya süzgeç seçenekleri" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Sıkıştırma açma, %s MiB belleğe gereksinim duyacak." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "%3$s MiB bellek kullanımı sınırını aşmamak için iş parçacığı sayısı %1$s -> %2$s olarak ayarlandı" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "İş parçacıklarının sayısı %s -> 1 olarak azaltıldı. %s MiB otomatik bellek sınırı hâlâ aşılıyor. %s MiB belleğe gereksinim var. Yine de sürdürülüyor." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "%s MiB bellek kullanım sınırını aşmamak için tek iş parçacıklı kipe geçiliyor" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "%4$s MiB bellek kullanımı sınırını aşmamak için LZMA%1$c sözlük boyutu %2$s MiB'dan %3$s MiB'e ayarlandı" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "%5$s MiB bellek kullanımı sınırını aşmamak için --filters%2$u için olan LZMA%1$c sözlük boyutu %3$s MiB'den %4$s MiB'a ayarlandı" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Süzgeç zinciri %u olarak değiştirilirken hata: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Veriyolu oluştururken hata: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: poll() başarısız oldu: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Dosya taşınmış gibi görünüyor, kaldırılmıyor" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Kaldırılamıyor: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Dosya sahibi ayarlanamıyor: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Dosya grubu ayarlanamıyor: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Dosya izinleri ayarlanamıyor: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Dosyayı eşzamanlama başarısız: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Dosyanın dizinini eşzamanlama başarısız: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Standart girdi'den dosya durum bayrakları alınırken hata: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Bir sembolik bağ, atlanıyor" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Bir dizin, atlanıyor" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Olağan bir dosya değil, atlanıyor" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Dosyanın setuid'si veya setgid biti ayarlanmış, atlanıyor" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Dosyanın yapışkan bit seti var, atlanıyor" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Girdi dosyasında birden çok sabit bağ var, atlanıyor" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Boş dosya adı, atlanıyor" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Standart girdi'ye durum bayrakları geri yüklenirken hata: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Standart çıktı'dan dosya durum bayrakları alınırken hata: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Dizini açma başarısız: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: Hedef olağan bir dosya değil" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Standart çıktı'dan O_APPEND bayrağı geri yüklenirken hata: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Dosyayı kapatma başarısız: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Bir aralıklı dosya oluşturmaya çalışırken arama başarısız: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Okuma hatası: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Dosyayı ararken hata: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Dosyanın beklenmedik sonu" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Yazma hatası: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Devre dışı" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Fiziksel bellek miktarı (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "İşlemci iş parçacığı sayısı:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Sıkıştırma:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Sıkıştırma açma:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Çok iş parçacıklı sıkıştırma açma:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "-T0 için öntanımlı:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Donanım bilgisi:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Bellek kullanım sınırları:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Akışlar:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Bloklar:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Sıkıştırılmış boyut:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Sıkıştırılmamış boyut:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Oran:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Denetim:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Akış dolgusu:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Gereken bellek:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Üstbilgideki boyut:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Dosya sayısı:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Akış" + +#: src/xz/list.c +msgid "Block" +msgstr "Blok" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Bloklar" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "SkştrOfseti" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "SkştrmmşOfset" + +#: src/xz/list.c +msgid "CompSize" +msgstr "SkştrBoyut" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "SkştrmmşBoyut" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "ToplamBoyut" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Oran" + +#: src/xz/list.c +msgid "Check" +msgstr "Denetim" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "DğrDentm" + +#: src/xz/list.c +msgid "Padding" +msgstr "Dolgu" + +#: src/xz/list.c +msgid "Header" +msgstr "Üstveri" + +#: src/xz/list.c +msgid "Flags" +msgstr "Bayrak" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "BelKullnm" + +#: src/xz/list.c +msgid "Filters" +msgstr "Süzgeçler" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Yok" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "?-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "?-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "?-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "?-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "?-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "?-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "?-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "?-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "?-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "?-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "?-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "?-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Dosya boş" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Geçerli bir .xz dosyası olabilmek için pek küçük" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr " Akış Blok Sıkıştırıl. Sıkıştırmas. Oran Denetim Dosya ad" + +#: src/xz/list.c +msgid "Yes" +msgstr "Evet" + +#: src/xz/list.c +msgid "No" +msgstr "Hayır" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "En düşük XZ Utils sürümü:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s dosya\n" +msgstr[1] "%s dosya\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Toplamlar:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list, yalnızca .xz dosyalarında çalışır (--format=xz veya --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr ".lzma dosyalarıyla 'lzmainfo'yu deneyin." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list, standart girdi'den okumayı desteklemez" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Dosya adları okunurken hata: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Dosya adları okunurken beklenmedik girdi sonu" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Dosya adları okunurken boş karakter bulundu; '--files' yerine '--files0' mı demek istediniz?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "--robot ile sıkıştırma ve sıkıştırma açma henüz desteklenmiyor." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Standart girdi'den dosya adları okunurken standart girdi'den veri okunamıyor" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "İç hata (yazılım hatası)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Sinyal işleyicileri tesis edilemiyor" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Bütünlülük denetimi yok; dosya bütünlüğü doğrulanmıyor" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Desteklenmeyen bütünlülük denetimi türü; dosya bütünlüğü doğrulanmıyor" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Bellek kullanım sınırına erişildi" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Dosya biçimi tanımlanamıyor" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Desteklenmeyen seçenekler" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Sıkıştırılmış veri hasarlı" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Beklenmedik girdi sonu" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "%s MiB bellek gerekiyor. Sınırlandırıcı devre dışı bırakıldı." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "%s MiB bellek gerekiyor. Sınır, %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Süzgeç zinciri: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Daha fazla bilgi için '%s --help' deneyin." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Yardım metni yazdırılırken hata (hata kodu %d)" + +#: src/xz/message.c +#, c-format +msgid "Usage: %s [OPTION]... [FILE]...\n" +msgstr "Kullanım: %s [SEÇENEK]... [DOSYA]...\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 biçimindeki DOSYAları sıkıştır veya sıkıştırmasını aç." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Uzun seçenekler için zorunlu olan argümanlar kısalar için de öyledir." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "İşlem kipi:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırmayı zorla" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırma açmayı zorla" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırılmış dosya bütünlüğünü sına" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 dosyaları hakkında bilgi ver" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "İşlem niteleyicileri:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "girdi dosyalarını tut (silme)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "çıktı dosyalarının üzerine yazılmasını zorla ve bağlantıları çöz" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "standart çıktıya yaz ve girdi dosyalarını silme" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "girdi dosyasını kaldırmadan önce çıktı dosyasını depolama aygıtına eşzamanlama" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "yalnızca ilk akışı çöz ve kalan olası girdi verisini sessizce yok say" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırma çözerken seyrek dosyalar oluşturma" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".SUF" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırılmış dosyalarda '.SUF' sonekini kullan" + +#: src/xz/message.c +msgid "FILE" +msgstr "DOSYA" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "DOSYA'dan işlemek için dosya adlarını oku; DOSYA verilmemişse dosya adları standart girdiden okunur; dosya adları, yenisatır karakteriyle sonlandırılmalıdır" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 gibi; ancak sonlandırıcı olarak boş karakterini kullanır" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Temel dosya biçimi ve sıkıştırma seçenekleri:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "BİÇİM" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "kodlamak veya çözmek için dosya biçimi; olası değerler: 'auto' (öntanımlı), 'xz', 'lzma', 'lzip' ve 'raw'" + +#: src/xz/message.c +msgid "NAME" +msgstr "AD" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "bütünlük denetimi türü: 'none' (dikkatlı kullanın), 'crc32', 'crc64' (öntanımlı) veya 'sha256'" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırmayı açarken bütünlük denetimini doğrulama" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırma önayarı; öntanımlı 6'dır; 7-9 kullanmadan önce sıkıştırıcı *ve* açıcı bellek kullanımını dikkate alın" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "daha çok CPU zamanı kullanarak sıkıştırma oranını iyileştirmeye çalış; sıkıştırma açıcı bellek gereksinimlerini etkilemez" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "SAYI" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "en çok SAYI iş parçacığı kullan; öntanımlı 1; var olan işlemci çekirdeği kadar iş parçacığı kullanmak için 0'a ayarlayın" + +#: src/xz/message.c +msgid "SIZE" +msgstr "BOYUT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "her BOYUT bayt girdiden sonra yeni bir .xz bloku başlat; iş parçacığı kullanan sıkıştırma için blok boyutunu ayarlamak için bunu kullanın" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOKLAR" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "verilen virgülle ayrılmış sıkıştırılmamış veri aralığından sonra yeni bir .xz bloku başlat; isteğe bağlı olarak, sıkıştırılmamış veri boyutundan önce bir süzgeç zinciri numarası belirtin (0-9, sonrasında ':' gelir)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırırken, bir önceki floştan SAYI milisaniyeden daha çok zaman geçtiyse ve daha çok okuma engelleyecekse tüm bekleyen veri floşlanır" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "SINIR" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "sıkıştırma, sıkıştırma açma, çok iş parçacıklı sıkıştırma açma veya bunların tümü için için bellek kullanımı sınırı ayarla; SINIR; bayt, bellek yüzdesi veya öntanımlılar için 0 olabilir" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırma ayarları bellek kullanımı sınırını aşıyorsa ayarı aşağı doğru çekmek yerine bir hata ver" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Sıkıştırma için özel süzgeç zinciri (önayar kullanımı alternatifi):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "SÜZGEÇLER" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "süzgeç zincirini liblzma süzgeç zinciri sözdizimi kullanarak ayarla; daha fazla bilgi için --filters-help kullanın" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 ile kullanmak üzere liblzma süzgeç dizisi sözdizimi kullanarak ek süzgeç zincirleri ayarla" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 süzgeç dizisi sözdizimi hakkında daha fazla bilgi görüntüle ve çık" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "SÇNK" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 veya LZMA2; SÇNK (seçenekler), aşağıdaki seçeneklerin hiçbirini veya bir sayısını içeren virgülle ayrılmış bir listedir (geçerli değerler; öntanımlı):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "ÖN" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "seçenekleri bir önayara sıfırla" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sözlük boyutu" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 "düz bağlam bitleri sayısı" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "düz konum bitleri sayısı" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "konum bitleri sayısı" + +#: src/xz/message.c +msgid "MODE" +msgstr "KİP" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sıkıştırma kipi" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "eşleşmenin öncelik uzunluğu" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "eşleşme bulucusu" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "en çok arama derinliği; 0=kendiliğinden (öntanımlı)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 süzgeci (32 ve 64 bit)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 süzgeci" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 süzgeci" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 süzgeci" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 süzgeci (yalnızca son büyük haneli)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 süzgeci" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 süzgeci" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 süzgeci" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Tüm BCJ süzgeçleri için geçerli SÇNK:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "dönüşümler için başlangıç ofseti (öntanımlı)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Fark süzgeci; geçerli SÇNK (geçerli değerler; öntanımlı):" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "birbirinden çıkarılan baytlar arasındaki uzaklık" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Diğer seçenekler:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "uyarıları sustur; hataları susturmak için iki kez belirt" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "ayrıntılı ol; daha da ayrıntı için iki kez belirt" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "uyarıların çıkış durumunu etkilemesine izin verme" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "makine tarafından ayrıştırılabilir iletiler kullan (betikler için yararlı)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "toplam RAM miktarını ve şu anki bellek kullanımı sınırlarını görüntüle ve çık" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "kısa yardımı görüntüle (yalnızca temel seçenekleri listeler)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "bu uzun yardımı görüntüle ve çık" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "bu kısa yardımı görüntüle ve çık" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "bu uzun yardımı görüntüle (ayrıca gelişmiş seçenekleri listeler)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "sürüm numarasını görüntüle ve çık" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "DOSYA olmadan veya DOSYA - iken standart girdi'yi oku." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "Hataları <%s> adresine bildir (İngilizce veya Fince)." + +#. 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 interpreted as a zero-width space (the 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 ana sayfası: <%s>" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "BU, NORMAL KULLANIM İÇİN OLMAYAN BİR GELİŞTİRME SÜRÜMÜDÜR." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "Süzgeç zincirleri --filters=SÜZGEÇLER veya --filters1=SÜZGEÇLER ... --filters9=SÜZGEÇLER seçenekleri kullanılarak ayarlanır. Zincirdeki her bir seçenek boşluklar veya '--' ile ayrılabilir. Alternatif olarak, bir süzgeç zinciri yerine bir %s önayarı da belirtilebilir." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Desteklenmeyen süzgeçler ve onların seçenekleri:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "Seçenekler, virgülle ayrılmış 'ad=değer' çiftleri olmalıdır" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Geçersiz seçenek adı" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Geçersiz seçenek değeri" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Desteklenmeyen LZMA1/LZMA2 önayarı: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "lc ve lp'nin toplamı 4'ü geçmemelidir" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Dosya adında bilinmeyen sonek var, atlanıyor" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Dosyada '%s' soneki halihazırda var, atlanıyor" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Geçersiz dosya adı soneki" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "Değer, bir negatif olmayan ondalık tamsayı" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Geçersiz çoklayıcı soneki" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Geçerli sonekler: 'KiB' (2^10), 'MiB' (2^20) ve 'GiB' (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "'%s' seçeneği değeri erimde olmalıdır [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Bir uçbirimden sıkıştırılmış veri okunamaz" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Bir uçbirime sıkıştırılmış veri yazılamaz" + +#: src/lzmainfo/lzmainfo.c +#, c-format +msgid "Usage: %s [--help] [--version] [FILE]...\n" +msgstr "Kullanım: %s [--help] [--version] [DOSYA]...\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-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 dosya üstbilgisinde depolanan bilgiyi göster." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Geçerli bir .xz dosyası olabilmek için pek küçük" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Bir .lzma dosyası değil" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Standart çıktı'ya yazma başarısız" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Bilinmeyen hata" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Desteklenmeyen önayarlar" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Önayarda desteklenmeyen bayrak" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Geçersiz seçenek adı" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Seçenek değeri boş olamaz" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Değer erim dışında" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "Bu seçenek herhangi bir çoklayıcı soneklerini desteklemiyor" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "Geçersiz çoklayıcı soneki (KiB, MiB veya GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Bilinmeyen süzgeç adı" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Bu süzgeç .xz biçiminde kullanılamaz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Bellek ayırma başarısız" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Boş diziye izin verilmiyor; bir öntanımlı değer gerekiyorsa '6' deneyin" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Olabilecek en çok süzgeç sayısı dörttür" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Süzgeç adı eksik" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Geçersiz süzgeç zinciri (sonda 'lzma2' mi eksik?)" diff --git a/cpp/third_party/xz-5.8.3/po/uk.gmo b/cpp/third_party/xz-5.8.3/po/uk.gmo new file mode 100644 index 0000000000..5975b6d850 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/uk.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/uk.po b/cpp/third_party/xz-5.8.3/po/uk.po new file mode 100644 index 0000000000..58d48af2a5 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/uk.po @@ -0,0 +1,1268 @@ +# SPDX-License-Identifier: 0BSD +# +# Ukrainian translation for xz. +# This file is published under the BSD Zero Clause License. +# Copyright (C) The XZ Utils authors and contributors +# +# Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\n" +"POT-Creation-Date: 2026-03-30 17:13+0300\n" +"PO-Revision-Date: 2025-01-24 13:54+0200\n" +"Last-Translator: Yuri Chornoivan \n" +"Language-Team: Ukrainian \n" +"Language: uk\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n" +"X-Generator: Lokalize 23.04.3\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: некоректний аргумент --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: забагато аргументів --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "У --block-list пропущено розмір блоку після номера ланцюжка фільтрів «%c:»" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 можна використовувати лише як останній елемент у --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: невідомий тип формату файлів" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: непідтримуваний тип перевірки цілісності" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Разом із параметрами --files або --files0 можна вказувати лише один файл." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "У змінній середовища %s міститься надто багато аргументів" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Підтримку стискання було вимкнено під час збирання програми" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Підтримку розпаковування було вимкнено під час збирання програми" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Підтримки стискання файлів lzip (.lz) не передбачено" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list буде проігноровано, якщо дані не стискаються до формату .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "" +"Якщо вказано --format=raw, слід вказати і --suffix=.SUF, якщо дані\n" +"виводяться не до стандартного виведення" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Максимальна кількість фільтрів — чотири" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Помилка у параметрі --filters%s=ФІЛЬТРИ:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Обмеження на використання пам'яті є надто жорстким для вказаного налаштування фільтрів." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "у --block-list використано ланцюжок фільтрів %u, але його не вказано за допомогою --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Не варто користуватися визначенням рівня у режимі без обробки." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Точний перелік параметрів рівнів може залежати від версій програмного забезпечення." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "У форматі .lzma передбачено підтримку лише фільтра LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 не можна використовувати разом із визначенням формату .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Ланцюжок фільтрування %u є несумісним із параметром --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Перемикаємося на однопотоковий режим через використання --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Непідтримувані параметри у ланцюжку фільтрів %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Використовуємо до % потоків обробки." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Непідтримуваний ланцюжок фільтрування або непідтримувані параметри фільтрування" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Для розпаковування знадобляться %s МіБ пам'яті." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Зменшено кількість потоків обробки з %s до %s, щоб не перевищувати обмеження щодо використання пам'яті у %s МіБ" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Кількість потоків обробки зменшено з %s до одного. Автоматичне обмеження використання пам'яті у %s МіБ усе ще перевищено. Потрібно %s МіБ пам'яті. Продовжуємо роботу попри це." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Перемикаємося на однопотоковий режим, щоб не перевищувати обмеження щодо використання пам'яті у %s МіБ" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Скориговано розмір словника LZMA%c з %s МіБ до %s МіБ, щоб не перевищувати обмеження на використання пам'яті у %s МіБ" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Скориговано розмір словника LZMA%c для --filters%u з %s МіБ до %s МіБ, щоб не перевищувати обмеження на використання пам'яті у %s МіБ" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Помилка під час спроби перейти до ланцюжка фільтрів %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Помилка під час створення каналу: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: помилка poll(): %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: здається, файл пересунуто; не вилучаємо" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: не вдалося вилучити: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: не вдалося встановити власника файла: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: не вдалося встановити групу власника файла: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: не вдалося встановити права доступу до файла: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: не вдалося синхронізувати файл: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: не вдалося синхронізувати каталог файла: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Помилка під час спроби отримання прапорців стану файла зі стандартного джерела вхідних даних: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: є символічним посиланням; пропускаємо" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: є каталогом; пропускаємо" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: не є звичайним файлом; пропускаємо" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: для файла встановлено біт setuid або setgid; пропускаємо" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: для файла встановлено липкий біт; пропускаємо" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: виявлено декілька жорстких посилань на файл із вхідними даними; пропускаємо" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Порожня назва файла; пропускаємо" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Помилка під час спроби відновлення прапорців стану для стандартного джерела вхідних даних: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Помилка під час спроби отримання прапорців стану файла зі стандартного виведення: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s: не вдалося відкрити каталог: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s: призначення не є звичайним файлом" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Помилка під час спроби відновлення прапорця O_APPEND для стандартного виведення: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: не вдалося закрити файл: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: помилка позиціювання під час спроби створити розріджений файл: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: помилка читання: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: помилка позиціювання у файлі: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: неочікуваний кінець файла" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: помилка під час спроби запису: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Вимкнено" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Обсяг фізичної пам'яті (RAM): " + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Кількість потоків обробки процесором:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Стискання:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Розпакування:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Багатопотокове розпаковування:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Типове для -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Дані щодо обладнання:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Обмеження на використання пам'яті:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Потоки:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Блоки:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Стиснутий розмір:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Нестиснутий розмір:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Пропорція:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Перевірка:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Доповнення потоку:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Потрібний об'єм пам'яті:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Розмір у заголовках:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Кількість файлів:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Потік" + +#: src/xz/list.c +msgid "Block" +msgstr "Блок" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Блоки" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "СтисЗсув" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "НестисЗсув" + +#: src/xz/list.c +msgid "CompSize" +msgstr "СтисРозмір" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "НестисРозмір" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "Загальний розмір" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Пропорція" + +#: src/xz/list.c +msgid "Check" +msgstr "Перевірка" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "ЗначПерев" + +#: src/xz/list.c +msgid "Padding" +msgstr "Заповн" + +#: src/xz/list.c +msgid "Header" +msgstr "Заголов" + +#: src/xz/list.c +msgid "Flags" +msgstr "Прапор" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "ВикПам" + +#: src/xz/list.c +msgid "Filters" +msgstr "Фільтри" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Немає" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "Невідомо-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "Невідомо-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "Невідомо-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "Невідомо-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "Невідомо-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "Невідомо-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "Невідомо-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "Невідом-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "Невідом-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "Невідом-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "Невідом-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "Невідом-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: файл порожній" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: є надто малим для коректного файла .xz" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Потоки Блоки Стиснуті Нестиснуті Коеф. Перев. Назва файла" + +#: src/xz/list.c +msgid "Yes" +msgstr "Так" + +#: src/xz/list.c +msgid "No" +msgstr "Ні" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "Мінімальна версія програм XZ:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s файл\n" +msgstr[1] "%s файли\n" +msgstr[2] "%s файлів\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Загалом:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list працює лише для файлів .xz (--format=xz або --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Спробуйте «lzmainfo» із файлами .lzma." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "Використання --list скасовує підтримку читання зі стандартного джерела вхідних даних" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: помилка під час читання назв файлів: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: неочікуваний кінець вхідних даних під час читання назв файлів" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: під час читання назв файлів виявлено нуль-символ; можливо, ви хотіли скористатися --files0, а не --files?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "У поточній версії ще не передбачено підтримки стискання або розпаковування з параметром --robot." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Читання даних зі стандартного джерела вхідних даних неможливе, якщо зі стандартного джерела даних виконується читання назв файлів standard input" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Внутрішня помилка (вада)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Не вдалося встановити обробники сигналів" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Немає перевірки цілісності; цілісність файлів перевірено не буде" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Непідтримуваний тип перевірки цілісності; перевірки цілісності виконано не буде" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Перевищено обмеження на використання пам'яті" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Формат файла не розпізнано" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Непідтримувані параметри" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Стиснені дані пошкоджено" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Несподіваний кінець вхідних даних" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "Потрібно %s МіБ пам'яті. Обмеження вимкнено." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "Потрібно %s МіБ пам'яті. Маємо обмеження у %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: ланцюжок фільтрування: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Спробуйте «%s --help» для отримання докладнішого опису." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "Помилка при друці тексту довідки (код помилки %d)" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "не створювати розріджених файлів при розпаковуванні" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".СУФ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "використати суфікс «.СУФ» для стиснутих файлів" + +#: src/xz/message.c +msgid "FILE" +msgstr "ФАЙЛ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "Параметри базового формату файлів та стискання:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "ФОРМАТ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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" + +#: src/xz/message.c +msgid "NAME" +msgstr "НАЗВА" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "спробувати поліпшити рівень стискання ширшим використанням процесора; не впливає на вимоги щодо пам'яті для розпаковування" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "ЧИСЛО" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "використовувати не більше N потоків; типовим є значення 0, за якого програма використовує стільки потоків, скільки є ядер у процесора" + +#: src/xz/message.c +msgid "SIZE" +msgstr "РОЗМІР" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 кожні РОЗМІР байтів вхідних даних; цим параметром слід користуватися для встановлення розміру блоку для пакування у декілька потоків" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "БЛОКИ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "під час стискання, якщо з часу попереднього спорожнення буфера і читання додаткового блоку вхідних даних минуло більше за ЧАС_ОЧІКУВАННЯ мілісекунд, витерти усі дані у черзі" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "ОБМЕЖЕННЯ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "Нетиповий ланцюжок фільтрування для стискання (альтернатива використання рівнів):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "ФІЛЬТРИ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 і завершити роботу" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "ПАРАМ" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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; ПАРАМ є список відокремлених комами нуля або декількох параметрів (коректні значення; типове):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "НАБ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "розмір словника" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "кількість позиційних бітів" + +#: src/xz/message.c +msgid "MODE" +msgstr "РЕЖИМ" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "фільтр BCJ x86 (32-бітовий і 64-бітовий)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "фільтр BCJ ARM" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "фільтр BCJ ARM-Thumb" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "фільтр BCJ ARM64" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "фільтр BCJ PowerPC (лише зі зворотним порядком байтів)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "фільтр BCJ IA-64 (Itanium)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "фільтр BCJ SPARC" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "фільтр BCJ RISC-V" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "Якщо вхідний файл не вказано, або якщо вказано символ -, читання буде виконано зі стандартного джерела вхідних даних." + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "Сповіщайте розробників про вади за адресою <%s> (англійською і фінською)." + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 "Підтримувані фільтри та їхні параметри:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "параметри -- пари «назва=значення», відокремлені комами" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: некоректна назва параметра" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "Некоректне значення параметра" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Непідтримуваний рівень стискання LZMA1/LZMA2: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Сума lc і lp не повинна перевищувати 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: назва файла має невідомий суфікс; пропускаємо" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: файл вже має суфікс назви %s; пропускаємо" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: некоректний суфікс назви файла" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "значення не є невід'ємним десятковим цілим" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: некоректний суфікс множника" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Коректними є суфікси «KiB» (2^10), «MiB» (2^20) та «GiB» (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Значення параметра «%s» має належати до діапазону [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Стиснені дані неможливо прочитати з термінала" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Стиснені дані неможливо записати до термінала" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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." + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Файл є надто малим, щоб бути файлом .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Не є файлом .lzma" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Не вдалося записати дані до стандартного виведення" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Невідома помилка" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "Непідтримуваний набір параметрів" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "Непідтримуваний прапорець у наборі параметрів" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "Невідома назва параметра" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "Значення параметра не може бути порожнім" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "Значення поза діапазоном" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "У цьому параметрі не передбачено використання суфіксів-множників" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "некоректний суфікс множника (KiB, MiB або GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "Невідома назва фільтра" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "Цей фільтр не можна використовувати у форматі .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "Не вдалося отримати місце у пам'яті" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "Не можна використовувати порожній рядок; спробуйте «6», якщо потрібне типове значення" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "Максимальна кількість фільтрів — чотири" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "Пропущено назву фільтра" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "Некоректний ланцюжок фільтрування (пропущено lzma2 у кінці?)" diff --git a/cpp/third_party/xz-5.8.3/po/vi.gmo b/cpp/third_party/xz-5.8.3/po/vi.gmo new file mode 100644 index 0000000000..6b124fe4c6 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/vi.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/vi.po b/cpp/third_party/xz-5.8.3/po/vi.po new file mode 100644 index 0000000000..c46e1303e8 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/vi.po @@ -0,0 +1,1671 @@ +# SPDX-License-Identifier: 0BSD +# +# Vietnamese translations for xz package +# Bản dịch tiếng Việt cho gói xz. +# This file is published under the BSD Zero Clause License. +# Trần Ngọc Quân , 2014-2024. +# +msgid "" +msgstr "" +"Project-Id-Version: xz 5.6.0-pre2\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\n" +"POT-Creation-Date: 2026-03-30 17:13+0300\n" +"PO-Revision-Date: 2024-02-24 10:23+0700\n" +"Last-Translator: Trần Ngọc Quân \n" +"Language-Team: Vietnamese \n" +"Language: vi\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=1; plural=0;\n" +"X-Generator: Gtranslator 42.0\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s: Đối số cho --block-list không hợp lệ" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s: Quá nhiều đối số cho --block-list" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "Trong --block-list, cỡ khối thiếu sau số mắt xích bộ lọc '%c:'" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 chỉ có thể dùng như là phần tử cuối trong --block-list" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s: Không hiểu kiểu định dạng tập tin" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s: Không hỗ trợ kiểu kiểm tra toàn vẹn" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "Chỉ được đưa ra một tập tin cho “--files” hay “--files0”." + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s: %s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "Biến môi trường %s chứa quá nhiều đối số" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "Hỗ trợ nén đã bị vô hiệu hóa tại thời điểm biên dịch" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "Hỗ trợ giải nén đã bị vô hiệu hóa tại thời điểm biên dịch" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "Nén tệp lzip (.lz) không được hỗ trợ" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list bị bỏ qua trừ khi nén theo định dạng .xz" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "Với --format=raw, --suffix=.SUF được yêu cầu trừ trường hợp ghi ra đầu ra tiêu chuẩn" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "Số lượng bộ lọc tối đa là bốn" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "Có lỗi trong tùy chọn --filters%s=FILTERS:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "Mức giới hạn dùng bộ nhớ là quá thấp cho việc cài đặt bộ lọc đã cho." + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "móc xích lọc %u được sử dụng bởi --block-list nhưng lại chưa đưa ra gì với --filters%u=" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "Dùng hiện tại trong chế độ thô là ngớ ngẩn." + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "Các tùy chọn trích xuất của chỉnh trước có thể biến đổi phụ thuộc vào phiên bản." + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "Định dạng .lzma chỉ hỗ trợ bộ lọc LZMA1" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 không thể được dùng với định dạng .xz" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "Móc xích lọc %u là không tương thích với --flush-timeout" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "Chuyển sang chế độ đơn tuyến trình bởi vì --flush-timeout" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "Các tùy chọn không được hỗ trợ trong chuỗi móc xích %u" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "Dùng đến % tuyến trình." + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "Không hỗ trợ lọc móc xích hay tùy chọn lọc" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "Giải nén sẽ cần %s MiB bộ nhớ." + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "Đã giảm số lượng tuyến trình từ %s xuống %s để không vượt quá giới hạn sử dụng bộ nhớ là %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "Đã giảm số lượng tuyến trình từ %s xuống còn một. Giới hạn sử dụng bộ nhớ tự động %s MiB vẫn đang bị vượt quá. Cần có %s MiB bộ nhớ. Vẫn tiếp tục." + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "Chuyển sang chế độ đơn tuyến trình để không vượt quá giới hạn sử dụng bộ nhớ là %sMiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Chỉnh cỡ từ điển LZMA%c từ %s MiB thành %s MiB để không vượt quá giới hạn tiêu dùng bộ nhớ là %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "Chỉnh cỡ từ điển LZMA%c cho --filters%u từ %s MiB thành %s MiB để không vượt quá giới hạn tiêu dùng bộ nhớ là %s MiB" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "Gặp lỗi thay đổi chuỗi móc xích lọc %u: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "Gặp lỗi khi tạo một ống dẫn: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s: hàm poll() bị lỗi: %s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s: Tập tin có lẽ đã bị di chuyển, không phải gỡ bỏ" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s: Không thể gỡ bỏ: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s: Không thể đặt chủ sở hữu tập tin: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s: Không thể đặt nhóm tập tin: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s: Không thể đặt chế độ đọc ghi cho tập tin: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s: Gặp lỗi khi đóng tập tin: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s: Gặp lỗi khi đóng tập tin: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "Gặp lỗi khi lấy các cờ trạng thái tập tin từ đầu vào tiêu chuẩn: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s: Là một liên kết mềm nên bỏ qua" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s: Không phải là một thư mục nên bỏ qua" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s: Không phải là tập tin thường nên bỏ qua" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s: Tập tin có đặt bít setuid hoặc setgid nên bỏ qua" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s: Tập tin có bít sticky nên bỏ qua" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s: Tập tin đầu vào có nhiều hơn một liên kết cứng nên bỏ qua" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "Tên tập tin trống rỗng nên bỏ qua" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "Gặp lỗi khi phục hồi các cờ trạng thái tới đầu vào tiêu chuẩn: %s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "Gặp lỗi khi lấy các cờ trạng thái tập tin từ đầu vào tiêu chuẩn: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Opening the directory failed: %s" +msgstr "%s: Gặp lỗi khi đóng tập tin: %s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Not a regular file, skipping" +msgid "%s: Destination is not a regular file" +msgstr "%s: Không phải là tập tin thường nên bỏ qua" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "Gặp lỗi khi phục hồi cờ O_APPEND trên đầu ra tiêu chuẩn: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s: Gặp lỗi khi đóng tập tin: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s: Gặp lỗi khi di chuyển vị trí đọc khi cố tạo một tập tin rải rác: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s: Lỗi đọc: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s: Gặp lỗi khi di chuyển vị trí đọc tập tin: %s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s: Kết thúc tập tin bất ngờ" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s: Lỗi ghi: %s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "Bị tắt" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "Tổng dung lượng bộ nhớ vật lý (RAM):" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "Số luồng bộ xử lý:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "Nén:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "Giải nén:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "Giải nén đa luồng:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "Mặc định cho -T0:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "Thông tin phần cứng:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "Đã chạm mốc giới hạn sử dụng bộ nhớ:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "Các luồng dữ liệu:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "Khối:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "Kích cỡ đã nén:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "Kích cỡ đã giải nén:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "Tỉ lệ:" + +#: src/xz/list.c +msgid "Check:" +msgstr "Kiểm tra:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "Đệm luồng dữ liệu:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "Bộ nhớ cần:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "Kích cỡ phần đầu:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "Số lượng tập tin:" + +#: src/xz/list.c +msgid "Stream" +msgstr "Luồng dữ liệu" + +#: src/xz/list.c +msgid "Block" +msgstr "Khối" + +#: src/xz/list.c +msgid "Blocks" +msgstr "Khối" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "BùNén" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "BùGiảiNén" + +#: src/xz/list.c +msgid "CompSize" +msgstr "CỡNén" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "CỡGiảiNén" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "CỡTổng" + +#: src/xz/list.c +msgid "Ratio" +msgstr "Tỷ lệ" + +#: src/xz/list.c +msgid "Check" +msgstr "Kiểm tra" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "Gtr.Kiểm" + +#: src/xz/list.c +msgid "Padding" +msgstr "Đệm" + +#: src/xz/list.c +msgid "Header" +msgstr "Phần đầu" + +#: src/xz/list.c +msgid "Flags" +msgstr "Cờ" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "DùngBộNhớ" + +#: src/xz/list.c +msgid "Filters" +msgstr "Bộ lọc" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "Không" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "ChưaBiết2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "ChưaBiết3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "ChưaBiết5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "ChưaBiết6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "ChưaBiết7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "ChưaBiết8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "ChưaBiết9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "ChưaBiết11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "ChưaBiết12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "ChưaBiết13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "ChưaBiết14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "ChưaBiết15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s: Tập tin trống rỗng" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s: Là quá nhỏ đối với tập tin .xz hợp lệ" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "Luồng Khối Nén Giải nén Tỷ lệ Ktra Tập tin" + +#: src/xz/list.c +msgid "Yes" +msgstr "Có" + +#: src/xz/list.c +msgid "No" +msgstr "Không" + +#: src/xz/list.c +#, fuzzy +#| msgid " Minimum XZ Utils version: %s\n" +msgid "Minimum XZ Utils version:" +msgstr " Phiên bản “XZ Utils” tối thiểu: %s\n" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s tập tin\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "Tổng cộng:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list chỉ hoạt động trên các tập tin .xz (--format=xz hay --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "Thử 'lzmainfo' với các tập tin .lzma." + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list không hỗ trợ đọc từ đầu vào tiêu chuẩn" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s: Gặp lỗi khi đọc tên tập tin: %s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s: Gặp kết thúc đầu vào bất ngờ khi đọc các tên tập tin" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s: Gặp ký hiệu null khi đọc tên tập tin; có lẽ ý bạn muốn là dùng “--files0” chứ không phải “--files'?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "Nén và giải nén với --robot vẫn chưa được hỗ trợ." + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "Không thể đọc dữ liệu từ đầu vào tiêu chuẩn khi đọc tập tin từ đầu vào tiêu chuẩn" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s: " + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "Lỗi nội bộ (lỗi)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "Không thể thiết lập bộ xử lý tín hiệu" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "Không có kiểm tra toàn vẹn nên không thể thẩm tra tính toàn vẹn của tập tin" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "Kiểu kiểm tra toàn vẹn chưa được hỗ trợ; nên không thể thẩm tra tính toàn vẹn của tập tin" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "Đã chạm mốc giới hạn sử dụng bộ nhớ" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "Không nhận ra định dạng tập tin" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "Tùy chọn không được hỗ trợ" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "Dữ liệu đã nén bị hỏng" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "Gặp kết thúc đầu vào bất ngờ" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "Yêu cầu cần có %s MiB bộ nhớ. Nhưng giới hạn bị tắt." + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "Yêu cầu cần có %s MiB bộ nhớ. Nhưng giới hạn là %s." + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s: Móc xích lọc: %s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "Hãy chạy lệnh “%s --help” để xem thông tin thêm." + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the 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 "" +#| "Usage: %s [OPTION]... [FILE]...\n" +#| "Compress or decompress FILEs in the .xz format.\n" +#| "\n" +msgid "Compress or decompress FILEs in the .xz format." +msgstr "" +"Cách dùng: %s [TÙY CHỌN]... [TẬP TIN]...\n" +"Nén hoặc giải nén các TẬP TIN có định dạng .xz.\n" +"\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "Các tùy chọn dài bắt buộc phải có đối số thì với tùy chọn ngắn cũng vậy.\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 " Chế độ thao tác:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "Giải nén:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "Giải nén:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Operation modifiers:\n" +msgid "Operation modifiers:" +msgstr "" +"\n" +" Bộ chỉnh sửa thao tác:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "Gặp lỗi khi ghi dữ liệu vào đầu ra tiêu chuẩn" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| " --single-stream decompress only the first stream, and silently\n" +#| " ignore possible remaining input data" +msgid "decompress only the first stream, and silently ignore possible remaining input data" +msgstr "" +" --single-stream chỉ giải nén luồng dữ liệu đầu, và bỏ qua\n" +" dữ liệu đầu vào còn lại có thể" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Basic file format and compression options:\n" +msgid "Basic file format and compression options:" +msgstr "" +"\n" +" Các tùy chọn về định dạng và nén cơ bản:\n" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 không thẩm tra tính toàn vẹn khi giải nén" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -0 ... -9 compression preset; default is 6; take compressor *and*\n" +#| " decompressor memory usage into account before using 7-9!" +msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!" +msgstr "" +" -0 ... -9 đặt mức nén; mặc định là 6; tiêu dùng nhiều bộ nhớ khi nén\n" +" và giải nén, nên tính toán trước khi dùng 7-9!" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -e, --extreme try to improve compression ratio by using more CPU time;\n" +#| " does not affect decompressor memory requirements" +msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements" +msgstr "" +" -e, --extreme cố gắng nâng cao mức nén bằng cách dùng nhiều CPU hơn;\n" +" nhưng không yêu cần nhiều bộ nhớ khi giải nén" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -T, --threads=NUM use at most NUM threads; the default is 0 which uses\n" +#| " as many threads as there are processor cores" +msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores" +msgstr "" +" -T, --threads=SỐ dùng tối đa là SỐ tuyến trình; mặc định là 0 ý là\n" +" dùng số lượng bằng số lõi vi xử lý" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-size=SIZE\n" +#| " start a new .xz block after every SIZE bytes of input;\n" +#| " use this to set the block size for threaded compression" +msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression" +msgstr "" +" --block-size=CỠ\n" +" bắt đầu một khối .xz mới sau mỗi CỠ byte của đầu vào;\n" +" dùng tùy chọn này để đặt cỡ khối cho nén tuyến trình" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-list=BLOCKS\n" +#| " start a new .xz block after the given comma-separated\n" +#| " intervals of uncompressed data; optionally, specify a\n" +#| " filter chain number (0-9) followed by a ':' before the\n" +#| " uncompressed data size" +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 "" +" --block-list=CỠ\n" +" bắt đầu một khối .xz mới sau một danh sách ngăn\n" +" cách bằng dấu phẩy nhịp dữ của dữ liệu chưa nén; tùy chọn\n" +" chỉ định số móc xích bộ lọc (0-9) theo sau là ':' trước\n" +" kích cỡ dữ liệu chưa nén" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --flush-timeout=TIMEOUT\n" +#| " when compressing, if more than TIMEOUT milliseconds has\n" +#| " passed since the previous flush and reading more input\n" +#| " would block, all pending data is flushed out" +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 "" +" --flush-timeout=THỜI_GIAN_CHỜ\n" +" khi đang nén, nếu đã trải qua hơn THỜI_GIAN_CHỜ milli-giây\n" +" kể từ lần đẩy dữ liệu lên đĩa trước đó và đang đọc thêm\n" +" khối nữa, mọi dữ liệu đang chờ sẽ được ghi lên đĩa" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --no-adjust if compression settings exceed the memory usage limit,\n" +#| " give an error instead of adjusting the settings downwards" +msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards" +msgstr "" +" --no-adjust nếu các cài đặt nén vượt quá giới hạn dùng bộ nhớ,\n" +" đưa ra một lỗi thay vì sửa đổi các cài đặt xuống" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Custom filter chain for compression (alternative for using presets):" +msgid "Custom filter chain for compression (an alternative to using presets):" +msgstr "" +"\n" +" Móc xích lọc tùy chỉnh cho nén (thay cho việc dùng chỉnh trước):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| " --filters=FILTERS set the filter chain using the liblzma filter string\n" +#| " syntax; use --filters-help for more information" +msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information" +msgstr "" +"\n" +" --filters=CÁC_BỘ_LỌC đặt móc xích bộ lọc sử dụng cú pháp chuỗi bộ lọc\n" +" liblzma dùng để biết thêm chi tiết" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --filters1=FILTERS ... --filters9=FILTERS\n" +#| " set additional filter chains using the liblzma filter\n" +#| " string syntax to use with --block-list" +msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list" +msgstr "" +" --filters1=CÁC_BỘ_LỌC ... --filters9=CÁC_BỘ_LỌC\n" +" đặt móc xích lọc thêm sử dụng cú pháp chuỗi bộ lọc\n" +" liblzma để dùng với --block-list" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --filters-help display more information about the liblzma filter string\n" +#| " syntax and exit." +msgid "display more information about the liblzma filter string syntax and exit" +msgstr "" +" --filters-help hiển thị thêm thông tin về cú pháp bộ lọc liblzma\n" +" rồi thoát." + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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:" +msgid "number of position bits" +msgstr "Số luồng bộ xử lý:" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "Giải nén:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Other options:\n" +msgid "Other options:" +msgstr "" +"\n" +" Tùy chọn khác:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 làm cho các cảnh báo không ảnh hưởng đến\n" +" trạng thái thoát" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 dùng các thông báo mà máy có thể phân tích\n" +" (hữu dụng với scripts)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --info-memory display the total amount of RAM and the currently active\n" +#| " memory usage limits, and exit" +msgid "display the total amount of RAM and the currently active memory usage limits, and exit" +msgstr "" +" --info-memory hiển thị tổng lượng RAM và mức giới hạn tiêu dùng\n" +" bộ nhớ hiện tại, rồi thoát" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 hiển thị số phiên bản và thoát" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| "With no FILE, or when FILE is -, read standard input.\n" +msgid "With no FILE, or when FILE is -, read standard input." +msgstr "" +"\n" +"Không có TẬP_TIN, hoặc TẬP_TIN là “-”, thì đọc đầu vào tiêu chuẩn.\n" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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" +msgid "Report bugs to <%s> (in English or Finnish)." +msgstr "" +"Hãy báo cáo lỗi cho <%s> (bằng tiếng Anh hoặc Phần Lan).\n" +"Thông báo lỗi dịch cho: .\n" + +#. 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 interpreted as a zero-width space (the 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 "Trang chủ %s: <%s>.\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "ĐÂY LÀ PHIÊN BẢN PHÁT TRIỂN VÀ NÓ KHÔNG PHÙ HỢP VỚI MỤC ĐÍCH SẢN XUẤT." + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "Filter chains are set using the --filters=FILTERS or\n" +#| "--filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain\n" +#| "can be separated by spaces or '--'. Alternatively a preset <0-9>[e] can be\n" +#| "specified instead of a filter chain.\n" +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 "" +"Các móc xích lọc được đặt bằng --filters=CÁC_BỘ_LỌC hoặc các tùy chọn\n" +"--filters1=CÁC_BỘ_LỌC ... --filters9=CÁC_BỘ_LỌC. Mỗi bộ lọc trong chuỗi\n" +"có thể được ngăn cách bằng khoảng trắng hoặc '--'. Cách khác là dùng <0-9>[e]\n" +"để chỉ định thay thay cho móc xích lọc.\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "Các bộ lọc và các tùy chọn của chúng được hỗ trợ là:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Options must be 'name=value' pairs separated with commas" +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "%s: Các tùy chọn phải là các cặp “tên=giá_trị” ngăn cách nhau bằng dấu phẩy" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s: Tên tùy chọn không hợp lệ" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option value" +msgid "Invalid option value" +msgstr "%s: Giá trị của tùy chọn không hợp lệ" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "Hiện nay chưa hỗ trợ LZMA1/LZMA2: %s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "Tổng số lượng lc và lp không được vượt quá 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s: Tên tập tin có phần hậu tố chưa biết nên bỏ qua" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s: Tập tin đã sẵn có hậu tố “%s” nên bỏ qua" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s: Hậu tố tên tập tin không hợp lệ" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Value is not a non-negative decimal integer" +msgid "Value is not a non-negative decimal integer" +msgstr "%s: Giá trị không phải là số thập phân nguyên không âm" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s: Hậu tố (đơn vị) nhân tố không hợp lệ" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "Các hậu tố (đơn vị) hợp lệ là “KiB” (2^10), “MiB” (2^20), và “GiB” (2^30)." + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "Giá trị của tùy chọn “%s” phải nằm trong vùng [%, %]" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "Dữ liệu đã nén không thể đọc từ thiết bị cuối" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "Dữ liệu đã nén không thể ghi ra thiết bị cuối" + +#: src/lzmainfo/lzmainfo.c +#, fuzzy, c-format +#| msgid "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Usage: %s [--help] [--version] [FILE]...\n" +msgstr "" +"Cách dùng: %s [--help] [--version] [TẬP TIN]...\n" +"Hiển thị thông tin được lưu trong phần đầu của tập tin .lzma" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-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 "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Show information stored in the .lzma file header." +msgstr "" +"Cách dùng: %s [--help] [--version] [TẬP TIN]...\n" +"Hiển thị thông tin được lưu trong phần đầu của tập tin .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "Tập tin quá nhỏ để có thể là một tin .lzma" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "Không phải là một tập tin .lzma" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "Gặp lỗi khi ghi dữ liệu vào đầu ra tiêu chuẩn" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "Lỗi chưa biết" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported options" +msgid "Unsupported preset" +msgstr "Tùy chọn không được hỗ trợ" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported filter chain or filter options" +msgid "Unsupported flag in the preset" +msgstr "Không hỗ trợ lọc móc xích hay tùy chọn lọc" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option name" +msgid "Unknown option name" +msgstr "%s: Tên tùy chọn không hợp lệ" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid multiplier suffix" +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "%s: Hậu tố (đơn vị) nhân tố không hợp lệ" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Unknown file format type" +msgid "Unknown filter name" +msgstr "%s: Không hiểu kiểu định dạng tập tin" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "LZMA1 cannot be used with the .xz format" +msgid "This filter cannot be used in the .xz format" +msgstr "LZMA1 không thể được dùng với định dạng .xz" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Maximum number of filters is four" +msgid "The maximum number of filters is four" +msgstr "Số lượng bộ lọc tối đa là bốn" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" + +#~ msgid "" +#~ " -z, --compress force compression\n" +#~ " -d, --decompress force decompression\n" +#~ " -t, --test test compressed file integrity\n" +#~ " -l, --list list information about .xz files" +#~ msgstr "" +#~ " -z, --compress ép buộc nén\n" +#~ " -d, --decompress ép buộc giải nén\n" +#~ " -t, --test kiểm tra tính toàn vẹn của tập tin nén\n" +#~ " -l, --list liệt kê các thông tin về tập tin .xz" + +#~ msgid "" +#~ " -k, --keep keep (don't delete) input files\n" +#~ " -f, --force force overwrite of output file and (de)compress links\n" +#~ " -c, --stdout write to standard output and don't delete input files" +#~ msgstr "" +#~ " -k, --keep giữ lại (đừng xóa) tập tin đầu vào\n" +#~ " -f, --force buộc ghi đè tập tin đầu ra và (giải) nén các liên kết\n" +#~ " -c, --stdout ghi ra đầu ra tiêu chuẩn và không xóa tập tin đầu vào" + +#~ msgid "" +#~ " --no-sparse do not create sparse files when decompressing\n" +#~ " -S, --suffix=.SUF use the suffix '.SUF' on compressed files\n" +#~ " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~ " omitted, filenames are read from the standard input;\n" +#~ " filenames must be terminated with the newline character\n" +#~ " --files0[=FILE] like --files but use the null character as terminator" +#~ msgstr "" +#~ " --no-sparse đừng tạo các tập tin rải rác khi giải nén\n" +#~ " -S, --suffix=.ĐUÔI dùng hậu tố “.ĐUÔI” trên các tập tin nén\n" +#~ " --files[=TẬP-TIN] đọc các tập tin cần xử lý từ TẬP-TIN; nếu không có\n" +#~ " TẬP-TIN thì tên tập tin sẽ được đọc vào từ đầu vào tiêu\n" +#~ " chuẩn; chúng phải được kết thúc bằng ký tự dòng mới\n" +#~ " --files0[=TẬP-TIN] giống --files nhưng ký tự kết thúc là null" + +#~ msgid "" +#~ " -F, --format=FMT file format to encode or decode; possible values are\n" +#~ " 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'\n" +#~ " -C, --check=CHECK integrity check type: 'none' (use with caution),\n" +#~ " 'crc32', 'crc64' (default), or 'sha256'" +#~ msgstr "" +#~ " -F, --format=ĐDạng định dạng tập tin cần mã hóa hoặc giải mã; giá trị có thể\n" +#~ " là “auto” (mặc định), “xz”, “lzma”, “lzip”, và “raw”\n" +#~ " -C, --check=KIỂM kiểu kiểm tra toàn vẹn: “none” (thận trọng khi dùng),\n" +#~ " “crc32”, “crc64” (mặc định), hay “sha256”" + +#, no-c-format +#~ msgid "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " --memlimit-mt-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " set memory usage limit for compression, decompression,\n" +#~ " threaded decompression, or all of these; LIMIT is in\n" +#~ " bytes, % of RAM, or 0 for defaults" +#~ msgstr "" +#~ " --memlimit-compress=GIỚI_HẠN\n" +#~ " --memlimit-decompress=GIỚI_HẠN\n" +#~ " --memlimit-mt-decompress=GIỚI_HẠN\n" +#~ " -M, --memlimit=GIỚI_HẠN\n" +#~ " đặt mức giới hạn dùng bộ nhớ cho việc nén, giải nén,\n" +#~ " giải nén tuyến trình, hoặc tất cả; GIỚI_HẠN có đơn vị là\n" +#~ " byte, % của RAM, hay 0 cho mặc định" + +#~ msgid "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1 or LZMA2; OPTS is a comma-separated list of zero or\n" +#~ " --lzma2[=OPTS] more of the following options (valid values; default):\n" +#~ " preset=PRE reset options to a preset (0-9[e])\n" +#~ " dict=NUM dictionary size (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NUM number of literal context bits (0-4; 3)\n" +#~ " lp=NUM number of literal position bits (0-4; 0)\n" +#~ " pb=NUM number of position bits (0-4; 2)\n" +#~ " mode=MODE compression mode (fast, normal; normal)\n" +#~ " nice=NUM nice length of a match (2-273; 64)\n" +#~ " mf=NAME match finder (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM maximum search depth; 0=automatic (default)" +#~ msgstr "" +#~ "\n" +#~ " --lzma1[=CTC] LZMA1 hay LZMA2; CÁC-TÙY-CHỌN là danh sách của không hoặc\n" +#~ " --lzma2[=CTC] hơn các tùy chọn sau đây (giá trị hợp lệ; mặc định):\n" +#~ " preset=PRE các tùy chọn tối ưu nén (0-9[e])\n" +#~ " dict=SỐ cỡ từ điển (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=SỐ số bít ngữ cảnh văn bản (0-4; 3)\n" +#~ " lp=SỐ số bít vị trí văn bản (0-4; 0)\n" +#~ " pb=SỐ số bít vị trí (0-4; 2)\n" +#~ " mode=CHẾ_ĐỘ chế độ nén (fast, normal; normal)\n" +#~ " nice=SỐ chiều dài “tốt” của khớp (2-273; 64)\n" +#~ " mf=TÊN bộ tìm khớp (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=SỐ mức sâu tìm kiếm tối đa; 0=tự động (mặc định)" + +#~ msgid "" +#~ "\n" +#~ " --x86[=OPTS] x86 BCJ filter (32-bit and 64-bit)\n" +#~ " --arm[=OPTS] ARM BCJ filter\n" +#~ " --armthumb[=OPTS] ARM-Thumb BCJ filter\n" +#~ " --arm64[=OPTS] ARM64 BCJ filter\n" +#~ " --powerpc[=OPTS] PowerPC BCJ filter (big endian only)\n" +#~ " --ia64[=OPTS] IA-64 (Itanium) BCJ filter\n" +#~ " --sparc[=OPTS] SPARC BCJ filter\n" +#~ " --riscv[=OPTS] RISC-V BCJ filter\n" +#~ " Valid OPTS for all BCJ filters:\n" +#~ " start=NUM start offset for conversions (default=0)" +#~ msgstr "" +#~ "\n" +#~ " --x86[=OPTS] bộ lọc x86 BCJ (32-bit và 64-bit)\n" +#~ " --arm[=OPTS] bộ lọc ARM BCJ\n" +#~ " --armthumb[=OPTS] bộ lọc ARM-Thumb BCJ\n" +#~ " --arm64[=OPTS] bộ lọc ARM64 BCJ\n" +#~ " --powerpc[=OPTS] bộ lọc PowerPC BCJ (chỉ big endian)\n" +#~ " --ia64[=OPTS] bộ lọc IA-64 (Itanium) BCJ\n" +#~ " --sparc[=OPTS] bộ lọc SPARC BCJ\n" +#~ " --riscv[=OPTS] bộ lọc RISC-V BCJ\n" +#~ " các tùy chọn hợp lệ cho mọi bộ lọc BCJ:\n" +#~ " start=SỐ khoảng bù khởi đầu cho chuyển đổi (mặc định=0)" + +#~ msgid "" +#~ "\n" +#~ " --delta[=OPTS] Delta filter; valid OPTS (valid values; default):\n" +#~ " dist=NUM distance between bytes being subtracted\n" +#~ " from each other (1-256; 1)" +#~ msgstr "" +#~ "\n" +#~ " --delta[=OPTS] bộ lọc Delta;\n" +#~ " CÁC-TÙY-CHỌN hợp lệ (giá trị hợp lệ; mặc định):\n" +#~ " dist=SỐ khoảng cách giữa các byte được trừ từ\n" +#~ " những cái khác (1-256; 1)" + +#~ msgid "" +#~ " -q, --quiet suppress warnings; specify twice to suppress errors too\n" +#~ " -v, --verbose be verbose; specify twice for even more verbose" +#~ msgstr "" +#~ " -q, --quiet không xuất các cảnh báo;\n" +#~ " chỉ định hai lần nến bạn muốn chặn cả báo lỗi\n" +#~ " -v, --verbose thông báo chi tiết; dùng hai lần nếu muốn chi tiết hơn" + +#~ msgid "" +#~ " -h, --help display the short help (lists only the basic options)\n" +#~ " -H, --long-help display this long help and exit" +#~ msgstr "" +#~ " -h, --help hiển thị trợ giúp dạng ngắn gọn\n" +#~ " (chỉ liệt kê các tùy chọn cơ bản)\n" +#~ " -H, --long-help hiển thị trợ giúp đầy đủ rồi thoát" + +#~ msgid "" +#~ " -h, --help display this short help and exit\n" +#~ " -H, --long-help display the long help (lists also the advanced options)" +#~ msgstr "" +#~ " -h, --help hiển thị trợ giúp dạng ngắn gọn rồi thoát\n" +#~ " -H, --long-help hiển thị trợ giúp đầy đủ\n" +#~ " (liệt kê cả những tùy chọn cấp cao)" + +#~ msgid "Failed to enable the sandbox" +#~ msgstr "Không bật được sandbox" + +#~ msgid "Memory usage limit for compression: " +#~ msgstr "Mức giới hạn dùng bộ nhớ cho nén: " + +#~ msgid " Streams: %s\n" +#~ msgstr " Luồng dữ liệu: %s\n" + +#~ msgid " Blocks: %s\n" +#~ msgstr " Khối: %s\n" + +#~ msgid " Ratio: %s\n" +#~ msgstr " Tỷ lệ nén: %s\n" + +#~ msgid " Check: %s\n" +#~ msgstr " Kiểm tra: %s\n" + +#~ msgid "" +#~ " Streams:\n" +#~ " Stream Blocks CompOffset UncompOffset CompSize UncompSize Ratio Check Padding" +#~ msgstr "" +#~ " Luồng dữ liệu:\n" +#~ " Luồng Khối BùNén BùGiảiNén CỡNén CỡGiảiNén TỷLệ Ktra Đệm" + +#~ msgid "" +#~ " Blocks:\n" +#~ " Stream Block CompOffset UncompOffset TotalSize UncompSize Ratio Check" +#~ msgstr "" +#~ " Khối:\n" +#~ " Luồng Khối BùNén BùGiảiNén CỡTổng CỡGiảiNén TỷLệ Ktra" + +#~ msgid " CheckVal %*s Header Flags CompSize MemUsage Filters" +#~ msgstr " GTrịKiểm %*s Đầu Cờ CỡNén DùngRAM BộLọc" + +#~ msgid "The selected match finder requires at least nice=%" +#~ msgstr "Bộ tìm khớp đã chọn yêu cầu mức “tốt” ít nhất là nice=%" + +#~ msgid "Error setting O_NONBLOCK on standard input: %s" +#~ msgstr "Lỗi cài đặt O_NONBLOCK trên đầu vào tiêu chuẩn: %s" + +#~ msgid "Error setting O_NONBLOCK on standard output: %s" +#~ msgstr "Lỗi cài đặt O_NONBLOCK trên đầu ra tiêu chuẩn: %s" + +#~ msgid "" +#~ " --block-size=SIZE\n" +#~ " when compressing to the .xz format, start a new block\n" +#~ " after every SIZE bytes of input; 0=disabled (default)" +#~ msgstr "" +#~ " --block-size=CỠ\n" +#~ " khi nén thành định dạng .xz, bắt đầu khối mới\n" +#~ " sau mỗi SỐ byte đầu vào; 0=tắt (mặc định)" diff --git a/cpp/third_party/xz-5.8.3/po/xz.pot b/cpp/third_party/xz-5.8.3/po/xz.pot new file mode 100644 index 0000000000..01e8484062 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/xz.pot @@ -0,0 +1,1264 @@ +# SPDX-License-Identifier: 0BSD +# +# SOME DESCRIPTIVE TITLE. +# Copyright (C) The XZ Utils authors and contributors +# This file is published under the BSD Zero Clause License. +# FIRST AUTHOR , YEAR. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: xz 5.8.3\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\n" +"POT-Creation-Date: 2026-03-27 18:13+0200\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"Language: \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=CHARSET\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=INTEGER; plural=EXPRESSION;\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "" + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "" + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "" + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr "" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "" + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "" + +#: src/xz/list.c +msgid "Streams:" +msgstr "" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "" + +#: src/xz/list.c +msgid "Check:" +msgstr "" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "" + +#: src/xz/list.c +msgid "Stream" +msgstr "" + +#: src/xz/list.c +msgid "Block" +msgstr "" + +#: src/xz/list.c +msgid "Blocks" +msgstr "" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "" + +#: src/xz/list.c +msgid "CompSize" +msgstr "" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "" + +#: src/xz/list.c +msgid "Ratio" +msgstr "" + +#: src/xz/list.c +msgid "Check" +msgstr "" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "" + +#: src/xz/list.c +msgid "Padding" +msgstr "" + +#: src/xz/list.c +msgid "Header" +msgstr "" + +#: src/xz/list.c +msgid "Flags" +msgstr "" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "" + +#: src/xz/list.c +msgid "Filters" +msgstr "" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr "" + +#: src/xz/list.c +msgid "Yes" +msgstr "" + +#: src/xz/list.c +msgid "No" +msgstr "" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "" +msgstr[1] "" + +#: src/xz/list.c +msgid "Totals:" +msgstr "" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "" + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "" + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "" + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "" + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "" + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "" + +#. 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 interpreted as a zero-width space (the 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 "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 "" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "" + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "" + +#: src/lzmainfo/lzmainfo.c +#, c-format +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 interpreted as a zero-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 "" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" diff --git a/cpp/third_party/xz-5.8.3/po/xz.pot-header b/cpp/third_party/xz-5.8.3/po/xz.pot-header new file mode 100644 index 0000000000..6d277c90f2 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/xz.pot-header @@ -0,0 +1,7 @@ +# SPDX-License-Identifier: 0BSD +# +# SOME DESCRIPTIVE TITLE. +# Copyright (C) The XZ Utils authors and contributors +# This file is published under the BSD Zero Clause License. +# FIRST AUTHOR , YEAR. +# diff --git a/cpp/third_party/xz-5.8.3/po/zh_CN.gmo b/cpp/third_party/xz-5.8.3/po/zh_CN.gmo new file mode 100644 index 0000000000..b9206e4583 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/zh_CN.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/zh_CN.po b/cpp/third_party/xz-5.8.3/po/zh_CN.po new file mode 100644 index 0000000000..b31aa378c9 --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/zh_CN.po @@ -0,0 +1,1650 @@ +# SPDX-License-Identifier: 0BSD +# +# xz 软件包的简体中文翻译。 +# Chinese translations for xz package +# This file is published under the BSD Zero Clause License. +# Boyuan Yang <073plan@gmail.com>, 2019, 2022, 2023, 2024. +# Mingye Wang , 2024. +# +msgid "" +msgstr "" +"Project-Id-Version: xz-5.6.0-pre2\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\n" +"POT-Creation-Date: 2026-03-30 17:13+0300\n" +"PO-Revision-Date: 2024-08-27 13:08+0800\n" +"Last-Translator: Mingye Wang (Artoria2e5) \n" +"Language-Team: Chinese (simplified) \n" +"Language: zh_CN\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.4.4\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s:--block-list 的无效参数" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s:--block-list 得到过多参数" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "在 --block-list 中,块大小在过滤器链编号 '%c:' 之后缺失" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 仅可用于 --block-list 的最后一个元素" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s:未知文件格式类型" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s:不支持的完整性检查类型" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "仅可使用 '--files' 或 '--files0' 指定单个文件。" + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s:%s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "环境变量 %s 包含过多参数" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "压缩支持已在构建时禁用" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "解压支持已在构建时禁用" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "不支持对 lzip 文件 (.lz) 的压缩" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "除非压缩为 .xz 格式,--block-list 将被忽略" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "启用 --format-raw 选项时,必须指定 --suffix=.SUF 获知写入至标准输出" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "过滤器最多数量为四" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "在 --filters%s=过滤器 选项中出现错误:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "内存用量限制对指定过滤器设置过低。" + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "--block-list 使用了过滤器链 %u,但未经由 --filters%u= 指定" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "不推荐在 raw 模式使用预设等级。" + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "各个预设等级所使用的准确选项列表在不同软件版本之间可能不同。" + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr ".lzma 格式只支持 LZMA1 过滤器" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 无法用于 .xz 格式" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "过滤器链 %u 和 --flush-timeout 不兼容" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "因 --flush-timeout 而切换至单线程模式" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "过滤器链 %u 中存在不支持的选项" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "使用最多 % 个线程。" + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "不支持的过滤器链或过滤器选项" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "解压缩需要 %s MiB 的内存。" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "已将所使用的线程数从 %s 减小为 %s,以不超出 %s MiB 的内存用量限制" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "已将所使用的线程数从 %s 减小为 1。这仍然超出了自动的内存使用限制 %s MiB。需要 %s MiB 的内存。继续操作。" + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "正在切换到单线程模式以不超出 %s MiB 的内存用量限制" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "已调整 LZMA%c 字典大小(从 %s MiB 调整为 %s MiB),以不超出 %s MiB 的内存用量限制" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "已调整 --filters%2$u LZMA%1$c 字典大小(从 %3$s MiB 调整为 %4$s MiB),以不超出 %5$s MiB 的内存用量限制" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "更改为过滤器链 %u 时出错:%s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "创建管道时出错:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s:poll() 失败:%s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s:文件似乎已移动,不再进行删除操作" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s:无法删除:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s:无法设置文件所有者:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s:无法设置文件所有组:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s:无法设置文件权限:%s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s:关闭文件失败:%s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s:关闭文件失败:%s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "从标准输入获取文件状态标志出错:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s:是符号链接,跳过" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s:是目录,跳过" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s:不是标准文件,跳过" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s:文件有设置用户ID或设置组ID标识,跳过" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s:文件有粘滞位标识,跳过" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s:输入文件有多于一个硬链接,跳过" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "空文件名,跳过" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "回复标准输入的状态标志时出错:%s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "获取标准输出的文件状态标志时出错:%s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Closing the file failed: %s" +msgid "%s: Opening the directory failed: %s" +msgstr "%s:关闭文件失败:%s" + +#: src/xz/file_io.c +#, fuzzy, c-format +#| msgid "%s: Not a regular file, skipping" +msgid "%s: Destination is not a regular file" +msgstr "%s:不是标准文件,跳过" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "恢复标准输出的 O_APPEND 标志时出错:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s:关闭文件失败:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s:尝试创建稀疏文件时 seek 失败:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s:读取错误:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s:seek 文件时出错:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s:未预期的文件结束" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s:写入错误:%s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "已禁用" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "物理内存(RAM)用量:" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "处理器线程数:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "压缩:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "解压缩:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "多线程解压缩:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "-T0 的默认值:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "硬件信息:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "内存使用限制:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "流:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "块:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "压缩后大小:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "解压缩大小:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "比例:" + +#: src/xz/list.c +msgid "Check:" +msgstr "校验:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "流填充大小:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "所需内存:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "头部存放大小:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "文件数量:" + +#: src/xz/list.c +msgid "Stream" +msgstr "流" + +#: src/xz/list.c +msgid "Block" +msgstr "块" + +#: src/xz/list.c +msgid "Blocks" +msgstr "块" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "压缩偏移量" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "解压偏移量" + +#: src/xz/list.c +msgid "CompSize" +msgstr "压缩后大小" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "解压缩大小" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "总大小" + +#: src/xz/list.c +msgid "Ratio" +msgstr "比例" + +#: src/xz/list.c +msgid "Check" +msgstr "校验" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "校验值" + +#: src/xz/list.c +msgid "Padding" +msgstr "填充" + +#: src/xz/list.c +msgid "Header" +msgstr "头部" + +#: src/xz/list.c +msgid "Flags" +msgstr "标志" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "内存用量" + +#: src/xz/list.c +msgid "Filters" +msgstr "过滤器" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "无" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "未知-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "未知-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "未知-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "未知-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "未知-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "未知-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "未知-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "未知-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "未知-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "未知-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "未知-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "未知-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s:文件为空" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s:过小,不可能是有效的 .xz 文件" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr " 流 块 压缩大小 解压大小 比例 校验 文件名" + +#: src/xz/list.c +msgid "Yes" +msgstr "是" + +#: src/xz/list.c +msgid "No" +msgstr "否" + +#: src/xz/list.c +#, fuzzy +#| msgid " Minimum XZ Utils version: %s\n" +msgid "Minimum XZ Utils version:" +msgstr " 最低 XZ Utils 版本:%s\n" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s 文件\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "总计:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list 仅适用于 .xz 文件(--format=xz 或 --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "试试用“lzmainfo”处理 .lzma 文件。" + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list 不支持从标准输入读取" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s:读取文件名列表时出错:%s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s:读取文件名列表时遇到未预期的输入结束" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s:读取文件名列表时获得了空字符;您可能想要使用 '--files0' 而非 '--files'?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "尚不支持带 --robot 的压缩和解压缩。" + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "无法同时从标准输入读取数据和文件名列表" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s:" + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "内部错误(bug)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "无法建立信号处理器" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "无完整性检查;将不验证文件完整性" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "不支持的完整性检查类型;将不验证文件完整性" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "达到内存使用限制" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "无法识别文件格式" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "不支持的选项" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "压缩数据已损坏" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "输入意外结束" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "需要 %s MiB 的内存空间。限制已禁用。" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "需要 %s MiB 的内存空间。限制为 %s。" + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s:过滤器链:%s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "请尝试执行 '%s --help' 来获取更多信息。" + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "" + +#: src/xz/message.c +#, c-format +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 interpreted as a zero-width space (the 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 "" +#| "Usage: %s [OPTION]... [FILE]...\n" +#| "Compress or decompress FILEs in the .xz format.\n" +#| "\n" +msgid "Compress or decompress FILEs in the .xz format." +msgstr "" +"用法:%s [选项]... [文件]...\n" +"使用 .xz 格式压缩或解压缩文件。\n" +"\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "必选参数对长短选项同时适用。\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 " 操作模式:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "解压缩:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "解压缩:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Operation modifiers:\n" +msgid "Operation modifiers:" +msgstr "" +"\n" +" 操作修饰符:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "写入标准输出失败" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| " --single-stream decompress only the first stream, and silently\n" +#| " ignore possible remaining input data" +msgid "decompress only the first stream, and silently ignore possible remaining input data" +msgstr " --single-stream 仅解压缩第一个流,忽略其后可能继续出现的输入数据" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid ".SUF" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "FILE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Basic file format and compression options:\n" +msgid "Basic file format and compression options:" +msgstr "" +"\n" +" 基本文件格式和压缩选项:\n" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "" + +#: src/xz/message.c +msgid "NAME" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 解压缩时不要进行完整性检查验证" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -0 ... -9 compression preset; default is 6; take compressor *and*\n" +#| " decompressor memory usage into account before using 7-9!" +msgid "compression preset; default is 6; take compressor *and* decompressor memory usage into account before using 7-9!" +msgstr "" +" -0 ... -9 压缩预设等级;默认为 6;使用 7-9 的等级之前,请先考虑\n" +" 压缩和解压缩所需的内存用量!(会占用大量内存空间)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -e, --extreme try to improve compression ratio by using more CPU time;\n" +#| " does not affect decompressor memory requirements" +msgid "try to improve compression ratio by using more CPU time; does not affect decompressor memory requirements" +msgstr "" +" -e, --extreme 尝试使用更多 CPU 时间来改进压缩比率;\n" +" 不会影响解压缩的内存需求量" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " -T, --threads=NUM use at most NUM threads; the default is 0 which uses\n" +#| " as many threads as there are processor cores" +msgid "use at most NUM threads; the default is 0 which uses as many threads as there are processor cores" +msgstr "" +" -T, --threads=数量 使用最多指定数量的线程;默认值为 0,即\n" +" 可以使用与处理器内核数量相同的线程数" + +#: src/xz/message.c +msgid "SIZE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-size=SIZE\n" +#| " start a new .xz block after every SIZE bytes of input;\n" +#| " use this to set the block size for threaded compression" +msgid "start a new .xz block after every SIZE bytes of input; use this to set the block size for threaded compression" +msgstr "" +" --block-size=块大小\n" +" 输入每读取指定块大小的数据后即开始一个新的 .xz 块;\n" +" 使用该选项可以设置多线程压缩中的块大小" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --block-list=BLOCKS\n" +#| " start a new .xz block after the given comma-separated\n" +#| " intervals of uncompressed data; optionally, specify a\n" +#| " filter chain number (0-9) followed by a ':' before the\n" +#| " uncompressed data size" +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 "" +" --block-list=块大小列表\n" +" 在所给出的未压缩数据间隔大小的数据之后开始一个新的\n" +" .xz 块(使用逗号分隔)\n" +" 可选:在未压缩大小之前提供一个过滤器链号(0-9),用\n" +" “:”和大小分开" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --flush-timeout=TIMEOUT\n" +#| " when compressing, if more than TIMEOUT milliseconds has\n" +#| " passed since the previous flush and reading more input\n" +#| " would block, all pending data is flushed out" +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 "" +" --flush-timeout=超时时间\n" +" 进行压缩时,如果从上次刷洗输出之后经过了指定的超时时间\n" +" 且读取更多数据会被阻塞,则刷洗输出所有缓冲数据" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 interpreted as a zero-width space (the 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 "" +#| " --no-adjust if compression settings exceed the memory usage limit,\n" +#| " give an error instead of adjusting the settings downwards" +msgid "if compression settings exceed the memory usage limit, give an error instead of adjusting the settings downwards" +msgstr " --no-adjust 如果压缩设置超出内存用量限制,不调整设置而直接报错" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Custom filter chain for compression (alternative for using presets):" +msgid "Custom filter chain for compression (an alternative to using presets):" +msgstr "" +"\n" +" 用于压缩的自定义过滤器链(不使用预设等级时的备选用法):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| " --filters=FILTERS set the filter chain using the liblzma filter string\n" +#| " syntax; use --filters-help for more information" +msgid "set the filter chain using the liblzma filter string syntax; use --filters-help for more information" +msgstr "" +"\n" +"--filters=FILTERS 使用 liblzma 过滤器字符串语法设置过滤器链\n" +" 使用 --filters-help 了解更多信息" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --filters1=FILTERS ... --filters9=FILTERS\n" +#| " set additional filter chains using the liblzma filter\n" +#| " string syntax to use with --block-list" +msgid "set additional filter chains using the liblzma filter string syntax to use with --block-list" +msgstr "" +"--filters1=过滤器 ... --filters9=过滤器\n" +" 使用 liblzma 过滤器语法设置其他过滤器链,\n" +" 与 --block-list 一起使用的" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --filters-help display more information about the liblzma filter string\n" +#| " syntax and exit." +msgid "display more information about the liblzma filter string syntax and exit" +msgstr "" +"--filters-help 显示有关 liblzma 过滤器字符串语法的更多信息\n" +" 然后退出。" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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:" +msgid "number of position bits" +msgstr "处理器线程数:" + +#: src/xz/message.c +msgid "MODE" +msgstr "" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "解压缩:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "\n" +#| " Other options:\n" +msgid "Other options:" +msgstr "" +"\n" +" 其它选项:\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 使得警告信息不影响程序退出返回值" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 使用机器可解析的信息(对于脚本有用)" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| " --info-memory display the total amount of RAM and the currently active\n" +#| " memory usage limits, and exit" +msgid "display the total amount of RAM and the currently active memory usage limits, and exit" +msgstr " --info-memory 显示 RAM 总量和当前配置的内存用量限制,然后退出" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 显示软件版本号并退出" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "" +#| "\n" +#| "With no FILE, or when FILE is -, read standard input.\n" +msgid "With no FILE, or when FILE is -, read standard input." +msgstr "" +"\n" +"如果没有指定文件,或者文件为\"-\",则从标准输入读取。\n" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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" +msgid "Report bugs to <%s> (in English or Finnish)." +msgstr "" +"请使用英文或芬兰语向 <%s> 报告软件错误。\n" +"请使用中文向 TP 简体中文翻译团队 \n" +"报告软件的简体中文翻译错误。\n" + +#. 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 interpreted as a zero-width space (the 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 主页:<%s>\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "" +#| "Filter chains are set using the --filters=FILTERS or\n" +#| "--filters1=FILTERS ... --filters9=FILTERS options. Each filter in the chain\n" +#| "can be separated by spaces or '--'. Alternatively a preset <0-9>[e] can be\n" +#| "specified instead of a filter chain.\n" +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=FILTERS 或\n" +"--filters1=FILTER … --filters9=FILTER选项。链中的每个过滤器\n" +"可以用空格或“--”分隔。或者可以指定预设 <0-9>[e]\n" +"而不是过滤器链。\n" +"\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "支持的筛选器及其选项包括:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Options must be 'name=value' pairs separated with commas" +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "%s:选项必须按照 '名称=值' 的格式成对出现,使用半角逗号分隔" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s:无效的选项名称" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option value" +msgid "Invalid option value" +msgstr "%s:无效的选项值" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "不支持的 LZMA1/LZMA2 预设等级:%s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "lc 和 lp 的和必须不大于 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s:文件名有未知后缀,跳过" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s:文件已有 '%s' 后缀名,跳过" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s:无效的文件名后缀" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Value is not a non-negative decimal integer" +msgid "Value is not a non-negative decimal integer" +msgstr "%s:值不是非负十进制整数" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s:无效的乘数后缀" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "有效的后缀包括“KiB”(2^10)、“MiB”(2^20)和“GiB”(2^30)。" + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "选项“%s”的值必须位于 [%, %] 范围内" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "压缩数据不能从终端读取" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "压缩数据不能向终端写入" + +#: src/lzmainfo/lzmainfo.c +#, fuzzy, c-format +#| msgid "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Usage: %s [--help] [--version] [FILE]...\n" +msgstr "" +"用法:%s [--help] [--version] [文件]...\n" +"显示存储在 .lzma 文件头中的信息" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-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 "" +#| "Usage: %s [--help] [--version] [FILE]...\n" +#| "Show information stored in the .lzma file header" +msgid "Show information stored in the .lzma file header." +msgstr "" +"用法:%s [--help] [--version] [文件]...\n" +"显示存储在 .lzma 文件头中的信息" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "%s:过小,不可能是有效的 .lzma 文件" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "不是 .lzma 文件" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "写入标准输出失败" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "未知错误" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported options" +msgid "Unsupported preset" +msgstr "不支持的选项" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Unsupported filter chain or filter options" +msgid "Unsupported flag in the preset" +msgstr "不支持的过滤器链或过滤器选项" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid option name" +msgid "Unknown option name" +msgstr "%s:无效的选项名称" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Invalid multiplier suffix" +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "%s:无效的乘数后缀" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "%s: Unknown file format type" +msgid "Unknown filter name" +msgstr "%s:未知文件格式类型" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "LZMA1 cannot be used with the .xz format" +msgid "This filter cannot be used in the .xz format" +msgstr "LZMA1 无法用于 .xz 格式" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "" + +#: src/liblzma/common/string_conversion.c +#, fuzzy +#| msgid "Maximum number of filters is four" +msgid "The maximum number of filters is four" +msgstr "过滤器最多数量为四" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "" + +#~ msgid "" +#~ " -z, --compress force compression\n" +#~ " -d, --decompress force decompression\n" +#~ " -t, --test test compressed file integrity\n" +#~ " -l, --list list information about .xz files" +#~ msgstr "" +#~ " -z, --compress 强制压缩\n" +#~ " -d, --decompress 强制解压缩\n" +#~ " -t, --test 测试压缩文件完整性\n" +#~ " -l, --list 列出 .xz 文件的信息" + +#~ msgid "" +#~ " -k, --keep keep (don't delete) input files\n" +#~ " -f, --force force overwrite of output file and (de)compress links\n" +#~ " -c, --stdout write to standard output and don't delete input files" +#~ msgstr "" +#~ " -k, --keep 保留(不要删除)输入文件\n" +#~ " -f, --force 强制覆写输出文件和(解)压缩链接\n" +#~ " -c, --stdout 向标准输出写入,同时不要删除输入文件" + +#~ msgid "" +#~ " --no-sparse do not create sparse files when decompressing\n" +#~ " -S, --suffix=.SUF use the suffix '.SUF' on compressed files\n" +#~ " --files[=FILE] read filenames to process from FILE; if FILE is\n" +#~ " omitted, filenames are read from the standard input;\n" +#~ " filenames must be terminated with the newline character\n" +#~ " --files0[=FILE] like --files but use the null character as terminator" +#~ msgstr "" +#~ " --no-sparse 解压缩时不要创建稀疏文件\n" +#~ " -S, --suffix=.SUF 压缩文件使用指定的“.SUF”后缀名\n" +#~ " --files[=文件] 从指定文件读取要处理的文件名列表;如果省略了指定文件名,\n" +#~ " 将从标准输入读取文件名列表;文件名必须使用换行符分隔、终止\n" +#~ " --files0[=文件] 类似 --files,但使用空(\\0)字符进行分隔" + +#~ msgid "" +#~ " -F, --format=FMT file format to encode or decode; possible values are\n" +#~ " 'auto' (default), 'xz', 'lzma', 'lzip', and 'raw'\n" +#~ " -C, --check=CHECK integrity check type: 'none' (use with caution),\n" +#~ " 'crc32', 'crc64' (default), or 'sha256'" +#~ msgstr "" +#~ " -F, --format=格式 要编码或解码的文件格式;可能的值包括\n" +#~ " “auto”(默认)、“xz”、“lzma”、\n" +#~ " “lzip”和“raw”\n" +#~ " -C, --check=类型 完整性检查类型:“none”(请谨慎使用)、\n" +#~ " “crc32”、“crc64”(默认)或“sha256”" + +#, no-c-format +#~ msgid "" +#~ " --memlimit-compress=LIMIT\n" +#~ " --memlimit-decompress=LIMIT\n" +#~ " --memlimit-mt-decompress=LIMIT\n" +#~ " -M, --memlimit=LIMIT\n" +#~ " set memory usage limit for compression, decompression,\n" +#~ " threaded decompression, or all of these; LIMIT is in\n" +#~ " bytes, % of RAM, or 0 for defaults" +#~ msgstr "" +#~ " --memlimit-compress=限制用量\n" +#~ " --memlimit-decompress=限制用量\n" +#~ " --memlimit-mt-decompress=限制用量\n" +#~ " -M, --memlimit=限制用量\n" +#~ " 设置压缩、解压缩、多线程解压缩或者共同的内存用量限制;\n" +#~ " 所指定限制量单位为字节,或以百分号 % 结尾表示内存比例,\n" +#~ " 或者指定 0 取软件默认值" + +#~ msgid "" +#~ "\n" +#~ " --lzma1[=OPTS] LZMA1 or LZMA2; OPTS is a comma-separated list of zero or\n" +#~ " --lzma2[=OPTS] more of the following options (valid values; default):\n" +#~ " preset=PRE reset options to a preset (0-9[e])\n" +#~ " dict=NUM dictionary size (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=NUM number of literal context bits (0-4; 3)\n" +#~ " lp=NUM number of literal position bits (0-4; 0)\n" +#~ " pb=NUM number of position bits (0-4; 2)\n" +#~ " mode=MODE compression mode (fast, normal; normal)\n" +#~ " nice=NUM nice length of a match (2-273; 64)\n" +#~ " mf=NAME match finder (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=NUM maximum search depth; 0=automatic (default)" +#~ msgstr "" +#~ "\n" +#~ " --lzma1[=选项] LZMA1 或 LZMA2;指定选项是用逗号分隔的下列选项的组合,\n" +#~ " --lzma2[=选项] 值应当为零或大于零(有效值;默认值):\n" +#~ " preset=PRE 将选项重置为预设配置 (0-9[e])\n" +#~ " dict=数字 字典大小 (4KiB - 1536MiB; 8MiB)\n" +#~ " lc=数字 literal context 位的数量 (0-4; 3)\n" +#~ " lp=数字 literal position 位的数量 (0-4; 0)\n" +#~ " pb=数字 position 位的数量 (0-4; 2)\n" +#~ " mode=模式 压缩模式 (fast, normal; normal)\n" +#~ " nice=数字 匹配的 nice 值 (2-273; 64)\n" +#~ " mf=名称 匹配搜索器 match finder\n" +#~ " (hc3, hc4, bt2, bt3, bt4; bt4)\n" +#~ " depth=数字 最大搜索深度; 0=自动(默认)" + +#~ msgid "" +#~ "\n" +#~ " --x86[=OPTS] x86 BCJ filter (32-bit and 64-bit)\n" +#~ " --arm[=OPTS] ARM BCJ filter\n" +#~ " --armthumb[=OPTS] ARM-Thumb BCJ filter\n" +#~ " --arm64[=OPTS] ARM64 BCJ filter\n" +#~ " --powerpc[=OPTS] PowerPC BCJ filter (big endian only)\n" +#~ " --ia64[=OPTS] IA-64 (Itanium) BCJ filter\n" +#~ " --sparc[=OPTS] SPARC BCJ filter\n" +#~ " --riscv[=OPTS] RISC-V BCJ filter\n" +#~ " Valid OPTS for all BCJ filters:\n" +#~ " start=NUM start offset for conversions (default=0)" +#~ msgstr "" +#~ "\n" +#~ " --x86[=选项] x86 BCJ 过滤器(32 位和 64 位)\n" +#~ " --arm[=选项] ARM BCJ 过滤器\n" +#~ " --armthumb[=选项] ARM-Thumb BCJ 过滤器\n" +#~ " --arm64[=选项] ARM64 BCJ 过滤器\n" +#~ " --powerpc[=选项] PowerPC BCJ 过滤器(仅大端序)\n" +#~ " --ia64[=选项] IA-64 (Itanium,安腾) BCJ 过滤器\n" +#~ " --sparc[=选项] SPARC BCJ 过滤器\n" +#~ " --riscv[=选项] RISC-V BCJ 过滤器\n" +#~ " 所有过滤器可用选项:\n" +#~ " start=数字 转换的起始偏移量(默认=0)" + +#~ msgid "" +#~ "\n" +#~ " --delta[=OPTS] Delta filter; valid OPTS (valid values; default):\n" +#~ " dist=NUM distance between bytes being subtracted\n" +#~ " from each other (1-256; 1)" +#~ msgstr "" +#~ "\n" +#~ " --delta[=选项] 增量过滤器;有效选项(有效值;默认值):\n" +#~ " dist=NUM 相减的字节之间的距离 (1-256; 1)" + +#~ msgid "" +#~ " -q, --quiet suppress warnings; specify twice to suppress errors too\n" +#~ " -v, --verbose be verbose; specify twice for even more verbose" +#~ msgstr "" +#~ " -q, --quiet 不显示警告信息;指定两次可不显示错误信息\n" +#~ " -v, --verbose 输出详细信息;指定两次可以输出更详细的信息" + +#~ msgid "" +#~ " -h, --help display the short help (lists only the basic options)\n" +#~ " -H, --long-help display this long help and exit" +#~ msgstr "" +#~ " -h, --help 显示短帮助信息(仅列出基本选项)\n" +#~ " -H, --long-help 显示本长帮助信息" + +#~ msgid "" +#~ " -h, --help display this short help and exit\n" +#~ " -H, --long-help display the long help (lists also the advanced options)" +#~ msgstr "" +#~ " -h, --help 显示本短帮助信息并退出\n" +#~ " -H, --long-help 显示长帮助信息(同时列出高级选项)" + +#~ msgid "Failed to enable the sandbox" +#~ msgstr "沙盒启用失败" + +#~ msgid "The selected match finder requires at least nice=%" +#~ msgstr "所选中的匹配搜索器(match finder)至少需要 nice=%" + +#~ msgid "Sandbox is disabled due to incompatible command line arguments" +#~ msgstr "沙盒已因不兼容的命令行参数而禁用" + +#~ msgid "Sandbox was successfully enabled" +#~ msgstr "已成功启用沙盒" + +#~ msgid "Memory usage limit for compression: " +#~ msgstr "用于压缩的内存用量限制: " + +#~ msgid " Streams: %s\n" +#~ msgstr " 流: %s\n" + +#~ msgid " Blocks: %s\n" +#~ msgstr " 块: %s\n" + +#~ msgid " Ratio: %s\n" +#~ msgstr " 压缩比: %s\n" + +#~ msgid " Check: %s\n" +#~ msgstr " 校验方式: %s\n" + +#~ msgid "" +#~ " Streams:\n" +#~ " Stream Blocks CompOffset UncompOffset CompSize UncompSize Ratio Check Padding" +#~ msgstr "" +#~ " 流:\n" +#~ " 流 块 压缩偏移量 解压偏移量 压缩大小 解压大小 比例 校验 填充" + +#~ msgid "" +#~ " Blocks:\n" +#~ " Stream Block CompOffset UncompOffset TotalSize UncompSize Ratio Check" +#~ msgstr "" +#~ " 块:\n" +#~ " 流 块 压缩偏移量 解压偏移量 总计大小 解压大小 比例 校验" + +#~ msgid " CheckVal %*s Header Flags CompSize MemUsage Filters" +#~ msgstr " CheckVal %*s 头部 标记 压缩大小 内存使用 过滤器" diff --git a/cpp/third_party/xz-5.8.3/po/zh_TW.gmo b/cpp/third_party/xz-5.8.3/po/zh_TW.gmo new file mode 100644 index 0000000000..38ebcdbb81 Binary files /dev/null and b/cpp/third_party/xz-5.8.3/po/zh_TW.gmo differ diff --git a/cpp/third_party/xz-5.8.3/po/zh_TW.po b/cpp/third_party/xz-5.8.3/po/zh_TW.po new file mode 100644 index 0000000000..596e898f4d --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po/zh_TW.po @@ -0,0 +1,1267 @@ +# SPDX-License-Identifier: 0BSD +# +# Chinese translations for xz package. +# This file is published under the BSD Zero Clause License. +# +# Yi-Jyun Pan , 2019, 2023, 2024 +msgid "" +msgstr "" +"Project-Id-Version: xz 5.7.1-dev1\n" +"Report-Msgid-Bugs-To: xz@tukaani.org\n" +"POT-Creation-Date: 2026-03-30 17:13+0300\n" +"PO-Revision-Date: 2025-02-02 00:12+0800\n" +"Last-Translator: Yi-Jyun Pan \n" +"Language-Team: Chinese (traditional) \n" +"Language: zh_TW\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=1; plural=0;\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"X-Generator: Poedit 3.5\n" +"X-Poedit-SourceCharset: UTF-8\n" + +#: src/xz/args.c +#, c-format +msgid "%s: Invalid argument to --block-list" +msgstr "%s:傳入 --block-list 的參數無效" + +#: src/xz/args.c +#, c-format +msgid "%s: Too many arguments to --block-list" +msgstr "%s:傳入 --block-list 的參數過多" + +#: src/xz/args.c +#, c-format +msgid "In --block-list, block size is missing after filter chain number '%c:'" +msgstr "在 --block-list 中,編號「%c:」後方遺漏區塊大小" + +#: src/xz/args.c +msgid "0 can only be used as the last element in --block-list" +msgstr "0 只能作為 --block-list 的最後一個元素" + +#: src/xz/args.c +#, c-format +msgid "%s: Unknown file format type" +msgstr "%s:未知檔案格式類型" + +#: src/xz/args.c +#, c-format +msgid "%s: Unsupported integrity check type" +msgstr "%s:不支援的完整性檢查類型" + +#: src/xz/args.c +msgid "Only one file can be specified with '--files' or '--files0'." +msgstr "「--files」或「--files0」只能指定一個檔案。" + +#. TRANSLATORS: This is a translatable +#. string because French needs a space +#. before the colon ("%s : %s"). +#: src/xz/args.c src/xz/coder.c src/xz/file_io.c src/xz/list.c src/xz/options.c +#: src/xz/util.c +#, c-format +msgid "%s: %s" +msgstr "%s:%s" + +#: src/xz/args.c +#, c-format +msgid "The environment variable %s contains too many arguments" +msgstr "%s 環境變數包含過多參數" + +#: src/xz/args.c +msgid "Compression support was disabled at build time" +msgstr "已在編譯時停用壓縮支援" + +#: src/xz/args.c +msgid "Decompression support was disabled at build time" +msgstr "已在編譯時停用解壓縮支援" + +#: src/xz/args.c +msgid "Compression of lzip files (.lz) is not supported" +msgstr "不支援壓縮為 lzip 檔案 (.lz)" + +#: src/xz/args.c +msgid "--block-list is ignored unless compressing to the .xz format" +msgstr "--block-list 只有在壓縮成 .xz 格式時才會生效" + +#: src/xz/args.c +msgid "With --format=raw, --suffix=.SUF is required unless writing to stdout" +msgstr "搭配 --format=raw 時,除非寫入標準輸出,否則需要傳入 --suffix=.SUF" + +#: src/xz/coder.c +msgid "Maximum number of filters is four" +msgstr "最多只能指定 4 個過濾器" + +#: src/xz/coder.c +#, c-format +msgid "Error in --filters%s=FILTERS option:" +msgstr "--filters%s=FILTERS 選項發生錯誤:" + +#: src/xz/coder.c +msgid "Memory usage limit is too low for the given filter setup." +msgstr "記憶體用量限制過低,不足以設定指定的過濾器。" + +#: src/xz/coder.c +#, c-format +msgid "filter chain %u used by --block-list but not specified with --filters%u=" +msgstr "--block-list 使用了 %u,但未使用 --filters%u= 指定" + +#: src/xz/coder.c +msgid "Using a preset in raw mode is discouraged." +msgstr "不建議在 Raw 模式使用設定檔。" + +#: src/xz/coder.c +msgid "The exact options of the presets may vary between software versions." +msgstr "設定檔的選項可能因軟體版本而有異。" + +#: src/xz/coder.c +msgid "The .lzma format supports only the LZMA1 filter" +msgstr ".lzma 格式僅支援 LZMA1 過濾器" + +#: src/xz/coder.c +msgid "LZMA1 cannot be used with the .xz format" +msgstr "LZMA1 不能與 .xz 格式一同使用" + +#: src/xz/coder.c +#, c-format +msgid "Filter chain %u is incompatible with --flush-timeout" +msgstr "過濾鏈 %u 與 --flush-timeout 不相容" + +#: src/xz/coder.c +msgid "Switching to single-threaded mode due to --flush-timeout" +msgstr "因指定 --flush-timeout,因此切換到單執行緒模式" + +#: src/xz/coder.c +#, c-format +msgid "Unsupported options in filter chain %u" +msgstr "過濾鏈 %u 不支援此選項" + +#: src/xz/coder.c +#, c-format +msgid "Using up to % threads." +msgstr "使用最多 % 個執行緒。" + +#: src/xz/coder.c +msgid "Unsupported filter chain or filter options" +msgstr "不支援的或過濾器選項" + +#: src/xz/coder.c +#, c-format +msgid "Decompression will need %s MiB of memory." +msgstr "解壓縮將需要 %s MiB 的記憶體。" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to %s to not exceed the memory usage limit of %s MiB" +msgstr "已將執行緒數量從 %s 個減少至 %s 個,以不超過記憶體用量的 %s MiB 限制" + +#: src/xz/coder.c +#, c-format +msgid "Reduced the number of threads from %s to one. The automatic memory usage limit of %s MiB is still being exceeded. %s MiB of memory is required. Continuing anyway." +msgstr "已將執行緒數量從 %s 減少至一個,但依然超出 %s MiB 的自動記憶體用量限制。需要 %s MiB 的記憶體。依然繼續執行。" + +#: src/xz/coder.c +#, c-format +msgid "Switching to single-threaded mode to not exceed the memory usage limit of %s MiB" +msgstr "正在切換至單執行緒模式,以免超出 %s MiB 的記憶體用量限制" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "已將 LZMA%c 的字典大小從 %s MiB 調整至 %s MiB,以不超過記憶體用量的 %s MiB 限制" + +#: src/xz/coder.c +#, c-format +msgid "Adjusted LZMA%c dictionary size for --filters%u from %s MiB to %s MiB to not exceed the memory usage limit of %s MiB" +msgstr "已將 --filters%2$u 的 LZMA%1$c 字典大小,將 %3$s MiB 調整為 %4$s MiB,以避免超過 %5$s MiB 的記憶體用量限制" + +#: src/xz/coder.c +#, c-format +msgid "Error changing to filter chain %u: %s" +msgstr "變更為 %u 時發生錯誤:%s" + +#: src/xz/file_io.c +#, c-format +msgid "Error creating a pipe: %s" +msgstr "建立管線時發生錯誤:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: poll() failed: %s" +msgstr "%s:poll() 失敗:%s" + +#. TRANSLATORS: When compression or decompression finishes, +#. and xz is going to remove the source file, xz first checks +#. if the source file still exists, and if it does, does its +#. device and inode numbers match what xz saw when it opened +#. the source file. If these checks fail, this message is +#. shown, %s being the filename, and the file is not deleted. +#. The check for device and inode numbers is there, because +#. it is possible that the user has put a new file in place +#. of the original file, and in that case it obviously +#. shouldn't be removed. +#: src/xz/file_io.c +#, c-format +msgid "%s: File seems to have been moved, not removing" +msgstr "%s:檔案似乎已經遷移,不移除" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot remove: %s" +msgstr "%s:無法移除:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file owner: %s" +msgstr "%s:無法設定檔案所有者:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file group: %s" +msgstr "%s:無法設定檔案群組:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Cannot set the file permissions: %s" +msgstr "%s:無法設定檔案權限:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the file failed: %s" +msgstr "%s:同步檔案失敗:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Synchronizing the directory of the file failed: %s" +msgstr "%s:同步檔案目錄失敗:%s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard input: %s" +msgstr "從標準輸入取得檔案狀態旗標時發生錯誤:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a symbolic link, skipping" +msgstr "%s:是個符號連結,跳過" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Is a directory, skipping" +msgstr "%s:是個目錄,跳過" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Not a regular file, skipping" +msgstr "%s:不是一般檔案,跳過" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has setuid or setgid bit set, skipping" +msgstr "%s:檔案已設定 setuid 或 setgid 位元,跳過" + +#: src/xz/file_io.c +#, c-format +msgid "%s: File has sticky bit set, skipping" +msgstr "%s:檔案已設定黏性位元(sticky bit),跳過" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Input file has more than one hard link, skipping" +msgstr "%s:輸入檔有超過一個實際連結 (hard link),跳過" + +#: src/xz/file_io.c +msgid "Empty filename, skipping" +msgstr "空檔名,跳過" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the status flags to standard input: %s" +msgstr "將狀態旗標還原到標準輸入時發生錯誤:%s" + +#: src/xz/file_io.c +#, c-format +msgid "Error getting the file status flags from standard output: %s" +msgstr "從標準輸出取得檔案狀態旗標時發生錯誤:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Opening the directory failed: %s" +msgstr "%s:開啟目錄失敗:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Destination is not a regular file" +msgstr "%s:目的地不是一般檔案" + +#: src/xz/file_io.c +#, c-format +msgid "Error restoring the O_APPEND flag to standard output: %s" +msgstr "將 O_APPEND 旗標還原到標準輸出時發生錯誤:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Closing the file failed: %s" +msgstr "%s:關閉檔案失敗:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Seeking failed when trying to create a sparse file: %s" +msgstr "%s:嘗試建立疏鬆檔案時發生搜尋失敗:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Read error: %s" +msgstr "%s:讀取時發生錯誤:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Error seeking the file: %s" +msgstr "%s:搜尋檔案時發生錯誤:%s" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Unexpected end of file" +msgstr "%s:非期望的檔案結尾" + +#: src/xz/file_io.c +#, c-format +msgid "%s: Write error: %s" +msgstr "%s:寫入時發生錯誤:%s" + +#: src/xz/hardware.c +msgid "Disabled" +msgstr "已停用" + +#: src/xz/hardware.c +msgid "Amount of physical memory (RAM):" +msgstr "實體記憶體 (RAM) 數量:" + +#: src/xz/hardware.c +msgid "Number of processor threads:" +msgstr "處理器執行緒的數量:" + +#: src/xz/hardware.c +msgid "Compression:" +msgstr "壓縮:" + +#: src/xz/hardware.c +msgid "Decompression:" +msgstr "解壓縮:" + +#: src/xz/hardware.c +msgid "Multi-threaded decompression:" +msgstr "多執行緒解壓縮:" + +#: src/xz/hardware.c +msgid "Default for -T0:" +msgstr "-T0 的預設值:" + +#: src/xz/hardware.c +msgid "Hardware information:" +msgstr "硬體資訊:" + +#: src/xz/hardware.c +msgid "Memory usage limits:" +msgstr "記憶體用量上限:" + +#: src/xz/list.c +msgid "Streams:" +msgstr "串流:" + +#: src/xz/list.c +msgid "Blocks:" +msgstr "區塊:" + +#: src/xz/list.c +msgid "Compressed size:" +msgstr "壓縮後大小:" + +#: src/xz/list.c +msgid "Uncompressed size:" +msgstr "壓縮前大小:" + +#: src/xz/list.c +msgid "Ratio:" +msgstr "壓縮比:" + +#: src/xz/list.c +msgid "Check:" +msgstr "檢查:" + +#: src/xz/list.c +msgid "Stream Padding:" +msgstr "串流填充:" + +#: src/xz/list.c +msgid "Memory needed:" +msgstr "所需記憶體:" + +#: src/xz/list.c +msgid "Sizes in headers:" +msgstr "檔頭中標示大小:" + +#: src/xz/list.c +msgid "Number of files:" +msgstr "檔案數:" + +#: src/xz/list.c +msgid "Stream" +msgstr "串流" + +#: src/xz/list.c +msgid "Block" +msgstr "區塊" + +#: src/xz/list.c +msgid "Blocks" +msgstr "區塊" + +#: src/xz/list.c +msgid "CompOffset" +msgstr "壓縮偏移" + +#: src/xz/list.c +msgid "UncompOffset" +msgstr "未壓縮偏移" + +#: src/xz/list.c +msgid "CompSize" +msgstr "壓縮大小" + +#: src/xz/list.c +msgid "UncompSize" +msgstr "未壓縮大小" + +#: src/xz/list.c +msgid "TotalSize" +msgstr "總計大小" + +#: src/xz/list.c +msgid "Ratio" +msgstr "比率" + +#: src/xz/list.c +msgid "Check" +msgstr "檢查" + +#: src/xz/list.c +msgid "CheckVal" +msgstr "檢查值" + +#: src/xz/list.c +msgid "Padding" +msgstr "補空" + +#: src/xz/list.c +msgid "Header" +msgstr "檔頭" + +#: src/xz/list.c +msgid "Flags" +msgstr "旗標" + +#: src/xz/list.c +msgid "MemUsage" +msgstr "Mem用量" + +#: src/xz/list.c +msgid "Filters" +msgstr "過濾器" + +#. TRANSLATORS: Indicates that there is no integrity check. +#. This string is used in tables. In older xz version this +#. string was limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "None" +msgstr "無" + +#. TRANSLATORS: Indicates that integrity check name is not known, +#. but the Check ID is known (here 2). In older xz version these +#. strings were limited to ten columns in a fixed-width font, but +#. nowadays there is no strict length restriction anymore. +#: src/xz/list.c +msgid "Unknown-2" +msgstr "未知-2" + +#: src/xz/list.c +msgid "Unknown-3" +msgstr "未知-3" + +#: src/xz/list.c +msgid "Unknown-5" +msgstr "未知-5" + +#: src/xz/list.c +msgid "Unknown-6" +msgstr "未知-6" + +#: src/xz/list.c +msgid "Unknown-7" +msgstr "未知-7" + +#: src/xz/list.c +msgid "Unknown-8" +msgstr "未知-8" + +#: src/xz/list.c +msgid "Unknown-9" +msgstr "未知-9" + +#: src/xz/list.c +msgid "Unknown-11" +msgstr "未知-11" + +#: src/xz/list.c +msgid "Unknown-12" +msgstr "未知-12" + +#: src/xz/list.c +msgid "Unknown-13" +msgstr "未知-13" + +#: src/xz/list.c +msgid "Unknown-14" +msgstr "未知-14" + +#: src/xz/list.c +msgid "Unknown-15" +msgstr "未知-15" + +#: src/xz/list.c +#, c-format +msgid "%s: File is empty" +msgstr "%s:檔案是空的" + +#: src/xz/list.c +#, c-format +msgid "%s: Too small to be a valid .xz file" +msgstr "%s:因過小而不認為是個有效 .xz 檔" + +#. TRANSLATORS: These are column headings. From Strms (Streams) +#. to Ratio, the columns are right aligned. Check and Filename +#. are left aligned. If you need longer words, it's OK to +#. use two lines here. Test with "xz -l foo.xz". +#: src/xz/list.c +msgid "Strms Blocks Compressed Uncompressed Ratio Check Filename" +msgstr " 串流 區塊 已壓縮 未壓縮 比例 檢驗碼 檔名" + +#: src/xz/list.c +msgid "Yes" +msgstr "是" + +#: src/xz/list.c +msgid "No" +msgstr "否" + +#: src/xz/list.c +msgid "Minimum XZ Utils version:" +msgstr "最小 XZ 工具程式版本:" + +#. TRANSLATORS: %s is an integer. Only the plural form of this +#. message is used (e.g. "2 files"). Test with "xz -l foo.xz bar.xz". +#: src/xz/list.c +#, c-format +msgid "%s file\n" +msgid_plural "%s files\n" +msgstr[0] "%s 個檔案\n" + +#: src/xz/list.c +msgid "Totals:" +msgstr "總計:" + +#: src/xz/list.c +msgid "--list works only on .xz files (--format=xz or --format=auto)" +msgstr "--list 只能在 .xz 檔使用(--format=xz 或 --format=auto)" + +#: src/xz/list.c +msgid "Try 'lzmainfo' with .lzma files." +msgstr "試試看用「lzmainfo」處理 .lzma 檔案。" + +#: src/xz/list.c +msgid "--list does not support reading from standard input" +msgstr "--list 不支援從標準輸入讀取" + +#: src/xz/main.c +#, c-format +msgid "%s: Error reading filenames: %s" +msgstr "%s:讀取檔名時發生錯誤:%s" + +#: src/xz/main.c +#, c-format +msgid "%s: Unexpected end of input when reading filenames" +msgstr "%s:讀取檔名時遇到非預期的輸入結尾" + +#: src/xz/main.c +#, c-format +msgid "%s: Null character found when reading filenames; maybe you meant to use '--files0' instead of '--files'?" +msgstr "%s:讀取檔名時發現空字元;或許您想使用「--files0」而非「--files」?" + +#: src/xz/main.c +msgid "Compression and decompression with --robot are not supported yet." +msgstr "尚未支援搭配 --robot 壓縮和解壓縮。" + +#: src/xz/main.c +msgid "Cannot read data from standard input when reading filenames from standard input" +msgstr "從標準輸入讀取檔名時,無法從標準輸入讀取資料" + +#. TRANSLATORS: This is the program name in the beginning +#. of the line in messages. Usually it becomes "xz: ". +#. This is a translatable string because French needs +#. a space before a colon. +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "%s: " +msgstr "%s:" + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +msgid "Internal error (bug)" +msgstr "內部錯誤(臭蟲)" + +#: src/xz/message.c +msgid "Cannot establish signal handlers" +msgstr "無法確立信號處理器" + +#: src/xz/message.c +msgid "No integrity check; not verifying file integrity" +msgstr "沒有完整性檢查;不驗證檔案完整性" + +#: src/xz/message.c +msgid "Unsupported type of integrity check; not verifying file integrity" +msgstr "未知完整性檢查類型;不驗證檔案完整性" + +#: src/xz/message.c +msgid "Memory usage limit reached" +msgstr "達到記憶體用量上限" + +#: src/xz/message.c +msgid "File format not recognized" +msgstr "無法識別檔案格式" + +#: src/xz/message.c +msgid "Unsupported options" +msgstr "不支援的選項" + +#: src/xz/message.c +msgid "Compressed data is corrupt" +msgstr "壓縮資料是損壞的" + +#: src/xz/message.c +msgid "Unexpected end of input" +msgstr "遇到非預期輸入結尾" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limiter is disabled." +msgstr "需要 %s MiB 的記憶體。已停用記憶體限制器。" + +#: src/xz/message.c +#, c-format +msgid "%s MiB of memory is required. The limit is %s." +msgstr "需要 %s MiB 的記憶體。記憶體限制為 %s。" + +#: src/xz/message.c +#, c-format +msgid "%s: Filter chain: %s\n" +msgstr "%s:過濾鏈:%s\n" + +#: src/xz/message.c +#, c-format +msgid "Try '%s --help' for more information." +msgstr "嘗試「%s --help」取得更多資訊。" + +#: src/xz/message.c src/lzmainfo/lzmainfo.c +#, c-format +msgid "Error printing the help text (error code %d)" +msgstr "輸出說明文字時發生錯誤(錯誤碼 %d)" + +#: src/xz/message.c +#, c-format +msgid "Usage: %s [OPTION]... [FILE]...\n" +msgstr "用法:%s [OPTION]... [FILE]...\n" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 格式壓縮,或解壓縮 .xz 格式中的 <檔案>。" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "不要在解壓縮時建立稀疏檔案" + +#: src/xz/message.c +msgid ".SUF" +msgstr ".SUF" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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」後綴" + +#: src/xz/message.c +msgid "FILE" +msgstr "FILE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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,\t則從標準輸入讀取檔案名稱。檔案名稱必須以換行字元結尾" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 但使用 null 字元作為終止字元" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "基本檔案格式與壓縮選項:" + +#: src/xz/message.c +msgid "FORMAT" +msgstr "FORMAT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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」(預設值)、\t「xz」、「lzma」、「lzip」和「raw」" + +#: src/xz/message.c +msgid "NAME" +msgstr "NAME" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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」、\t「crc64」(預設值)或「sha256」" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 壓縮等級前,\t請務必考量壓縮與解壓縮的記憶體用量!" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 時間來改善壓縮率\t(不影響解壓縮器的記憶體需求)" + +#. TRANSLATORS: Short for NUMBER. A longer string is fine but +#. wider than 5 columns makes --long-help a few lines longer. +#: src/xz/message.c +msgid "NUM" +msgstr "NUM" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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,即使用所有的處理器核心" + +#: src/xz/message.c +msgid "SIZE" +msgstr "SIZE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "每處理 SIZE 位元組的輸入資料後,就開始一個新的 .xz 區塊。\t使用這個設定多執行緒壓縮的區塊大小" + +#: src/xz/message.c +msgid "BLOCKS" +msgstr "BLOCKS" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 區塊,\t可以選擇在未壓縮資料大小前加上過濾鏈編號(0-9)\t和冒號「:」" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 毫秒,\t且讀取更多輸入會造成阻塞,則將所有待處理資料排清" + +#: src/xz/message.c +msgid "LIMIT" +msgstr "LIMIT" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 "設定壓縮、解壓縮、多執行緒解壓縮或所有這些模式的記憶體\t上限。\tLIMIT 的單位可以是位元組、\t記憶體佔用百分比,\t或 0 表示預設值" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "自訂壓縮過濾鏈(設定檔以外的替代選項):" + +#: src/xz/message.c +msgid "FILTERS" +msgstr "FILTERS" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 過濾器字串語法的更多資訊後結束" + +#. TRANSLATORS: Short for OPTIONS. +#: src/xz/message.c +msgid "OPTS" +msgstr "OPTS" + +#. TRANSLATORS: Use semicolon (or its fullwidth form) +#. in "(valid values; default)" even if it is weird in +#. 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 interpreted as a zero-width space (the tab 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 是個以逗號分隔的列表,內有 0 或多個下述選項(有效值;預設值):" + +#. TRANSLATORS: Short for PRESET. A longer string is +#. fine but wider than 4 columns makes --long-help +#. one line longer. +#: src/xz/message.c +msgid "PRE" +msgstr "PRE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "字典大小" + +#. TRANSLATORS: The word "literal" in "literal context +#. 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 interpreted as a zero-width space (the 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 literal context bits" +msgstr "字元上下文位元數" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 literal position bits" +msgstr "字元位置位元數" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the 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 position bits" +msgstr "位置位元的數量" + +#: src/xz/message.c +msgid "MODE" +msgstr "MODE" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 過濾器都有效的 OPTS:" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 "差異過濾器。有效 OPTS(有效值;預設值):" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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 "如果 FILE 沒有指定或指定為 -,則從標準輸入讀取。" + +#. TRANSLATORS: This message indicates the bug reporting +#. 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 interpreted as a zero-width space (the 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)." +msgstr "請回報臭蟲至 <%s>(使用英文或芬蘭語)。" + +#. 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 interpreted as a zero-width space (the 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 interpreted as a zero-width space (the tab 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 interpreted as a zero-width space (the 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=FILTERS 或 --filters1=FILTERS ... --filters9=FILTERS 選項來設定。鏈中的每個過濾器可以用空格或 '--' 分隔。您也可以指定 %s 設定檔來取代過濾鏈。" + +#. This is word wrapped at spaces. The Unicode character U+00A0 works as a non-breaking space. Tab (\t) is interpreted as a zero-width space (the tab 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 "支援的過濾器和選項為:" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Options must be 'name=value' pairs separated with commas" +msgstr "選項必須是以逗號分隔的「name=value」值對" + +#: src/xz/options.c +#, c-format +msgid "%s: Invalid option name" +msgstr "%s:選項名稱無效" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "Invalid option value" +msgstr "選項值無效" + +#: src/xz/options.c +#, c-format +msgid "Unsupported LZMA1/LZMA2 preset: %s" +msgstr "不支援的 LZMA1/LZMA2 設定檔:%s" + +#: src/xz/options.c src/liblzma/common/string_conversion.c +msgid "The sum of lc and lp must not exceed 4" +msgstr "lc 和 lp 的總和不能超過 4" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Filename has an unknown suffix, skipping" +msgstr "%s:檔名有未知後綴,跳過" + +#: src/xz/suffix.c +#, c-format +msgid "%s: File already has '%s' suffix, skipping" +msgstr "%s:檔案已有「%s」後綴,略過" + +#: src/xz/suffix.c +#, c-format +msgid "%s: Invalid filename suffix" +msgstr "%s:檔名後綴無效" + +#: src/xz/util.c src/liblzma/common/string_conversion.c +msgid "Value is not a non-negative decimal integer" +msgstr "數值不是非負數十進位整數" + +#: src/xz/util.c +#, c-format +msgid "%s: Invalid multiplier suffix" +msgstr "%s:乘數後綴無效" + +#: src/xz/util.c +msgid "Valid suffixes are 'KiB' (2^10), 'MiB' (2^20), and 'GiB' (2^30)." +msgstr "有效的後綴有「KiB」(2^10)、「MiB」(2^20) 及「GiB」(2^30)。" + +#: src/xz/util.c +#, c-format +msgid "Value of the option '%s' must be in the range [%, %]" +msgstr "選項「%s」的數值必須落在 [%, %] 範圍內" + +#: src/xz/util.c +msgid "Compressed data cannot be read from a terminal" +msgstr "不能從終端機讀入已壓縮資料" + +#: src/xz/util.c +msgid "Compressed data cannot be written to a terminal" +msgstr "不能將已壓縮資料寫入終端機" + +#: src/lzmainfo/lzmainfo.c +#, c-format +msgid "Usage: %s [--help] [--version] [FILE]...\n" +msgstr "用法:%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 interpreted as a zero-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 檔案標頭中的資訊。" + +#: src/lzmainfo/lzmainfo.c +msgid "File is too small to be a .lzma file" +msgstr "檔案過小,故不是 .lzma 檔案" + +#: src/lzmainfo/lzmainfo.c +msgid "Not a .lzma file" +msgstr "不是 .lzma 檔案" + +#: src/common/tuklib_exit.c +msgid "Writing to standard output failed" +msgstr "寫入標準輸出失敗" + +#: src/common/tuklib_exit.c +msgid "Unknown error" +msgstr "未知錯誤" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported preset" +msgstr "不支援的設定檔" + +#: src/liblzma/common/string_conversion.c +msgid "Unsupported flag in the preset" +msgstr "設定檔中包含不支援的旗標" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown option name" +msgstr "未知選項名稱" + +#: src/liblzma/common/string_conversion.c +msgid "Option value cannot be empty" +msgstr "選項值不能空白" + +#: src/liblzma/common/string_conversion.c +msgid "Value out of range" +msgstr "數值超出範圍" + +#: src/liblzma/common/string_conversion.c +msgid "This option does not support any multiplier suffixes" +msgstr "這個選項不支援任何乘數後綴" + +#. TRANSLATORS: Don't translate the +#. suffixes "KiB", "MiB", or "GiB" +#. because a user can only specify +#. untranslated suffixes. +#: src/liblzma/common/string_conversion.c +msgid "Invalid multiplier suffix (KiB, MiB, or GiB)" +msgstr "乘數後綴無效(KiB、MiB 或 GiB)" + +#: src/liblzma/common/string_conversion.c +msgid "Unknown filter name" +msgstr "未知過濾器名稱" + +#: src/liblzma/common/string_conversion.c +msgid "This filter cannot be used in the .xz format" +msgstr "這個過濾器不能在 .xz 格式中使用" + +#: src/liblzma/common/string_conversion.c +msgid "Memory allocation failed" +msgstr "分配記憶體失敗" + +#: src/liblzma/common/string_conversion.c +msgid "Empty string is not allowed, try '6' if a default value is needed" +msgstr "不允許輸入空白字串,如需預設值請輸入「6」" + +#: src/liblzma/common/string_conversion.c +msgid "The maximum number of filters is four" +msgstr "過濾器最多只能指定 4 個" + +#: src/liblzma/common/string_conversion.c +msgid "Filter name is missing" +msgstr "缺少過濾器名稱" + +#: src/liblzma/common/string_conversion.c +msgid "Invalid filter chain ('lzma2' missing at the end?)" +msgstr "無效的過濾鏈(結尾缺少「lzma2」?)" diff --git a/cpp/third_party/xz-5.8.3/po4a/ar.po b/cpp/third_party/xz-5.8.3/po4a/ar.po new file mode 100644 index 0000000000..7c1822245c --- /dev/null +++ b/cpp/third_party/xz-5.8.3/po4a/ar.po @@ -0,0 +1,3905 @@ +# SPDX-License-Identifier: 0BSD +# Arabic translation for xz-man. +# Copyright (C) The XZ Utils authors and contributors +# This file is published under the BSD Zero Clause License. +# +# Zayed Al-Saidi , 2026. +msgid "" +msgstr "" +"Project-Id-Version: xz-man-5.8.2-pre1\n" +"POT-Creation-Date: 2025-10-31 13:23+0200\n" +"PO-Revision-Date: 2026-02-04 11:05+0400\n" +"Last-Translator: Zayed Al-Saidi \n" +"Language-Team: Arabic <(nothing)>\n" +"Language: ar\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Bugs: Report translation errors to the Language-Team address.\n" +"Plural-Forms: nplurals=6; plural=n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100 >= 3 && n%100<=10 ? 3 : n%100 >= 11 && n%100<=99 ? 4 : 5;\n" +"X-Generator: Lokalize 23.08.5\n" + +#. type: TH +#: ../src/xz/xz.1 +#, no-wrap +msgid "XZ" +msgstr "XZ" + +#. type: TH +#: ../src/xz/xz.1 +#, no-wrap +msgid "2025-03-08" +msgstr "2025-03-08" + +#. type: TH +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 ../src/lzmainfo/lzmainfo.1 +#: ../src/scripts/xzdiff.1 ../src/scripts/xzgrep.1 ../src/scripts/xzless.1 +#: ../src/scripts/xzmore.1 +#, no-wrap +msgid "Tukaani" +msgstr "توكاني" + +#. type: TH +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 ../src/lzmainfo/lzmainfo.1 +#: ../src/scripts/xzdiff.1 ../src/scripts/xzgrep.1 ../src/scripts/xzless.1 +#: ../src/scripts/xzmore.1 +#, no-wrap +msgid "XZ Utils" +msgstr "أدوات XZ" + +#. type: SH +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 ../src/lzmainfo/lzmainfo.1 +#: ../src/scripts/xzdiff.1 ../src/scripts/xzgrep.1 ../src/scripts/xzless.1 +#: ../src/scripts/xzmore.1 +#, no-wrap +msgid "NAME" +msgstr "الاسم" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "xz, unxz, xzcat, lzma, unlzma, lzcat - Compress or decompress .xz and .lzma files" +msgstr "xz, unxz, xzcat, lzma, unlzma, lzcat - ضغط أو فك ضغط ملفات .xz و .lzma" + +#. type: SH +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 ../src/lzmainfo/lzmainfo.1 +#: ../src/scripts/xzdiff.1 ../src/scripts/xzgrep.1 ../src/scripts/xzless.1 +#: ../src/scripts/xzmore.1 +#, no-wrap +msgid "SYNOPSIS" +msgstr "موجز" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B [I] [I]" +msgstr "B [I<خيار...>] [I<ملف...>]" + +#. type: SH +#: ../src/xz/xz.1 +#, no-wrap +msgid "COMMAND ALIASES" +msgstr "أسماء مستعارة للأمر" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B is equivalent to B." +msgstr "B يكافئ B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B is equivalent to B." +msgstr "B يكافئ B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B is equivalent to B." +msgstr "B يكافئ B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B is equivalent to B." +msgstr "B يكافئ B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B is equivalent to B." +msgstr "B يكافئ B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When writing scripts that need to decompress files, it is recommended to always use the name B with appropriate arguments (B or B) instead of the names B and B." +msgstr "عند كتابة سكربتات تحتاج لفك ضغط الملفات، يُوصى دائماً باستخدام الاسم B مع المعطيات المناسبة (B أو B) بدلاً من الاسمين B و B." + +#. type: SH +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 ../src/lzmainfo/lzmainfo.1 +#: ../src/scripts/xzdiff.1 ../src/scripts/xzgrep.1 ../src/scripts/xzless.1 +#: ../src/scripts/xzmore.1 +#, no-wrap +msgid "DESCRIPTION" +msgstr "الوصف" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B is a general-purpose data compression tool with command line syntax similar to B(1) and B(1). The native file format is the B<.xz> format, but the legacy B<.lzma> format used by LZMA Utils and raw compressed streams with no container format headers are also supported. In addition, decompression of the B<.lz> format used by B is supported." +msgstr "B أداة ضغط بيانات عامة الأغراض مع صياغة سطر أوامر مشابهة لـ B(1) و B(1). تنسيق الملف الأصلي هو تنسيق B<.xz>، ولكن يدعم أيضاً تنسيق B<.lzma> الموروث المستخدم في LZMA Utils والتدفقات المضغوطة الخام بدون ترويسات تنسيق الحاوية. بالإضافة إلى ذلك، يدعم فك ضغط تنسيق B<.lz> المستخدم بواسطة B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B compresses or decompresses each I according to the selected operation mode. If no I are given or I is B<->, B reads from standard input and writes the processed data to standard output. B will refuse (display an error and skip the I) to write compressed data to standard output if it is a terminal. Similarly, B will refuse to read compressed data from standard input if it is a terminal." +msgstr "يضغط B أو يفك ضغط كل I<ملف> وفقاً لوضع التشغيل المحدد. إذا لم تُعطَ I<ملفات> أو كان I<الملف> هو B<->، يقرأ B من الدخل القياسي ويكتب البيانات المعالجة إلى الخرج القياسي. يرفض B (يعرض خطأ ويتخطى I<الملف>) كتابة البيانات المضغوطة إلى الخرج القياسي إذا كان طرفية. وبالمثل، يرفض B قراءة البيانات المضغوطة من الدخل القياسي إذا كان طرفية." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Unless B<--stdout> is specified, I other than B<-> are written to a new file whose name is derived from the source I name:" +msgstr "ما لم يحدد الخيار B<--stdout>، تُكتب I<الملفات> بخلاف B<-> في ملف جديد يُشتق اسمه من اسم I<ملف> المصدر:" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "\\(bu" +msgstr "\\(bu" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When compressing, the suffix of the target file format (B<.xz> or B<.lzma>) is appended to the source filename to get the target filename." +msgstr "عند الضغط، يُلحق ملحق تنسيق الملف الهدف (B<.xz> أو B<.lzma>) باسم ملف المصدر للحصول على اسم الملف الهدف." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When decompressing, the B<.xz>, B<.lzma>, or B<.lz> suffix is removed from the filename to get the target filename. B also recognizes the suffixes B<.txz> and B<.tlz>, and replaces them with the B<.tar> suffix." +msgstr "عند فك الضغط، يُزال الملحق B<.xz> أو B<.lzma> أو B<.lz> من اسم الملف للحصول على اسم الملف الهدف. يتعرف B أيضاً على الملحقات B<.txz> و B<.tlz>، ويستبدلها بالملحق B<.tar>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If the target file already exists, an error is displayed and the I is skipped." +msgstr "إذا كان الملف الهدف موجوداً بالفعل، يُعرض خطأ ويتخطى I<الملف>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Unless writing to standard output, B will display a warning and skip the I if any of the following applies:" +msgstr "ما لم يكتب إلى المخرج القياسي، يعرض B تحذيراً ويتخطى I<الملف> في حال انطباق أي مما يلي:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I is not a regular file. Symbolic links are not followed, and thus they are not considered to be regular files." +msgstr "I<الملف> ليس ملفاً عادياً. لا تُتبع الوصلات الرمزية، وبالتالي لا تُعتبر ملفات عادية." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I has more than one hard link." +msgstr "I<الملف> له أكثر من وصلة صلبة واحدة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I has setuid, setgid, or sticky bit set." +msgstr "I<الملف> عُينت له بتات setuid أو setgid أو sticky." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The operation mode is set to compress and the I already has a suffix of the target file format (B<.xz> or B<.txz> when compressing to the B<.xz> format, and B<.lzma> or B<.tlz> when compressing to the B<.lzma> format)." +msgstr "وضع التشغيل مضبوط على الضغط و I<الملف> يمتلك بالفعل ملحقاً لتنسيق الملف الهدف (B<.xz> أو B<.txz> عند الضغط بتنسيق B<.xz>، و B<.lzma> أو B<.tlz> عند الضغط بتنسيق B<.lzma>)." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The operation mode is set to decompress and the I doesn't have a suffix of any of the supported file formats (B<.xz>, B<.txz>, B<.lzma>, B<.tlz>, or B<.lz>)." +msgstr "وضع التشغيل مضبوط على فك الضغط و I<الملف> لا يمتلك ملحقاً لأي من تنسيقات الملفات المدعومة (B<.xz> أو B<.txz> أو B<.lzma> أو B<.tlz> أو B<.lz>)." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "After successfully compressing or decompressing the I, B copies the owner, group, permissions, access time, and modification time from the source I to the target file. If copying the group fails, the permissions are modified so that the target file doesn't become accessible to users who didn't have permission to access the source I. B doesn't support copying other metadata like access control lists or extended attributes yet." +msgstr "بعد ضغط I<الملف> أو فك ضغطه بنجاح، ينسخ B المالك والمجموعة والأذونات ووقت الوصول ووقت التعديل من I<ملف> المصدر إلى الملف الهدف. إذا فشل نسخ المجموعة، تُعدل الأذونات حتى لا يصبح الملف الهدف متاحاً للمستخدمين الذين لم يمتلكوا إذناً للوصول إلى I<ملف> المصدر. لا يدعم B نسخ البيانات الوصفية الأخرى مثل قوائم التحكم في الوصول أو السمات الممتدة بعد." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Once the target file has been successfully closed, the source I is removed unless B<--keep> was specified. The source I is never removed if the output is written to standard output or if an error occurs." +msgstr "بمجرد إغلاق الملف الهدف بنجاح، يُحذف I<ملف> المصدر ما لم يُحدد الخيار B<--keep>. لا يُحذف I<ملف> المصدر أبداً إذا كُتب المخرج إلى المخرج القياسي أو عند حدوث خطأ." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Sending B or B to the B process makes it print progress information to standard error. This has only limited use since when standard error is a terminal, using B<--verbose> will display an automatically updating progress indicator." +msgstr "إرسال B أو B إلى عملية B يجعلها تطبع معلومات التقدم إلى الخطأ القياسي. هذا له استخدام محدود لأنه عندما يكون الخطأ القياسي هو الطرفية، فإن استخدام B<--verbose> يعرض مؤشر تقدم يحدث آلياً." + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "Memory usage" +msgstr "استخدام الذاكرة" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The memory usage of B 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 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 B currently requires 65\\ MiB of memory. Still, it is possible to have B<.xz> files that require several gigabytes of memory to decompress." +msgstr "يختلف استخدام الذاكرة لـ B من بضع مئات الكيلوبايتات إلى عدة جيجابايتات اعتماداً على إعدادات الضغط. تحدد الإعدادات المستخدمة عند ضغط الملف متطلبات الذاكرة لبرنامج فك الضغط. عادةً يحتاج برنامج فك الضغط من 5% إلى 20% من كمية الذاكرة التي احتاج إليها الضاغط عند إنشاء الملف. على سبيل المثال، يتطلب فك ضغط ملف أُنشئ باستخدام B حالياً 65 ميجابايت من الذاكرة. ومع ذلك، من الممكن وجود ملفات B<.xz> تتطلب عدة جيجابايتات من الذاكرة لفك ضغطها." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Especially users of older systems may find the possibility of very large memory usage annoying. To prevent uncomfortable surprises, B 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 example, using B(1) to limit virtual memory tends to cripple B(2))." +msgstr "قد يجد مستخدمو الأنظمة القديمة خصوصاً احتمال استهلاك الذاكرة بشكل كبير جداً أمراً مزعجاً. لمنع المفاجآت غير المريحة، يمتلك B محدد استهلاك ذاكرة مدمجاً، وهو معطل بشكل مبدئي. في حين توفر بعض أنظمة التشغيل طرقاً للحد من استهلاك الذاكرة للعمليات، لم يُعتبر الاعتماد عليها مرناً بما يكفي (على سبيل المثال، استخدام B(1) للحد من الذاكرة الافتراضية يؤدي إلى إضعاف B(2))." + +#. TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +#. It's a name of an environment variable. +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The memory usage limiter can be enabled with the command line option B<--memlimit=>I. Often it is more convenient to enable the limiter by default by setting the environment variable B, for example, B. It is possible to set the limits separately for compression and decompression by using B<--memlimit-compress=>I and B<--memlimit-decompress=>I. Using these two options outside B is rarely useful because a single run of B cannot do both compression and decompression and B<--memlimit=>I (or B<-M> I) is shorter to type on the command line." +msgstr "يمكن تفعيل محدد استهلاك الذاكرة عبر خيار سطر الأوامر B<--memlimit=>I. غالباً ما يكون من الأنسب تفعيل المحدد بشكل مبدئي عن طريق ضبط متغير البيئة B، مثلاً: B. يمكن ضبط الحدود بشكل منفصل للضغط وفك الضغط باستخدام B<--memlimit-compress=>I و B<--memlimit-decompress=>I. نادراً ما يكون استخدام هذين الخيارين خارج B مفيداً لأن تشغيلاً واحداً لبرنامج B لا يمكنه القيام بالضغط وفك الضغط معاً، كما أن الخيار B<--memlimit=>I (أو B<-M> I) أسهل في الكتابة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If the specified memory usage limit is exceeded when decompressing, B will display an error and decompressing the file will fail. If the limit is exceeded when compressing, B will try to scale the settings down so that the limit is no longer exceeded (except when using B<--format=raw> or B<--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 B, the settings will be scaled down only a little, not all the way down to B." +msgstr "إذا تم تجاوز حد استهلاك الذاكرة المحدد عند فك الضغط، يعرض B خطأ ويفشل فك ضغط الملف. إذا تم تجاوز الحد عند الضغط، يحاول B خفض الإعدادات بحيث لا يتم تجاوز الحد (إلا عند استخدام B<--format=raw> أو B<--no-adjust>). بهذه الطريقة لن تفشل العملية إلا إذا كان الحد صغيراً جداً. يتم خفض الإعدادات بخطوات لا تطابق مستويات الضغط المعدة مسبقاً؛ فمثلاً إذا كان الحد أقل بقليل من الكمية المطلوبة للخيار B، تُخفض الإعدادات قليلاً فقط، وليس إلى مستوى B." + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "Concatenation and padding with .xz files" +msgstr "الدمج والحشو مع ملفات .xz" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "It is possible to concatenate B<.xz> files as is. B will decompress such files as if they were a single B<.xz> file." +msgstr "من الممكن دمج ملفات B<.xz> كما هي. سيفك B ضغط هذه الملفات كما لو كانت ملفاً واحداً بصيغة B<.xz>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 B<.xz> file is stored on a medium that measures file sizes in 512-byte blocks." +msgstr "من الممكن إدراج حشو بين الأجزاء المدمجة أو بعد الجزء الأخير. يجب أن يتكون الحشو من بايتات صفرية ويجب أن يكون حجم الحشو مضاعفاً لأربعة بايتات. يمكن أن يكون هذا مفيداً، مثلاً، إذا كان ملف B<.xz> مخزناً على وسيط يقيس أحجام الملفات بكتل سعة 512 بايت." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Concatenation and padding are not allowed with B<.lzma> files or raw streams." +msgstr "الدمج والحشو غير مسموح بهما مع ملفات B<.lzma> أو التدفقات الخام." + +#. type: SH +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 +#, no-wrap +msgid "OPTIONS" +msgstr "خيارات" + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "Integer suffixes and special values" +msgstr "لواحق الأعداد والقيم الخاصة" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "In most places where an integer argument is expected, an optional suffix is supported to easily indicate large integers. There must be no space between the integer and the suffix." +msgstr "في معظم الأماكن التي يُتوقع فيها معامل عددي، تُدعم لاحقة اختيارية للإشارة بسهولة إلى الأعداد الكبيرة. يجب ألا توجد مسافة بين العدد واللاحقة." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Multiply the integer by 1,024 (2^10). B, B, B, B, and B are accepted as synonyms for B." +msgstr "ضرب العدد في 1,024 (2^10). تُقبل B و B و B و B و B كمرادفات لـ B." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Multiply the integer by 1,048,576 (2^20). B, B, B, and B are accepted as synonyms for B." +msgstr "ضرب العدد في 1,048,576 (2^20). تُقبل B و B و B و B كمرادفات لـ B." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Multiply the integer by 1,073,741,824 (2^30). B, B, B, and B are accepted as synonyms for B." +msgstr "ضرب العدد في 1,073,741,824 (2^30). تُقبل B و B و B و B كمرادفات لـ B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The special value B can be used to indicate the maximum integer value supported by the option." +msgstr "يمكن استخدام القيمة الخاصة B للإشارة إلى أقصى قيمة عددية يدعمها الخيار." + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "Operation mode" +msgstr "وضع التشغيل" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If multiple operation mode options are given, the last one takes effect." +msgstr "إذا أُعطيت عدة خيارات لوضع التشغيل، فإن الأخير هو الذي يسري مفعوله." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-z>, B<--compress>" +msgstr "B<-z>, B<--compress>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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, B implies B<--decompress>)." +msgstr "يضغط. هذا هو وضع التشغيل الـ B<مبدئي> عند عدم تحديد خيار وضع تشغيل وعدم استنتاج وضع تشغيل آخر من اسم الأمر (على سبيل المثال، B يقتضي B<--decompress>)." + +#. The DESCRIPTION section already says this but it's good to repeat it +#. here because the default behavior is a bit dangerous and new users +#. in a hurry may skip reading the DESCRIPTION section. +#. type: Plain text +#: ../src/xz/xz.1 +msgid "After successful compression, the source file is removed unless writing to standard output or B<--keep> was specified." +msgstr "بعد الضغط بنجاح، يُحذف ملف المصدر ما لم يُحدد المخرج القياسي أو الخيار B<--keep>." + +#. type: TP +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 +#, no-wrap +msgid "B<-d>, B<--decompress>, B<--uncompress>" +msgstr "B<-d>, B<--decompress>, B<--uncompress>" + +#. The DESCRIPTION section already says this but it's good to repeat it +#. here because the default behavior is a bit dangerous and new users +#. in a hurry may skip reading the DESCRIPTION section. +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Decompress. After successful decompression, the source file is removed unless writing to standard output or B<--keep> was specified." +msgstr "يفك الضغط. بعد فك الضغط بنجاح، يزال الملف المصدر ما لم يكن الكتابة إلى الخرج القياسي أو خيار B<--keep> محدداً." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-t>, B<--test>" +msgstr "B<-t>, B<--test>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Test the integrity of compressed I. This option is equivalent to B<--decompress --stdout> except that the decompressed data is discarded instead of being written to standard output. No files are created or removed." +msgstr "يختبر سلامة I<الملفات> المضغوطة. هذا الخيار يكافئ B<--decompress --stdout> باستثناء أن البيانات المفكوك ضغطها تُهمَل بدلاً من كتابتها إلى الخرج القياسي. لا تُنشأ ولا تُزال أي ملفات." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-l>, B<--list>" +msgstr "B<-l>, B<--list>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Print information about compressed I. 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." +msgstr "يطبع معلومات حول I<الملفات> المضغوطة. لا يُنتج أي خرج مفكوك ضغطه، ولا تُنشأ ولا تُزال أي ملفات. في وضع القائمة، لا يستطيع البرنامج قراءة البيانات المضغوطة من الدخل القياسي أو من المصادر الأخرى التي لا تدعم البحث (unseekable)." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The default listing shows basic information about I, one file per line. To get more detailed information, use also the B<--verbose> option. For even more information, use B<--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 example, B may be convenient if the terminal isn't wide enough." +msgstr "تُظهر القائمة المبدئية معلومات أساسية حول I<الملفات>، بمعدل ملف واحد لكل سطر. للحصول على معلومات أكثر تفصيلاً، استخدم أيضاً الخيار B<--verbose>. لمزيد من المعلومات، استخدم B<--verbose> مرتين، لكن لاحظ أن هذا قد يكون بطيئاً لأن الحصول على كل المعلومات الإضافية يتطلب العديد من عمليات البحث. يتجاوز عرض المخرج التفصيلي 80 حرفاً، لذا قد يكون من المناسب تمرير المخرج إلى B مثلاً إذا لم تكن الطرفية عريضة بما يكفي." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The exact output may vary between B versions and different locales. For machine-readable output, B<--robot --list> should be used." +msgstr "قد يختلف المخرج الدقيق بين إصدارات B والإعدادات المحلية المختلفة. للمخرج القابل للقراءة آلياً، يجب استخدام B<--robot --list>." + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "Operation modifiers" +msgstr "معدلات العمليات" + +#. type: TP +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 +#, no-wrap +msgid "B<-k>, B<--keep>" +msgstr "B<-k>, B<--keep>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Don't delete the input files." +msgstr "عدم حذف ملفات المدخلات." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Since B 5.2.6, this option also makes B 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 B<--force>." +msgstr "منذ B 5.2.6، يجعل هذا الخيار B يضغط أو يفك الضغط حتى لو كان المدخل وصلاً رمزياً لملف عادي، أو يمتلك أكثر من وصلة صلبة، أو عُينت له بتات setuid أو setgid أو sticky. لا تُنسخ بتات setuid و setgid و sticky إلى الملف الهدف. في الإصدارات الأقدم، كان هذا يتم فقط مع الخيار B<--force>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-f>, B<--force>" +msgstr "B<-f>, B<--force>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This option has several effects:" +msgstr "هذا الخيار له عدة تأثيرات:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If the target file already exists, delete it before compressing or decompressing." +msgstr "إذا كان الملف الهدف موجوداً بالفعل، يُحذف قبل الضغط أو فك الضغط." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "الضغط أو فك الضغط حتى لو كان المدخل وصلاً رمزياً لملف عادي، أو يمتلك أكثر من وصلة صلبة، أو عُينت له بتات setuid أو setgid أو sticky. لا تُنسخ بتات setuid و setgid و sticky إلى الملف الهدف." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When used with B<--decompress> B<--stdout> and B cannot recognize the type of the source file, copy the source file as is to standard output. This allows B B<--force> to be used like B(1) for files that have not been compressed with B. Note that in future, B might support new compressed file formats, which may make B decompress more types of files instead of copying them as is to standard output. B<--format=>I can be used to restrict B to decompress only a single file format." +msgstr "عند استخدامه مع B<--decompress> و B<--stdout> وتعذر على B التعرف على نوع ملف المصدر، ينسخ ملف المصدر كما هو إلى المخرج القياسي. هذا يسمح باستخدام B B<--force> مثل B(1) للملفات التي لم تُضغط باستخدام B. لاحظ أنه مستقبلاً، قد يدعم B تنسيقات ملفات مضغوطة جديدة، مما قد يجعل B يفك ضغط أنواع أكثر من الملفات بدلاً من نسخها كما هي إلى المخرج القياسي. يمكن استخدام B<--format=>I لقصر B على فك ضغط تنسيق ملف واحد فقط." + +#. type: TP +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 +#, no-wrap +msgid "B<-c>, B<--stdout>, B<--to-stdout>" +msgstr "B<-c>, B<--stdout>, B<--to-stdout>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Write the compressed or decompressed data to standard output instead of a file. This implies B<--keep>." +msgstr "كتابة البيانات المضغوطة أو المفكوكة إلى المخرج القياسي بدلاً من ملف. هذا يتضمن الخيار B<--keep>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--single-stream>" +msgstr "B<--single-stream>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Decompress only the first B<.xz> stream, and silently ignore possible remaining input data following the stream. Normally such trailing garbage makes B display an error." +msgstr "فك ضغط أول تدفق B<.xz> فقط، وتجاهل أي بيانات مدخلات متبقية محتملة تتبع التدفق بصمت. عادة ما تتسبب هذه البيانات الزائدة في عرض خطأ من قبل B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B never decompresses more than one stream from B<.lzma> files or raw streams, but this option still makes B ignore the possible trailing data after the B<.lzma> file or raw stream." +msgstr "لا يقوم B أبداً بفك ضغط أكثر من تدفق واحد من ملفات B<.lzma> أو التدفقات الخام، لكن هذا الخيار لا يزال يجعل B يتجاهل البيانات اللاحقة المحتملة بعد ملف B<.lzma> أو التدفق الخام." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This option has no effect if the operation mode is not B<--decompress> or B<--test>." +msgstr "هذا الخيار ليس له تأثير إذا لم يكن وضع التشغيل هو B<--decompress> أو B<--test>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Since B 5.7.1alpha, B<--single-stream> implies B<--keep>." +msgstr "منذ B 5.7.1alpha، يتضمن B<--single-stream> الخيار B<--keep>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--no-sparse>" +msgstr "B<--no-sparse>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Disable creation of sparse files. By default, if decompressing into a regular file, B 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." +msgstr "يعطل إنشاء الملفات المتفرقة. الـ B<مبدئي>، عند فك الضغط إلى ملف عادي، يحاول B جعل الملف متفرقاً إذا كانت البيانات المفكوك ضغطها تحتوي على B<تسلسل>ات طويلة من الأصفار الثنائية. يعمل هذا أيضاً عند الكتابة إلى الخرج القياسي طالما كان الخرج القياسي متصلاً بملف عادي واستيفاء شروط إضافية معينة لضمان الأمان. قد يوفر إنشاء الملفات المتفرقة مساحة القرص ويسرع فك الضغط بتقليل كمية عمليات الإدخال والإخراج للقرص." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-S> I<.suf>, B<--suffix=>I<.suf>" +msgstr "B<-S> I<.suf>, B<--suffix=>I<.suf>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When compressing, use I<.suf> as the suffix for the target file instead of B<.xz> or B<.lzma>. If not writing to standard output and the source file already has the suffix I<.suf>, a warning is displayed and the file is skipped." +msgstr "عند الضغط، استخدم I<.suf> كملحق للملف الهدف بدلاً من B<.xz> أو B<.lzma>. إذا لم تكن الكتابة إلى المخرج القياسي وكان ملف المصدر يمتلك بالفعل الملحق I<.suf>، يُعرض تحذير ويُتخطى الملف." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When decompressing, recognize files with the suffix I<.suf> in addition to files with the B<.xz>, B<.txz>, B<.lzma>, B<.tlz>, or B<.lz> suffix. If the source file has the suffix I<.suf>, the suffix is removed to get the target filename." +msgstr "عند فك الضغط، تعرف على الملفات ذات الملحق I<.suf> بالإضافة إلى الملفات ذات الملحقات B<.xz> أو B<.txz> أو B<.lzma> أو B<.tlz> أو B<.lz>. إذا كان لملف المصدر الملحق I<.suf>، يُزال الملحق للحصول على اسم الملف الهدف." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When compressing or decompressing raw streams (B<--format=raw>), the suffix must always be specified unless writing to standard output, because there is no default suffix for raw streams." +msgstr "عند ضغط أو فك ضغط التدفقات الخام (B<--format=raw>)، يجب دائماً تحديد الملحق ما لم تكن الكتابة إلى المخرج القياسي، لأنه لا يوجد ملحق مبدئي للتدفقات الخام." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--files>[B<=>I]" +msgstr "B<--files>[B<=>I]" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Read the filenames to process from I; if I is omitted, filenames are read from standard input. Filenames must be terminated with the newline character. A dash (B<->) is taken as a regular filename; it doesn't mean standard input. If filenames are given also as command line arguments, they are processed before the filenames read from I." +msgstr "قراءة أسماء الملفات المطلوب معالجتها من I<ملف>؛ إذا حُذف I<ملف>، تُقرأ أسماء الملفات من المدخل القياسي. يجب إنهاء أسماء الملفات بحرف سطر جديد. تُعامل الشَرطة (B<->) كاسم ملف عادي؛ ولا تعني المدخل القياسي. إذا أُعطيت أسماء ملفات أيضاً كمعاملات لسطر الأوامر، فستتم معالجتها قبل أسماء الملفات المقروءة من I<ملف>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--files0>[B<=>I]" +msgstr "B<--files0>[B<=>I]" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This is identical to B<--files>[B<=>I] except that each filename must be terminated with the null character." +msgstr "هذا مطابق للخيار B<--files>[B<=>I] باستثناء أنه يجب إنهاء كل اسم ملف بالحرف الصفري (null)." + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "Basic file format and compression options" +msgstr "تنسيق الملف الأساسي وخيارات الضغط" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-F> I, B<--format=>I" +msgstr "B<-F> I, B<--format=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify the file I to compress or decompress:" +msgstr "حدد I<تنسيق> الملف للضغط أو فك الضغط:" + +#. TRANSLATORS: Don't translate bold string B. +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This is the default. When compressing, B is equivalent to B. When decompressing, the format of the input file is automatically detected. Note that raw streams (created with B<--format=raw>) cannot be auto-detected." +msgstr "هذا هو المبدئي. عند الضغط، يكون B مكافئاً لـ B. عند فك الضغط، يُكتشف تنسيق ملف المدخلات آلياً. لاحظ أن التدفقات الخام (التي تم إنشاؤها باستخدام B<--format=raw>) لا يمكن اكتشافها آلياً." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compress to the B<.xz> file format, or accept only B<.xz> files when decompressing." +msgstr "الضغط بتنسيق ملف B<.xz>، أو قبول ملفات B<.xz> فقط عند فك الضغط." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B, B" +msgstr "B, B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compress to the legacy B<.lzma> file format, or accept only B<.lzma> files when decompressing. The alternative name B is provided for backwards compatibility with LZMA Utils." +msgstr "الضغط بتنسيق ملف B<.lzma> القديم، أو قبول ملفات B<.lzma> فقط عند فك الضغط. تم توفير الاسم البديل B للتوافق مع الإصدارات السابقة من أدوات LZMA." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Accept only B<.lz> files when decompressing. Compression is not supported." +msgstr "قبول ملفات B<.lz> فقط عند فك الضغط. الضغط غير مدعوم." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The B<.lz> format versions 0 and 1 are supported. Version 0 files were produced by B 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 B 1.18. B 1.4 and later create files in the format version 1." +msgstr "تنسيق B<.lz> الإصداران 0 و 1 مدعومان. ملفات الإصدار 0 أُنتجت بواسطة B 1.3 وما قبله. هذه الملفات ليست شائعة ولكن يمكن العثور عليها في أرشيفات الملفات حيث أُصدرت بعض حزم المصدر بهذا التنسيق. قد يمتلك الأشخاص ملفات شخصية قديمة بهذا التنسيق أيضاً. أزيل دعم فك الضغط لتنسيق الإصدار 0 في B 1.18. يقوم B 1.4 والإصدارات الأحدث بإنشاء ملفات بتنسيق الإصدار 1." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compress or uncompress a raw stream (no headers). This is meant for advanced users only. To decode raw streams, you need use B<--format=raw> and explicitly specify the filter chain, which normally would have been stored in the container headers." +msgstr "ضغط أو فك ضغط تدفق خام (بدون ترويسات). هذا مخصص للمستخدمين المتقدمين فقط. لفك ترميز التدفقات الخام، تحتاج لاستخدام B<--format=raw> وتحديد سلسلة المرشحات صراحة، والتي كان من المفترض تخزينها في ترويسات الحاوية بشكل طبيعي." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-C> I, B<--check=>I" +msgstr "B<-C> I, B<--check=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify the type of the integrity check. The check is calculated from the uncompressed data and stored in the B<.xz> file. This option has an effect only when compressing into the B<.xz> format; the B<.lzma> format doesn't support integrity checks. The integrity check (if any) is verified when the B<.xz> file is decompressed." +msgstr "حدد نوع فحص السلامة. يتم حساب الفحص من البيانات غير المضغوطة ويُخزن في ملف B<.xz>. هذا الخيار له تأثير فقط عند الضغط بتنسيق B<.xz>؛ تنسيق B<.lzma> لا يدعم فحوصات السلامة. يتم التحقق من فحص السلامة (إن وجد) عند فك ضغط ملف B<.xz>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Supported I types:" +msgstr "أنواع I<الفحص> المدعومة:" + +#. TRANSLATORS: Don't translate the bold strings B, B, +#. B, and B. The command line option --check accepts +#. only the untranslated strings. +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "عدم حساب فحص السلامة على الإطلاق. عادة ما تكون هذه فكرة سيئة. قد يكون هذا مفيداً عندما يتم التحقق من سلامة البيانات بوسائل أخرى على أي حال." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Calculate CRC32 using the polynomial from IEEE-802.3 (Ethernet)." +msgstr "حساب CRC32 باستخدام الحدودية من IEEE-802.3 (إيثرنت)." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 negligible." +msgstr "حساب CRC64 باستخدام الحدودية من ECMA-182. هذا هو المبدئي، لأنه أفضل قليلاً من CRC32 في اكتشاف الملفات التالفة وفارق السرعة ضئيل." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Calculate SHA-256. This is somewhat slower than CRC32 and CRC64." +msgstr "حساب SHA-256. هذا أبطأ نوعاً ما من CRC32 و CRC64." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Integrity of the B<.xz> headers is always verified with CRC32. It is not possible to change or disable it." +msgstr "يتم دائماً التحقق من سلامة ترويسات B<.xz> باستخدام CRC32. لا يمكن تغييره أو تعطيله." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--ignore-check>" +msgstr "B<--ignore-check>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Don't verify the integrity check of the compressed data when decompressing. The CRC32 values in the B<.xz> headers will still be verified normally." +msgstr "عدم التحقق من فحص سلامة البيانات المضغوطة عند فك الضغط. سيستمر التحقق من قيم CRC32 في ترويسات B<.xz> بشكل طبيعي." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B Possible reasons to use this option:" +msgstr "B<لا تستخدم هذا الخيار إلا إذا كنت تعرف ما تفعله.> الأسباب المحتملة لاستخدام هذا الخيار:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Trying to recover data from a corrupt .xz file." +msgstr "محاولة استعادة البيانات من ملف .xz تالف." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "تسريع فك الضغط. يهم هذا غالباً مع SHA-256 أو مع الملفات التي ضُغطت بشكل جيد للغاية. يوصى بعدم استخدام هذا الخيار لهذا الغرض إلا إذا تم التحقق من سلامة الملف خارجياً بطريقة أخرى." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-0> ... B<-9>" +msgstr "B<-0> ... B<-9>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Select a compression preset level. The default is B<-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." +msgstr "اختر مستوى ضغط معداً مسبقاً. المستوى المبدئي هو B<-6>. إذا حُددت عدة مستويات معدة مسبقاً، فإن الأخير هو الذي يسري مفعوله. إذا تم تحديد سلسلة مرشحات مخصصة بالفعل، فإن اختيار مستوى ضغط معد مسبقاً يمسح سلسلة المرشحات المخصصة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The differences between the presets are more significant than with B(1) and B(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, B like it often is with B(1) and B(1)." +msgstr "الاختلافات بين الإعدادات المسبقة أكثر وضوحاً مما هي عليه في B(1) و B(1). تحدد إعدادات الضغط المختارة متطلبات الذاكرة لفك الضغط، لذا فإن استخدام مستوى مرتفع جداً قد يجعل فك ضغط الملف مؤلماً على نظام قديم بذاكرة وصول عشوائي قليلة. تحديداً، B<ليست فكرة جيدة استخدام -9 بشكل أعمى لكل شيء> كما هو الحال غالباً مع B(1) و B(1)." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-0> ... B<-3>" +msgstr "B<-0> ... B<-3>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "These are somewhat fast presets. B<-0> is sometimes faster than B while compressing much better. The higher ones often have speed comparable to B(1) with comparable or better compression ratio, although the results depend a lot on the type of data being compressed." +msgstr "تُعد هذه عمليات ضبط مسبق سريعة نوعاً ما. يكون المستوى B<-0> أحياناً أسرع من B مع توفير ضغط أفضل بكثير. وغالباً ما تملك المستويات الأعلى سرعة تُضاهي B(1) مع نسبة ضغط مماثلة أو أفضل، رغم أن النتائج تعتمد كثيراً على نوع البيانات الجاري ضغطها." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-4> ... B<-6>" +msgstr "B<-4> ... B<-6>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Good to very good compression while keeping decompressor memory usage reasonable even for old systems. B<-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. (B<-5e> or B<-6e> may be worth considering too. See B<--extreme>.)" +msgstr "ضغط جيد إلى جيد جداً مع الحفاظ على استهلاك ذاكرة فك الضغط معقولاً حتى للأنظمة القديمة. B<-6> هو المبدئي، وهو عادة خيار جيد لتوزيع الملفات التي يجب أن تكون قابلة لفك الضغط حتى على أنظمة بذاكرة 16\\ ميجابايت فقط. (قد يكون من الجدير بالذكر التفكير في B<-5e> أو B<-6e> أيضاً. انظر B<--extreme>.)" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-7 ... -9>" +msgstr "B<-7 ... -9>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "These are like B<-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." +msgstr "هذه تشبه B<-6> ولكن مع متطلبات ذاكرة أعلى للضغط وفك الضغط. هذه مفيدة فقط عند ضغط ملفات أكبر من 8\\ ميجابايت، و 16\\ ميجابايت، و 32\\ ميجابايت على التوالي." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "على نفس العتاد، سرعة فك الضغط هي تقريباً عدد ثابت من بايتات البيانات المضغوطة في الثانية. بمعنى آخر، كلما كان الضغط أفضل، كان فك الضغط أسرع عادة. يعني هذا أيضاً أن كمية المخرج غير المضغوط المنتج في الثانية يمكن أن تختلف كثيراً." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The following table summarises the features of the presets:" +msgstr "يلخص الجدول التالي مميزات الإعدادات المسبقة:" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "Preset" +msgstr "المستوى" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "DictSize" +msgstr "حجم القاموس" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "CompCPU" +msgstr "معالج الضغط" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "CompMem" +msgstr "ذاكرة الضغط" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "DecMem" +msgstr "ذاكرة فك الضغط" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-0" +msgstr "-0" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "256 KiB" +msgstr "256 كيلوبايت" + +#. type: TP +#: ../src/xz/xz.1 ../src/scripts/xzgrep.1 +#, no-wrap +msgid "0" +msgstr "0" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "3 MiB" +msgstr "3 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "1 MiB" +msgstr "1 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-1" +msgstr "-1" + +#. type: TP +#: ../src/xz/xz.1 ../src/scripts/xzgrep.1 +#, no-wrap +msgid "1" +msgstr "1" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "9 MiB" +msgstr "9 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "2 MiB" +msgstr "2 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-2" +msgstr "-2" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "2" +msgstr "2" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "17 MiB" +msgstr "17 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-3" +msgstr "-3" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "4 MiB" +msgstr "4 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "3" +msgstr "3" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "32 MiB" +msgstr "32 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "5 MiB" +msgstr "5 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-4" +msgstr "-4" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "4" +msgstr "4" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "48 MiB" +msgstr "48 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-5" +msgstr "-5" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "8 MiB" +msgstr "8 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "5" +msgstr "5" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "94 MiB" +msgstr "94 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-6" +msgstr "-6" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "6" +msgstr "6" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-7" +msgstr "-7" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "16 MiB" +msgstr "16 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "186 MiB" +msgstr "186 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-8" +msgstr "-8" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "370 MiB" +msgstr "370 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "33 MiB" +msgstr "33 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-9" +msgstr "-9" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "64 MiB" +msgstr "64 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "674 MiB" +msgstr "674 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "65 MiB" +msgstr "65 ميجابايت" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Column descriptions:" +msgstr "وصف الأعمدة:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 B<-7> ... B<-9> when there's no real need for them. At B<-6> and lower, the amount of memory wasted is usually low enough to not matter." +msgstr "DictSize هو حجم قاموس LZMA2. من هدر الذاكرة استخدام قاموس أكبر من حجم الملف غير المضغوط. لهذا السبب من الجيد تجنب استخدام الإعدادات المسبقة B<-7> ... B<-9> عندما لا تكون هناك حاجة حقيقية لها. في المستوى B<-6> وما دونه، تكون كمية الذاكرة المهدرة عادة منخفضة بما يكفي بحيث لا تهم." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 B<-6> ... B<-9>, higher levels still tend to be a little slower. To get even slower and thus possibly better compression, see B<--extreme>." +msgstr "CompCPU هو تمثيل مبسط لإعدادات LZMA2 التي تؤثر على سرعة الضغط. يؤثر حجم القاموس على السرعة أيضاً، لذا بينما CompCPU هو نفسه للمستويات B<-6> ... B<-9>، فإن المستويات الأعلى لا تزال تميل إلى أن تكون أبطأ قليلاً. للحصول على ضغط أبطأ وبالتالي ربما أفضل، انظر B<--extreme>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "CompMem contains the compressor memory requirements in the single-threaded mode. It may vary slightly between B versions." +msgstr "CompMem يحتوي على متطلبات ذاكرة الضغط في وضع الخيط الواحد. قد يختلف قليلاً بين إصدارات B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "DecMem يحتوي على متطلبات ذاكرة فك الضغط. أي أن إعدادات الضغط تحدد متطلبات الذاكرة لفك الضغط. استهلاك ذاكرة فك الضغط الفعلي هو أكثر بقليل من حجم قاموس LZMA2، ولكن تم تقريب القيم في الجدول إلى أقرب ميجابايت كاملة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Memory requirements of the multi-threaded mode are significantly higher than that of the single-threaded mode. With the default value of B<--block-size>, each thread needs 3*3*DictSize plus CompMem or DecMem. For example, four threads with preset B<-6> needs 660\\(en670\\ MiB of memory." +msgstr "متطلبات الذاكرة لوضع الخيوط المتعددة أعلى بكثير من وضع الخيط الواحد. مع القيمة المبدئية لـ B<--block-size>، يحتاج كل خيط إلى 3*3*DictSize بالإضافة إلى CompMem أو DecMem. على سبيل المثال، أربعة خيوط مع المستوى B<-6> تحتاج من 660 إلى 670 ميجابايت من الذاكرة." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-e>, B<--extreme>" +msgstr "B<-e>, B<--extreme>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Use a slower variant of the selected compression preset level (B<-0> ... B<-9>) to hopefully get a little bit better compression ratio, but with bad luck this can also make it worse. Decompressor memory usage is not affected, but compressor memory usage increases a little at preset levels B<-0> ... B<-3>." +msgstr "استخدم نوعاً أبطأ من مستوى الضغط المختار (B<-0> ... B<-9>) على أمل الحصول على نسبة ضغط أفضل قليلاً، ولكن مع سوء الحظ قد يجعل هذا الأمر أسوأ. لا يتأثر استهلاك ذاكرة فك الضغط، ولكن استهلاك ذاكرة الضغط يزداد قليلاً في المستويات B<-0> ... B<-3>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Since there are two presets with dictionary sizes 4\\ MiB and 8\\ MiB, the presets B<-3e> and B<-5e> use slightly faster settings (lower CompCPU) than B<-4e> and B<-6e>, respectively. That way no two presets are identical." +msgstr "بما أن هناك مستويين بحجم قاموس 4 ميجابايت و 8 ميجابايت، فإن المستويين B<-3e> و B<-5e> يستخدمان إعدادات أسرع قليلاً (CompCPU أقل) من B<-4e> و B<-6e> على التوالي. بهذه الطريقة لا توجد مستويات متطابقة." + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-0e" +msgstr "-0e" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "8" +msgstr "8" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-1e" +msgstr "-1e" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "13 MiB" +msgstr "13 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-2e" +msgstr "-2e" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "25 MiB" +msgstr "25 ميجابايت" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-3e" +msgstr "-3e" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "7" +msgstr "7" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-4e" +msgstr "-4e" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-5e" +msgstr "-5e" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-6e" +msgstr "-6e" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-7e" +msgstr "-7e" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-8e" +msgstr "-8e" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "-9e" +msgstr "-9e" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "For example, there are a total of four presets that use 8\\ MiB dictionary, whose order from the fastest to the slowest is B<-5>, B<-6>, B<-5e>, and B<-6e>." +msgstr "على سبيل المثال، هناك إجمالي أربعة إعدادات مسبقة تستخدم قاموساً بحجم 8 ميجابايت، وترتيبها من الأسرع إلى الأبطأ هو B<-5> و B<-6> و B<-5e> و B<-6e>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--fast>" +msgstr "B<--fast>" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--best>" +msgstr "B<--best>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "These are somewhat misleading aliases for B<-0> and B<-9>, respectively. These are provided only for backwards compatibility with LZMA Utils. Avoid using these options." +msgstr "هذه أسماء بديلة مضللة نوعاً ما لـ B<-0> و B<-9> على التوالي. تم توفيرها فقط للتوافق مع الإصدارات السابقة من أدوات LZMA. تجنب استخدام هذه الخيارات." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--block-size=>I" +msgstr "B<--block-size=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When compressing to the B<.xz> format, split the input data into blocks of I bytes. The blocks are compressed independently from each other, which helps with multi-threading and makes limited random-access decompression possible. This option is typically used to override the default block size in multi-threaded mode, but this option can be used in single-threaded mode too." +msgstr "عند الضغط بتنسيق B<.xz>، قم بتقسيم بيانات المدخلات إلى كتل بحجم I بايت. تُضغط الكتل بشكل مستقل عن بعضها البعض، مما يساعد في تعدد الخيوط ويجعل فك الضغط العشوائي المحدود ممكناً. يستخدم هذا الخيار عادةً لتجاوز حجم الكتلة المبدئي في وضع تعدد الخيوط، ولكن يمكن استخدامه في وضع الخيط الواحد أيضاً." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "In multi-threaded mode about three times I bytes will be allocated in each thread for buffering input and output. The default I is three times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a good value is 2\\(en4 times the size of the LZMA2 dictionary or at least 1 MiB. Using I 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 decompression." +msgstr "في وضع تعدد الخيوط، يتم تخصيص حوالي ثلاثة أضعاف I بايت في كل خيط لتخزين المدخلات والمخرجات مؤقتاً. الحجم I المبدئي هو ثلاثة أضعاف حجم قاموس LZMA2 أو 1 ميجابايت، أيهما أكثر. عادة ما تكون القيمة الجيدة من 2 إلى 4 أضعاف حجم قاموس LZMA2 أو على الأقل 1 ميجابايت. استخدام حجم I أقل من حجم قاموس LZMA2 هو هدر لذاكرة الوصول العشوائي لأن ذاكرة قاموس LZMA2 المؤقتة لن تُستخدم بالكامل أبداً. في وضع تعدد الخيوط، تُخزن أحجام الكتل في ترويسات الكتل. معلومات الحجم هذه مطلوبة لفك الضغط المتعدد الخيوط." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "In single-threaded mode no block splitting is done by default. Setting 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 B won't be able decompress the files in multi-threaded mode." +msgstr "في وضع الخيط الواحد لا يتم تقسيم الكتل بشكل مبدئي. ضبط هذا الخيار لا يؤثر على استهلاك الذاكرة. لا تُخزن معلومات الحجم في ترويسات الكتل، وبالتالي فإن الملفات المنشأة في وضع الخيط الواحد لن تكون متطابقة مع الملفات المنشأة في وضع تعدد الخيوط. نقص معلومات الحجم يعني أيضاً أن B لن يتمكن من فك ضغط الملفات في وضع تعدد الخيوط." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--block-list=>I" +msgstr "B<--block-list=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When compressing to the B<.xz> format, start a new block with an optional custom filter chain after the given intervals of uncompressed data." +msgstr "عند الضغط بتنسيق B<.xz>، ابدأ كتلة جديدة مع سلسلة مرشحات مخصصة اختيارية بعد فواصل زمنية معينة من البيانات غير المضغوطة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The I are a comma-separated list. Each item consists of an optional filter chain number between 0 and 9 followed by a colon (B<:>) 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." +msgstr "I<العناصر> هي قائمة مفصولة بفاصلة. يتكون كل عنصر من رقم سلسلة مرشحات اختياري بين 0 و 9 تليها نقطتان (B<:>) وحجم مطلوب للبيانات غير المضغوطة. حذف عنصر (فاصلتان متتاليتان أو أكثر) هو اختصار لاستخدام حجم ومرشحات العنصر السابق." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If the input file is bigger than the sum of the sizes in I, the last item is repeated until the end of the file. A special value of B<0> may be used as the last size to indicate that the rest of the file should be encoded as a single block." +msgstr "إذا كان ملف المدخلات أكبر من مجموع الأحجام في I<العناصر>، فسيتم تكرار العنصر الأخير حتى نهاية الملف. يمكن استخدام القيمة الخاصة B<0> كآخر حجم للإشارة إلى وجوب ترميز بقية الملف ككتلة واحدة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "An alternative filter chain for each block can be specified in combination with the B<--filters1=>I \\&...\\& B<--filters9=>I options. These options define filter chains with an identifier between 1\\(en9. 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 (B<:>). For example, if one specifies B<--block-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB> then blocks will be created using:" +msgstr "يمكن تحديد سلسلة مرشحات بديلة لكل كتلة بالاشتراك مع الخيارات B<--filters1=>I \\&...\\& B<--filters9=>I. تعرف هذه الخيارات سلاسل المرشحات بمعرف بين 1 و 9. يمكن استخدام سلسلة المرشحات 0 للإشارة إلى سلسلة المرشحات المبدئية، وهو ما يماثل عدم تحديد سلسلة مرشحات. يمكن استخدام معرف سلسلة المرشحات قبل الحجم غير المضغوط، متبوعاً بنقطتين (B<:>). على سبيل المثال، إذا حدد أحدهم B<--block-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB> فسيتم إنشاء الكتل باستخدام:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The filter chain specified by B<--filters1> and 2 MiB input" +msgstr "سلسلة المرشحات المحددة بواسطة B<--filters1> و 2 ميجابايت من المدخلات" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The filter chain specified by B<--filters3> and 2 MiB input" +msgstr "سلسلة المرشحات المحددة بواسطة B<--filters3> و 2 ميجابايت من المدخلات" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The filter chain specified by B<--filters2> and 4 MiB input" +msgstr "سلسلة المرشحات المحددة بواسطة B<--filters2> و 4 ميجابايت من المدخلات" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The default filter chain and 2 MiB input" +msgstr "سلسلة المرشحات المبدئية و 2 ميجابايت من المدخلات" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The default filter chain and 4 MiB input for every block until end of input." +msgstr "سلسلة المرشحات المبدئية و 4 ميجابايت من المدخلات لكل كتلة حتى نهاية المدخلات." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If one specifies a size that exceeds the encoder's block size (either the default value in threaded mode or the value specified with B<--block-size=>I), the encoder will create additional blocks while keeping the boundaries specified in I. For example, if one specifies B<--block-size=10MiB> B<--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." +msgstr "إذا حدد أحدهم حجماً يتجاوز حجم كتلة المرمّز (سواء القيمة المبدئية في وضع تعدد الخيوط أو القيمة المحددة باستخدام B<--block-size=>I)، فسيقوم المرمّز بإنشاء كتل إضافية مع الحفاظ على الحدود المحددة في I<العناصر>. على سبيل المثال، إذا حدد أحدهم B<--block-size=10MiB> و B<--block-list=5MiB,10MiB,8MiB,12MiB,24MiB> وكان ملف المدخلات 80 ميجابايت، فسيحصل على 11 كتلة: 5، 10، 8، 10، 2، 10، 10، 4، 10، 10، و 1 ميجابايت." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "في وضع تعدد الخيوط تُخزن أحجام الكتل في ترويسات الكتل. لا يتم ذلك في وضع الخيط الواحد، لذا لن يكون المخرج المرمّز مطابقاً لمخرج وضع تعدد الخيوط." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--flush-timeout=>I" +msgstr "B<--flush-timeout=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When compressing, if more than I 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 B is used to compress data that is streamed over a network. Small I values make the data available at the receiving end with a small delay, but large I values give better compression ratio." +msgstr "عند الضغط، إذا مر أكثر من I ميلي ثانية (عدد صحيح موجب) منذ التفريغ السابق وكان قراءة المزيد من المدخلات سيؤدي إلى التوقف، فسيتم تفريغ جميع بيانات المدخلات المعلقة من المرمّز وجعلها متاحة في تدفق المخرجات. يمكن أن يكون هذا مفيداً إذا استخدم B لضغط البيانات التي تتدفق عبر الشبكة. تجعل قيم I الصغيرة البيانات متاحة في طرف الاستلام بتأخير بسيط، لكن قيم I الكبيرة تعطي نسبة ضغط أفضل." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This feature is disabled by default. If this option is specified more than once, the last one takes effect. The special I value of B<0> can be used to explicitly disable this feature." +msgstr "هذه الميزة معطلة بشكل مبدئي. إذا حُدد هذا الخيار أكثر من مرة، فإن الأخير هو الذي يسري مفعوله. يمكن استخدام قيمة I الخاصة B<0> لتعطيل هذه الميزة صراحة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This feature is not available on non-POSIX systems." +msgstr "هذه الميزة غير متوفرة في الأنظمة غير المتوافقة مع POSIX." + +#. FIXME +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B Currently B is unsuitable for decompressing the stream in real time due to how B does buffering." +msgstr "B<هذه الميزة لا تزال تجريبية.> حالياً يعد B غير مناسب لفك ضغط التدفق في الوقت الفعلي نظراً لكيفية قيام B بالتخزين المؤقت." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--no-sync>" +msgstr "B<--no-sync>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Do not synchronize the target file and its directory to the storage device before removing the source file. This can improve 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 storage device but the delete operation was. In that case neither the original source file nor the target file is available." +msgstr "عدم مزامنة الملف الهدف ودليله مع جهاز التخزين قبل حذف ملف المصدر. يمكن لهذا أن يحسن الأداء عند ضغط أو فك ضغط العديد من الملفات الصغيرة. ومع ذلك، إذا تعطل النظام بعد الحذف بفترة وجيزة، فمن المحتمل ألا يكون الملف الهدف قد كُتب على جهاز التخزين رغم تنفيذ عملية الحذف. في هذه الحالة، لن يتوفر ملف المصدر الأصلي ولا الملف الهدف." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This option has an effect only when B is going to remove the source file. In other cases synchronization is never done." +msgstr "هذا الخيار له تأثير فقط عندما يهم B بحذف ملف المصدر. في الحالات الأخرى لا تتم المزامنة أبداً." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The synchronization and B<--no-sync> were added in B 5.7.1alpha." +msgstr "أضيفت المزامنة و B<--no-sync> في B 5.7.1alpha." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--memlimit-compress=>I" +msgstr "B<--memlimit-compress=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Set a memory usage limit for compression. If this option is specified multiple times, the last one takes effect." +msgstr "تعيين حد استهلاك الذاكرة للضغط. إذا حُدد هذا الخيار عدة مرات، فإن الأخير هو الذي يسري مفعوله." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If the compression settings exceed the I, B will attempt to adjust the settings downwards so that the limit is no longer exceeded 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 I, and finally reducing the LZMA2 dictionary size." +msgstr "إذا تجاوزت إعدادات الضغط I<الحد>، فسيحاول B ضبط الإعدادات نحو الأسفل بحيث لا يتم تجاوز الحد وعرض إشعار بأنه تم إجراء ضبط آلي. يتم الضبط بهذا الترتيب: تقليل عدد الخيوط، والتحويل إلى وضع الخيط الواحد إذا كان خيط واحد في وضع تعدد الخيوط يتجاوز I<الحد>، وأخيراً تقليل حجم قاموس LZMA2." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When compressing with B<--format=raw> or if B<--no-adjust> has been specified, only the number of threads may be reduced since it can be done without affecting the compressed output." +msgstr "عند الضغط باستخدام B<--format=raw> أو إذا تم تحديد B<--no-adjust>، يمكن فقط تقليل عدد الخيوط لأنه يمكن القيام بذلك دون التأثير على المخرج المضغوط." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If the I cannot be met even with the adjustments described above, an error is displayed and B will exit with exit status 1." +msgstr "إذا تعذر الالتزام بـ I<الحد> حتى مع عمليات الضبط الموضحة أعلاه، فسيُعرض خطأ ويخرج B بحالة الخروج 1." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The I can be specified in multiple ways:" +msgstr "يمكن تحديد I<الحد> بعدة طرق:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The I can be an absolute value in bytes. Using an integer suffix like B can be useful. Example: B<--memlimit-compress=80MiB>" +msgstr "يمكن أن يكون I<الحد> قيمة مطلقة بالبايت. استخدام لاحقة عددية مثل B قد يكون مفيداً. مثال: B<--memlimit-compress=80MiB>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The I can be specified as a percentage of total physical memory (RAM). This can be useful especially when setting the B environment variable in a shell initialization script that is shared between different computers. That way the limit is automatically bigger on systems with more memory. Example: B<--memlimit-compress=70%>" +msgstr "يمكن تحديد I<الحد> كنسبة مئوية من إجمالي الذاكرة الفيزيائية (RAM). يمكن أن يكون هذا مفيداً خاصة عند ضبط متغير البيئة B في نص برمجي لبدء تشغيل الصدفة مشترك بين حواسيب مختلفة. بهذه الطريقة يكون الحد أكبر آلياً على الأنظمة ذات الذاكرة الأكبر. مثال: B<--memlimit-compress=70%>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The I can be reset back to its default value by setting it to B<0>. This is currently equivalent to setting the I to B (no memory usage limit)." +msgstr "يمكن إعادة I<الحد> إلى قيمته المبدئية بضبطه على B<0>. هذا يعادل حالياً ضبط I<الحد> على B (لا يوجد حد لاستهلاك الذاكرة)." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "For 32-bit B there is a special case: if the I would be over B<4020\\ MiB>, the I is set to B<4020\\ MiB>. On MIPS32 B<2000\\ MiB> is used instead. (The values B<0> and B 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." +msgstr "بالنسبة لنسخة B ذات 32 بت، هناك حالة خاصة: إذا كان I<الحد> سيتجاوز B<4020\\ MiB>، فسيتم ضبط I<الحد> على B<4020\\ MiB>. في MIPS32 يتم استخدام B<2000\\ MiB> بدلاً من ذلك. (القيم B<0> و B لا تتأثر بهذا. لا توجد ميزة مماثلة لفك الضغط). يمكن أن يكون هذا مفيداً عندما يكون لملف تنفيذي 32 بت إمكانية الوصول إلى مساحة عنوان 4 جيجابايت (2 جيجابايت في MIPS32) مع الأمل في عدم إلحاق ضرر في الحالات الأخرى." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "See also the section B." +msgstr "انظر أيضاً قسم B<استهلاك الذاكرة>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--memlimit-decompress=>I" +msgstr "B<--memlimit-decompress=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Set a memory usage limit for decompression. This also affects the B<--list> mode. If the operation is not possible without exceeding the I, B will display an error and decompressing the file will fail. See B<--memlimit-compress=>I for possible ways to specify the I." +msgstr "تعيين حد استهلاك الذاكرة لفك الضغط. يؤثر هذا أيضاً على وضع B<--list>. إذا كانت العملية غير ممكنة دون تجاوز I<الحد>، فسيقوم B بعرض خطأ ويفشل فك ضغط الملف. انظر B<--memlimit-compress=>I للتعرف على الطرق الممكنة لتحديد I<الحد>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--memlimit-mt-decompress=>I" +msgstr "B<--memlimit-mt-decompress=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Set a memory usage limit for multi-threaded decompression. This can only affect the number of threads; this will never make B refuse to decompress a file. If I is too low to allow any multi-threading, the I is ignored and B will continue in single-threaded mode. Note that if also B<--memlimit-decompress> is used, it will always apply to both single-threaded and multi-threaded modes, and so the effective I for multi-threading will never be higher than the limit set with B<--memlimit-decompress>." +msgstr "تعيين حد استهلاك الذاكرة لفك الضغط المتعدد الخيوط. يمكن أن يؤثر هذا فقط على عدد الخيوط؛ لن يجعل هذا B يرفض فك ضغط ملف أبداً. إذا كان I<الحد> منخفضاً جداً بحيث لا يسمح بتعدد الخيوط، فسيتم تجاهل I<الحد> وسيقوم B بالاستمرار في وضع الخيط الواحد. لاحظ أنه في حال استخدام B<--memlimit-decompress> أيضاً، فسيتم تطبيقه دائماً على وضعي الخيط الواحد وتعدد الخيوط، وبالتالي لن يكون I<الحد> الفعلي لتعدد الخيوط أعلى من الحد المحدد بواسطة B<--memlimit-decompress>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "In contrast to the other memory usage limit options, B<--memlimit-mt-decompress=>I has a system-specific default I. B can be used to see the current value." +msgstr "على عكس خيارات حدود استهلاك الذاكرة الأخرى، يمتلك B<--memlimit-mt-decompress=>I حداً مبدئياً خاصاً بالنظام. يمكن استخدام B لرؤية القيمة الحالية." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 I is too low on your system, feel free to increase the I but never set it to a value larger than the amount of usable RAM as with appropriate input files B 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 performance." +msgstr "يوجد هذا الخيار وقيمته المبدئية لأنه بدون أي حد يمكن أن ينتهي الأمر ببرنامج فك الضغط المتعدد الخيوط بتخصيص كمية جنونية من الذاكرة مع بعض ملفات المدخلات. إذا كان I<الحد> المبدئي منخفضاً جداً على نظامك، فلا تتردد في زيادة I<الحد> ولكن لا تضبطه أبداً على قيمة أكبر من كمية ذاكرة الوصول العشوائي القابلة للاستخدام، حيث سيحاول B مع ملفات المدخلات المناسبة استخدام تلك الكمية من الذاكرة حتى مع وجود عدد قليل من الخيوط. نفاذ الذاكرة أو استخدام مساحة التبادل لن يحسن أداء فك الضغط." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "See B<--memlimit-compress=>I for possible ways to specify the I. Setting I to B<0> resets the I to the default system-specific value." +msgstr "انظر B<--memlimit-compress=>I للتعرف على الطرق الممكنة لتحديد I<الحد>. ضبط I<الحد> على B<0> يعيد I<الحد> إلى القيمة المبدئية الخاصة بالنظام." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-M> I, B<--memlimit=>I, B<--memory=>I" +msgstr "B<-M> I, B<--memlimit=>I, B<--memory=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This is equivalent to specifying B<--memlimit-compress=>I B<--memlimit-decompress=>I B<--memlimit-mt-decompress=>I." +msgstr "هذا يعادل تحديد B<--memlimit-compress=>I و B<--memlimit-decompress=>I و B<--memlimit-mt-decompress=>I." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--no-adjust>" +msgstr "B<--no-adjust>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 B 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." +msgstr "عرض خطأ والخروج إذا تعذر الالتزام بحد استهلاك الذاكرة دون ضبط الإعدادات التي تؤثر على المخرج المضغوط. أي أن هذا يمنع B من تحويل المرمّز من وضع تعدد الخيوط إلى وضع الخيط الواحد ومن تقليل حجم قاموس LZMA2. حتى عند استخدام هذا الخيار، قد يتم تقليل عدد الخيوط للالتزام بحد استهلاك الذاكرة لأن ذلك لن يؤثر على المخرج المضغوط." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Automatic adjusting is always disabled when creating raw streams (B<--format=raw>)." +msgstr "الضبط الآلي معطل دائماً عند إنشاء تدفقات خام (B<--format=raw>)." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-T> I, B<--threads=>I" +msgstr "B<-T> I, B<--threads=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify the number of worker threads to use. Setting I to a special value B<0> makes B use up to as many threads as the processor(s) on the system support. The actual number of threads can be fewer than I 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." +msgstr "حدد عدد خيوط العمل المراد استخدامها. ضبط I على القيمة الخاصة B<0> يجعل B يستخدم عدداً من الخيوط يصل إلى ما يدعمه المعالج (أو المعالجات) في النظام. قد يكون عدد الخيوط الفعلي أقل من I إذا لم يكن ملف المدخلات كبيراً بما يكفي لتعدد الخيوط مع الإعدادات المعطاة أو إذا كان استخدام المزيد من الخيوط سيتجاوز حد استهلاك الذاكرة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 decompressed using multiple threads. Setting I to B<1> will use the single-threaded mode. Setting I to any other value, including B<0>, will use the multi-threaded compressor even if the system supports only one hardware thread. (B 5.2.x used single-threaded mode in this situation.)" +msgstr "ينتج ضاغط الخيط الواحد وضاغط تعدد الخيوط مخرجات مختلفة. سيعطي ضاغط الخيط الواحد أصغر حجم ملف ولكن فقط مخرجات ضاغط تعدد الخيوط يمكن فك ضغطها باستخدام عدة خيوط. ضبط I على B<1> سيستخدم وضع الخيط الواحد. ضبط I على أي قيمة أخرى، بما في ذلك B<0>، سيستخدم ضاغط تعدد الخيوط حتى لو كان النظام يدعم خيطاً عتادياً واحداً فقط. (كان B 5.2.x يستخدم وضع الخيط الواحد في هذه الحالة)." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "To use multi-threaded mode with only one thread, set I to B<+1>. The B<+> prefix has no effect with values other than B<1>. A memory usage limit can still make B switch to single-threaded mode unless B<--no-adjust> is used. Support for the B<+> prefix was added in B 5.4.0." +msgstr "لاستخدام وضع تعدد الخيوط مع خيط واحد فقط، اضبط I على B<+1>. السابقة B<+> ليس لها تأثير مع قيم أخرى غير B<1>. لا يزال بإمكان حد استهلاك الذاكرة أن يجعل B يتحول إلى وضع الخيط الواحد ما لم يتم استخدام B<--no-adjust>. أُضيف دعم السابقة B<+> في B 5.4.0." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 becomes one, thus a soft limit will never stop B from compressing or decompressing. This default soft limit will not make B switch from multi-threaded mode to single-threaded mode. The active limits can be seen with B." +msgstr "إذا تم طلب عدد آلي من الخيوط ولم يتم تحديد حد لاستهلاك الذاكرة، فسيتم استخدام حد مرن مبدئي خاص بالنظام لاحتمال تقليل عدد الخيوط. هو حد مرن بمعنى أنه يتم تجاهله إذا أصبح عدد الخيوط واحداً، وبالتالي فإن الحد المرن لن يمنع B أبداً من الضغط أو فك الضغط. هذا الحد المرن المبدئي لن يجعل B يتحول من وضع تعدد الخيوط إلى وضع الخيط الواحد. يمكن رؤية الحدود النشطة باستخدام B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 B<--block-size=>I option." +msgstr "حالياً الطريقة الوحيدة لتعدد الخيوط هي تقسيم المدخلات إلى كتل وضغطها بشكل مستقل عن بعضها البعض. يعتمد حجم الكتلة المبدئي على مستوى الضغط ويمكن تجاوزه باستخدام الخيار B<--block-size=>I." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 B<--block-size=>I has been used." +msgstr "يعمل فك الضغط المتعدد الخيوط فقط على الملفات التي تحتوي على كتل متعددة مع معلومات الحجم في ترويسات الكتل. جميع الملفات الكبيرة بما يكفي والمضغوطة في وضع تعدد الخيوط تفي بهذا الشرط، لكن الملفات المضغوطة في وضع الخيط الواحد لا تفي به حتى لو تم استخدام B<--block-size=>I." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The default value for I is B<0>. In B 5.4.x and older the default is B<1>." +msgstr "القيمة المبدئية لـ I هي B<0>. في B 5.4.x والإصدارات الأقدم كانت القيمة المبدئية هي B<1>." + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "Custom compressor filter chains" +msgstr "سلاسل مرشحات ضاغط مخصصة" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "A custom filter chain allows specifying the compression settings in detail instead of relying on the settings associated to the presets. When a custom filter chain is specified, preset options (B<-0> \\&...\\& B<-9> and B<--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." +msgstr "تسمح سلسلة المرشحات المخصصة بتحديد إعدادات الضغط بالتفصيل بدلاً من الاعتماد على الإعدادات المرتبطة بالمستويات المعدة مسبقاً. عند تحديد سلسلة مرشحات مخصصة، يتم نسيان خيارات المستويات المسبقة (B<-0> \\&...\\& B<-9> و B<--extreme>) المذكورة سابقاً في سطر الأوامر. إذا تم تحديد خيار مستوى مسبق بعد واحد أو أكثر من خيارات سلسلة المرشحات المخصصة، فإن المستوى المسبق الجديد يسري مفعوله ويتم نسيان خيارات سلسلة المرشحات المخصصة المحددة سابقاً." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "A filter chain is comparable to piping on the command line. When compressing, 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." +msgstr "سلسلة المرشحات تشبه الأنابيب (piping) في سطر الأوامر. عند الضغط، تذهب المدخلات غير المضغوطة إلى المرشح الأول، والذي يذهب مخرجه إلى المرشح التالي (إن وجد). يُكتب مخرج المرشح الأخير في الملف المضغوط. الحد الأقصى لعدد المرشحات في السلسلة هو أربعة، ولكن عادةً ما تحتوي سلسلة المرشحات على مرشح واحد أو اثنين فقط." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 exists to prevent security issues." +msgstr "تمتلك العديد من المرشحات قيوداً على مكان وجودها في سلسلة المرشحات: بعض المرشحات يمكن أن تعمل فقط كآخر مرشح في السلسلة، وبعضها فقط كمرشح غير أخير، وبعضها يعمل في أي موضع في السلسلة. اعتماداً على المرشح، يكون هذا القيد إما متأصلاً في تصميم المرشح أو موجوداً لمنع المشكلات الأمنية." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "A custom filter chain can be specified in two different ways. The options B<--filters=>I and B<--filters1=>I \\&...\\& B<--filters9=>I 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 filter options is significant! When decoding raw streams (B<--format=raw>), the filter chain must be specified in the same order as it was specified when compressing. Any individual filter or preset options specified before the full chain option (B<--filters=>I) will be forgotten. Individual filters specified after the full chain option will reset the filter chain." +msgstr "يمكن تحديد سلسلة مرشحات مخصصة بطريقتين مختلفتين. تسمح الخيارات B<--filters=>I و B<--filters1=>I \\&...\\& B<--filters9=>I بتحديد سلسلة مرشحات كاملة في خيار واحد باستخدام صيغة نص مرشح liblzma. بدلاً من ذلك، يمكن تحديد سلسلة مرشحات باستخدام خيار مرشح فردي واحد أو أكثر بالترتيب المطلوب في سلسلة المرشحات. أي أن ترتيب خيارات المرشحات الفردية مهم! عند فك ترميز التدفقات الخام (B<--format=raw>)، يجب تحديد سلسلة المرشحات بنفس الترتيب الذي حُددت به عند الضغط. سيتم نسيان أي مرشح فردي أو خيارات مستوى مسبق محددة قبل خيار السلسلة الكاملة (B<--filters=>I). المرشحات الفردية المحددة بعد خيار السلسلة الكاملة ستعيد ضبط سلسلة المرشحات." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Both the full and individual filter options take filter-specific I as a comma-separated list. Extra commas in I are ignored. Every option has a default value, so specify those you want to change." +msgstr "تأخذ كل من خيارات المرشح الكاملة والفردية I<خيارات> خاصة بالمرشح كقائمة مفصولة بفاصلة. الفواصل الزائدة في I<الخيارات> يتم تجاهلها. كل خيار له قيمة مبدئية، لذا حدد فقط تلك التي تريد تغييرها." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "To see the whole filter chain and I, use B (that is, use B<--verbose> twice). This works also for viewing the filter chain options used by presets." +msgstr "لرؤية سلسلة المرشحات بالكامل و I<الخيارات>، استخدم B (أي استخدم B<--verbose> مرتين). يعمل هذا أيضاً لعرض خيارات سلسلة المرشحات المستخدمة بواسطة المستويات المسبقة." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--filters=>I" +msgstr "B<--filters=>I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify the full filter chain or a preset in a single option. Each filter can be separated by spaces or two dashes (B<-->). I may need to be quoted on the shell command line so it is parsed as a single option. To denote I, use B<:> or B<=>. A preset can be prefixed with a B<-> and followed with zero or more flags. The only supported flag is B to apply the same options as B<--extreme>." +msgstr "حدد سلسلة المرشحات الكاملة أو مستوى مسبقاً في خيار واحد. يمكن فصل كل مرشح بمسافات أو شرطتين (B<-->). قد تحتاج I<المرشحات> لوضعها بين علامتي اقتباس في سطر أوامر الصدفة ليتم تحليلها كخيار واحد. للإشارة إلى I<الخيارات>، استخدم B<:> أو B<=>. يمكن أن يسبق المستوى المسبق B<-> ويتبعه صفر أو أكثر من الأعلام. العلم الوحيد المدعوم هو B لتطبيق نفس خيارات B<--extreme>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--filters1>=I ... B<--filters9>=I" +msgstr "B<--filters1>=I ... B<--filters9>=I" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify up to nine additional filter chains that can be used with B<--block-list>." +msgstr "حدد ما يصل إلى تسع سلاسل مرشحات إضافية يمكن استخدامها مع B<--block-list>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "على سبيل المثال، عند ضغط أرشيف يحتوي على ملفات تنفيذية تليها ملفات نصية، يمكن للجزء التنفيذي استخدام سلسلة مرشحات مع مرشح BCJ والجزء النصي يستخدم مرشح LZMA2 فقط." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--filters-help>" +msgstr "B<--filters-help>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Display a help message describing how to specify presets and custom filter chains in the B<--filters> and B<--filters1=>I \\&...\\& B<--filters9=>I options, and exit successfully." +msgstr "عرض رسالة مساعدة تصف كيفية تحديد المستويات المسبقة وسلاسل المرشحات المخصصة في الخيارات B<--filters> و B<--filters1=>I \\&...\\& B<--filters9=>I، والخروج بنجاح." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--lzma1>[B<=>I]" +msgstr "B<--lzma1>[B<=>I]" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--lzma2>[B<=>I]" +msgstr "B<--lzma2>[B<=>I]" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Add LZMA1 or LZMA2 filter to the filter chain. These filters can be used only as the last filter in the chain." +msgstr "إضافة مرشح LZMA1 أو LZMA2 إلى سلسلة المرشحات. يمكن استخدام هذه المرشحات فقط كآخر مرشح في السلسلة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "LZMA1 is a legacy filter, which is supported almost solely due to the legacy B<.lzma> file format, which supports only LZMA1. LZMA2 is an updated version of LZMA1 to fix some practical issues of LZMA1. The B<.xz> format uses LZMA2 and doesn't support LZMA1 at all. Compression speed and ratios of LZMA1 and LZMA2 are practically the same." +msgstr "LZMA1 هو مرشح قديم، ومدعوم تقريباً فقط بسبب تنسيق ملف B<.lzma> القديم، الذي يدعم LZMA1 فقط. LZMA2 هو نسخة محدثة من LZMA1 لإصلاح بعض المشكلات العملية في LZMA1. يستخدم تنسيق B<.xz> مرشح LZMA2 ولا يدعم LZMA1 على الإطلاق. سرعة ونسب ضغط LZMA1 و LZMA2 متماثلة تقريباً." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "LZMA1 and LZMA2 share the same set of I:" +msgstr "يشترك LZMA1 و LZMA2 في نفس مجموعة I<الخيارات>:" + +#. TRANSLATORS: Don't translate bold strings like B, B, +#. B, B, B, or B because those are command line +#. options. On the other hand, do translate the italic strings like +#. I, I, and I, because such italic strings are +#. placeholders which a user replaces with an actual value. +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Reset all LZMA1 or LZMA2 I to I. I consist of an integer, which may be followed by single-letter preset modifiers. The integer can be from B<0> to B<9>, matching the command line options B<-0> \\&...\\& B<-9>. The only supported modifier is currently B, which matches B<--extreme>. If no B is specified, the default values of LZMA1 or LZMA2 I are taken from the preset B<6>." +msgstr "إعادة ضبط جميع I<خيارات> LZMA1 أو LZMA2 إلى I. يتكون I من عدد صحيح، قد يتبعه معدلات مستوى مسبق من حرف واحد. يمكن أن يكون العدد الصحيح من B<0> إلى B<9>، بما يطابق خيارات سطر الأوامر B<-0> \\&...\\& B<-9>. المعدل الوحيد المدعوم حالياً هو B، الذي يطابق B<--extreme>. إذا لم يتم تحديد B، فسيتم أخذ القيم المبدئية لـ I<خيارات> LZMA1 أو LZMA2 من المستوى المسبق B<6>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Dictionary (history buffer) I 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 bigger the dictionary, the higher is the chance to find a match. Thus, increasing dictionary I usually improves compression ratio, but a dictionary bigger than the uncompressed file is waste of memory." +msgstr "يشير I<حجم> القاموس (مخزن التاريخ المؤقت) إلى عدد بايتات البيانات غير المضغوطة التي تمت معالجتها مؤخراً والمحفوظة في الذاكرة. تحاول الخوارزمية العثور على تسلسلات بايت متكررة (تطابقات) في البيانات غير المضغوطة، واستبدالها بمراجع للبيانات الموجودة حالياً في القاموس. كلما كبر القاموس، زادت فرصة العثور على تطابق. وبالتالي، فإن زيادة I<حجم> القاموس يحسن عادةً نسبة الضغط، ولكن القاموس الأكبر من الملف غير المضغوط هو هدر للذاكرة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Typical dictionary I is from 64\\ KiB to 64\\ MiB. The minimum is 4\\ KiB. The maximum for compression is currently 1.5\\ GiB (1536\\ MiB). The decompressor already supports dictionaries up to one byte less than 4\\ GiB, which is the maximum for the LZMA1 and LZMA2 stream formats." +msgstr "I<حجم> القاموس النموذجي يتراوح من 64\\ كيلوبايت إلى 64\\ ميجابايت. الحد الأدنى هو 4\\ كيلوبايت. الحد الأقصى للضغط حالياً هو 1.5\\ جيجابايت (1536\\ ميجابايت). يدعم برنامج فك الضغط بالفعل قواميس تصل إلى أقل من 4\\ جيجابايت ببايب واحد، وهو الحد الأقصى لتنسيقات تدفق LZMA1 و LZMA2." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Dictionary I and match finder (I) together determine the memory usage of the LZMA1 or LZMA2 encoder. The same (or bigger) dictionary I 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 B<.xz> headers store the dictionary I either as 2^I or 2^I + 2^(I-1), so these I are somewhat preferred for compression. Other I will get rounded up when stored in the B<.xz> headers." +msgstr "يحدد I<حجم> القاموس وباحث التطابق (I) معاً مقدار استهلاك الذاكرة لمشفر LZMA1 أو LZMA2. يتطلب فك الضغط نفس I<حجم> القاموس (أو أكبر) الذي استُخدم عند الضغط، وبالتالي فإن استهلاك الذاكرة لفك الترميز يحدده حجم القاموس المستخدم أثناء الضغط. تخزن ترويسات B<.xz> I<حجم> القاموس إما كـ 2^I أو 2^I + 2^(I-1)، لذا تُفضل هذه I<الأحجام> نوعاً ما للضغط. الأحجام الأخرى تُقرب للأعلى عند تخزينها في ترويسات B<.xz>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 I and I must not exceed 4." +msgstr "حدد عدد بتات سياق الحروف (literal context bits). الحد الأدنى 0 والأقصى 4؛ الإعداد المبدئي هو 3. بالإضافة إلى ذلك، يجب ألا يتجاوز مجموع I و I العدد 4." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "كل البايتات التي لا يمكن تشفيرها كتطابقات تُشفر كحروف (literals). أي أن الحروف هي ببساطة بايتات من 8 بت تُشفر كل واحدة على حدة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The literal coding makes an assumption that the highest I 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 I is at least 3, the literal coding can take advantage of this property in the uncompressed data." +msgstr "يفترض ترميز الحروف أن أعلى بتات I من البايت السابق غير المضغوط ترتبط بالبايت التالي. على سبيل المثال، في النص الإنجليزي المعتاد، غالباً ما يتبع الحرف الكبير حرف صغير، والحرف الصغير يتبعه عادةً حرف صغير آخر. في مجموعة محارف US-ASCII، أعلى ثلاثة بتات هي 010 للحروف الكبيرة و 011 للحروف الصغيرة. عندما تكون I على الأقل 3، يستفيد ترميز الحروف من هذه الخاصية في البيانات غير المضغوطة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The default value (3) is usually good. If you want maximum compression, test B. Sometimes it helps a little, and sometimes it makes compression worse. If it makes it worse, test B too." +msgstr "القيمة المبدئية (3) جيدة عادةً. إذا أردت أقصى ضغط، اختبر B. أحياناً تساعد قليلاً، وأحياناً تجعل الضغط أسوأ. إذا جعلته أسوأ، اختبر B أيضاً." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify the number of literal position bits. The minimum is 0 and the maximum is 4; the default is 0." +msgstr "حدد عدد بتات موضع الحروف (literal position bits). الحد الأدنى 0 والأقصى 4؛ الإعداد المبدئي هو 0." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I affects what kind of alignment in the uncompressed data is assumed when encoding literals. See I below for more information about alignment." +msgstr "تؤثر I على نوع المحاذاة المفترضة في البيانات غير المضغوطة عند تشفير الحروف. انظر I أدناه لمزيد من المعلومات حول المحاذاة." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify the number of position bits. The minimum is 0 and the maximum is 4; the default is 2." +msgstr "حدد عدد بتات الموضع (position bits). الحد الأدنى 0 والأقصى 4؛ الإعداد المبدئي هو 2." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I affects what kind of alignment in the uncompressed data is assumed in general. The default means four-byte alignment (2^I=2^2=4), which is often a good choice when there's no better guess." +msgstr "تؤثر I على نوع المحاذاة المفترضة في البيانات غير المضغوطة بشكل عام. الإعداد المبدئي يعني محاذاة من أربعة بايتات (2^I=2^2=4)، وهو غالباً خيار جيد عند عدم وجود تخمين أفضل." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When the alignment is known, setting I accordingly may reduce the file size a little. For example, with text files having one-byte alignment (US-ASCII, ISO-8859-*, UTF-8), setting B can improve compression slightly. For UTF-16 text, B is a good choice. If the alignment is an odd number like 3 bytes, B might be the best choice." +msgstr "عندما تكون المحاذاة معروفة، فإن ضبط I وفقاً لذلك قد يقلل حجم الملف قليلاً. على سبيل المثال، مع ملفات النصوص ذات محاذاة البايت الواحد (US-ASCII، ISO-8859-*، UTF-8)، فإن ضبط B يحسن الضغط قليلاً. لنصوص UTF-16، يعد B خياراً جيداً. إذا كانت المحاذاة رقماً فردياً مثل 3 بايتات، فقد يكون B هو الخيار الأفضل." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Even though the assumed alignment can be adjusted with I and I, 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." +msgstr "على الرغم من إمكانية تعديل المحاذاة المفترضة باستخدام I و I، لا يزال LZMA1 و LZMA2 يفضلان قليلاً محاذاة 16 بايت. قد يكون من الجيد أخذ ذلك في الاعتبار عند تصميم تنسيقات الملفات التي يُرجح ضغطها غالباً باستخدام LZMA1 أو LZMA2." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 I: 0 uses B, 1\\(en3 use B, and the rest use B." +msgstr "لباحث التطابق تأثير كبير على سرعة المشفر، واستهلاك الذاكرة، ونسبة الضغط. عادةً ما تكون باحثات سلسلة الهاش (Hash Chain) أسرع من باحثات الشجرة الثنائية (Binary Tree). يعتمد الإعداد المبدئي على الإعداد المسبق (I): 0 يستخدم B، ومن 1 إلى 3 تستخدم B، والبقية تستخدم B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The following match finders are supported. The memory usage formulas below are rough approximations, which are closest to the reality when I is a power of two." +msgstr "باحثات التطابق التالية مدعومة. صيغ استهلاك الذاكرة أدناه هي تقريبات خشنة، تكون أقرب للواقع عندما يكون I أسّاً للعدد اثنين." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Hash Chain with 2- and 3-byte hashing" +msgstr "سلسلة هاش مع هاش 2 و 3 بايت" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Minimum value for I: 3" +msgstr "أقل قيمة لـ I: 3" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Memory usage:" +msgstr "استهلاك الذاكرة:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I * 7.5 (if I E= 16 MiB);" +msgstr "I * 7.5 (إذا كان I E= 16 ميجابايت)؛" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I * 5.5 + 64 MiB (if I E 16 MiB)" +msgstr "I * 5.5 + 64 ميجابايت (إذا كان I E 16 ميجابايت)" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Hash Chain with 2-, 3-, and 4-byte hashing" +msgstr "سلسلة هاش مع هاش 2 و 3 و 4 بايت" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Minimum value for I: 4" +msgstr "أقل قيمة لـ I: 4" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I * 7.5 (if I E= 32 MiB);" +msgstr "I * 7.5 (إذا كان I E= 32 ميجابايت)؛" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I * 6.5 (if I E 32 MiB)" +msgstr "I * 6.5 (إذا كان I E 32 ميجابايت)" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Binary Tree with 2-byte hashing" +msgstr "شجرة ثنائية مع هاش 2 بايت" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Minimum value for I: 2" +msgstr "أقل قيمة لـ I: 2" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Memory usage: I * 9.5" +msgstr "استهلاك الذاكرة: I * 9.5" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Binary Tree with 2- and 3-byte hashing" +msgstr "شجرة ثنائية مع هاش 2 و 3 بايت" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I * 11.5 (if I E= 16 MiB);" +msgstr "I * 11.5 (إذا كان I E= 16 ميجابايت)؛" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I * 9.5 + 64 MiB (if I E 16 MiB)" +msgstr "I * 9.5 + 64 ميجابايت (إذا كان I E 16 ميجابايت)" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Binary Tree with 2-, 3-, and 4-byte hashing" +msgstr "شجرة ثنائية مع هاش 2 و 3 و 4 بايت" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I * 11.5 (if I E= 32 MiB);" +msgstr "I * 11.5 (إذا كان I E= 32 ميجابايت)؛" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I * 10.5 (if I E 32 MiB)" +msgstr "I * 10.5 (إذا كان I E 32 ميجابايت)" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compression I specifies the method to analyze the data produced by the match finder. Supported I are B and B. The default is B for I 0\\(en3 and B for I 4\\(en9." +msgstr "يحدد I<نمط> الضغط طريقة تحليل البيانات الناتجة عن باحث التطابق. الأنماط المدعومة هي B و B. النمط المبدئي هو B للإعدادات المسبقة 0-3 و B للإعدادات المسبقة 4-9." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Usually B is used with Hash Chain match finders and B with Binary Tree match finders. This is also what the I do." +msgstr "عادةً ما يُستخدم B مع باحثات سلسلة الهاش و B مع باحثات الشجرة الثنائية. وهذا ما تفعله الإعدادات المسبقة أيضاً." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify what is considered to be a nice length for a match. Once a match of at least I bytes is found, the algorithm stops looking for possibly better matches." +msgstr "حدد ما يُعتبر طولاً جيداً (nice) للتطابق. بمجرد العثور على تطابق بطول I بايت على الأقل، تتوقف الخوارزمية عن البحث عن تطابقات أفضل محتملة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I can be 2\\(en273 bytes. Higher values tend to give better compression ratio at the expense of speed. The default depends on the I." +msgstr "يمكن أن يتراوح I بين 2-273 بايت. تميل القيم الأعلى لإعطاء نسبة ضغط أفضل على حساب السرعة. يعتمد الإعداد المبدئي على الإعداد المسبق." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify the maximum search depth in the match finder. The default is the special value of 0, which makes the compressor determine a reasonable I from I and I." +msgstr "حدد أقصى عمق للبحث في باحث التطابق. القيمة المبدئية هي القيمة الخاصة 0، التي تجعل الضاغط يحدد عمقاً (I) معقولاً بناءً على I و I." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Reasonable I for Hash Chains is 4\\(en100 and 16\\(en1000 for Binary Trees. Using very high values for I can make the encoder extremely slow with some files. Avoid setting the I over 1000 unless you are prepared to interrupt the compression in case it is taking far too long." +msgstr "العمق (I) المعقول لسلاسل الهاش هو 4-100 وللأشجار الثنائية هو 16-1000. استخدام قيم عالية جداً لـ I قد يجعل المشفر بطيئاً للغاية مع بعض الملفات. تجنب ضبط I فوق 1000 إلا إذا كنت مستعداً لمقاطعة عملية الضغط في حال استغرقت وقتاً طويلاً جداً." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When decoding raw streams (B<--format=raw>), LZMA2 needs only the dictionary I. LZMA1 needs also I, I, and I." +msgstr "عند فك ترميز التدفقات الخام (B<--format=raw>)، يحتاج LZMA2 فقط إلى I<حجم> القاموس. يحتاج LZMA1 أيضاً إلى I و I و I." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--x86>[B<=>I]" +msgstr "B<--x86>[B<=>I<خيارات>]" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--arm>[B<=>I]" +msgstr "B<--arm>[B<=>I<خيارات>]" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--armthumb>[B<=>I]" +msgstr "B<--armthumb>[B<=>I<خيارات>]" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--arm64>[B<=>I]" +msgstr "B<--arm64>[B<=>I<خيارات>]" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--powerpc>[B<=>I]" +msgstr "B<--powerpc>[B<=>I<خيارات>]" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--ia64>[B<=>I]" +msgstr "B<--ia64>[B<=>I<خيارات>]" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--sparc>[B<=>I]" +msgstr "B<--sparc>[B<=>I<خيارات>]" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--riscv>[B<=>I]" +msgstr "B<--riscv>[B<=>I<خيارات>]" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "أضف مرشح فرع/استدعاء/قفز (BCJ) إلى تسلسل المرشحات. يمكن استخدام هذه المرشحات فقط كمرشح غير أخير في تسلسل المرشحات." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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\\(en15\\ % smaller B<.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." +msgstr "يقوم مرشح BCJ بتحويل العناوين النسبية في كود الآلة إلى نظرائها المطلقة. هذا لا يغير حجم البيانات ولكنه يزيد التكرار، مما يساعد LZMA2 على إنتاج ملف B<.xz> أصغر بنسبة 0-15%. مرشحات BCJ دائماً قابلة للعكس، لذا فإن استخدام مرشح BCJ لنوع خاطئ من البيانات لا يسبب أي فقدان للبيانات، رغم أنه قد يجعل نسبة الضغط أسوأ قليلاً. مرشحات BCJ سريعة جداً وتستهلك كمية ضئيلة من الذاكرة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "These BCJ filters have known problems related to the compression ratio:" +msgstr "هناك مشاكل معروفة لمرشحات BCJ تتعلق بنسبة الضغط:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 conversion, which will make the compression worse with these files." +msgstr "بعض أنواع الملفات التي تحتوي على كود قابل للتنفيذ (مثل ملفات الكائنات، والمكتبات الساكنة، ووحدات نواة Linux) تحتوي على عناوين في التعليمات مملوءة بقيم حشو. ستستمر مرشحات BCJ هذه في إجراء تحويل العناوين، مما يجعل الضغط أسوأ مع هذه الملفات." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "إذا طُبق مرشح BCJ على أرشيف، فمن المحتمل أن يجعل نسبة الضغط أسوأ مما لو لم يُستخدم. على سبيل المثال، إذا كانت هناك ملفات تنفيذية متشابهة أو حتى متطابقة، فإن الترشيح سيجعل الملفات أقل تشابهاً وبالتالي يكون الضغط أسوأ. محتويات الملفات غير القابلة للتنفيذ في نفس الأرشيف قد تؤثر أيضاً. في الممارسة العملية، يجب التجربة مع وبدون مرشح BCJ لمعرفة أيهما أفضل في كل حالة." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "مجموعات التعليمات المختلفة لها محاذاة مختلفة: يجب محاذاة الملف القابل للتنفيذ إلى مضاعف لهذه القيمة في بيانات الإدخال ليعمل المرشح." + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "Filter" +msgstr "المرشح" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "Alignment" +msgstr "المحاذاة" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "Notes" +msgstr "ملاحظات" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "x86" +msgstr "x86" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "32-bit or 64-bit x86" +msgstr "32-بت أو 64-بت x86" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "ARM" +msgstr "ARM" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "ARM-Thumb" +msgstr "ARM-Thumb" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "ARM64" +msgstr "ARM64" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "4096-byte alignment is best" +msgstr "محاذاة 4096 بايت هي الأفضل" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "PowerPC" +msgstr "PowerPC" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "Big endian only" +msgstr "Big endian فقط" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "IA-64" +msgstr "IA-64" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "16" +msgstr "16" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "Itanium" +msgstr "Itanium" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "SPARC" +msgstr "SPARC" + +#. type: tbl table +#: ../src/xz/xz.1 +#, no-wrap +msgid "RISC-V" +msgstr "RISC-V" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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:" +msgstr "بما أن البيانات المرشحة بـ BCJ تُضغط عادةً باستخدام LZMA2، فقد تتحسن نسبة الضغط قليلاً إذا ضُبطت خيارات LZMA2 لتناسب محاذاة مرشح BCJ المختار. أمثلة:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "IA-64 filter has 16-byte alignment so B is good with LZMA2 (2^4=16)." +msgstr "مرشح IA-64 له محاذاة 16 بايت، لذا B جيد مع LZMA2 (2^4=16)." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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, B or B is good. When 16-bit instructions aren't present, B is the best. B can be used to check if \"RVC\" appears on the \"Flags\" line." +msgstr "كود RISC-V له محاذاة 2 بايت أو 4 بايت اعتماداً على ما إذا كان الملف يحتوي على تعليمات مضغوطة بـ 16 بت (ملحق C). عند استخدام تعليمات 16 بت، يكون B أو B جيداً. عند عدم وجود تعليمات 16 بت، يكون B هو الأفضل. يمكن استخدام B للتحقق مما إذا كانت \"RVC\" تظهر في سطر \"Flags\"." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "ARM64 is always 4-byte aligned so B is the best." +msgstr "ARM64 دائماً محاذى لـ 4 بايت لذا B هو الأفضل." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The x86 filter is an exception. It's usually good to stick to LZMA2's defaults (B) when compressing x86 executables." +msgstr "مرشح x86 استثناء. من الجيد عادةً الالتزام بإعدادات LZMA2 المبدئية (B) عند ضغط ملفات x86 التنفيذية." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "All BCJ filters support the same I:" +msgstr "كل مرشحات BCJ تدعم نفس الـ I<خيارات>:" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI<إزاحة>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify the start I that is used when converting between relative and absolute addresses. The I must be a multiple of the alignment of the filter (see the table above). The default is zero. In practice, the default is good; specifying a custom I is almost never useful." +msgstr "حدد I<إزاحة> البداية المستخدمة عند التحويل بين العناوين النسبية والمطلقة. يجب أن تكون الـ I<إزاحة> مضاعفاً لمحاذاة المرشح (انظر الجدول أعلاه). القيمة المبدئية هي صفر. عملياً، القيمة المبدئية جيدة؛ تحديد I<إزاحة> مخصصة ليس مفيداً تقريباً." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--delta>[B<=>I]" +msgstr "B<--delta>[B<=>I<خيارات>]" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Add the Delta filter to the filter chain. The Delta filter can be only used as a non-last filter in the filter chain." +msgstr "أضف مرشح دلتا إلى تسلسل المرشحات. يمكن استخدام مرشح دلتا فقط كمرشح غير أخير في تسلسل المرشحات." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 purpose algorithms may give significantly better results than Delta + LZMA2. This is true especially with audio, which compresses faster and better, for example, with B(1)." +msgstr "حالياً، الحساب البسيط للدلتا لكل بايت هو المدعوم فقط. يمكن أن يكون مفيداً عند ضغط صور bitmap غير المضغوطة أو صوت PCM غير المضغوط مثلاً. ومع ذلك، قد تعطي خوارزميات مخصصة نتائج أفضل بكثير من دلتا + LZMA2. هذا ينطبق بشكل خاص على الصوت، الذي يُضغط بشكل أسرع وأفضل باستخدام B(1) مثلاً." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Supported I:" +msgstr "الـ I<خيارات> المدعومة:" + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "BI" +msgstr "BI<مسافة>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Specify the I of the delta calculation in bytes. I must be 1\\(en256. The default is 1." +msgstr "حدد I<مسافة> حساب الدلتا بالبايت. يجب أن تكون الـ I<مسافة> 1-256. القيمة المبدئية هي 1." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "For example, with B and eight-byte input A1 B1 A2 B3 A3 B5 A4 B7, the output will be A1 B1 01 02 01 02 01 02." +msgstr "على سبيل المثال، مع B ومدخلات من ثمانية بايتات A1 B1 A2 B3 A3 B5 A4 B7، سيكون المخرج A1 B1 01 02 01 02 01 02." + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "Other options" +msgstr "خيارات أخرى" + +#. type: TP +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 +#, no-wrap +msgid "B<-q>, B<--quiet>" +msgstr "B<-q>, B<--quiet>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 indicate a warning is still used." +msgstr "اكتم التحذيرات والملاحظات. حدد هذا الخيار مرتين لكتم الأخطاء أيضاً. ليس لهذا الخيار تأثير على حالة الخروج. أي أنه حتى لو كُتم التحذير، فستظل حالة الخروج التي تشير لوعود تحذير مستخدمة." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-v>, B<--verbose>" +msgstr "B<-v>, B<--verbose>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Be verbose. If standard error is connected to a terminal, B will display a progress indicator. Specifying B<--verbose> twice will give even more verbose output." +msgstr "كن مسهباً. إذا كان الخطأ القياسي متصلاً بطرفية، سيعرض B مؤشر تقدم. تحديد B<--verbose> مرتين سيعطي مخرجات أكثر إسهاباً." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The progress indicator shows the following information:" +msgstr "يعرض مؤشر التقدم المعلومات التالية:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Completion percentage is shown if the size of the input file is known. That is, the percentage cannot be shown in pipes." +msgstr "تظهر نسبة الإكمال إذا كان حجم ملف الإدخال معروفاً. أي أن النسبة لا يمكن عرضها في الأنابيب (pipes)." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Amount of compressed data produced (compressing) or consumed (decompressing)." +msgstr "كمية البيانات المضغوطة المنتجة (عند الضغط) أو المستهلكة (عند فك الضغط)." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Amount of uncompressed data consumed (compressing) or produced (decompressing)." +msgstr "كمية البيانات غير المضغوطة المستهلكة (عند الضغط) أو المنتجة (عند فك الضغط)." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compression ratio, which is calculated by dividing the amount of compressed data processed so far by the amount of uncompressed data processed so far." +msgstr "نسبة الضغط، وتُحسب بقسمة كمية البيانات المضغوطة المعالجة حتى الآن على كمية البيانات غير المضغوطة المعالجة حتى الآن." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 B started processing the file." +msgstr "سرعة الضغط أو فك الضغط. تُقاس بكمية البيانات غير المضغوطة المستهلكة (ضغط) أو المنتجة (فك ضغط) في الثانية. تظهر بعد مرور بضع ثوانٍ على بدء B في معالجة الملف." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Elapsed time in the format M:SS or H:MM:SS." +msgstr "الوقت المنقضي بتنسيق M:SS أو H:MM:SS." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Estimated remaining time is shown only when the size of the input file is known and a couple of seconds have already passed since B started processing the file. The time is shown in a less precise format which never has any colons, for example, 2 min 30 s." +msgstr "يظهر الوقت المتبقي المقدر فقط عندما يكون حجم ملف الإدخال معروفاً وبعد مرور ثانيتين على بدء B في معالجة الملف. يظهر الوقت بتنسيق أقل دقة لا يحتوي أبداً على نقطتين رأسيتين، مثلاً، 2 min 30 s." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "When standard error is not a terminal, B<--verbose> will make B 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." +msgstr "عندما لا يكون الخطأ القياسي طرفية، سيجعل B<--verbose> أداة B تطبع اسم الملف، والحجم المضغوط، والحجم غير المضغوط، ونسبة الضغط، وربما أيضاً السرعة والوقت المنقضي في سطر واحد إلى الخطأ القياسي بعد ضغط أو فك ضغط الملف. تُدرج السرعة والوقت المنقضي فقط عندما تستغرق العملية بضع ثوانٍ على الأقل. إذا لم تنتهِ العملية، بسبب مقاطعة المستخدم مثلاً، تُطبع أيضاً نسبة الإكمال إذا كان حجم ملف الإدخال معروفاً." + +#. type: TP +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 +#, no-wrap +msgid "B<-Q>, B<--no-warn>" +msgstr "B<-Q>, B<--no-warn>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 B<--quiet> and B<--no-warn> have to be used to not display warnings and to not alter the exit status." +msgstr "لا تضبط حالة الخروج على 2 حتى لو اكتُشفت حالة تستحق التحذير. لا يؤثر هذا الخيار على مستوى الإسهاب، لذا يجب استخدام كل من B<--quiet> و B<--no-warn> معاً لعدم عرض التحذيرات وعدم تغيير حالة الخروج." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--robot>" +msgstr "B<--robot>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Print messages in a machine-parsable format. This is intended to ease writing frontends that want to use B instead of liblzma, which may be the case with various scripts. The output with this option enabled is meant to be stable across B releases. See the section B for details." +msgstr "اطبع الرسائل بتنسيق قابل للتحليل آلياً. الهدف من ذلك هو تسهيل كتابة واجهات تريد استخدام B بدلاً من liblzma، كما قد يكون الحال مع السكربتات المختلفة. المخرجات مع تمكين هذا الخيار يُفترض أن تكون مستقرة عبر إصدارات B. انظر قسم B للتفاصيل." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<--info-memory>" +msgstr "B<--info-memory>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Display, in human-readable format, how much physical memory (RAM) and how many processor threads B thinks the system has and the memory usage limits for compression and decompression, and exit successfully." +msgstr "اعرض، بتنسيق قابل للقراءة البشرية، مقدار الذاكرة الفعلية (RAM) وعدد خيوط المعالج التي يعتقد B أن النظام يمتلكها وحدود استهلاك الذاكرة للضغط وفك الضغط، واخرج بنجاح." + +#. type: TP +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 +#, no-wrap +msgid "B<-h>, B<--help>" +msgstr "B<-h>, B<--help>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Display a help message describing the most commonly used options, and exit successfully." +msgstr "اعرض رسالة مساعدة تصف الخيارات الأكثر استخداماً، واخرج بنجاح." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B<-H>, B<--long-help>" +msgstr "B<-H>, B<--long-help>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Display a help message describing all features of B, and exit successfully" +msgstr "اعرض رسالة مساعدة تصف كافة ميزات B، واخرج بنجاح" + +#. type: TP +#: ../src/xz/xz.1 ../src/xzdec/xzdec.1 +#, no-wrap +msgid "B<-V>, B<--version>" +msgstr "B<-V>, B<--version>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Display the version number of B and liblzma in human readable format. To get machine-parsable output, specify B<--robot> before B<--version>." +msgstr "اعرض رقم إصدار B و liblzma بتنسيق قابل للقراءة البشرية. للحصول على مخرج قابل للتحليل آلياً، حدد B<--robot> قبل B<--version>." + +#. type: SH +#: ../src/xz/xz.1 +#, no-wrap +msgid "ROBOT MODE" +msgstr "نمط الروبوت" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The robot mode is activated with the B<--robot> option. It makes the output of B easier to parse by other programs. Currently B<--robot> is supported only together with B<--list>, B<--filters-help>, B<--info-memory>, and B<--version>. It will be supported for compression and decompression in the future." +msgstr "يُفعل نمط الروبوت باستخدام خيار B<--robot>. فهو يجعل مخرجات B أسهل في التحليل بواسطة البرامج الأخرى. حالياً B<--robot> مدعوم فقط مع B<--list> و B<--filters-help> و B<--info-memory> و B<--version>. وسيُدعم للضغط وفك الضغط مستقبلاً." + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "List mode" +msgstr "نمط القائمة" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B uses tab-separated output. The first column of every line has a string that indicates the type of the information found on that line:" +msgstr "تستخدم B مخرجات مفصولة بعلامات جدولة (tabs). يحتوي العمود الأول من كل سطر على سلسلة نصية تشير إلى نوع المعلومات الموجودة في ذلك السطر:" + +#. TRANSLATORS: The bold strings B, B, B, B, +#. B, and B are produced by the xz tool for scripts to +#. parse, thus the untranslated strings must be included in the translated +#. man page. It may be useful to provide a translated string in parenthesis +#. without bold, for example: "B (nimi)" +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B (الاسم)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This is always the first line when starting to list a file. The second column on the line is the filename." +msgstr "هذا دائماً هو السطر الأول عند البدء في سرد ملف. العمود الثاني في السطر هو اسم الملف." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B (الملف)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This line contains overall information about the B<.xz> file. This line is always printed after the B line." +msgstr "يحتوي هذا السطر على معلومات عامة حول ملف B<.xz>. يُطبع هذا السطر دائماً بعد سطر B." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B (التدفق)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This line type is used only when B<--verbose> was specified. There are as many B lines as there are streams in the B<.xz> file." +msgstr "يُستخدم نوع السطر هذا فقط عند تحديد B<--verbose>. يوجد من أسطر B بعدد التدفقات الموجودة في ملف B<.xz>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B (الكتلة)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This line type is used only when B<--verbose> was specified. There are as many B lines as there are blocks in the B<.xz> file. The B lines are shown after all the B lines; different line types are not interleaved." +msgstr "يُستخدم نوع السطر هذا فقط عند تحديد B<--verbose>. يوجد من أسطر B بعدد الكتل الموجودة في ملف B<.xz>. تظهر أسطر B بعد كل أسطر B؛ ولا تتداخل أنواع الأسطر المختلفة." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B (الملخص)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This line type is used only when B<--verbose> was specified twice. This line is printed after all B lines. Like the B line, the B line contains overall information about the B<.xz> file." +msgstr "يُستخدم نوع السطر هذا فقط عند تحديد B<--verbose> مرتين. يُطبع هذا السطر بعد كل أسطر B. مثل سطر B، يحتوي سطر B على معلومات عامة حول ملف B<.xz>." + +#. type: TP +#: ../src/xz/xz.1 +#, no-wrap +msgid "B" +msgstr "B (الإجماليات)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "This line is always the very last line of the list output. It shows the total counts and sizes." +msgstr "هذا السطر هو دائماً السطر الأخير تماماً في مخرجات القائمة. يعرض الأعداد والأحجام الإجمالية." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The columns of the B lines:" +msgstr "أعمدة أسطر B:" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "2." +msgstr "2." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Number of streams in the file" +msgstr "عدد التدفقات في الملف" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "3." +msgstr "3." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Total number of blocks in the stream(s)" +msgstr "إجمالي عدد الكتل في التدفق (التدفقات)" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "4." +msgstr "4." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compressed size of the file" +msgstr "الحجم المضغوط للملف" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "5." +msgstr "5." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Uncompressed size of the file" +msgstr "الحجم غير المضغوط للملف" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "6." +msgstr "6." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compression ratio, for example, B<0.123>. If ratio is over 9.999, three dashes (B<--->) are displayed instead of the ratio." +msgstr "نسبة الضغط، مثلاً B<0.123>. إذا كانت النسبة فوق 9.999، تُعرض ثلاث شرطات (B<--->) بدلاً من النسبة." + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "7." +msgstr "7." + +#. TRANSLATORS: Don't translate the bold strings B, B, +#. B, B, or B here. In robot mode, xz produces +#. them in untranslated form for scripts to parse. +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Comma-separated list of integrity check names. The following strings are used for the known check types: B, B, B, and B. For unknown check types, BI is used, where I is the Check ID as a decimal number (one or two digits)." +msgstr "قائمة مفصولة بفواصل لأسماء فحوصات السلامة. تُستخدم السلاسل التالية لأنواع الفحص المعروفة: B، B، B، و B. لأنواع الفحص غير المعروفة، يُستخدم BI، حيث I هو معرّف الفحص كرقم عشري (رقم واحد أو رقمان)." + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "8." +msgstr "8." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Total size of stream padding in the file" +msgstr "إجمالي حجم حشو التدفق في الملف" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The columns of the B lines:" +msgstr "أعمدة أسطر B:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Stream number (the first stream is 1)" +msgstr "رقم التدفق (التدفق الأول هو 1)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Number of blocks in the stream" +msgstr "عدد الكتل في التدفق" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compressed start offset" +msgstr "إزاحة البداية المضغوطة" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Uncompressed start offset" +msgstr "إزاحة البداية غير المضغوطة" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compressed size (does not include stream padding)" +msgstr "الحجم المضغوط (لا يشمل حشو التدفق)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Uncompressed size" +msgstr "الحجم غير المضغوط" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compression ratio" +msgstr "نسبة الضغط" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "9." +msgstr "9." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Name of the integrity check" +msgstr "اسم فحص السلامة" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "10." +msgstr "10." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Size of stream padding" +msgstr "حجم حشو التدفق" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The columns of the B lines:" +msgstr "أعمدة أسطر B:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Number of the stream containing this block" +msgstr "رقم التدفق الذي يحتوي على هذه الكتلة" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Block number relative to the beginning of the stream (the first block is 1)" +msgstr "رقم الكتلة بالنسبة لبداية التدفق (الكتلة الأولى هي 1)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Block number relative to the beginning of the file" +msgstr "رقم الكتلة بالنسبة لبداية الملف" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compressed start offset relative to the beginning of the file" +msgstr "إزاحة البداية المضغوطة بالنسبة لبداية الملف" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Uncompressed start offset relative to the beginning of the file" +msgstr "إزاحة البداية غير المضغوطة بالنسبة لبداية الملف" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Total compressed size of the block (includes headers)" +msgstr "إجمالي الحجم المضغوط للكتلة (يشمل الترويسات)" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If B<--verbose> was specified twice, additional columns are included on the B lines. These are not displayed with a single B<--verbose>, because getting this information requires many seeks and can thus be slow:" +msgstr "إذا حُدد B<--verbose> مرتين، تضاف أعمدة إضافية في أسطر B. لا تُعرض هذه الأعمدة مع B<--verbose> واحدة، لأن الحصول عليها يتطلب عمليات بحث (seeks) كثيرة وبالتالي قد يكون بطيئاً:" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "11." +msgstr "11." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Value of the integrity check in hexadecimal" +msgstr "قيمة فحص السلامة بالتمثيل الست عشري" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "12." +msgstr "12." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Block header size" +msgstr "حجم ترويسة الكتلة" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "13." +msgstr "13." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Block flags: B indicates that compressed size is present, and B indicates that uncompressed size is present. If the flag is not set, a dash (B<->) is shown instead to keep the string length fixed. New flags may be added to the end of the string in the future." +msgstr "أعلام الكتلة: يشير B إلى وجود الحجم المضغوط، ويشير B إلى وجود الحجم غير المضغوط. إذا لم يُضبط العلم، تظهر شرطة (B<->) بدلاً منه للحفاظ على طول السلسلة ثابتاً. قد تضاف أعلام جديدة في نهاية السلسلة مستقبلاً." + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "14." +msgstr "14." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Size of the actual compressed data in the block (this excludes the block header, block padding, and check fields)" +msgstr "حجم البيانات المضغوطة الفعلية في الكتلة (هذا يستثني ترويسة الكتلة، وحشو الكتلة، وحقول الفحص)" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "15." +msgstr "15." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Amount of memory (in bytes) required to decompress this block with this B version" +msgstr "مقدار الذاكرة (بالبايت) المطلوبة لفك ضغط هذه الكتلة باستخدام إصدار B هذا" + +#. type: IP +#: ../src/xz/xz.1 +#, no-wrap +msgid "16." +msgstr "16." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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 B<.xz> headers." +msgstr "تسلسل المرشحات. لاحظ أن معظم الخيارات المستخدمة وقت الضغط لا يمكن معرفتها، لأن الخيارات اللازمة لفك الضغط فقط هي التي تخزن في ترويسات B<.xz>." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The columns of the B lines:" +msgstr "أعمدة أسطر B:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Amount of memory (in bytes) required to decompress this file with this B version" +msgstr "مقدار الذاكرة (بالبايت) المطلوبة لفك ضغط هذا الملف باستخدام إصدار B هذا" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B or B indicating if all block headers have both compressed size and uncompressed size stored in them" +msgstr "B أو B للإشارة إلى ما إذا كانت كل ترويسات الكتل تحتوي على الحجم المضغوط وغير المضغوط مخزنين فيها" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "I B I<5.1.2alpha:>" +msgstr "I<منذ> B I<5.1.2alpha:>" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Minimum B version required to decompress the file" +msgstr "أقل إصدار B مطلوب لفك ضغط الملف" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "The columns of the B line:" +msgstr "أعمدة سطر B:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Number of streams" +msgstr "عدد التدفقات" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Number of blocks" +msgstr "عدد الكتل" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Compressed size" +msgstr "الحجم المضغوط" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Average compression ratio" +msgstr "متوسط نسبة الضغط" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Comma-separated list of integrity check names that were present in the files" +msgstr "قائمة مفصولة بفواصل لأسماء فحوصات السلامة التي كانت موجودة في الملفات" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Stream padding size" +msgstr "حجم حشو التدفق" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Number of files. This is here to keep the order of the earlier columns the same as on B lines." +msgstr "عدد الملفات. هذا موجود للحفاظ على ترتيب الأعمدة السابقة بنفس ترتيبها في أسطر B." + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "If B<--verbose> was specified twice, additional columns are included on the B line:" +msgstr "إذا حُدد B<--verbose> مرتين، تضاف أعمدة إضافية في سطر B:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "Maximum amount of memory (in bytes) required to decompress the files with this B version" +msgstr "أقصى مقدار للذاكرة (بالبايت) المطلوبة لفك ضغط الملفات باستخدام إصدار B هذا" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "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." +msgstr "قد تضيف الإصدارات المستقبلية أنواع أسطر جديدة وأعمدة جديدة للأنواع الحالية، لكن الأعمدة الحالية لن تتغير." + +#. type: SS +#: ../src/xz/xz.1 +#, no-wrap +msgid "Filters help" +msgstr "مساعدة المرشحات" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "B prints the supported filters in the following format:" +msgstr "تطبع B المرشحات المدعومة بالتنسيق التالي:" + +#. type: Plain text +#: ../src/xz/xz.1 +msgid "IB<:>I