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"
28 static void prune_options (struct cl_decoded_option **, unsigned int *);
30 /* Perform a binary search to find which option the command-line INPUT
31 matches. Returns its index in the option array, and
32 OPT_SPECIAL_unknown on failure.
34 This routine is quite subtle. A normal binary search is not good
35 enough because some options can be suffixed with an argument, and
36 multiple sub-matches can occur, e.g. input of "-pedantic" matching
37 the initial substring of "-pedantic-errors".
39 A more complicated example is -gstabs. It should match "-g" with
40 an argument of "stabs". Suppose, however, that the number and list
41 of switches are such that the binary search tests "-gen-decls"
42 before having tested "-g". This doesn't match, and as "-gen-decls"
43 is less than "-gstabs", it will become the lower bound of the
44 binary search range, and "-g" will never be seen. To resolve this
45 issue, 'optc-gen.awk' makes "-gen-decls" point, via the back_chain member,
46 to "-g" so that failed searches that end between "-gen-decls" and
47 the lexicographically subsequent switch know to go back and see if
48 "-g" causes a match (which it does in this example).
50 This search is done in such a way that the longest match for the
51 front end in question wins. If there is no match for the current
52 front end, the longest match for a different front end is returned
53 (or N_OPTS if none) and the caller emits an error message. */
55 find_opt (const char *input, int lang_mask)
57 size_t mn, mn_orig, mx, md, opt_len;
58 size_t match_wrong_lang;
62 mx = cl_options_count;
64 /* Find mn such this lexicographical inequality holds:
65 cl_options[mn] <= input < cl_options[mn + 1]. */
69 opt_len = cl_options[md].opt_len;
70 comp = strncmp (input, cl_options[md].opt_text + 1, opt_len);
80 /* This is the switch that is the best match but for a different
81 front end, or OPT_SPECIAL_unknown if there is no match at all. */
82 match_wrong_lang = OPT_SPECIAL_unknown;
84 /* Backtrace the chain of possible matches, returning the longest
85 one, if any, that fits best. With current GCC switches, this
86 loop executes at most twice. */
89 const struct cl_option *opt = &cl_options[mn];
91 /* Is the input either an exact match or a prefix that takes a
93 if (!strncmp (input, opt->opt_text + 1, opt->opt_len)
94 && (input[opt->opt_len] == '\0' || (opt->flags & CL_JOINED)))
96 /* If language is OK, return it. */
97 if (opt->flags & lang_mask)
100 /* If we haven't remembered a prior match, remember this
101 one. Any prior match is necessarily better. */
102 if (match_wrong_lang == OPT_SPECIAL_unknown)
103 match_wrong_lang = mn;
106 /* Try the next possibility. This is cl_options_count if there
108 mn = opt->back_chain;
110 while (mn != cl_options_count);
112 if (match_wrong_lang == OPT_SPECIAL_unknown && input[0] == '-')
114 /* Long options, starting "--", may be abbreviated if the
115 abbreviation is unambiguous. This only applies to options
116 not taking a joined argument, and abbreviations of "--option"
117 are permitted even if there is a variant "--option=". */
118 size_t mnc = mn_orig + 1;
119 size_t cmp_len = strlen (input);
120 while (mnc < cl_options_count
121 && strncmp (input, cl_options[mnc].opt_text + 1, cmp_len) == 0)
123 /* Option matching this abbreviation. OK if it is the first
124 match and that does not take a joined argument, or the
125 second match, taking a joined argument and with only '='
126 added to the first match; otherwise considered
128 if (mnc == mn_orig + 1
129 && !(cl_options[mnc].flags & CL_JOINED))
130 match_wrong_lang = mnc;
131 else if (mnc == mn_orig + 2
132 && match_wrong_lang == mn_orig + 1
133 && (cl_options[mnc].flags & CL_JOINED)
134 && (cl_options[mnc].opt_len
135 == cl_options[mn_orig + 1].opt_len + 1)
136 && strncmp (cl_options[mnc].opt_text + 1,
137 cl_options[mn_orig + 1].opt_text + 1,
138 cl_options[mn_orig + 1].opt_len) == 0)
139 ; /* OK, as long as there are no more matches. */
141 return OPT_SPECIAL_unknown;
146 /* Return the best wrong match, or OPT_SPECIAL_unknown if none. */
147 return match_wrong_lang;
150 /* If ARG is a non-negative integer made up solely of digits, return its
151 value, otherwise return -1. */
154 integral_argument (const char *arg)
158 while (*p && ISDIGIT (*p))
167 /* Return whether OPTION is OK for the language given by
170 option_ok_for_language (const struct cl_option *option,
171 unsigned int lang_mask)
173 if (!(option->flags & lang_mask))
175 else if ((option->flags & CL_TARGET)
176 && (option->flags & (CL_LANG_ALL | CL_DRIVER))
177 && !(option->flags & (lang_mask & ~CL_COMMON & ~CL_TARGET)))
178 /* Complain for target flag language mismatches if any languages
185 /* Fill in the canonical option part of *DECODED with an option
186 described by OPT_INDEX, ARG and VALUE. */
189 generate_canonical_option (size_t opt_index, const char *arg, int value,
190 struct cl_decoded_option *decoded)
192 const struct cl_option *option = &cl_options[opt_index];
193 const char *opt_text = option->opt_text;
196 && !(option->flags & CL_REJECT_NEGATIVE)
197 && (opt_text[1] == 'W' || opt_text[1] == 'f' || opt_text[1] == 'm'))
199 char *t = XNEWVEC (char, option->opt_len + 5);
205 memcpy (t + 5, opt_text + 2, option->opt_len);
209 decoded->canonical_option[2] = NULL;
210 decoded->canonical_option[3] = NULL;
214 if ((option->flags & CL_SEPARATE)
215 && !(option->flags & CL_SEPARATE_ALIAS))
217 decoded->canonical_option[0] = opt_text;
218 decoded->canonical_option[1] = arg;
219 decoded->canonical_option_num_elements = 2;
223 gcc_assert (option->flags & CL_JOINED);
224 decoded->canonical_option[0] = concat (opt_text, arg, NULL);
225 decoded->canonical_option[1] = NULL;
226 decoded->canonical_option_num_elements = 1;
231 decoded->canonical_option[0] = opt_text;
232 decoded->canonical_option[1] = NULL;
233 decoded->canonical_option_num_elements = 1;
237 /* Structure describing mappings from options on the command line to
238 options to look up with find_opt. */
241 /* Prefix of the option on the command line. */
243 /* If two argv elements are considered to be merged into one option,
244 prefix for the second element, otherwise NULL. */
246 /* The new prefix to map to. */
247 const char *new_prefix;
248 /* Whether at least one character is needed following opt1 or opt0
249 for this mapping to be used. (--optimize= is valid for -O, but
250 --warn- is not valid for -W.) */
251 bool another_char_needed;
252 /* Whether the original option is a negated form of the option
253 resulting from this map. */
256 static const struct option_map option_map[] =
258 { "-Wno-", NULL, "-W", false, true },
259 { "-fno-", NULL, "-f", false, true },
260 { "-mno-", NULL, "-m", false, true },
261 { "--debug=", NULL, "-g", false, false },
262 { "--machine-", NULL, "-m", true, false },
263 { "--machine-no-", NULL, "-m", false, true },
264 { "--machine=", NULL, "-m", false, false },
265 { "--machine=no-", NULL, "-m", false, true },
266 { "--machine", "", "-m", false, false },
267 { "--machine", "no-", "-m", false, true },
268 { "--optimize=", NULL, "-O", false, false },
269 { "--std=", NULL, "-std=", false, false },
270 { "--std", "", "-std=", false, false },
271 { "--warn-", NULL, "-W", true, false },
272 { "--warn-no-", NULL, "-W", false, true },
273 { "--", NULL, "-f", true, false },
274 { "--no-", NULL, "-f", false, true }
277 /* Decode the switch beginning at ARGV for the language indicated by
278 LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
279 the structure *DECODED. Returns the number of switches
283 decode_cmdline_option (const char **argv, unsigned int lang_mask,
284 struct cl_decoded_option *decoded)
289 unsigned int result = 1, i, extra_args, separate_args = 0;
293 const struct cl_option *option;
295 const char *warn_message = NULL;
296 bool separate_arg_flag;
297 bool joined_arg_flag;
298 bool have_separate_arg = false;
302 opt_index = find_opt (argv[0] + 1, lang_mask);
304 while (opt_index == OPT_SPECIAL_unknown
305 && i < ARRAY_SIZE (option_map))
307 const char *opt0 = option_map[i].opt0;
308 const char *opt1 = option_map[i].opt1;
309 const char *new_prefix = option_map[i].new_prefix;
310 bool another_char_needed = option_map[i].another_char_needed;
311 size_t opt0_len = strlen (opt0);
312 size_t opt1_len = (opt1 == NULL ? 0 : strlen (opt1));
313 size_t optn_len = (opt1 == NULL ? opt0_len : opt1_len);
314 size_t new_prefix_len = strlen (new_prefix);
316 extra_args = (opt1 == NULL ? 0 : 1);
317 value = !option_map[i].negated;
319 if (strncmp (argv[0], opt0, opt0_len) == 0
321 || (argv[1] != NULL && strncmp (argv[1], opt1, opt1_len) == 0))
322 && (!another_char_needed
323 || argv[extra_args][optn_len] != 0))
325 size_t arglen = strlen (argv[extra_args]);
328 adjust_len = (int) optn_len - (int) new_prefix_len;
329 dup = XNEWVEC (char, arglen + 1 - adjust_len);
330 memcpy (dup, new_prefix, new_prefix_len);
331 memcpy (dup + new_prefix_len, argv[extra_args] + optn_len,
332 arglen - optn_len + 1);
333 opt_index = find_opt (dup + 1, lang_mask);
339 if (opt_index == OPT_SPECIAL_unknown)
347 option = &cl_options[opt_index];
349 /* Reject negative form of switches that don't take negatives as
351 if (!value && (option->flags & CL_REJECT_NEGATIVE))
353 opt_index = OPT_SPECIAL_unknown;
354 errors |= CL_ERR_NEGATIVE;
359 result = extra_args + 1;
360 warn_message = option->warn_message;
362 /* Check to see if the option is disabled for this configuration. */
363 if (option->flags & CL_DISABLED)
364 errors |= CL_ERR_DISABLED;
366 /* Determine whether there may be a separate argument based on
367 whether this option is being processed for the driver, and, if
368 so, how many such arguments. */
369 separate_arg_flag = ((option->flags & CL_SEPARATE)
370 && !((option->flags & CL_NO_DRIVER_ARG)
371 && (lang_mask & CL_DRIVER)));
372 separate_args = (separate_arg_flag
373 ? ((option->flags & CL_SEPARATE_NARGS_MASK)
374 >> CL_SEPARATE_NARGS_SHIFT) + 1
376 joined_arg_flag = (option->flags & CL_JOINED) != 0;
378 /* Sort out any argument the switch takes. */
381 /* Have arg point to the original switch. This is because
382 some code, such as disable_builtin_function, expects its
383 argument to be persistent until the program exits. */
384 arg = argv[extra_args] + cl_options[opt_index].opt_len + 1 + adjust_len;
386 if (*arg == '\0' && !(option->flags & CL_MISSING_OK))
388 if (separate_arg_flag)
390 arg = argv[extra_args + 1];
391 result = extra_args + 2;
393 result = extra_args + 1;
395 have_separate_arg = true;
398 /* Missing argument. */
402 else if (separate_arg_flag)
404 arg = argv[extra_args + 1];
405 for (i = 0; i < separate_args; i++)
406 if (argv[extra_args + 1 + i] == NULL)
408 errors |= CL_ERR_MISSING_ARG;
411 result = extra_args + 1 + i;
413 have_separate_arg = true;
416 if (arg == NULL && (separate_arg_flag || joined_arg_flag))
417 errors |= CL_ERR_MISSING_ARG;
419 /* Is this option an alias (or an ignored option, marked as an alias
420 of OPT_SPECIAL_ignore)? */
421 if (option->alias_target != N_OPTS
422 && (!(option->flags & CL_SEPARATE_ALIAS) || have_separate_arg))
424 size_t new_opt_index = option->alias_target;
426 if (new_opt_index == OPT_SPECIAL_ignore)
428 gcc_assert (option->alias_arg == NULL);
429 gcc_assert (option->neg_alias_arg == NULL);
430 opt_index = new_opt_index;
436 const struct cl_option *new_option = &cl_options[new_opt_index];
438 /* The new option must not be an alias itself. */
439 gcc_assert (new_option->alias_target == N_OPTS
440 || (new_option->flags & CL_SEPARATE_ALIAS));
442 if (option->neg_alias_arg)
444 gcc_assert (option->alias_arg != NULL);
445 gcc_assert (arg == NULL);
447 arg = option->alias_arg;
449 arg = option->neg_alias_arg;
452 else if (option->alias_arg)
454 gcc_assert (value == 1);
455 gcc_assert (arg == NULL);
456 arg = option->alias_arg;
459 opt_index = new_opt_index;
463 gcc_assert (!(option->flags & CL_REJECT_NEGATIVE));
465 /* Recompute what arguments are allowed. */
466 separate_arg_flag = ((option->flags & CL_SEPARATE)
467 && !((option->flags & CL_NO_DRIVER_ARG)
468 && (lang_mask & CL_DRIVER)));
469 joined_arg_flag = (option->flags & CL_JOINED) != 0;
471 if (separate_args > 1 || (option->flags & CL_SEPARATE_NARGS_MASK))
472 gcc_assert (separate_args
473 == ((option->flags & CL_SEPARATE_NARGS_MASK)
474 >> CL_SEPARATE_NARGS_SHIFT) + 1);
476 if (!(errors & CL_ERR_MISSING_ARG))
478 if (separate_arg_flag || joined_arg_flag)
480 if ((option->flags & CL_MISSING_OK) && arg == NULL)
482 gcc_assert (arg != NULL);
485 gcc_assert (arg == NULL);
488 /* Recheck for warnings and disabled options. */
489 if (option->warn_message)
491 gcc_assert (warn_message == NULL);
492 warn_message = option->warn_message;
494 if (option->flags & CL_DISABLED)
495 errors |= CL_ERR_DISABLED;
499 /* Check if this is a switch for a different front end. */
500 if (!option_ok_for_language (option, lang_mask))
501 errors |= CL_ERR_WRONG_LANG;
503 /* If the switch takes an integer, convert it. */
504 if (arg && (option->flags & CL_UINTEGER))
506 value = integral_argument (arg);
508 errors |= CL_ERR_UINT_ARG;
512 decoded->opt_index = opt_index;
514 decoded->value = value;
515 decoded->errors = errors;
516 decoded->warn_message = warn_message;
518 if (opt_index == OPT_SPECIAL_unknown)
519 gcc_assert (result == 1);
521 gcc_assert (result >= 1 && result <= ARRAY_SIZE (decoded->canonical_option));
522 decoded->canonical_option_num_elements = result;
524 for (i = 0; i < ARRAY_SIZE (decoded->canonical_option); i++)
528 if (opt_index == OPT_SPECIAL_unknown)
529 decoded->canonical_option[i] = argv[i];
531 decoded->canonical_option[i] = NULL;
532 total_len += strlen (argv[i]) + 1;
535 decoded->canonical_option[i] = NULL;
537 if (opt_index != OPT_SPECIAL_unknown && opt_index != OPT_SPECIAL_ignore)
539 generate_canonical_option (opt_index, arg, value, decoded);
540 if (separate_args > 1)
542 for (i = 0; i < separate_args; i++)
544 if (argv[extra_args + 1 + i] == NULL)
547 decoded->canonical_option[1 + i] = argv[extra_args + 1 + i];
549 gcc_assert (result == 1 + i);
550 decoded->canonical_option_num_elements = result;
553 decoded->orig_option_with_args_text = p = XNEWVEC (char, total_len);
554 for (i = 0; i < result; i++)
556 size_t len = strlen (argv[i]);
558 memcpy (p, argv[i], len);
569 /* Decode command-line options (ARGC and ARGV being the arguments of
570 main) into an array, setting *DECODED_OPTIONS to a pointer to that
571 array and *DECODED_OPTIONS_COUNT to the number of entries in the
572 array. The first entry in the array is always one for the program
573 name (OPT_SPECIAL_program_name). LANG_MASK indicates the language
574 flags applicable for decoding (including CL_COMMON and CL_TARGET if
575 those options should be considered applicable). Do not produce any
576 diagnostics or set state outside of these variables. */
579 decode_cmdline_options_to_array (unsigned int argc, const char **argv,
580 unsigned int lang_mask,
581 struct cl_decoded_option **decoded_options,
582 unsigned int *decoded_options_count)
585 struct cl_decoded_option *opt_array;
586 unsigned int num_decoded_options;
587 bool argv_copied = false;
589 opt_array = XNEWVEC (struct cl_decoded_option, argc);
591 opt_array[0].opt_index = OPT_SPECIAL_program_name;
592 opt_array[0].warn_message = NULL;
593 opt_array[0].arg = argv[0];
594 opt_array[0].orig_option_with_args_text = argv[0];
595 opt_array[0].canonical_option_num_elements = 1;
596 opt_array[0].canonical_option[0] = argv[0];
597 opt_array[0].canonical_option[1] = NULL;
598 opt_array[0].canonical_option[2] = NULL;
599 opt_array[0].canonical_option[3] = NULL;
600 opt_array[0].value = 1;
601 opt_array[0].errors = 0;
602 num_decoded_options = 1;
604 for (i = 1; i < argc; i += n)
606 const char *opt = argv[i];
608 /* Interpret "-" or a non-switch as a file name. */
609 if (opt[0] != '-' || opt[1] == '\0')
611 generate_option_input_file (opt, &opt_array[num_decoded_options]);
612 num_decoded_options++;
617 n = decode_cmdline_option (argv + i, lang_mask,
618 &opt_array[num_decoded_options]);
619 num_decoded_options++;
624 *decoded_options = opt_array;
625 *decoded_options_count = num_decoded_options;
626 prune_options (decoded_options, decoded_options_count);
629 /* Return true if NEXT_OPT_IDX cancels OPT_IDX. Return false if the
630 next one is the same as ORIG_NEXT_OPT_IDX. */
633 cancel_option (int opt_idx, int next_opt_idx, int orig_next_opt_idx)
635 /* An option can be canceled by the same option or an option with
637 if (cl_options [next_opt_idx].neg_index == opt_idx)
640 if (cl_options [next_opt_idx].neg_index != orig_next_opt_idx)
641 return cancel_option (opt_idx, cl_options [next_opt_idx].neg_index,
647 /* Filter out options canceled by the ones after them. */
650 prune_options (struct cl_decoded_option **decoded_options,
651 unsigned int *decoded_options_count)
653 unsigned int old_decoded_options_count = *decoded_options_count;
654 struct cl_decoded_option *old_decoded_options = *decoded_options;
655 unsigned int new_decoded_options_count;
656 struct cl_decoded_option *new_decoded_options
657 = XNEWVEC (struct cl_decoded_option, old_decoded_options_count);
659 const struct cl_option *option;
661 /* Remove arguments which are negated by others after them. */
662 new_decoded_options_count = 0;
663 for (i = 0; i < old_decoded_options_count; i++)
665 unsigned int j, opt_idx, next_opt_idx;
667 if (old_decoded_options[i].errors & ~CL_ERR_WRONG_LANG)
670 opt_idx = old_decoded_options[i].opt_index;
673 case OPT_SPECIAL_unknown:
674 case OPT_SPECIAL_ignore:
675 case OPT_SPECIAL_program_name:
676 case OPT_SPECIAL_input_file:
680 gcc_assert (opt_idx < cl_options_count);
681 option = &cl_options[opt_idx];
682 if (option->neg_index < 0)
685 /* Skip joined switches. */
686 if ((option->flags & CL_JOINED))
689 for (j = i + 1; j < old_decoded_options_count; j++)
691 if (old_decoded_options[j].errors & ~CL_ERR_WRONG_LANG)
693 next_opt_idx = old_decoded_options[j].opt_index;
694 if (next_opt_idx >= cl_options_count)
696 if (cl_options[next_opt_idx].neg_index < 0)
698 if ((cl_options[next_opt_idx].flags & CL_JOINED))
700 if (cancel_option (opt_idx, next_opt_idx, next_opt_idx))
703 if (j == old_decoded_options_count)
706 new_decoded_options[new_decoded_options_count]
707 = old_decoded_options[i];
708 new_decoded_options_count++;
714 free (old_decoded_options);
715 new_decoded_options = XRESIZEVEC (struct cl_decoded_option,
717 new_decoded_options_count);
718 *decoded_options = new_decoded_options;
719 *decoded_options_count = new_decoded_options_count;
722 /* Handle option DECODED for the language indicated by LANG_MASK,
723 using the handlers in HANDLERS and setting fields in OPTS and
724 OPTS_SET. KIND is the diagnostic_t if this is a diagnostics
725 option, DK_UNSPECIFIED otherwise. GENERATED_P is true for an
726 option generated as part of processing another option or otherwise
727 generated internally, false for one explicitly passed by the user.
728 Returns false if the switch was invalid. DC is the diagnostic
729 context for options affecting diagnostics state, or NULL. */
732 handle_option (struct gcc_options *opts,
733 struct gcc_options *opts_set,
734 const struct cl_decoded_option *decoded,
735 unsigned int lang_mask, int kind,
736 const struct cl_option_handlers *handlers,
737 bool generated_p, diagnostic_context *dc)
739 size_t opt_index = decoded->opt_index;
740 const char *arg = decoded->arg;
741 int value = decoded->value;
742 const struct cl_option *option = &cl_options[opt_index];
743 void *flag_var = option_flag_var (opt_index, opts);
747 set_option (opts, (generated_p ? NULL : opts_set),
748 opt_index, value, arg, kind, dc);
750 for (i = 0; i < handlers->num_handlers; i++)
751 if (option->flags & handlers->handlers[i].mask)
753 if (!handlers->handlers[i].handler (opts, opts_set, decoded,
754 lang_mask, kind, handlers, dc))
757 handlers->post_handling_callback (decoded,
758 handlers->handlers[i].mask);
764 /* Like handle_option, but OPT_INDEX, ARG and VALUE describe the
765 option instead of DECODED. This is used for callbacks when one
766 option implies another instead of an option being decoded from the
770 handle_generated_option (struct gcc_options *opts,
771 struct gcc_options *opts_set,
772 size_t opt_index, const char *arg, int value,
773 unsigned int lang_mask, int kind,
774 const struct cl_option_handlers *handlers,
775 diagnostic_context *dc)
777 struct cl_decoded_option decoded;
779 generate_option (opt_index, arg, value, lang_mask, &decoded);
780 return handle_option (opts, opts_set, &decoded, lang_mask, kind, handlers,
784 /* Fill in *DECODED with an option described by OPT_INDEX, ARG and
785 VALUE for a front end using LANG_MASK. This is used when the
786 compiler generates options internally. */
789 generate_option (size_t opt_index, const char *arg, int value,
790 unsigned int lang_mask, struct cl_decoded_option *decoded)
792 const struct cl_option *option = &cl_options[opt_index];
794 decoded->opt_index = opt_index;
795 decoded->warn_message = NULL;
797 decoded->value = value;
798 decoded->errors = (option_ok_for_language (option, lang_mask)
800 : CL_ERR_WRONG_LANG);
802 generate_canonical_option (opt_index, arg, value, decoded);
803 switch (decoded->canonical_option_num_elements)
806 decoded->orig_option_with_args_text = decoded->canonical_option[0];
810 decoded->orig_option_with_args_text
811 = concat (decoded->canonical_option[0], " ",
812 decoded->canonical_option[1], NULL);
820 /* Fill in *DECODED with an option for input file FILE. */
823 generate_option_input_file (const char *file,
824 struct cl_decoded_option *decoded)
826 decoded->opt_index = OPT_SPECIAL_input_file;
827 decoded->warn_message = NULL;
829 decoded->orig_option_with_args_text = file;
830 decoded->canonical_option_num_elements = 1;
831 decoded->canonical_option[0] = file;
832 decoded->canonical_option[1] = NULL;
833 decoded->canonical_option[2] = NULL;
834 decoded->canonical_option[3] = NULL;
839 /* Handle the switch DECODED for the language indicated by LANG_MASK,
840 using the handlers in *HANDLERS and setting fields in OPTS and
841 OPTS_SET and using diagnostic context DC (if not NULL) for
842 diagnostic options. */
845 read_cmdline_option (struct gcc_options *opts,
846 struct gcc_options *opts_set,
847 struct cl_decoded_option *decoded,
848 unsigned int lang_mask,
849 const struct cl_option_handlers *handlers,
850 diagnostic_context *dc)
852 const struct cl_option *option;
853 const char *opt = decoded->orig_option_with_args_text;
855 if (decoded->warn_message)
856 warning (0, decoded->warn_message, opt);
858 if (decoded->opt_index == OPT_SPECIAL_unknown)
860 if (handlers->unknown_option_callback (decoded))
861 error ("unrecognized command line option %qs", decoded->arg);
865 if (decoded->opt_index == OPT_SPECIAL_ignore)
868 option = &cl_options[decoded->opt_index];
870 if (decoded->errors & CL_ERR_DISABLED)
872 error ("command line option %qs"
873 " is not supported by this configuration", opt);
877 if (decoded->errors & CL_ERR_WRONG_LANG)
879 handlers->wrong_lang_callback (decoded, lang_mask);
883 if (decoded->errors & CL_ERR_MISSING_ARG)
885 if (option->missing_argument_error)
886 error (option->missing_argument_error, opt);
888 error ("missing argument to %qs", opt);
892 if (decoded->errors & CL_ERR_UINT_ARG)
894 error ("argument to %qs should be a non-negative integer",
899 gcc_assert (!decoded->errors);
901 if (!handle_option (opts, opts_set, decoded, lang_mask, DK_UNSPECIFIED,
902 handlers, false, dc))
903 error ("unrecognized command line option %qs", opt);
906 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
907 OPT_INDEX according to VALUE and ARG, diagnostic kind KIND, using
908 diagnostic context DC if not NULL for diagnostic
912 set_option (struct gcc_options *opts, struct gcc_options *opts_set,
913 int opt_index, int value, const char *arg, int kind,
914 diagnostic_context *dc)
916 const struct cl_option *option = &cl_options[opt_index];
917 void *flag_var = option_flag_var (opt_index, opts);
918 void *set_flag_var = NULL;
923 if (opts_set != NULL)
924 set_flag_var = option_flag_var (opt_index, opts_set);
926 switch (option->var_type)
929 *(int *) flag_var = value;
931 *(int *) set_flag_var = 1;
935 *(int *) flag_var = (value
937 : !option->var_value);
939 *(int *) set_flag_var = 1;
944 if ((value != 0) == (option->var_type == CLVC_BIT_SET))
945 *(int *) flag_var |= option->var_value;
947 *(int *) flag_var &= ~option->var_value;
949 *(int *) set_flag_var |= option->var_value;
953 *(const char **) flag_var = arg;
955 *(const char **) set_flag_var = "";
959 if ((diagnostic_t) kind != DK_UNSPECIFIED
961 diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind,
965 /* Return the address of the flag variable for option OPT_INDEX in
966 options structure OPTS, or NULL if there is no flag variable. */
969 option_flag_var (int opt_index, struct gcc_options *opts)
971 const struct cl_option *option = &cl_options[opt_index];
973 if (option->flag_var_offset == (unsigned short) -1)
975 return (void *)(((char *) opts) + option->flag_var_offset);