CbC/CbC_gcc: gcc/opts-common.c comparison

comparison gcc/opts-common.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Command line option handling.
-Copyright (C) 2006-2018 Free Software Foundation, Inc.
+Copyright (C) 2006-2020 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 	{
 	  errno = 0;
 	  value = strtoull (arg, &end, 0);
 	  if (*end)
 	    {
-	      /* errno is most likely EINVAL here.  */
+	      if (errno)
-	      *err = errno;
+		*err = errno;
+	      else
+		*err = EINVAL;
 	      return -1;
 	    }
 	  return value;
 	}
 	  char *alternative = concat (opt0 + 1, opt_text + new_prefix_len,
 				      NULL);
 	  candidates->safe_push (alternative);
 	}
 }
+/* For all params (e.g. --param=key=value),
+include also '--param key=value'.  */
+const char *prefix = "--param=";
+if (strstr (opt_text, prefix) == opt_text)
+{
+char *param = xstrdup (opt_text + 1);
+gcc_assert (param[6] == '=');
+param[6] = ' ';
+candidates->safe_push (param);
+}
 }
 /* Decode the switch beginning at ARGV for the language indicated by
 LANG_MASK (including CL_COMMON and CL_TARGET if applicable), into
 the structure *DECODED.  Returns the number of switches
 bool joined_arg_flag;
 bool have_separate_arg = false;
 extra_args = 0;
-opt_index = find_opt (argv[0] + 1, lang_mask);
+const char *opt_value = argv[0] + 1;
+opt_index = find_opt (opt_value, lang_mask);
 i = 0;
 while (opt_index == OPT_SPECIAL_unknown
 	 && i < ARRAY_SIZE (option_map))
 {
 const char *opt0 = option_map[i].opt0;
 && (!option->cl_separate_alias || have_separate_arg))
 {
 size_t new_opt_index = option->alias_target;
 if (new_opt_index == OPT_SPECIAL_ignore
-	  || new_opt_index == OPT_SPECIAL_deprecated)
+	  || new_opt_index == OPT_SPECIAL_warn_removed)
 	{
 	  gcc_assert (option->alias_arg == NULL);
 	  gcc_assert (option->neg_alias_arg == NULL);
 	  opt_index = new_opt_index;
 	  arg = NULL;
 }
 /* Check if this is a switch for a different front end.  */
 if (!option_ok_for_language (option, lang_mask))
 errors |= CL_ERR_WRONG_LANG;
+else if (strcmp (option->opt_text, "-Werror=") == 0
+	   && strchr (opt_value, ',') == NULL)
+{
+/* Verify that -Werror argument is a valid warning
+	 for a language.  */
+char *werror_arg = xstrdup (opt_value + 6);
+werror_arg[0] = 'W';
+size_t warning_index = find_opt (werror_arg, lang_mask);
+if (warning_index != OPT_SPECIAL_unknown)
+	{
+	  const struct cl_option *warning_option
+	    = &cl_options[warning_index];
+	  if (!option_ok_for_language (warning_option, lang_mask))
+	    errors |= CL_ERR_WRONG_LANG;
+	}
+}
 /* Convert the argument to lowercase if appropriate.  */
 if (arg && option->cl_tolower)
 {
 size_t j;
 	}
 else
 	decoded->canonical_option[i] = NULL;
 }
 if (opt_index != OPT_SPECIAL_unknown && opt_index != OPT_SPECIAL_ignore
-&& opt_index != OPT_SPECIAL_deprecated)
+&& opt_index != OPT_SPECIAL_warn_removed)
 {
 generate_canonical_option (opt_index, arg, value, decoded);
 if (separate_args > 1)
 	{
 	  for (i = 0; i < separate_args; i++)
 	  num_decoded_options++;
 	  n = 1;
 	  continue;
 	}
+/* Interpret "--param" "key=name" as "--param=key=name".  */
+const char *needle = "--param";
+if (i + 1 < argc && strcmp (opt, needle) == 0)
+	{
+	  const char *replacement
+	    = opts_concat (needle, "=", argv[i + 1], NULL);
+	  argv[++i] = replacement;
+	}
 n = decode_cmdline_option (argv + i, lang_mask,
 				 &opt_array[num_decoded_options]);
 num_decoded_options++;
 }
 opt_idx = old_decoded_options[i].opt_index;
 switch (opt_idx)
 	{
 	case OPT_SPECIAL_unknown:
 	case OPT_SPECIAL_ignore:
-	case OPT_SPECIAL_deprecated:
+	case OPT_SPECIAL_warn_removed:
 	case OPT_SPECIAL_program_name:
 	case OPT_SPECIAL_input_file:
 	  goto keep;
 	/* Do not save OPT_fdiagnostics_color_, just remember the last one.  */
 	  option = &cl_options[opt_idx];
 	  if (option->neg_index < 0)
 	    goto keep;
 	  /* Skip joined switches.  */
-	  if ((option->flags & CL_JOINED))
+	  if ((option->flags & CL_JOINED)
+	      && (!option->cl_reject_negative
+		  || (unsigned int) option->neg_index != opt_idx))
 	    goto keep;
 	  for (j = i + 1; j < old_decoded_options_count; j++)
 	    {
 	      if (old_decoded_options[j].errors & ~CL_ERR_WRONG_LANG)
 	      next_opt_idx = old_decoded_options[j].opt_index;
 	      if (next_opt_idx >= cl_options_count)
 		continue;
 	      if (cl_options[next_opt_idx].neg_index < 0)
 		continue;
-	      if ((cl_options[next_opt_idx].flags & CL_JOINED))
+	      if ((cl_options[next_opt_idx].flags & CL_JOINED)
-		  continue;
+		  && (!cl_options[next_opt_idx].cl_reject_negative
+		      || ((unsigned int) cl_options[next_opt_idx].neg_index
+			  != next_opt_idx)))
+		continue;
 	      if (cancel_option (opt_idx, next_opt_idx, next_opt_idx))
 		break;
 	    }
 	  if (j == old_decoded_options_count)
 	    {
 		      const char *opt, const char *arg, int errors,
 		      unsigned int lang_mask)
 {
 if (errors & CL_ERR_DISABLED)
 {
-error_at (loc, "command line option %qs"
+error_at (loc, "command-line option %qs"
 		     " is not supported by this configuration", opt);
 return true;
 }
 if (errors & CL_ERR_MISSING_ARG)
 warning_at (loc, 0, decoded->warn_message, opt);
 if (decoded->opt_index == OPT_SPECIAL_unknown)
 {
 if (handlers->unknown_option_callback (decoded))
-	error_at (loc, "unrecognized command line option %qs", decoded->arg);
+	error_at (loc, "unrecognized command-line option %qs", decoded->arg);
 return;
 }
 if (decoded->opt_index == OPT_SPECIAL_ignore)
 return;
-if (decoded->opt_index == OPT_SPECIAL_deprecated)
+if (decoded->opt_index == OPT_SPECIAL_warn_removed)
 {
 /* Warn only about positive ignored options.  */
 if (decoded->value)
 	warning_at (loc, 0, "switch %qs is no longer supported", opt);
 return;
 gcc_assert (!decoded->errors);
 if (!handle_option (opts, opts_set, decoded, lang_mask, DK_UNSPECIFIED,
 		      loc, handlers, false, dc))
-error_at (loc, "unrecognized command line option %qs", opt);
+error_at (loc, "unrecognized command-line option %qs", opt);
 }
 /* Set any field in OPTS, and OPTS_SET if not NULL, for option
 OPT_INDEX according to VALUE and ARG, diagnostic kind KIND,
 location LOC, using diagnostic context DC if not NULL for
 /* Return 1 if option OPT_IDX is enabled in OPTS, 0 if it is disabled,
 or -1 if it isn't a simple on-off switch.  */
 int
-option_enabled (int opt_idx, void *opts)
+option_enabled (int opt_idx, unsigned lang_mask, void *opts)
 {
 const struct cl_option *option = &(cl_options[opt_idx]);
+/* A language-specific option can only be considered enabled when it's
+valid for the current language.  */
+if (!(option->flags & CL_COMMON)
+&& (option->flags & CL_LANG_ALL)
+&& !(option->flags & lang_mask))
+return 0;
 struct gcc_options *optsg = (struct gcc_options *) opts;
 void *flag_var = option_flag_var (opt_idx, optsg);
 if (flag_var)
 switch (option->var_type)
 		     : sizeof (int));
 break;
 case CLVC_BIT_CLEAR:
 case CLVC_BIT_SET:
-state->ch = option_enabled (option, opts);
+state->ch = option_enabled (option, -1, opts);
 state->data = &state->ch;
 state->size = 1;
 break;
 case CLVC_STRING:
 		  && !cl_options[opt_index].cl_negative_alias);
 if (cl_options[opt_index].alias_arg)
 	arg = cl_options[opt_index].alias_arg;
 opt_index = cl_options[opt_index].alias_target;
 }
-if (opt_index == OPT_SPECIAL_ignore || opt_index == OPT_SPECIAL_deprecated)
+if (opt_index == OPT_SPECIAL_ignore || opt_index == OPT_SPECIAL_warn_removed)
 return;
 if (dc)
 diagnostic_classify_diagnostic (dc, opt_index, (diagnostic_t) kind, loc);
 if (imply)
 {

Mercurial > hg > CbC > CbC_gcc

comparison gcc/opts-common.c @ 145:1830386684a0