diff --git a/.github/workflows/compatibility-test.yml b/.github/workflows/compatibility-test.yml new file mode 100644 index 000000000..e26a566b2 --- /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 3dc8c5baf..546adfd8f 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 75cc55a4f..91ea672da 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 f51c4eded..d78595929 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 153e75dc2..e82888645 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 000000000..e5ba85bdb --- /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 000000000..a3d4ab4ba --- /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 000000000..0e8f6c086 --- /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 000000000..4bab00e13 --- /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 000000000..e13724e78 --- /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 000000000..c5d6ad39f --- /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 000000000..351108c87 --- /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 000000000..1c8fcd8f4 --- /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 000000000..f097e0405 --- /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 000000000..576428c1c --- /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 000000000..126ce8089 --- /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 000000000..006037ba8 --- /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 000000000..ee22d3f77 --- /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 000000000..00d2a0952 --- /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 000000000..ab3ff879c --- /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 000000000..6d602c5da --- /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 000000000..5cb3b913d --- /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 000000000..2dcb55382 --- /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 000000000..3f26da626 --- /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 000000000..d13649e0c --- /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 000000000..9d9141b28 --- /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 000000000..d6a98efbf --- /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 000000000..ca021d6a9 --- /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 000000000..4cf791673 --- /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 000000000..e6e16bb0b --- /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 000000000..cf72a5b48 --- /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 000000000..5ccb3a813 --- /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 000000000..9e93e6f04 --- /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 000000000..5698955ba --- /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 000000000..09bdaa5ee --- /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 000000000..c1d7729b4 --- /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 000000000..219cbaa13 --- /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 000000000..8c0d8602d --- /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 000000000..65ec1942a --- /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 000000000..c83770340 --- /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 000000000..928ef3440 --- /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 000000000..29f2c95f8 --- /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 000000000..98b1d7a3d --- /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 000000000..4bffe858a --- /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 000000000..b70d063ff --- /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 000000000..4a741c5ea --- /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 000000000..67e9a8b9a --- /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 000000000..acff1e1be --- /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 000000000..b2d8a7cfb --- /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 000000000..dead5ed43 --- /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 000000000..9e1305407 --- /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 000000000..3c1de54e6 --- /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 000000000..4670cf7d2 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 000000000..1f22beadd --- /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 000000000..f9ebe3d90 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 000000000..57949f732 --- /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 000000000..460dae3cf 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 000000000..bea97ac0f --- /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 000000000..b1880f4e7 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 000000000..ab7d433b7 --- /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 000000000..ac96ad9f3 --- /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 000000000..287e2e735 --- /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 000000000..7839b5360 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 000000000..e30cd8620 --- /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 000000000..abc29a1e5 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 000000000..4517d1957 --- /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 000000000..a85048858 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 000000000..d5c2d1c19 --- /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 000000000..6b7b53ba2 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 000000000..78b90de94 --- /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 000000000..e43f132de 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 000000000..85f53b09d --- /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 000000000..800f81294 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 000000000..de9ef3301 --- /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 000000000..f9534e7ed --- /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 000000000..910262b2d 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 000000000..a8cce1559 --- /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 000000000..a3573a11d 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 000000000..748bf695a --- /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 000000000..4d7123e36 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 000000000..a3271d773 --- /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 000000000..6f2c6756b 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 000000000..4dc897f5e --- /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 000000000..93864523d 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 000000000..4a74b938c --- /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 000000000..506bb9612 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 000000000..44cbd4708 --- /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 000000000..82858f761 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 000000000..07b3d73ad --- /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 000000000..eb0e08dad --- /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 000000000..8c70dfbf1 --- /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 000000000..0c8bdccbe 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 000000000..732e7ecbe --- /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 000000000..979a12df0 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 000000000..8c4d98726 --- /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 000000000..9788f7023 --- /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 000000000..93c65cb07 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 000000000..9dc9da13b --- /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 000000000..80e350199 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 000000000..f6d0a7639 --- /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 000000000..5975b6d85 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 000000000..58d48af2a --- /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 000000000..6b124fe4c 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 000000000..c46e1303e --- /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 000000000..01e848406 --- /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 000000000..6d277c90f --- /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 000000000..b9206e458 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 000000000..b31aa378c --- /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 000000000..38ebcdbb8 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 000000000..596e898f4 --- /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 000000000..7c1822245 --- /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