Update XZ Utils to 5.0.3 (in deps)

src/xz/args.c

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       args.c
 /// \brief      Argument parsing
 ///
 /// \note       Filter-specific options parsing is in options.c.
 //
 //  Author:     Lasse Collin
 //
 //  This file has been put into the public domain.
 //  You can do whatever you want with this file.
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "private.h"
 
 #include "getopt.h"
 #include <ctype.h>
 
 
 bool opt_stdout = false;
 bool opt_force = false;
 bool opt_keep_original = false;
 bool opt_robot = false;
 
 // We don't modify or free() this, but we need to assign it in some
 // non-const pointers.
-const char *stdin_filename = "(stdin)";
+const char stdin_filename[] = "(stdin)";
+
+
+/// Parse and set the memory usage limit for compression and/or decompression.
+static void
+parse_memlimit(const char *name, const char *name_percentage, char *str,
+                bool set_compress, bool set_decompress)
+{
+        bool is_percentage = false;
+        uint64_t value;
+
+        const size_t len = strlen(str);
+        if (len > 0 && str[len - 1] == '%') {
+                str[len - 1] = '\0';
+                is_percentage = true;
+                value = str_to_uint64(name_percentage, str, 1, 100);
+        } else {
+                // On 32-bit systems, SIZE_MAX would make more sense than
+                // UINT64_MAX. But use UINT64_MAX still so that scripts
+                // that assume > 4 GiB values don't break.
+                value = str_to_uint64(name, str, 0, UINT64_MAX);
+        }
+
+        hardware_memlimit_set(
+                        value, set_compress, set_decompress, is_percentage);
+        return;
+}
 
 
 static void
 parse_real(args_info *args, int argc, char **argv)
 {
         enum {
                 OPT_X86 = INT_MIN,
                 OPT_POWERPC,
                 OPT_IA64,
                 OPT_ARM,
                 OPT_ARMTHUMB,
                 OPT_SPARC,
                 OPT_DELTA,
                 OPT_LZMA1,
                 OPT_LZMA2,
 
                 OPT_NO_SPARSE,
                 OPT_FILES,
                 OPT_FILES0,
+                OPT_MEM_COMPRESS,
+                OPT_MEM_DECOMPRESS,
                 OPT_NO_ADJUST,
                 OPT_INFO_MEMORY,
                 OPT_ROBOT,
         };
 
         static const char short_opts[]
                         = "cC:defF:hHlkM:qQrS:tT:vVz0123456789";
 
         static const struct option long_opts[] = {
                 // Operation mode
@@ skipping 10 matching lines @@
                 { "to-stdout",    no_argument,       NULL,  'c' },
                 { "no-sparse",    no_argument,       NULL,  OPT_NO_SPARSE },
                 { "suffix",       required_argument, NULL,  'S' },
                 // { "recursive",      no_argument,       NULL,  'r' }, // TODO
                 { "files",        optional_argument, NULL,  OPT_FILES },
                 { "files0",       optional_argument, NULL,  OPT_FILES0 },
 
                 // Basic compression settings
                 { "format",       required_argument, NULL,  'F' },
                 { "check",        required_argument, NULL,  'C' },
+                { "memlimit-compress",   required_argument, NULL, OPT_MEM_COMPRESS },
+                { "memlimit-decompress", required_argument, NULL, OPT_MEM_DECOMPRESS },
+                { "memlimit",     required_argument, NULL,  'M' },
+                { "memory",       required_argument, NULL,  'M' }, // Old alias
                 { "no-adjust",    no_argument,       NULL,  OPT_NO_ADJUST },
-                { "memory",       required_argument, NULL,  'M' },
                 { "threads",      required_argument, NULL,  'T' },
 
                 { "extreme",      no_argument,       NULL,  'e' },
                 { "fast",         no_argument,       NULL,  '0' },
                 { "best",         no_argument,       NULL,  '9' },
 
                 // Filters
                 { "lzma1",        optional_argument, NULL,  OPT_LZMA1 },
                 { "lzma2",        optional_argument, NULL,  OPT_LZMA2 },
                 { "x86",          optional_argument, NULL,  OPT_X86 },
                 { "powerpc",      optional_argument, NULL,  OPT_POWERPC },
                 { "ia64",         optional_argument, NULL,  OPT_IA64 },
                 { "arm",          optional_argument, NULL,  OPT_ARM },
                 { "armthumb",     optional_argument, NULL,  OPT_ARMTHUMB },
                 { "sparc",        optional_argument, NULL,  OPT_SPARC },
                 { "delta",        optional_argument, NULL,  OPT_DELTA },
 
                 // Other options
                 { "quiet",        no_argument,       NULL,  'q' },
                 { "verbose",      no_argument,       NULL,  'v' },
                 { "no-warn",      no_argument,       NULL,  'Q' },
                 { "robot",        no_argument,       NULL,  OPT_ROBOT },
                 { "info-memory",  no_argument,       NULL,  OPT_INFO_MEMORY },
                 { "help",         no_argument,       NULL,  'h' },
                 { "long-help",    no_argument,       NULL,  'H' },
                 { "version",      no_argument,       NULL,  'V' },
 
-                { NULL,                 0,                 NULL,   0 }
+                { NULL,           0,                 NULL,   0 }
         };
 
         int c;
 
         while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL))
                         != -1) {
                 switch (c) {
                 // Compression preset (also for decompression if --format=raw)
                 case '0': case '1': case '2': case '3': case '4':
                 case '5': case '6': case '7': case '8': case '9':
                         coder_set_preset(c - '0');
                         break;
 
-                // --memory
-                case 'M': {
-                        // Support specifying the limit as a percentage of
-                        // installed physical RAM.
-                        size_t len = strlen(optarg);
-                        if (len > 0 && optarg[len - 1] == '%') {
-                                optarg[len - 1] = '\0';
-                                hardware_memlimit_set_percentage(
-                                                str_to_uint64(
-                                                "memory%", optarg, 1, 100));
-                        } else {
-                                // On 32-bit systems, SIZE_MAX would make more
-                                // sense than UINT64_MAX. But use UINT64_MAX
-                                // still so that scripts that assume > 4 GiB
-                                // values don't break.
-                                hardware_memlimit_set(str_to_uint64(
-                                                "memory", optarg,
-                                                0, UINT64_MAX));
-                        }
+                // --memlimit-compress
+                case OPT_MEM_COMPRESS:
+                        parse_memlimit("memlimit-compress",
+                                        "memlimit-compress%", optarg,
+                                        true, false);
+                        break;
 
+                // --memlimit-decompress
+                case OPT_MEM_DECOMPRESS:
+                        parse_memlimit("memlimit-decompress",
+                                        "memlimit-decompress%", optarg,
+                                        false, true);
                         break;
-                }
+
+                // --memlimit
+                case 'M':
+                        parse_memlimit("memlimit", "memlimit%", optarg,
+                                        true, true);
+                        break;
 
                 // --suffix
                 case 'S':
                         suffix_set(optarg);
                         break;
 
                 case 'T':
                         hardware_threadlimit_set(str_to_uint64(
                                         "threads", optarg, 0, UINT32_MAX));
                         break;
@@ skipping 19 matching lines @@
                         break;
 
                 // --force
                 case 'f':
                         opt_force = true;
                         break;
 
                 // --info-memory
                 case OPT_INFO_MEMORY:
                         // This doesn't return.
-                        message_memlimit();
+                        hardware_memlimit_show();
 
                 // --help
                 case 'h':
                         // This doesn't return.
                         message_help(false);
 
                 // --long-help
                 case 'H':
                         // This doesn't return.
                         message_help(true);
@@ skipping 184 matching lines @@
                         message_try_help();
                         tuklib_exit(E_ERROR, E_ERROR, false);
                 }
         }
 
         return;
 }
 
 
 static void
-parse_environment(args_info *args, char *argv0)
+parse_environment(args_info *args, char *argv0, const char *varname)
 {
-        char *env = getenv("XZ_OPT");
+        char *env = getenv(varname);
         if (env == NULL)
                 return;
 
         // We modify the string, so make a copy of it.
         env = xstrdup(env);
 
         // Calculate the number of arguments in env. argc stats at one
         // to include space for the program name.
         int argc = 1;
         bool prev_was_space = true;
         for (size_t i = 0; env[i] != '\0'; ++i) {
                 // NOTE: Cast to unsigned char is needed so that correct
                 // value gets passed to isspace(), which expects
                 // unsigned char cast to int. Casting to int is done
                 // automatically due to integer promotion, but we need to
                 // force char to unsigned char manually. Otherwise 8-bit
                 // characters would get promoted to wrong value if
                 // char is signed.
                 if (isspace((unsigned char)env[i])) {
                         prev_was_space = true;
                 } else if (prev_was_space) {
                         prev_was_space = false;
 
                         // Keep argc small enough to fit into a singed int
                         // and to keep it usable for memory allocation.
                         if (++argc == my_min(
                                         INT_MAX, SIZE_MAX / sizeof(char *)))
                                 message_fatal(_("The environment variable "
-                                                "XZ_OPT contains too many "
-                                                "arguments"));
+                                                "%s contains too many "
+                                                "arguments"), varname);
                 }
         }
 
         // Allocate memory to hold pointers to the arguments. Add one to get
         // space for the terminating NULL (if some systems happen to need it).
         char **argv = xmalloc(((size_t)(argc) + 1) * sizeof(char *));
         argv[0] = argv0;
         argv[argc] = NULL;
 
         // Go through the string again. Split the arguments using '\0'
@@ skipping 67 matching lines @@
                         opt_mode = MODE_DECOMPRESS;
                         opt_stdout = true;
                 } else if (strstr(name, "unlzma") != NULL) {
                         opt_format = FORMAT_LZMA;
                         opt_mode = MODE_DECOMPRESS;
                 } else if (strstr(name, "lzma") != NULL) {
                         opt_format = FORMAT_LZMA;
                 }
         }
 
-        // First the flags from environment
-        parse_environment(args, argv[0]);
+        // First the flags from the environment
+        parse_environment(args, argv[0], "XZ_DEFAULTS");
+        parse_environment(args, argv[0], "XZ_OPT");
 
         // Then from the command line
         parse_real(args, argc, argv);
 
         // Never remove the source file when the destination is not on disk.
         // In test mode the data is written nowhere, but setting opt_stdout
         // will make the rest of the code behave well.
         if (opt_stdout || opt_mode == MODE_TEST) {
                 opt_keep_original = true;
                 opt_stdout = true;
@@ skipping 21 matching lines @@
                 args->arg_count = 1;
         } else {
                 // We got at least one filename from the command line, or
                 // --files or --files0 was specified.
                 args->arg_names = argv + optind;
                 args->arg_count = argc - optind;
         }
 
         return;
 }