Update XZ Utils to 5.0.3 (in deps)

src/xz/list.c

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       list.c
 /// \brief      Listing information about .xz files
 //
 //  Author:     Lasse Collin
 //
 //  This file has been put into the public domain.
 //  You can do whatever you want with this file.
 //
@@ skipping 31 matching lines @@
         /// A few of the Block Flags as a string
         char flags[3];
 
         /// Size of the Compressed Data field in the Block
         lzma_vli compressed_size;
 
         /// Decoder memory usage for this Block
         uint64_t memusage;
 
         /// The filter chain of this Block in human-readable form
-        const char *filter_chain;
+        char filter_chain[FILTERS_STR_SIZE];
 
 } block_header_info;
 
 
 /// Check ID to string mapping
 static const char check_names[LZMA_CHECK_ID_MAX + 1][12] = {
-        "None",
+        // TRANSLATORS: Indicates that there is no integrity check.
+        // This string is used in tables, so the width must not
+        // exceed ten columns with a fixed-width font.
+        N_("None"),
         "CRC32",
-        "Unknown-2",
-        "Unknown-3",
+        // TRANSLATORS: Indicates that integrity check name is not known,
+        // but the Check ID is known (here 2). This and other "Unknown-N"
+        // strings are used in tables, so the width must not exceed ten
+        // columns with a fixed-width font. It's OK to omit the dash if
+        // you need space for one extra letter, but don't use spaces.
+        N_("Unknown-2"),
+        N_("Unknown-3"),
         "CRC64",
-        "Unknown-5",
-        "Unknown-6",
-        "Unknown-7",
-        "Unknown-8",
-        "Unknown-9",
+        N_("Unknown-5"),
+        N_("Unknown-6"),
+        N_("Unknown-7"),
+        N_("Unknown-8"),
+        N_("Unknown-9"),
         "SHA-256",
-        "Unknown-11",
-        "Unknown-12",
-        "Unknown-13",
-        "Unknown-14",
-        "Unknown-15",
+        N_("Unknown-11"),
+        N_("Unknown-12"),
+        N_("Unknown-13"),
+        N_("Unknown-14"),
+        N_("Unknown-15"),
 };
 
+/// Buffer size for get_check_names(). This may be a bit ridiculous,
+/// but at least it's enough if some language needs many multibyte chars.
+#define CHECKS_STR_SIZE 1024
+
 
 /// Value of the Check field as hexadecimal string.
 /// This is set by parse_check_value().
 static char check_value[2 * LZMA_CHECK_SIZE_MAX + 1];
 
 
 /// Totals that are displayed if there was more than one file.
 /// The "files" counter is also used in print_info_adv() to show
 /// the file number.
 static struct {
@@ skipping 109 matching lines @@
                 if ((lzma_vli)(pos) < index_size + LZMA_STREAM_HEADER_SIZE) {
                         message_error("%s: %s", pair->src_name,
                                         message_strm(LZMA_DATA_ERROR));
                         goto error;
                 }
 
                 // Set pos to the beginning of the Index.
                 pos -= index_size;
 
                 // See how much memory we can use for decoding this Index.
-                uint64_t memlimit = hardware_memlimit_get();
+                uint64_t memlimit = hardware_memlimit_get(MODE_LIST);
                 uint64_t memused = 0;
                 if (combined_index != NULL) {
                         memused = lzma_index_memused(combined_index);
                         if (memused > memlimit)
                                 message_bug();
 
                         memlimit -= memused;
                 }
 
                 // Decode the Index.
@@ skipping 218 matching lines @@
         bhi->header_size = block.header_size;
         bhi->compressed_size = block.compressed_size;
 
         // Calculate the decoder memory usage and update the maximum
         // memory usage of this Block.
         bhi->memusage = lzma_raw_decoder_memusage(filters);
         if (xfi->memusage_max < bhi->memusage)
                 xfi->memusage_max = bhi->memusage;
 
         // Convert the filter chain to human readable form.
-        bhi->filter_chain = message_filters_to_str(filters, false);
+        message_filters_to_str(bhi->filter_chain, filters, false);
 
         // Free the memory allocated by lzma_block_header_decode().
         for (size_t i = 0; filters[i].id != LZMA_VLI_UNKNOWN; ++i)
                 free(filters[i].options);
 
         return false;
 
 data_error:
         // Show the error message.
         message_error("%s: %s", pair->src_name,
@@ skipping 70 matching lines @@
 
         if (parse_check_value(pair, iter))
                 return true;
 
         return false;
 }
 
 
 /// \brief      Get the compression ratio
 ///
-/// This has slightly different format than that is used by in message.c.
+/// This has slightly different format than that is used in message.c.
 static const char *
 get_ratio(uint64_t compressed_size, uint64_t uncompressed_size)
 {
         if (uncompressed_size == 0)
                 return "---";
 
         const double ratio = (double)(compressed_size)
                         / (double)(uncompressed_size);
         if (ratio > 9.999)
                 return "---";
 
-        static char buf[6];
+        static char buf[16];
         snprintf(buf, sizeof(buf), "%.3f", ratio);
         return buf;
 }
 
 
 /// \brief      Get a comma-separated list of Check names
 ///
+/// The check names are translated with gettext except when in robot mode.
+///
+/// \param      buf     Buffer to hold the resulting string
 /// \param      checks  Bit mask of Checks to print
 /// \param      space_after_comma
 ///                     It's better to not use spaces in table-like listings,
 ///                     but in more verbose formats a space after a comma
 ///                     is good for readability.
-static const char *
-get_check_names(uint32_t checks, bool space_after_comma)
+static void
+get_check_names(char buf[CHECKS_STR_SIZE],
+                uint32_t checks, bool space_after_comma)
 {
         assert(checks != 0);
 
-        static char buf[sizeof(check_names)];
         char *pos = buf;
-        size_t left = sizeof(buf);
+        size_t left = CHECKS_STR_SIZE;
 
         const char *sep = space_after_comma ? ", " : ",";
         bool comma = false;
 
         for (size_t i = 0; i <= LZMA_CHECK_ID_MAX; ++i) {
                 if (checks & (UINT32_C(1) << i)) {
                         my_snprintf(&pos, &left, "%s%s",
-                                        comma ? sep : "", check_names[i]);
+                                        comma ? sep : "",
+                                        opt_robot ? check_names[i]
+                                                : _(check_names[i]));
                         comma = true;
                 }
         }
 
-        return buf;
+        return;
 }
 
 
 static bool
 print_info_basic(const xz_file_info *xfi, file_pair *pair)
 {
         static bool headings_displayed = false;
         if (!headings_displayed) {
                 headings_displayed = true;
-                // TRANSLATORS: These are column titles. From Strms (Streams)
+                // 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 --list.
+                // use two lines here. Test with "xz -l foo.xz".
                 puts(_("Strms  Blocks   Compressed Uncompressed  Ratio  "
                                 "Check   Filename"));
         }
 
-        printf("%5s %7s  %11s  %11s  %5s  %-7s %s\n",
-                        uint64_to_str(lzma_index_stream_count(xfi->idx), 0),
-                        uint64_to_str(lzma_index_block_count(xfi->idx), 1),
-                        uint64_to_nicestr(lzma_index_file_size(xfi->idx),
-                                NICESTR_B, NICESTR_TIB, false, 2),
-                        uint64_to_nicestr(
-                                lzma_index_uncompressed_size(xfi->idx),
-                                NICESTR_B, NICESTR_TIB, false, 3),
-                        get_ratio(lzma_index_file_size(xfi->idx),
-                                lzma_index_uncompressed_size(xfi->idx)),
-                        get_check_names(lzma_index_checks(xfi->idx), false),
-                        pair->src_name);
+        char checks[CHECKS_STR_SIZE];
+        get_check_names(checks, lzma_index_checks(xfi->idx), false);
+
+        const char *cols[7] = {
+                uint64_to_str(lzma_index_stream_count(xfi->idx), 0),
+                uint64_to_str(lzma_index_block_count(xfi->idx), 1),
+                uint64_to_nicestr(lzma_index_file_size(xfi->idx),
+                        NICESTR_B, NICESTR_TIB, false, 2),
+                uint64_to_nicestr(lzma_index_uncompressed_size(xfi->idx),
+                        NICESTR_B, NICESTR_TIB, false, 3),
+                get_ratio(lzma_index_file_size(xfi->idx),
+                        lzma_index_uncompressed_size(xfi->idx)),
+                checks,
+                pair->src_name,
+        };
+        printf("%*s %*s  %*s  %*s  %*s  %-*s %s\n",
+                        tuklib_mbstr_fw(cols[0], 5), cols[0],
+                        tuklib_mbstr_fw(cols[1], 7), cols[1],
+                        tuklib_mbstr_fw(cols[2], 11), cols[2],
+                        tuklib_mbstr_fw(cols[3], 11), cols[3],
+                        tuklib_mbstr_fw(cols[4], 5), cols[4],
+                        tuklib_mbstr_fw(cols[5], 7), cols[5],
+                        cols[6]);
 
         return false;
 }
 
 
 static void
 print_adv_helper(uint64_t stream_count, uint64_t block_count,
                 uint64_t compressed_size, uint64_t uncompressed_size,
                 uint32_t checks, uint64_t stream_padding)
 {
+        char checks_str[CHECKS_STR_SIZE];
+        get_check_names(checks_str, checks, true);
+
         printf(_("  Streams:            %s\n"),
                         uint64_to_str(stream_count, 0));
         printf(_("  Blocks:             %s\n"),
                         uint64_to_str(block_count, 0));
         printf(_("  Compressed size:    %s\n"),
                         uint64_to_nicestr(compressed_size,
                                 NICESTR_B, NICESTR_TIB, true, 0));
         printf(_("  Uncompressed size:  %s\n"),
                         uint64_to_nicestr(uncompressed_size,
                                 NICESTR_B, NICESTR_TIB, true, 0));
         printf(_("  Ratio:              %s\n"),
                         get_ratio(compressed_size, uncompressed_size));
-        printf(_("  Check:              %s\n"),
-                        get_check_names(checks, true));
+        printf(_("  Check:              %s\n"), checks_str);
         printf(_("  Stream padding:     %s\n"),
                         uint64_to_nicestr(stream_padding,
                                 NICESTR_B, NICESTR_TIB, true, 0));
         return;
 }
 
 
 static bool
 print_info_adv(xz_file_info *xfi, file_pair *pair)
 {
         // Print the overall information.
         print_adv_helper(lzma_index_stream_count(xfi->idx),
                         lzma_index_block_count(xfi->idx),
                         lzma_index_file_size(xfi->idx),
                         lzma_index_uncompressed_size(xfi->idx),
                         lzma_index_checks(xfi->idx),
                         xfi->stream_padding);
 
         // Size of the biggest Check. This is used to calculate the width
         // of the CheckVal field. The table would get insanely wide if
         // we always reserved space for 64-byte Check (128 chars as hex).
         uint32_t check_max = 0;
 
         // Print information about the Streams.
+        //
+        // TRANSLATORS: The second line is column headings. All except
+        // Check are right aligned; Check is left aligned. Test with
+        // "xz -lv foo.xz".
         puts(_("  Streams:\n    Stream    Blocks"
                         "      CompOffset    UncompOffset"
                         "        CompSize      UncompSize  Ratio"
                         "  Check      Padding"));
 
         lzma_index_iter iter;
         lzma_index_iter_init(&iter, xfi->idx);
 
         while (!lzma_index_iter_next(&iter, LZMA_INDEX_ITER_STREAM)) {
-                printf("    %6s %9s %15s %15s ",
-                                uint64_to_str(iter.stream.number, 0),
-                                uint64_to_str(iter.stream.block_count, 1),
-                                uint64_to_str(
-                                        iter.stream.compressed_offset, 2),
-                                uint64_to_str(
-                                        iter.stream.uncompressed_offset, 3));
-                printf("%15s %15s  %5s  %-10s %7s\n",
-                                uint64_to_str(iter.stream.compressed_size, 0),
-                                uint64_to_str(
-                                        iter.stream.uncompressed_size, 1),
-                                get_ratio(iter.stream.compressed_size,
-                                        iter.stream.uncompressed_size),
-                                check_names[iter.stream.flags->check],
-                                uint64_to_str(iter.stream.padding, 2));
+                const char *cols1[4] = {
+                        uint64_to_str(iter.stream.number, 0),
+                        uint64_to_str(iter.stream.block_count, 1),
+                        uint64_to_str(iter.stream.compressed_offset, 2),
+                        uint64_to_str(iter.stream.uncompressed_offset, 3),
+                };
+                printf("    %*s %*s %*s %*s ",
+                                tuklib_mbstr_fw(cols1[0], 6), cols1[0],
+                                tuklib_mbstr_fw(cols1[1], 9), cols1[1],
+                                tuklib_mbstr_fw(cols1[2], 15), cols1[2],
+                                tuklib_mbstr_fw(cols1[3], 15), cols1[3]);
+
+                const char *cols2[5] = {
+                        uint64_to_str(iter.stream.compressed_size, 0),
+                        uint64_to_str(iter.stream.uncompressed_size, 1),
+                        get_ratio(iter.stream.compressed_size,
+                                iter.stream.uncompressed_size),
+                        _(check_names[iter.stream.flags->check]),
+                        uint64_to_str(iter.stream.padding, 2),
+                };
+                printf("%*s %*s  %*s  %-*s %*s\n",
+                                tuklib_mbstr_fw(cols2[0], 15), cols2[0],
+                                tuklib_mbstr_fw(cols2[1], 15), cols2[1],
+                                tuklib_mbstr_fw(cols2[2], 5), cols2[2],
+                                tuklib_mbstr_fw(cols2[3], 10), cols2[3],
+                                tuklib_mbstr_fw(cols2[4], 7), cols2[4]);
 
                 // Update the maximum Check size.
                 if (lzma_check_size(iter.stream.flags->check) > check_max)
                         check_max = lzma_check_size(iter.stream.flags->check);
         }
 
         // Cache the verbosity level to a local variable.
         const bool detailed = message_verbosity_get() >= V_DEBUG;
 
         // Information collected from Block Headers
         block_header_info bhi;
 
         // Print information about the Blocks but only if there is
         // at least one Block.
         if (lzma_index_block_count(xfi->idx) > 0) {
                 // Calculate the width of the CheckVal field.
                 const int checkval_width = my_max(8, 2 * check_max);
 
-                // Print the headings.
+                // TRANSLATORS: The second line is column headings. All
+                // except Check are right aligned; Check is left aligned.
                 printf(_("  Blocks:\n    Stream     Block"
                         "      CompOffset    UncompOffset"
                         "       TotalSize      UncompSize  Ratio  Check"));
 
-                if (detailed)
-                        printf(_("      %-*s  Header  Flags        CompSize"
-                                        "    MemUsage  Filters"),
-                                        checkval_width, _("CheckVal"));
+                if (detailed) {
+                        // TRANSLATORS: These are additional column headings
+                        // for the most verbose listing mode. CheckVal
+                        // (Check value), Flags, and Filters are left aligned.
+                        // Header (Block Header Size), CompSize, and MemUsage
+                        // are right aligned. %*s is replaced with 0-120
+                        // spaces to make the CheckVal column wide enough.
+                        // Test with "xz -lvv foo.xz".
+                        printf(_("      CheckVal %*s Header  Flags        "
+                                        "CompSize    MemUsage  Filters"),
+                                        checkval_width - 8, "");
+                }
 
                 putchar('\n');
 
                 lzma_index_iter_init(&iter, xfi->idx);
 
                 // Iterate over the Blocks.
                 while (!lzma_index_iter_next(&iter, LZMA_INDEX_ITER_BLOCK)) {
                         if (detailed && parse_details(pair, &iter, &bhi, xfi))
                                         return true;
 
-                        printf("    %6s %9s %15s %15s ",
+                        const char *cols1[4] = {
                                 uint64_to_str(iter.stream.number, 0),
                                 uint64_to_str(
                                         iter.block.number_in_stream, 1),
                                 uint64_to_str(
                                         iter.block.compressed_file_offset, 2),
                                 uint64_to_str(
-                                        iter.block.uncompressed_file_offset,
-                                        3));
-                        printf("%15s %15s  %5s  %-*s",
+                                        iter.block.uncompressed_file_offset, 3)
+                        };
+                        printf("    %*s %*s %*s %*s ",
+                                tuklib_mbstr_fw(cols1[0], 6), cols1[0],
+                                tuklib_mbstr_fw(cols1[1], 9), cols1[1],
+                                tuklib_mbstr_fw(cols1[2], 15), cols1[2],
+                                tuklib_mbstr_fw(cols1[3], 15), cols1[3]);
+
+                        const char *cols2[4] = {
                                 uint64_to_str(iter.block.total_size, 0),
                                 uint64_to_str(iter.block.uncompressed_size,
                                                 1),
                                 get_ratio(iter.block.total_size,
                                         iter.block.uncompressed_size),
-                                detailed ? 11 : 1,
-                                check_names[iter.stream.flags->check]);
+                                _(check_names[iter.stream.flags->check])
+                        };
+                        printf("%*s %*s  %*s  %-*s",
+                                tuklib_mbstr_fw(cols2[0], 15), cols2[0],
+                                tuklib_mbstr_fw(cols2[1], 15), cols2[1],
+                                tuklib_mbstr_fw(cols2[2], 5), cols2[2],
+                                tuklib_mbstr_fw(cols2[3], detailed ? 11 : 1),
+                                        cols2[3]);
 
                         if (detailed) {
-                                // Show MiB for memory usage, because it
-                                // is the only size which is not in bytes.
                                 const lzma_vli compressed_size
                                                 = iter.block.unpadded_size
                                                 - bhi.header_size
                                                 - lzma_check_size(
                                                 iter.stream.flags->check);
-                                printf("%-*s  %6s  %-5s %15s %7s MiB  %s",
-                                        checkval_width, check_value,
+
+                                const char *cols3[6] = {
+                                        check_value,
                                         uint64_to_str(bhi.header_size, 0),
                                         bhi.flags,
                                         uint64_to_str(compressed_size, 1),
                                         uint64_to_str(
                                                 round_up_to_mib(bhi.memusage),
                                                 2),
-                                        bhi.filter_chain);
+                                        bhi.filter_chain
+                                };
+                                // Show MiB for memory usage, because it
+                                // is the only size which is not in bytes.
+                                printf("%-*s  %*s  %-5s %*s %*s MiB  %s",
+                                        checkval_width, cols3[0],
+                                        tuklib_mbstr_fw(cols3[1], 6), cols3[1],
+                                        cols3[2],
+                                        tuklib_mbstr_fw(cols3[3], 15),
+                                                cols3[3],
+                                        tuklib_mbstr_fw(cols3[4], 7), cols3[4],
+                                        cols3[5]);
                         }
 
                         putchar('\n');
                 }
         }
 
         if (detailed) {
                 printf(_("  Memory needed:      %s MiB\n"), uint64_to_str(
                                 round_up_to_mib(xfi->memusage_max), 0));
                 printf(_("  Sizes in headers:   %s\n"),
                                 xfi->all_have_sizes ? _("Yes") : _("No"));
         }
 
         return false;
 }
 
 
 static bool
 print_info_robot(xz_file_info *xfi, file_pair *pair)
 {
+        char checks[CHECKS_STR_SIZE];
+        get_check_names(checks, lzma_index_checks(xfi->idx), false);
+
         printf("name\t%s\n", pair->src_name);
 
         printf("file\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64
                         "\t%s\t%s\t%" PRIu64 "\n",
                         lzma_index_stream_count(xfi->idx),
                         lzma_index_block_count(xfi->idx),
                         lzma_index_file_size(xfi->idx),
                         lzma_index_uncompressed_size(xfi->idx),
                         get_ratio(lzma_index_file_size(xfi->idx),
                                 lzma_index_uncompressed_size(xfi->idx)),
-                        get_check_names(lzma_index_checks(xfi->idx), false),
+                        checks,
                         xfi->stream_padding);
 
         if (message_verbosity_get() >= V_VERBOSE) {
                 lzma_index_iter iter;
                 lzma_index_iter_init(&iter, xfi->idx);
 
                 while (!lzma_index_iter_next(&iter, LZMA_INDEX_ITER_STREAM))
                         printf("stream\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64
                                 "\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64
                                 "\t%s\t%s\t%" PRIu64 "\n",
@@ skipping 77 matching lines @@
 
 static void
 print_totals_basic(void)
 {
         // Print a separator line.
         char line[80];
         memset(line, '-', sizeof(line));
         line[sizeof(line) - 1] = '\0';
         puts(line);
 
+        // Get the check names.
+        char checks[CHECKS_STR_SIZE];
+        get_check_names(checks, totals.checks, false);
+
         // Print the totals except the file count, which needs
         // special handling.
         printf("%5s %7s  %11s  %11s  %5s  %-7s ",
                         uint64_to_str(totals.streams, 0),
                         uint64_to_str(totals.blocks, 1),
                         uint64_to_nicestr(totals.compressed_size,
                                 NICESTR_B, NICESTR_TIB, false, 2),
                         uint64_to_nicestr(totals.uncompressed_size,
                                 NICESTR_B, NICESTR_TIB, false, 3),
                         get_ratio(totals.compressed_size,
                                 totals.uncompressed_size),
-                        get_check_names(totals.checks, false));
+                        checks);
 
         // Since we print totals only when there are at least two files,
         // the English message will always use "%s files". But some other
         // languages need different forms for different plurals so we
-        // have to translate this string still.
+        // have to translate this with ngettext().
         //
-        // TRANSLATORS: This simply indicates the number of files shown
-        // by --list even though the format string uses %s.
-        printf(N_("%s file", "%s files\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".
+        printf(ngettext("%s file\n", "%s files\n",
                         totals.files <= ULONG_MAX ? totals.files
                                 : (totals.files % 1000000) + 1000000),
                         uint64_to_str(totals.files, 0));
 
         return;
 }
 
 
 static void
 print_totals_adv(void)
@@ skipping 13 matching lines @@
                                 totals.all_have_sizes ? _("Yes") : _("No"));
         }
 
         return;
 }
 
 
 static void
 print_totals_robot(void)
 {
+        char checks[CHECKS_STR_SIZE];
+        get_check_names(checks, totals.checks, false);
+
         printf("totals\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64 "\t%" PRIu64
                         "\t%s\t%s\t%" PRIu64 "\t%" PRIu64,
                         totals.streams,
                         totals.blocks,
                         totals.compressed_size,
                         totals.uncompressed_size,
                         get_ratio(totals.compressed_size,
                                 totals.uncompressed_size),
-                        get_check_names(totals.checks, false),
+                        checks,
                         totals.stream_padding,
                         totals.files);
 
         if (message_verbosity_get() >= V_DEBUG)
                 printf("\t%" PRIu64 "\t%s",
                                 totals.memusage_max,
                                 totals.all_have_sizes ? "yes" : "no");
 
         putchar('\n');
 
@@ skipping 67 matching lines @@
                 // broken files.
                 if (!fail)
                         update_totals(&xfi);
 
                 lzma_index_end(xfi.idx, NULL);
         }
 
         io_close(pair, false);
         return;
 }