?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / tools / misc / xz / src / xz / args.c
blob4bd84a0c141c7e1165b0a485e0fa1774b6480301
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 /// \file args.c
4 /// \brief Argument parsing
5 ///
6 /// \note Filter-specific options parsing is in options.c.
7 //
8 // Author: Lasse Collin
9 //
10 // This file has been put into the public domain.
11 // You can do whatever you want with this file.
12 //
13 ///////////////////////////////////////////////////////////////////////////////
14
15 #include "private.h"
16
17 #include "getopt.h"
18 #include <ctype.h>
19
20
21 bool opt_stdout = false;
22 bool opt_force = false;
23 bool opt_keep_original = false;
24 bool opt_robot = false;
25
26 // We don't modify or free() this, but we need to assign it in some
27 // non-const pointers.
28 const char stdin_filename[] = "(stdin)";
29
30
31 /// Parse and set the memory usage limit for compression and/or decompression.
32 static void
33 parse_memlimit(const char *name, const char *name_percentage, char *str,
34 bool set_compress, bool set_decompress)
35 {
36 bool is_percentage = false;
37 uint64_t value;
38
39 const size_t len = strlen(str);
40 if (len > 0 && str[len - 1] == '%') {
41 str[len - 1] = '\0';
42 is_percentage = true;
43 value = str_to_uint64(name_percentage, str, 1, 100);
44 } else {
45 // On 32-bit systems, SIZE_MAX would make more sense than
46 // UINT64_MAX. But use UINT64_MAX still so that scripts
47 // that assume > 4 GiB values don't break.
48 value = str_to_uint64(name, str, 0, UINT64_MAX);
49 }
50
51 hardware_memlimit_set(
52 value, set_compress, set_decompress, is_percentage);
53 return;
54 }
55
56
57 static void
58 parse_real(args_info *args, int argc, char **argv)
59 {
60 enum {
61 OPT_X86 = INT_MIN,
62 OPT_POWERPC,
63 OPT_IA64,
64 OPT_ARM,
65 OPT_ARMTHUMB,
66 OPT_SPARC,
67 OPT_DELTA,
68 OPT_LZMA1,
69 OPT_LZMA2,
70
71 OPT_NO_SPARSE,
72 OPT_FILES,
73 OPT_FILES0,
74 OPT_MEM_COMPRESS,
75 OPT_MEM_DECOMPRESS,
76 OPT_NO_ADJUST,
77 OPT_INFO_MEMORY,
78 OPT_ROBOT,
79 };
80
81 static const char short_opts[]
82 = "cC:defF:hHlkM:qQrS:tT:vVz0123456789";
83
84 static const struct option long_opts[] = {
85 // Operation mode
86 { "compress", no_argument, NULL, 'z' },
87 { "decompress", no_argument, NULL, 'd' },
88 { "uncompress", no_argument, NULL, 'd' },
89 { "test", no_argument, NULL, 't' },
90 { "list", no_argument, NULL, 'l' },
91
92 // Operation modifiers
93 { "keep", no_argument, NULL, 'k' },
94 { "force", no_argument, NULL, 'f' },
95 { "stdout", no_argument, NULL, 'c' },
96 { "to-stdout", no_argument, NULL, 'c' },
97 { "no-sparse", no_argument, NULL, OPT_NO_SPARSE },
98 { "suffix", required_argument, NULL, 'S' },
99 // { "recursive", no_argument, NULL, 'r' }, // TODO
100 { "files", optional_argument, NULL, OPT_FILES },
101 { "files0", optional_argument, NULL, OPT_FILES0 },
102
103 // Basic compression settings
104 { "format", required_argument, NULL, 'F' },
105 { "check", required_argument, NULL, 'C' },
106 { "memlimit-compress", required_argument, NULL, OPT_MEM_COMPRESS },
107 { "memlimit-decompress", required_argument, NULL, OPT_MEM_DECOMPRESS },
108 { "memlimit", required_argument, NULL, 'M' },
109 { "memory", required_argument, NULL, 'M' }, // Old alias
110 { "no-adjust", no_argument, NULL, OPT_NO_ADJUST },
111 { "threads", required_argument, NULL, 'T' },
112
113 { "extreme", no_argument, NULL, 'e' },
114 { "fast", no_argument, NULL, '0' },
115 { "best", no_argument, NULL, '9' },
116
117 // Filters
118 { "lzma1", optional_argument, NULL, OPT_LZMA1 },
119 { "lzma2", optional_argument, NULL, OPT_LZMA2 },
120 { "x86", optional_argument, NULL, OPT_X86 },
121 { "powerpc", optional_argument, NULL, OPT_POWERPC },
122 { "ia64", optional_argument, NULL, OPT_IA64 },
123 { "arm", optional_argument, NULL, OPT_ARM },
124 { "armthumb", optional_argument, NULL, OPT_ARMTHUMB },
125 { "sparc", optional_argument, NULL, OPT_SPARC },
126 { "delta", optional_argument, NULL, OPT_DELTA },
127
128 // Other options
129 { "quiet", no_argument, NULL, 'q' },
130 { "verbose", no_argument, NULL, 'v' },
131 { "no-warn", no_argument, NULL, 'Q' },
132 { "robot", no_argument, NULL, OPT_ROBOT },
133 { "info-memory", no_argument, NULL, OPT_INFO_MEMORY },
134 { "help", no_argument, NULL, 'h' },
135 { "long-help", no_argument, NULL, 'H' },
136 { "version", no_argument, NULL, 'V' },
137
138 { NULL, 0, NULL, 0 }
139 };
140
141 int c;
142
143 while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL))
144 != -1) {
145 switch (c) {
146 // Compression preset (also for decompression if --format=raw)
147 case '0': case '1': case '2': case '3': case '4':
148 case '5': case '6': case '7': case '8': case '9':
149 coder_set_preset(c - '0');
150 break;
151
152 // --memlimit-compress
153 case OPT_MEM_COMPRESS:
154 parse_memlimit("memlimit-compress",
155 "memlimit-compress%", optarg,
156 true, false);
157 break;
158
159 // --memlimit-decompress
160 case OPT_MEM_DECOMPRESS:
161 parse_memlimit("memlimit-decompress",
162 "memlimit-decompress%", optarg,
163 false, true);
164 break;
165
166 // --memlimit
167 case 'M':
168 parse_memlimit("memlimit", "memlimit%", optarg,
169 true, true);
170 break;
171
172 // --suffix
173 case 'S':
174 suffix_set(optarg);
175 break;
176
177 case 'T':
178 hardware_threadlimit_set(str_to_uint64(
179 "threads", optarg, 0, UINT32_MAX));
180 break;
181
182 // --version
183 case 'V':
184 // This doesn't return.
185 message_version();
186
187 // --stdout
188 case 'c':
189 opt_stdout = true;
190 break;
191
192 // --decompress
193 case 'd':
194 opt_mode = MODE_DECOMPRESS;
195 break;
196
197 // --extreme
198 case 'e':
199 coder_set_extreme();
200 break;
201
202 // --force
203 case 'f':
204 opt_force = true;
205 break;
206
207 // --info-memory
208 case OPT_INFO_MEMORY:
209 // This doesn't return.
210 hardware_memlimit_show();
211
212 // --help
213 case 'h':
214 // This doesn't return.
215 message_help(false);
216
217 // --long-help
218 case 'H':
219 // This doesn't return.
220 message_help(true);
221
222 // --list
223 case 'l':
224 opt_mode = MODE_LIST;
225 break;
226
227 // --keep
228 case 'k':
229 opt_keep_original = true;
230 break;
231
232 // --quiet
233 case 'q':
234 message_verbosity_decrease();
235 break;
236
237 case 'Q':
238 set_exit_no_warn();
239 break;
240
241 case 't':
242 opt_mode = MODE_TEST;
243 break;
244
245 // --verbose
246 case 'v':
247 message_verbosity_increase();
248 break;
249
250 // --robot
251 case OPT_ROBOT:
252 opt_robot = true;
253
254 // This is to make sure that floating point numbers
255 // always have a dot as decimal separator.
256 setlocale(LC_NUMERIC, "C");
257 break;
258
259 case 'z':
260 opt_mode = MODE_COMPRESS;
261 break;
262
263 // Filter setup
264
265 case OPT_X86:
266 coder_add_filter(LZMA_FILTER_X86,
267 options_bcj(optarg));
268 break;
269
270 case OPT_POWERPC:
271 coder_add_filter(LZMA_FILTER_POWERPC,
272 options_bcj(optarg));
273 break;
274
275 case OPT_IA64:
276 coder_add_filter(LZMA_FILTER_IA64,
277 options_bcj(optarg));
278 break;
279
280 case OPT_ARM:
281 coder_add_filter(LZMA_FILTER_ARM,
282 options_bcj(optarg));
283 break;
284
285 case OPT_ARMTHUMB:
286 coder_add_filter(LZMA_FILTER_ARMTHUMB,
287 options_bcj(optarg));
288 break;
289
290 case OPT_SPARC:
291 coder_add_filter(LZMA_FILTER_SPARC,
292 options_bcj(optarg));
293 break;
294
295 case OPT_DELTA:
296 coder_add_filter(LZMA_FILTER_DELTA,
297 options_delta(optarg));
298 break;
299
300 case OPT_LZMA1:
301 coder_add_filter(LZMA_FILTER_LZMA1,
302 options_lzma(optarg));
303 break;
304
305 case OPT_LZMA2:
306 coder_add_filter(LZMA_FILTER_LZMA2,
307 options_lzma(optarg));
308 break;
309
310 // Other
311
312 // --format
313 case 'F': {
314 // Just in case, support both "lzma" and "alone" since
315 // the latter was used for forward compatibility in
316 // LZMA Utils 4.32.x.
317 static const struct {
318 char str[8];
319 enum format_type format;
320 } types[] = {
321 { "auto", FORMAT_AUTO },
322 { "xz", FORMAT_XZ },
323 { "lzma", FORMAT_LZMA },
324 { "alone", FORMAT_LZMA },
325 // { "gzip", FORMAT_GZIP },
326 // { "gz", FORMAT_GZIP },
327 { "raw", FORMAT_RAW },
328 };
329
330 size_t i = 0;
331 while (strcmp(types[i].str, optarg) != 0)
332 if (++i == ARRAY_SIZE(types))
333 message_fatal(_("%s: Unknown file "
334 "format type"),
335 optarg);
336
337 opt_format = types[i].format;
338 break;
339 }
340
341 // --check
342 case 'C': {
343 static const struct {
344 char str[8];
345 lzma_check check;
346 } types[] = {
347 { "none", LZMA_CHECK_NONE },
348 { "crc32", LZMA_CHECK_CRC32 },
349 { "crc64", LZMA_CHECK_CRC64 },
350 { "sha256", LZMA_CHECK_SHA256 },
351 };
352
353 size_t i = 0;
354 while (strcmp(types[i].str, optarg) != 0) {
355 if (++i == ARRAY_SIZE(types))
356 message_fatal(_("%s: Unsupported "
357 "integrity "
358 "check type"), optarg);
359 }
360
361 // Use a separate check in case we are using different
362 // liblzma than what was used to compile us.
363 if (!lzma_check_is_supported(types[i].check))
364 message_fatal(_("%s: Unsupported integrity "
365 "check type"), optarg);
366
367 coder_set_check(types[i].check);
368 break;
369 }
370
371 case OPT_NO_SPARSE:
372 io_no_sparse();
373 break;
374
375 case OPT_FILES:
376 args->files_delim = '\n';
377
378 // Fall through
379
380 case OPT_FILES0:
381 if (args->files_name != NULL)
382 message_fatal(_("Only one file can be "
383 "specified with `--files' "
384 "or `--files0'."));
385
386 if (optarg == NULL) {
387 args->files_name = (char *)stdin_filename;
388 args->files_file = stdin;
389 } else {
390 args->files_name = optarg;
391 args->files_file = fopen(optarg,
392 c == OPT_FILES ? "r" : "rb");
393 if (args->files_file == NULL)
394 message_fatal("%s: %s", optarg,
395 strerror(errno));
396 }
397
398 break;
399
400 case OPT_NO_ADJUST:
401 opt_auto_adjust = false;
402 break;
403
404 default:
405 message_try_help();
406 tuklib_exit(E_ERROR, E_ERROR, false);
407 }
408 }
409
410 return;
411 }
412
413
414 static void
415 parse_environment(args_info *args, char *argv0, const char *varname)
416 {
417 char *env = getenv(varname);
418 if (env == NULL)
419 return;
420
421 // We modify the string, so make a copy of it.
422 env = xstrdup(env);
423
424 // Calculate the number of arguments in env. argc stats at one
425 // to include space for the program name.
426 int argc = 1;
427 bool prev_was_space = true;
428 for (size_t i = 0; env[i] != '\0'; ++i) {
429 // NOTE: Cast to unsigned char is needed so that correct
430 // value gets passed to isspace(), which expects
431 // unsigned char cast to int. Casting to int is done
432 // automatically due to integer promotion, but we need to
433 // force char to unsigned char manually. Otherwise 8-bit
434 // characters would get promoted to wrong value if
435 // char is signed.
436 if (isspace((unsigned char)env[i])) {
437 prev_was_space = true;
438 } else if (prev_was_space) {
439 prev_was_space = false;
440
441 // Keep argc small enough to fit into a singed int
442 // and to keep it usable for memory allocation.
443 if (++argc == my_min(
444 INT_MAX, SIZE_MAX / sizeof(char *)))
445 message_fatal(_("The environment variable "
446 "%s contains too many "
447 "arguments"), varname);
448 }
449 }
450
451 // Allocate memory to hold pointers to the arguments. Add one to get
452 // space for the terminating NULL (if some systems happen to need it).
453 char **argv = xmalloc(((size_t)(argc) + 1) * sizeof(char *));
454 argv[0] = argv0;
455 argv[argc] = NULL;
456
457 // Go through the string again. Split the arguments using '\0'
458 // characters and add pointers to the resulting strings to argv.
459 argc = 1;
460 prev_was_space = true;
461 for (size_t i = 0; env[i] != '\0'; ++i) {
462 if (isspace((unsigned char)env[i])) {
463 prev_was_space = true;
464 env[i] = '\0';
465 } else if (prev_was_space) {
466 prev_was_space = false;
467 argv[argc++] = env + i;
468 }
469 }
470
471 // Parse the argument list we got from the environment. All non-option
472 // arguments i.e. filenames are ignored.
473 parse_real(args, argc, argv);
474
475 // Reset the state of the getopt_long() so that we can parse the
476 // command line options too. There are two incompatible ways to
477 // do it.
478 #ifdef HAVE_OPTRESET
479 // BSD
480 optind = 1;
481 optreset = 1;
482 #else
483 // GNU, Solaris
484 optind = 0;
485 #endif
486
487 // We don't need the argument list from environment anymore.
488 free(argv);
489 free(env);
490
491 return;
492 }
493
494
495 extern void
496 args_parse(args_info *args, int argc, char **argv)
497 {
498 // Initialize those parts of *args that we need later.
499 args->files_name = NULL;
500 args->files_file = NULL;
501 args->files_delim = '\0';
502
503 // Check how we were called.
504 {
505 // Remove the leading path name, if any.
506 const char *name = strrchr(argv[0], '/');
507 if (name == NULL)
508 name = argv[0];
509 else
510 ++name;
511
512 // NOTE: It's possible that name[0] is now '\0' if argv[0]
513 // is weird, but it doesn't matter here.
514
515 // Look for full command names instead of substrings like
516 // "un", "cat", and "lz" to reduce possibility of false
517 // positives when the programs have been renamed.
518 if (strstr(name, "xzcat") != NULL) {
519 opt_mode = MODE_DECOMPRESS;
520 opt_stdout = true;
521 } else if (strstr(name, "unxz") != NULL) {
522 opt_mode = MODE_DECOMPRESS;
523 } else if (strstr(name, "lzcat") != NULL) {
524 opt_format = FORMAT_LZMA;
525 opt_mode = MODE_DECOMPRESS;
526 opt_stdout = true;
527 } else if (strstr(name, "unlzma") != NULL) {
528 opt_format = FORMAT_LZMA;
529 opt_mode = MODE_DECOMPRESS;
530 } else if (strstr(name, "lzma") != NULL) {
531 opt_format = FORMAT_LZMA;
532 }
533 }
534
535 // First the flags from the environment
536 parse_environment(args, argv[0], "XZ_DEFAULTS");
537 parse_environment(args, argv[0], "XZ_OPT");
538
539 // Then from the command line
540 parse_real(args, argc, argv);
541
542 // Never remove the source file when the destination is not on disk.
543 // In test mode the data is written nowhere, but setting opt_stdout
544 // will make the rest of the code behave well.
545 if (opt_stdout || opt_mode == MODE_TEST) {
546 opt_keep_original = true;
547 opt_stdout = true;
548 }
549
550 // When compressing, if no --format flag was used, or it
551 // was --format=auto, we compress to the .xz format.
552 if (opt_mode == MODE_COMPRESS && opt_format == FORMAT_AUTO)
553 opt_format = FORMAT_XZ;
554
555 // Compression settings need to be validated (options themselves and
556 // their memory usage) when compressing to any file format. It has to
557 // be done also when uncompressing raw data, since for raw decoding
558 // the options given on the command line are used to know what kind
559 // of raw data we are supposed to decode.
560 if (opt_mode == MODE_COMPRESS || opt_format == FORMAT_RAW)
561 coder_set_compression_settings();
562
563 // If no filenames are given, use stdin.
564 if (argv[optind] == NULL && args->files_name == NULL) {
565 // We don't modify or free() the "-" constant. The caller
566 // modifies this so don't make the struct itself const.
567 static char *names_stdin[2] = { (char *)"-", NULL };
568 args->arg_names = names_stdin;
569 args->arg_count = 1;
570 } else {
571 // We got at least one filename from the command line, or
572 // --files or --files0 was specified.
573 args->arg_names = argv + optind;
574 args->arg_count = argc - optind;
575 }
576
577 return;
578 }
Tomato firmware and modifications.