1 /* Command line option handling.
2 Copyright (C) 2006, 2007, 2008, 2010 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
26 #include "diagnostic.h"
27 #include "tm.h" /* For SWITCH_TAKES_ARG and WORD_SWITCH_TAKES_ARG. */
29 /* Perform a binary search to find which option the command-line INPUT
30 matches. Returns its index in the option array, and
31 OPT_SPECIAL_unknown on failure.
33 This routine is quite subtle. A normal binary search is not good
34 enough because some options can be suffixed with an argument, and
35 multiple sub-matches can occur, e.g. input of "-pedantic" matching
36 the initial substring of "-pedantic-errors".
38 A more complicated example is -gstabs. It should match "-g" with
39 an argument of "stabs". Suppose, however, that the number and list
40 of switches are such that the binary search tests "-gen-decls"
41 before having tested "-g". This doesn't match, and as "-gen-decls"
42 is less than "-gstabs", it will become the lower bound of the
43 binary search range, and "-g" will never be seen. To resolve this
44 issue, 'optc-gen.awk' makes "-gen-decls" point, via the back_chain member,
45 to "-g" so that failed searches that end between "-gen-decls" and
46 the lexicographically subsequent switch know to go back and see if
47 "-g" causes a match (which it does in this example).
49 This search is done in such a way that the longest match for the
50 front end in question wins. If there is no match for the current
51 front end, the longest match for a different front end is returned
52 (or N_OPTS if none) and the caller emits an error message. */
54 find_opt (const char *input, int lang_mask)
56 size_t mn, mx, md, opt_len;
57 size_t match_wrong_lang;
61 mx = cl_options_count;
63 /* Find mn such this lexicographical inequality holds:
64 cl_options[mn] <= input < cl_options[mn + 1]. */
68 opt_len = cl_options[md].opt_len;
69 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
77 /* This is the switch that is the best match but for a different
78 front end, or OPT_SPECIAL_unknown if there is no match at all. */
79 match_wrong_lang = OPT_SPECIAL_unknown;
81 /* Backtrace the chain of possible matches, returning the longest
82 one, if any, that fits best. With current GCC switches, this
83 loop executes at most twice. */
86 const struct cl_option *opt = &cl_options[mn];
88 /* Is the input either an exact match or a prefix that takes a
90 if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
91 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
93 /* If language is OK, return it. */
94 if (opt->flags & lang_mask)
97 /* If we haven't remembered a prior match, remember this
98 one. Any prior match is necessarily better. */
99 if (match_wrong_lang == OPT_SPECIAL_unknown)
100 match_wrong_lang = mn;
103 /* Try the next possibility. This is cl_options_count if there
105 mn = opt->back_chain;
107 while (mn != cl_options_count);
109 /* Return the best wrong match, or OPT_SPECIAL_unknown if none. */
110 return match_wrong_lang;
113 /* If ARG is a non-negative integer made up solely of digits, return its
114 value, otherwise return -1. */
117 integral_argument (const char *arg)
121 while (*p && ISDIGIT (*p))
130 /* Return whether OPTION is OK for the language given by
133 option_ok_for_language (const struct cl_option *option,
134 unsigned int lang_mask)
136 if (!(option->flags & lang_mask))
138 else if ((option->flags & CL_TARGET)
139 && (option->flags & (CL_LANG_ALL | CL_DRIVER))
140 && !(option->flags & (lang_mask & ~CL_COMMON & ~CL_TARGET)))
141 /* Complain for target flag language mismatches if any languages
147 /* Decode the switch beginning at ARGV for the language indicated by
148 LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
149 the structure *DECODED. Returns the number of switches
153 decode_cmdline_option (const char **argv, unsigned int lang_mask,
154 struct cl_decoded_option *decoded)
157 const char *opt, *arg = 0;
160 unsigned int result = 1, i;
163 const struct cl_option *option;
165 bool separate_arg_flag;
166 bool joined_arg_flag;
170 opt_index = find_opt (opt + 1, lang_mask);
171 if (opt_index == OPT_SPECIAL_unknown
172 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
173 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
175 /* Drop the "no-" from negative switches. */
176 size_t len = strlen (opt) - 3;
178 dup = XNEWVEC (char, len + 1);
181 memcpy (dup + 2, opt + 5, len - 2 + 1);
184 opt_index = find_opt (opt + 1, lang_mask);
187 if (opt_index == OPT_SPECIAL_unknown)
193 option = &cl_options[opt_index];
195 /* Reject negative form of switches that don't take negatives as
197 if (!value && (option->flags & CL_REJECT_NEGATIVE))
199 opt_index = OPT_SPECIAL_unknown;
200 errors |= CL_ERR_NEGATIVE;
205 /* Check to see if the option is disabled for this configuration. */
206 if (option->flags & CL_DISABLED)
207 errors |= CL_ERR_DISABLED;
209 /* Determine whether there may be a separate argument based on
210 whether this option is being processed for the driver. */
211 separate_arg_flag = ((option->flags & CL_SEPARATE)
212 && !((option->flags & CL_NO_DRIVER_ARG)
213 && (lang_mask & CL_DRIVER)));
214 joined_arg_flag = (option->flags & CL_JOINED) != 0;
216 /* Sort out any argument the switch takes. */
219 /* Have arg point to the original switch. This is because
220 some code, such as disable_builtin_function, expects its
221 argument to be persistent until the program exits. */
222 arg = argv[0] + cl_options[opt_index].opt_len + 1;
224 arg += strlen ("no-");
226 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
228 if (separate_arg_flag)
236 /* Missing argument. */
240 else if (separate_arg_flag)
248 /* Check if this is a switch for a different front end. */
249 if (!option_ok_for_language (option, lang_mask))
250 errors |= CL_ERR_WRONG_LANG;
252 if (arg == NULL && (separate_arg_flag || joined_arg_flag))
253 errors |= CL_ERR_MISSING_ARG;
255 /* If the switch takes an integer, convert it. */
256 if (arg && (option->flags & CL_UINTEGER))
258 value = integral_argument (arg);
260 errors |= CL_ERR_UINT_ARG;
266 decoded->opt_index = opt_index;
268 decoded->value = value;
269 decoded->errors = errors;
271 if (opt_index == OPT_SPECIAL_unknown)
273 /* Skip the correct number of arguments for options handled
275 const char *popt = argv[0] + 1;
278 gcc_assert (result == 1);
279 if (SWITCH_TAKES_ARG (c) > (popt[1] != 0))
280 result += SWITCH_TAKES_ARG (c) - (popt[1] != 0);
281 else if (WORD_SWITCH_TAKES_ARG (popt))
282 result += WORD_SWITCH_TAKES_ARG (popt);
284 for (i = 1; i < result; i++)
292 gcc_assert (result >= 1 && result <= ARRAY_SIZE (decoded->canonical_option));
293 decoded->canonical_option_num_elements = result;
295 for (i = 0; i < ARRAY_SIZE (decoded->canonical_option); i++)
299 decoded->canonical_option[i] = argv[i];
300 total_len += strlen (argv[i]) + 1;
303 decoded->canonical_option[i] = NULL;
305 decoded->orig_option_with_args_text = p = XNEWVEC (char, total_len);
306 for (i = 0; i < result; i++)
308 size_t len = strlen (argv[i]);
310 memcpy (p, argv[i], len);
321 /* Decode command-line options (ARGC and ARGV being the arguments of
322 main) into an array, setting *DECODED_OPTIONS to a pointer to that
323 array and *DECODED_OPTIONS_COUNT to the number of entries in the
324 array. The first entry in the array is always one for the program
325 name (OPT_SPECIAL_program_name). LANG_MASK indicates the language
326 flags applicable for decoding (including CL_COMMON and CL_TARGET if
327 those options should be considered applicable). Do not produce any
328 diagnostics or set state outside of these variables. */
331 decode_cmdline_options_to_array (unsigned int argc, const char **argv,
332 unsigned int lang_mask,
333 struct cl_decoded_option **decoded_options,
334 unsigned int *decoded_options_count)
337 struct cl_decoded_option *opt_array;
338 unsigned int num_decoded_options;
340 opt_array = XNEWVEC (struct cl_decoded_option, argc);
342 opt_array[0].opt_index = OPT_SPECIAL_program_name;
343 opt_array[0].arg = argv[0];
344 opt_array[0].orig_option_with_args_text = argv[0];
345 opt_array[0].canonical_option_num_elements = 1;
346 opt_array[0].canonical_option[0] = argv[0];
347 opt_array[0].canonical_option[1] = NULL;
348 opt_array[0].canonical_option[2] = NULL;
349 opt_array[0].canonical_option[3] = NULL;
350 opt_array[0].value = 1;
351 opt_array[0].errors = 0;
352 num_decoded_options = 1;
354 for (i = 1; i < argc; i += n)
356 const char *opt = argv[i];
358 /* Interpret "-" or a non-switch as a file name. */
359 if (opt[0] != '-' || opt[1] == '\0')
361 generate_option_input_file (opt, &opt_array[num_decoded_options]);
362 num_decoded_options++;
367 n = decode_cmdline_option (argv + i, lang_mask,
368 &opt_array[num_decoded_options]);
369 num_decoded_options++;
372 opt_array = XRESIZEVEC (struct cl_decoded_option, opt_array,
373 num_decoded_options);
374 *decoded_options = opt_array;
375 *decoded_options_count = num_decoded_options;
378 /* Return true if NEXT_OPT_IDX cancels OPT_IDX. Return false if the
379 next one is the same as ORIG_NEXT_OPT_IDX. */
382 cancel_option (int opt_idx, int next_opt_idx, int orig_next_opt_idx)
384 /* An option can be canceled by the same option or an option with
386 if (cl_options [next_opt_idx].neg_index == opt_idx)
389 if (cl_options [next_opt_idx].neg_index != orig_next_opt_idx)
390 return cancel_option (opt_idx, cl_options [next_opt_idx].neg_index,
396 /* Filter out options canceled by the ones after them. */
399 prune_options (int *argcp, char ***argvp)
402 int *options = XNEWVEC (int, argc);
403 /* We will only return this replacement argv if we remove at least
404 one argument, so it does not need to be size (argc + 1) to
405 make room for the terminating NULL because we will always have
406 freed up at least one slot when we end up using it at all. */
407 char **argv = XNEWVEC (char *, argc);
408 int i, arg_count, need_prune = 0;
409 const struct cl_option *option;
412 /* Scan all arguments. */
413 for (i = 1; i < argc; i++)
416 const char *opt = (*argvp) [i];
418 opt_index = find_opt (opt + 1, -1);
419 if (opt_index == OPT_SPECIAL_unknown
420 && (opt[1] == 'W' || opt[1] == 'f' || opt[1] == 'm')
421 && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-')
425 /* Drop the "no-" from negative switches. */
426 size_t len = strlen (opt) - 3;
428 dup = XNEWVEC (char, len + 1);
431 memcpy (dup + 2, opt + 5, len - 2 + 1);
434 opt_index = find_opt (opt + 1, -1);
438 if (opt_index == OPT_SPECIAL_unknown)
445 option = &cl_options[opt_index];
446 if (option->neg_index < 0)
449 /* Skip joined switches. */
450 if ((option->flags & CL_JOINED))
453 /* Reject negative form of switches that don't take negatives as
455 if (!value && (option->flags & CL_REJECT_NEGATIVE))
458 options [i] = (int) opt_index;
459 need_prune |= options [i];
465 /* Remove arguments which are negated by others after them. */
466 argv [0] = (*argvp) [0];
468 for (i = 1; i < argc; i++)
472 opt_idx = options [i];
476 for (j = i + 1; j < argc; j++)
478 next_opt_idx = options [j];
480 && cancel_option (opt_idx, next_opt_idx,
491 argv [arg_count] = (*argvp) [i];
496 if (arg_count != argc)
500 /* Add NULL-termination. Guaranteed not to overflow because
501 arg_count here can only be less than argc. */
513 /* Handle option DECODED for the language indicated by LANG_MASK,
514 using the handlers in HANDLERS. KIND is the diagnostic_t if this
515 is a diagnostics option, DK_UNSPECIFIED otherwise. Returns false
516 if the switch was invalid. */
519 handle_option (const struct cl_decoded_option *decoded,
520 unsigned int lang_mask, int kind,
521 const struct cl_option_handlers *handlers)
523 size_t opt_index = decoded->opt_index;
524 const char *arg = decoded->arg;
525 int value = decoded->value;
526 const struct cl_option *option = &cl_options[opt_index];
529 if (option->flag_var)
530 set_option (opt_index, value, arg, kind);
532 for (i = 0; i < handlers->num_handlers; i++)
533 if (option->flags & handlers->handlers[i].mask)
535 if (!handlers->handlers[i].handler (decoded,
536 lang_mask, kind, handlers))
539 handlers->post_handling_callback (decoded,
540 handlers->handlers[i].mask);
546 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
547 option instead of DECODED. This is used for callbacks when one
548 option implies another instead of an option being decoded from the
552 handle_generated_option (size_t opt_index, const char *arg, int value,
553 unsigned int lang_mask, int kind,
554 const struct cl_option_handlers *handlers)
556 struct cl_decoded_option decoded;
558 generate_option (opt_index, arg, value, lang_mask, &decoded);
559 return handle_option (&decoded, lang_mask, kind, handlers);
562 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
563 VALUE for a front end using LANG_MASK. This is used when the
564 compiler generates options internally. */
567 generate_option (size_t opt_index, const char *arg, int value,
568 unsigned int lang_mask, struct cl_decoded_option *decoded)
570 const struct cl_option *option = &cl_options[opt_index];
572 decoded->opt_index = opt_index;
574 decoded->canonical_option[2] = NULL;
575 decoded->canonical_option[3] = NULL;
576 decoded->value = value;
577 decoded->errors = (option_ok_for_language (option, lang_mask)
579 : CL_ERR_WRONG_LANG);
583 if (option->flags & CL_SEPARATE)
585 decoded->orig_option_with_args_text = concat (option->opt_text, " ",
587 decoded->canonical_option[0] = option->opt_text;
588 decoded->canonical_option[1] = arg;
589 decoded->canonical_option_num_elements = 2;
593 gcc_assert (option->flags & CL_JOINED);
594 decoded->orig_option_with_args_text = concat (option->opt_text, arg,
596 decoded->canonical_option[0] = decoded->orig_option_with_args_text;
597 decoded->canonical_option[1] = NULL;
598 decoded->canonical_option_num_elements = 1;
603 decoded->orig_option_with_args_text = option->opt_text;
604 decoded->canonical_option[0] = option->opt_text;
605 decoded->canonical_option[1] = NULL;
606 decoded->canonical_option_num_elements = 1;
610 /* Fill in *DECODED with an option for input file FILE. */
613 generate_option_input_file (const char *file,
614 struct cl_decoded_option *decoded)
616 decoded->opt_index = OPT_SPECIAL_input_file;
618 decoded->orig_option_with_args_text = file;
619 decoded->canonical_option_num_elements = 1;
620 decoded->canonical_option[0] = file;
621 decoded->canonical_option[1] = NULL;
622 decoded->canonical_option[2] = NULL;
623 decoded->canonical_option[3] = NULL;
628 /* Handle the switch DECODED for the language indicated by LANG_MASK,
629 using the handlers in *HANDLERS. */
632 read_cmdline_option (struct cl_decoded_option *decoded,
633 unsigned int lang_mask,
634 const struct cl_option_handlers *handlers)
636 const struct cl_option *option;
639 if (decoded->opt_index == OPT_SPECIAL_unknown)
641 if (handlers->unknown_option_callback (decoded))
642 error ("unrecognized command line option %qs", decoded->arg);
646 option = &cl_options[decoded->opt_index];
647 opt = decoded->orig_option_with_args_text;
649 if (decoded->errors & CL_ERR_DISABLED)
651 error ("command line option %qs"
652 " is not supported by this configuration", opt);
656 if (decoded->errors & CL_ERR_WRONG_LANG)
658 handlers->wrong_lang_callback (decoded, lang_mask);
662 if (decoded->errors & CL_ERR_MISSING_ARG)
664 if (option->missing_argument_error)
665 error (option->missing_argument_error, opt);
667 error ("missing argument to %qs", opt);
671 if (decoded->errors & CL_ERR_UINT_ARG)
673 error ("argument to %qs should be a non-negative integer",
678 gcc_assert (!decoded->errors);
680 if (!handle_option (decoded, lang_mask, DK_UNSPECIFIED, handlers))
681 error ("unrecognized command line option %qs", opt);
684 /* Set any variable for option OPT_INDEX according to VALUE and ARG,
685 diagnostic kind KIND. */
688 set_option (int opt_index, int value, const char *arg, int kind)
690 const struct cl_option *option = &cl_options[opt_index];
692 if (!option->flag_var)
695 switch (option->var_type)
698 *(int *) option->flag_var = value;
702 *(int *) option->flag_var = (value
704 : !option->var_value);
709 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
710 *(int *) option->flag_var |= option->var_value;
712 *(int *) option->flag_var &= ~option->var_value;
713 if (option->flag_var == &target_flags)
714 target_flags_explicit |= option->var_value;
718 *(const char **) option->flag_var = arg;
722 if ((diagnostic_t) kind != DK_UNSPECIFIED)
723 diagnostic_classify_diagnostic (global_dc, opt_index, (diagnostic_t) kind,