Update XZ Utils to 5.0.3 (in deps)

src/xz/coder.c

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       coder.c
 /// \brief      Compresses or uncompresses a file
 //
 //  Author:     Lasse Collin
 //
 //  This file has been put into the public domain.
 //  You can do whatever you want with this file.
 //
@@ skipping 24 matching lines @@
 /// Input and output buffers
 static io_buf in_buf;
 static io_buf out_buf;
 
 /// Number of filters. Zero indicates that we are using a preset.
 static size_t filters_count = 0;
 
 /// Number of the preset (0-9)
 static size_t preset_number = 6;
 
-/// Indicate if no preset has been explicitly given. In that case, if we need
-/// to auto-adjust for lower memory usage, we won't print a warning.
-static bool preset_default = true;
-
 /// If a preset is used (no custom filter chain) and preset_extreme is true,
 /// a significantly slower compression is used to achieve slightly better
 /// compression ratio.
 static bool preset_extreme = false;
 
 /// Integrity check type
 static lzma_check check;
 
 /// This becomes false if the --check=CHECK option is used.
 static bool check_default = true;
 
 
 extern void
 coder_set_check(lzma_check new_check)
 {
         check = new_check;
         check_default = false;
         return;
 }
 
 
 extern void
 coder_set_preset(size_t new_preset)
 {
         preset_number = new_preset;
-        preset_default = false;
+
+        // Setting a preset makes us forget a possibly defined custom
+        // filter chain.
+        while (filters_count > 0) {
+                --filters_count;
+                free(filters[filters_count].options);
+                filters[filters_count].options = NULL;
+        }
+
         return;
 }
 
 
 extern void
 coder_set_extreme(void)
 {
         preset_extreme = true;
         return;
 }
 
 
 extern void
 coder_add_filter(lzma_vli id, void *options)
 {
         if (filters_count == LZMA_FILTERS_MAX)
                 message_fatal(_("Maximum number of filters is four"));
 
         filters[filters_count].id = id;
         filters[filters_count].options = options;
         ++filters_count;
 
         return;
 }
 
 
-static void lzma_attribute((noreturn))
+static void lzma_attribute((__noreturn__))
 memlimit_too_small(uint64_t memory_usage)
 {
         message(V_ERROR, _("Memory usage limit is too low for the given "
                         "filter setup."));
         message_mem_needed(V_ERROR, memory_usage);
         tuklib_exit(E_ERROR, E_ERROR, false);
 }
 
 
 extern void
@@ skipping 22 matching lines @@
                         preset_number |= LZMA_PRESET_EXTREME;
 
                 if (lzma_lzma_preset(&opt_lzma, preset_number))
                         message_bug();
 
                 // Use LZMA2 except with --format=lzma we use LZMA1.
                 filters[0].id = opt_format == FORMAT_LZMA
                                 ? LZMA_FILTER_LZMA1 : LZMA_FILTER_LZMA2;
                 filters[0].options = &opt_lzma;
                 filters_count = 1;
-        } else {
-                preset_default = false;
         }
 
         // Terminate the filter options array.
         filters[filters_count].id = LZMA_VLI_UNKNOWN;
 
         // If we are using the .lzma format, allow exactly one filter
         // which has to be LZMA1.
         if (opt_format == FORMAT_LZMA && (filters_count != 1
                         || filters[0].id != LZMA_FILTER_LZMA1))
                 message_fatal(_("The .lzma format supports only "
                                 "the LZMA1 filter"));
 
         // If we are using the .xz format, make sure that there is no LZMA1
         // filter to prevent LZMA_PROG_ERROR.
         if (opt_format == FORMAT_XZ)
                 for (size_t i = 0; i < filters_count; ++i)
                         if (filters[i].id == LZMA_FILTER_LZMA1)
                                 message_fatal(_("LZMA1 cannot be used "
                                                 "with the .xz format"));
 
         // Print the selected filter chain.
         message_filters_show(V_DEBUG, filters);
 
         // If using --format=raw, we can be decoding. The memusage function
         // also validates the filter chain and the options used for the
         // filters.
-        const uint64_t memory_limit = hardware_memlimit_get();
+        const uint64_t memory_limit = hardware_memlimit_get(opt_mode);
         uint64_t memory_usage;
         if (opt_mode == MODE_COMPRESS)
                 memory_usage = lzma_raw_encoder_memusage(filters);
         else
                 memory_usage = lzma_raw_decoder_memusage(filters);
 
         if (memory_usage == UINT64_MAX)
                 message_fatal(_("Unsupported filter chain or filter options"));
 
         // Print memory usage info before possible dictionary
         // size auto-adjusting.
         message_mem_needed(V_DEBUG, memory_usage);
+        if (opt_mode == MODE_COMPRESS) {
+                const uint64_t decmem = lzma_raw_decoder_memusage(filters);
+                if (decmem != UINT64_MAX)
+                        message(V_DEBUG, _("Decompression will need "
+                                        "%s MiB of memory."), uint64_to_str(
+                                                round_up_to_mib(decmem), 0));
+        }
 
         if (memory_usage > memory_limit) {
                 // If --no-auto-adjust was used or we didn't find LZMA1 or
                 // LZMA2 as the last filter, give an error immediately.
                 // --format=raw implies --no-auto-adjust.
                 if (!opt_auto_adjust || opt_format == FORMAT_RAW)
                         memlimit_too_small(memory_usage);
 
                 assert(opt_mode == MODE_COMPRESS);
 
@@ skipping 33 matching lines @@
                         if (memory_usage <= memory_limit)
                                 break;
 
                         // Otherwise 1 MiB down and try again. I hope this
                         // isn't too slow method for cases where the original
                         // dict_size is very big.
                         opt->dict_size -= UINT32_C(1) << 20;
                 }
 
                 // Tell the user that we decreased the dictionary size.
-                // However, omit the message if no preset or custom chain
-                // was given. FIXME: Always warn?
-                if (!preset_default)
-                        message(V_WARNING, _("Adjusted LZMA%c dictionary size "
-                                        "from %s MiB to %s MiB to not exceed "
-                                        "the memory usage limit of %s MiB"),
-                                        filters[i].id == LZMA_FILTER_LZMA2
-                                                ? '2' : '1',
-                                        uint64_to_str(orig_dict_size >> 20, 0),
-                                        uint64_to_str(opt->dict_size >> 20, 1),
-                                        uint64_to_str(round_up_to_mib(
-                                                memory_limit), 2));
+                message(V_WARNING, _("Adjusted LZMA%c dictionary size "
+                                "from %s MiB to %s MiB to not exceed "
+                                "the memory usage limit of %s MiB"),
+                                filters[i].id == LZMA_FILTER_LZMA2
+                                        ? '2' : '1',
+                                uint64_to_str(orig_dict_size >> 20, 0),
+                                uint64_to_str(opt->dict_size >> 20, 1),
+                                uint64_to_str(round_up_to_mib(
+                                        memory_limit), 2));
         }
 
 /*
         // Limit the number of worker threads so that memory usage
         // limit isn't exceeded.
         assert(memory_usage > 0);
         size_t thread_limit = memory_limit / memory_usage;
         if (thread_limit == 0)
                 thread_limit = 1;
 
@@ skipping 139 matching lines @@
                         // passthru mode with --test.
                         if (opt_mode == MODE_DECOMPRESS
                                         && opt_stdout && opt_force)
                                 return CODER_INIT_PASSTHRU;
 
                         ret = LZMA_FORMAT_ERROR;
                         break;
 
                 case FORMAT_XZ:
                         ret = lzma_stream_decoder(&strm,
-                                        hardware_memlimit_get(), flags);
+                                        hardware_memlimit_get(
+                                                MODE_DECOMPRESS), flags);
                         break;
 
                 case FORMAT_LZMA:
                         ret = lzma_alone_decoder(&strm,
-                                        hardware_memlimit_get());
+                                        hardware_memlimit_get(
+                                                MODE_DECOMPRESS));
                         break;
 
                 case FORMAT_RAW:
                         // Memory usage has already been checked in
                         // coder_set_compression_settings().
                         ret = lzma_raw_decoder(&strm, filters);
                         break;
                 }
 
                 // Try to decode the headers. This will catch too low
@@ skipping 221 matching lines @@
                         }
                 }
         }
 
         // Close the file pair. It needs to know if coding was successful to
         // know if the source or target file should be unlinked.
         io_close(pair, success);
 
         return;
 }