coretypes.h (struct cl_option_handlers): Declare.

	* coretypes.h (struct cl_option_handlers): Declare.
	* hooks.c (hook_int_size_t_constcharptr_int_0): Remove.
	* hooks.h (hook_int_size_t_constcharptr_int_0): Remove.
	* langhooks-def.h (lhd_handle_option): Declare.
	(LANG_HOOKS_HANDLE_OPTION): Use lhd_handle_option.
	* langhooks.c (lhd_handle_option): New.
	* langhooks.h (struct lang_hooks): Update prototype and return
	value type of handle_option hook.
	* optc-gen.awk: Generate target_flags_explicit definition for the
	driver.
	* opts-common.c: Include diagnostic.h.
	(handle_option): Move from opts.c.  Update prototype and return
	value type.  Use handlers structure.
	(read_cmdline_option): Move from opts.c.  Update prototype.  Use
	handlers structure.
	(set_option): Move from opts.c.
	* opts.c (common_handle_option): Update prototype and return value
	type.  Update calls to handle_option and enable_warning_as_error.
	(unknown_option_callback, post_handling_callback,
	lang_handle_option, target_handle_option): New.
	(handle_option, read_cmdline_option): Move to opts-common.c.
	(read_cmdline_options): Update prototype.  Update call to
	read_cmdline_option.
	(decode_options): Initialize and use handlers structure.
	(set_option): Move to opts-common.c.
	(enable_warning_as_error): Update prototype.  Update call to
	handle_option.
	* opts.h (struct cl_option_handler_func, struct
	cl_option_handlers): New.
	(handle_option, enable_warning_as_error): Update prototypes.
	(read_cmdline_option): Declare.
	* Makefile.in (opts-common.o): Update dependencies.

ada:
	* gcc-interface/misc.c (gnat_handle_option): Update prototype and
	return value type.  Don't check for missing arguments here.

c-family:
	* c-common.h (c_common_handle_option): Update prototype and return
	value type.
	* c-opts.c (c_common_handle_option): Update prototype and return
	value type.  Update calls to handle_option and
	enable_warning_as_error.

fortran:
	* gfortran.h (gfc_handle_option): Update prototype and return
	value type.
	* options.c (gfc_handle_option): Update prototype and return value
	type.

java:
	* lang.c (java_handle_option): Update prototype and return value
	type.

lto:
	* lto-lang.c (lto_handle_option): Update prototype and return
	value type.  Remove duplicate assignment to result.

From-SVN: r162601

gcc/ChangeLog

+2010-07-27  Joseph Myers  <joseph@codesourcery.com>
+
+	* coretypes.h (struct cl_option_handlers): Declare.
+	* hooks.c (hook_int_size_t_constcharptr_int_0): Remove.
+	* hooks.h (hook_int_size_t_constcharptr_int_0): Remove.
+	* langhooks-def.h (lhd_handle_option): Declare.
+	(LANG_HOOKS_HANDLE_OPTION): Use lhd_handle_option.
+	* langhooks.c (lhd_handle_option): New.
+	* langhooks.h (struct lang_hooks): Update prototype and return
+	value type of handle_option hook.
+	* optc-gen.awk: Generate target_flags_explicit definition for the
+	driver.
+	* opts-common.c: Include diagnostic.h.
+	(handle_option): Move from opts.c.  Update prototype and return
+	value type.  Use handlers structure.
+	(read_cmdline_option): Move from opts.c.  Update prototype.  Use
+	handlers structure.
+	(set_option): Move from opts.c.
+	* opts.c (common_handle_option): Update prototype and return value
+	type.  Update calls to handle_option and enable_warning_as_error.
+	(unknown_option_callback, post_handling_callback,
+	lang_handle_option, target_handle_option): New.
+	(handle_option, read_cmdline_option): Move to opts-common.c.
+	(read_cmdline_options): Update prototype.  Update call to
+	read_cmdline_option.
+	(decode_options): Initialize and use handlers structure.
+	(set_option): Move to opts-common.c.
+	(enable_warning_as_error): Update prototype.  Update call to
+	handle_option.
+	* opts.h (struct cl_option_handler_func, struct
+	cl_option_handlers): New.
+	(handle_option, enable_warning_as_error): Update prototypes.
+	(read_cmdline_option): Declare.
+	* Makefile.in (opts-common.o): Update dependencies.
+
 2010-07-27  Maxim Kuvyrkov  <maxim@codesourcery.com>
 
 	* config/arm/arm.c (params.h): Include.

gcc/Makefile.in

@@ -2806,7 +2806,7 @@ opts.o : opts.c opts.h options.h $(TOPLEV_H) $(DIAGNOSTIC_CORE_H) $(CONFIG_H) $(
    $(FLAGS_H) $(PARAMS_H) $(TREE_PASS_H) $(DBGCNT_H) debug.h \
    $(PLUGIN_H) $(EXCEPT_H) $(LTO_STREAMER_H) opts-diagnostic.h
 opts-common.o : opts-common.c opts.h options.h $(CONFIG_H) $(SYSTEM_H) \
-   coretypes.h intl.h
+   coretypes.h intl.h $(DIAGNOSTIC_H)
 targhooks.o : targhooks.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TREE_H) \
    $(EXPR_H) $(TM_H) $(RTL_H) $(TM_P_H) $(FUNCTION_H) output.h $(TOPLEV_H) $(DIAGNOSTIC_CORE_H) \
    $(MACHMODE_H) $(TARGET_DEF_H) $(TARGET_H) $(GGC_H) gt-targhooks.h \

gcc/ada/ChangeLog

 2010-07-27  Joseph Myers  <joseph@codesourcery.com>
 
+	* gcc-interface/misc.c (gnat_handle_option): Update prototype and
+	return value type.  Don't check for missing arguments here.
+
+2010-07-27  Joseph Myers  <joseph@codesourcery.com>
+
 	* gcc-interface/misc.c (gnat_option_lang_mask): New.
 	(gnat_init_options): Update prototype.  Reconstruct argv array
 	from decoded options.

gcc/ada/gcc-interface/misc.c

@@ -64,7 +64,8 @@ static bool gnat_init			(void);
 static unsigned int gnat_option_lang_mask (void);
 static void gnat_init_options		(unsigned int,
 					 struct cl_decoded_option *);
-static int gnat_handle_option		(size_t, const char *, int, int);
+static bool gnat_handle_option		(size_t, const char *, int, int,
+					 const struct cl_option_handlers *);
 static bool gnat_post_options		(const char **);
 static alias_set_type gnat_get_alias_set (tree);
 static void gnat_print_decl		(FILE *, tree, int);
@@ -186,22 +187,15 @@ gnat_parse_file (int set_yydebug ATTRIBUTE_UNUSED)
 
 /* Decode all the language specific options that cannot be decoded by GCC.
    The option decoding phase of GCC calls this routine on the flags that
-   it cannot decode.  Return the number of consecutive arguments from ARGV
-   that have been successfully decoded or 0 on failure.  */
+   are marked as Ada-specific.  Return true on success or false on failure.  */
 
-static int
-gnat_handle_option (size_t scode, const char *arg, int value,
-		    int kind ATTRIBUTE_UNUSED)
+static bool
+gnat_handle_option (size_t scode, const char *arg ATTRIBUTE_UNUSED, int value,
+		    int kind ATTRIBUTE_UNUSED,
+		    const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 {
-  const struct cl_option *option = &cl_options[scode];
   enum opt_code code = (enum opt_code) scode;
 
-  if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE)))
-    {
-      error ("missing argument to \"-%s\"", option->opt_text);
-      return 1;
-    }
-
   switch (code)
     {
     case OPT_Wall:
@@ -250,7 +244,7 @@ gnat_handle_option (size_t scode, const char *arg, int value,
       gcc_unreachable ();
     }
 
-  return 1;
+  return true;
 }
 
 /* Return language mask for option processing.  */

gcc/c-family/ChangeLog

+2010-07-27  Joseph Myers  <joseph@codesourcery.com>
+
+	* c-common.h (c_common_handle_option): Update prototype and return
+	value type.
+	* c-opts.c (c_common_handle_option): Update prototype and return
+	value type.  Update calls to handle_option and
+	enable_warning_as_error.
+
 2010-07-27  Jakub Jelinek  <jakub@redhat.com>
 
 	PR c/45079

gcc/c-family/c-common.h

@@ -658,7 +658,8 @@ extern void set_Wformat (int);
 extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
 extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
 extern bool attribute_takes_identifier_p (const_tree);
-extern int c_common_handle_option (size_t code, const char *arg, int value, int kind);
+extern bool c_common_handle_option (size_t, const char *, int, int,
+				    const struct cl_option_handlers *);
 extern tree c_common_type_for_mode (enum machine_mode, int);
 extern tree c_common_type_for_size (unsigned int, int);
 extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,

gcc/c-family/c-opts.c

@@ -319,16 +319,15 @@ c_common_init_options (unsigned int decoded_options_count,
 }
 
 /* Handle switch SCODE with argument ARG.  VALUE is true, unless no-
-   form of an -f or -W option was given.  Returns 0 if the switch was
-   invalid, a negative number to prevent language-independent
-   processing in toplev.c (a hack necessary for the short-term).  */
-int
+   form of an -f or -W option was given.  Returns false if the switch was
+   invalid, true if valid.  Use HANDLERS in recursive handle_option calls.  */
+bool
 c_common_handle_option (size_t scode, const char *arg, int value,
-			int kind)
+			int kind, const struct cl_option_handlers *handlers)
 {
   const struct cl_option *option = &cl_options[scode];
   enum opt_code code = (enum opt_code) scode;
-  int result = 1;
+  bool result = true;
 
   /* Prevent resetting the language standard to a C dialect when the driver
      has already determined that we're looking at assembler input.  */
@@ -341,10 +340,10 @@ c_common_handle_option (size_t scode, const char *arg, int value,
 	{
 	  if ((option->flags & CL_TARGET)
 	      && ! targetcm.handle_c_option (scode, arg, value))
-	    result = 0;
+	    result = false;
 	  break;
 	}
-      result = 0;
+      result = false;
       break;
 
     case OPT__output_pch_:
@@ -438,7 +437,8 @@ c_common_handle_option (size_t scode, const char *arg, int value,
     case OPT_Wall:
       warn_unused = value;
       set_Wformat (value);
-      handle_option (OPT_Wimplicit, value, NULL, c_family_lang_mask, kind);
+      handle_option (OPT_Wimplicit, NULL, value, c_family_lang_mask, kind,
+		     handlers);
       warn_char_subscripts = value;
       warn_missing_braces = value;
       warn_parentheses = value;
@@ -524,7 +524,8 @@ c_common_handle_option (size_t scode, const char *arg, int value,
     case OPT_Werror_implicit_function_declaration:
       /* For backward compatibility, this is the same as
 	 -Werror=implicit-function-declaration.  */
-      enable_warning_as_error ("implicit-function-declaration", value, CL_C | CL_ObjC);
+      enable_warning_as_error ("implicit-function-declaration", value,
+			       CL_C | CL_ObjC, handlers);
       break;
 
     case OPT_Wformat:
@@ -538,11 +539,11 @@ c_common_handle_option (size_t scode, const char *arg, int value,
     case OPT_Wimplicit:
       gcc_assert (value == 0 || value == 1);
       if (warn_implicit_int == -1)
-	handle_option (OPT_Wimplicit_int, value, NULL,
-		       c_family_lang_mask, kind);
+	handle_option (OPT_Wimplicit_int, NULL, value,
+		       c_family_lang_mask, kind, handlers);
       if (warn_implicit_function_declaration == -1)
-	handle_option (OPT_Wimplicit_function_declaration, value, NULL,
-		       c_family_lang_mask, kind);
+	handle_option (OPT_Wimplicit_function_declaration, NULL, value,
+		       c_family_lang_mask, kind, handlers);
       break;
 
     case OPT_Wimport:
@@ -655,7 +656,7 @@ c_common_handle_option (size_t scode, const char *arg, int value,
 
     case OPT_fbuiltin_:
       if (value)
-	result = 0;
+	result = false;
       else
 	disable_builtin_function (arg);
       break;

gcc/coretypes.h

@@ -68,6 +68,7 @@ struct cl_target_option;
 struct cl_optimization;
 struct cl_option;
 struct cl_decoded_option;
+struct cl_option_handlers;
 struct gimple_seq_d;
 typedef struct gimple_seq_d *gimple_seq;
 typedef const struct gimple_seq_d *const_gimple_seq;

gcc/fortran/ChangeLog

 2010-07-27  Joseph Myers  <joseph@codesourcery.com>
 
+	* gfortran.h (gfc_handle_option): Update prototype and return
+	value type.
+	* options.c (gfc_handle_option): Update prototype and return value
+	type.
+
+2010-07-27  Joseph Myers  <joseph@codesourcery.com>
+
 	* cpp.c (gfc_cpp_init_options): Update prototype.  Use number of
 	decoded options in allocating deferred_opt.
 	* cpp.h (gfc_cpp_init_options): Update prototype.

gcc/fortran/gfortran.h

@@ -2358,7 +2358,8 @@ int get_c_kind (const char *, CInteropKind_t *);
 unsigned int gfc_option_lang_mask (void);
 void gfc_init_options (unsigned int,
 		       struct cl_decoded_option *);
-int gfc_handle_option (size_t, const char *, int, int);
+bool gfc_handle_option (size_t, const char *, int, int,
+			const struct cl_option_handlers *);
 bool gfc_post_options (const char **);
 
 /* f95-lang.c */

gcc/fortran/options.c

@@ -542,20 +542,21 @@ gfc_handle_runtime_check_option (const char *arg)
 /* Handle command-line options.  Returns 0 if unrecognized, 1 if
    recognized and handled.  */
 
-int
+bool
 gfc_handle_option (size_t scode, const char *arg, int value,
-		   int kind ATTRIBUTE_UNUSED)
+		   int kind ATTRIBUTE_UNUSED,
+		   const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 {
-  int result = 1;
+  bool result = true;
   enum opt_code code = (enum opt_code) scode;
 
   if (gfc_cpp_handle_option (scode, arg, value) == 1)
-    return 1;
+    return true;
 
   switch (code)
     {
     default:
-      result = 0;
+      result = false;
       break;
 
     case OPT_Wall:

gcc/hooks.c

@@ -160,14 +160,6 @@ hook_int_rtx_bool_0 (rtx a ATTRIBUTE_UNUSED, bool b ATTRIBUTE_UNUSED)
   return 0;
 }
 
-int
-hook_int_size_t_constcharptr_int_0 (size_t a ATTRIBUTE_UNUSED,
-				    const char *b ATTRIBUTE_UNUSED,
-				    int c ATTRIBUTE_UNUSED)
-{
-  return 0;
-}
-
 unsigned int
 hook_uint_void_0 (void)
 {

gcc/hooks.h

@@ -63,7 +63,6 @@ extern int hook_int_const_tree_0 (const_tree);
 extern int hook_int_const_tree_const_tree_1 (const_tree, const_tree);
 extern int hook_int_rtx_0 (rtx);
 extern int hook_int_rtx_bool_0 (rtx, bool);
-extern int hook_int_size_t_constcharptr_int_0 (size_t, const char *, int);
 
 extern tree hook_tree_const_tree_null (const_tree);
 

gcc/java/ChangeLog

 2010-07-27  Joseph Myers  <joseph@codesourcery.com>
 
+	* lang.c (java_handle_option): Update prototype and return value
+	type.
+
+2010-07-27  Joseph Myers  <joseph@codesourcery.com>
+
 	* lang.c (java_option_lang_mask): New.
 	(java_init_options): Update prototype.
 	(LANG_HOOKS_OPTION_LANG_MASK): Define.

gcc/java/lang.c

@@ -50,7 +50,8 @@ static unsigned int java_option_lang_mask (void);
 static void java_init_options (unsigned int, struct cl_decoded_option *);
 static bool java_post_options (const char **);
 
-static int java_handle_option (size_t scode, const char *arg, int value, int kind);
+static bool java_handle_option (size_t, const char *, int, int,
+				const struct cl_option_handlers *);
 static void put_decl_string (const char *, int);
 static void put_decl_node (tree, int);
 static void java_print_error_function (diagnostic_context *, const char *,
@@ -174,11 +175,12 @@ struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 
 /*
  * process java-specific compiler command-line options
- * return 0, but do not complain if the option is not recognized.
+ * return false, but do not complain if the option is not recognized.
  */
-static int
+static bool
 java_handle_option (size_t scode, const char *arg, int value,
-		    int kind ATTRIBUTE_UNUSED)
+		    int kind ATTRIBUTE_UNUSED,
+		    const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 {
   enum opt_code code = (enum opt_code) scode;
 
@@ -269,7 +271,7 @@ java_handle_option (size_t scode, const char *arg, int value,
 
     case OPT_fdump_:
       if (!dump_switch_p (arg))
-	return 0;
+	return false;
       break;
 
     case OPT_fencoding_:
@@ -298,7 +300,7 @@ java_handle_option (size_t scode, const char *arg, int value,
       gcc_unreachable ();
     }
 
-  return 1;
+  return true;
 }
 
 /* Global open file.  */

gcc/langhooks-def.h

@@ -69,6 +69,8 @@ extern void lhd_initialize_diagnostics (struct diagnostic_context *);
 extern void lhd_init_options (unsigned int,
 			      struct cl_decoded_option *);
 extern bool lhd_complain_wrong_lang_p (const struct cl_option *);
+extern bool lhd_handle_option (size_t, const char *, int, int,
+			       const struct cl_option_handlers *);
 extern tree lhd_callgraph_analyze_expr (tree *, int *);
 
 
@@ -89,7 +91,7 @@ extern void lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *,
 #define LANG_HOOKS_INIT_OPTIONS		lhd_init_options
 #define LANG_HOOKS_INITIALIZE_DIAGNOSTICS lhd_initialize_diagnostics
 #define LANG_HOOKS_COMPLAIN_WRONG_LANG_P lhd_complain_wrong_lang_p
-#define LANG_HOOKS_HANDLE_OPTION	hook_int_size_t_constcharptr_int_0
+#define LANG_HOOKS_HANDLE_OPTION	lhd_handle_option
 #define LANG_HOOKS_POST_OPTIONS		lhd_post_options
 #define LANG_HOOKS_MISSING_NORETURN_OK_P hook_bool_tree_true
 #define LANG_HOOKS_GET_ALIAS_SET	lhd_get_alias_set

gcc/langhooks.c

@@ -351,6 +351,16 @@ lhd_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED)
   return true;
 }
 
+/* By default, no language-specific options are valid.  */
+bool
+lhd_handle_option (size_t code ATTRIBUTE_UNUSED,
+		   const char *arg ATTRIBUTE_UNUSED,
+		   int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
+		   const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
+{
+  return false;
+}
+
 /* The default function to print out name of current function that caused
    an error.  */
 void

gcc/langhooks.h

@@ -292,11 +292,12 @@ struct lang_hooks
      which points to permanent storage.  The handler is responsible for
      checking whether ARG is NULL, which indicates that no argument
      was in fact supplied.  For -f and -W switches, VALUE is 1 or 0
-     for the positive and negative forms respectively.
+     for the positive and negative forms respectively.  HANDLERS should
+     be passed to any recursive handle_option calls.
 
-     Return 1 if the switch is valid, 0 if invalid, and -1 if it's
-     valid and should not be treated as language-independent too.  */
-  int (*handle_option) (size_t code, const char *arg, int value, int kind);
+     Return true if the switch is valid, false if invalid.  */
+  bool (*handle_option) (size_t code, const char *arg, int value, int kind,
+			 const struct cl_option_handlers *handlers);
 
   /* Called when all command line options have been parsed to allow
      further processing and initialization

gcc/lto/ChangeLog

 2010-07-27  Joseph Myers  <joseph@codesourcery.com>
 
+	* lto-lang.c (lto_handle_option): Update prototype and return
+	value type.  Remove duplicate assignment to result.
+
+2010-07-27  Joseph Myers  <joseph@codesourcery.com>
+
 	* lto-lang.c (lto_option_lang_mask, lto_complain_wrong_lang_p):
 	New.
 	(lto_init_options): Update prototype.

gcc/lto/lto-lang.c

@@ -631,18 +631,18 @@ lto_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED,
    of the option was supplied.  */
 
 const char *resolution_file_name;
-static int
+static bool
 lto_handle_option (size_t scode, const char *arg,
-		   int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED)
+		   int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED,
+		   const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 {
   enum opt_code code = (enum opt_code) scode;
-  int result = 1;
+  bool result = true;
 
   switch (code)
     {
     case OPT_fresolution_:
       resolution_file_name = arg;
-      result = 1;
       break;
 
     case OPT_Wabi:

gcc/optc-gen.awk

@@ -73,6 +73,7 @@ print "#include " quote "intl.h" quote
 print ""
 print "#ifdef GCC_DRIVER"
 print "int target_flags;"
+print "int target_flags_explicit;"
 print "#else"
 print "#include " quote "flags.h" quote
 print "#include " quote "target.h" quote

gcc/opts-common.c

@@ -23,6 +23,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "coretypes.h"
 #include "opts.h"
 #include "options.h"
+#include "diagnostic.h"
 
 /* Perform a binary search to find which option the command-line INPUT
    matches.  Returns its index in the option array, and
@@ -453,3 +454,136 @@ done:
 
   free (options);
 }
+
+/* Handle option OPT_INDEX, and argument ARG, for the language
+   indicated by LANG_MASK, using the handlers in HANDLERS.  VALUE is
+   the option value as for the value field of cl_decoded_option.  KIND
+   is the diagnostic_t if this is a diagnostics option, DK_UNSPECIFIED
+   otherwise.  Returns false if the switch was invalid.  */
+
+bool
+handle_option (size_t opt_index, const char *arg, int value,
+	       unsigned int lang_mask, int kind,
+	       const struct cl_option_handlers *handlers)
+{
+  const struct cl_option *option = &cl_options[opt_index];
+  size_t i;
+
+  if (option->flag_var)
+    set_option (opt_index, value, arg, kind);
+
+  for (i = 0; i < handlers->num_handlers; i++)
+    if (option->flags & handlers->handlers[i].mask)
+      {
+	if (!handlers->handlers[i].handler (opt_index, arg, value,
+					    lang_mask, kind, handlers))
+	  return false;
+	else
+	  handlers->post_handling_callback (opt_index, arg, value,
+					    handlers->handlers[i].mask);
+      }
+  
+  return true;
+}
+
+/* Handle the switch DECODED for the language indicated by LANG_MASK,
+   using the handlers in *HANDLERS.  */
+
+void
+read_cmdline_option (struct cl_decoded_option *decoded,
+		     unsigned int lang_mask,
+		     const struct cl_option_handlers *handlers)
+{
+  const struct cl_option *option;
+  const char *opt;
+
+  if (decoded->opt_index == OPT_SPECIAL_unknown)
+    {
+      opt = decoded->arg;
+
+      if (handlers->unknown_option_callback (opt))
+	error ("unrecognized command line option %qs", opt);
+      return;
+    }
+
+  option = &cl_options[decoded->opt_index];
+  opt = decoded->orig_option_with_args_text;
+
+  if (decoded->errors & CL_ERR_DISABLED)
+    {
+      error ("command line option %qs"
+	     " is not supported by this configuration", opt);
+      return;
+    }
+
+  if (decoded->errors & CL_ERR_WRONG_LANG)
+    {
+      handlers->wrong_lang_callback (opt, option, lang_mask);
+      return;
+    }
+
+  if (decoded->errors & CL_ERR_MISSING_ARG)
+    {
+      if (option->missing_argument_error)
+	error (option->missing_argument_error, opt);
+      else
+	error ("missing argument to %qs", opt);
+      return;
+    }
+
+  if (decoded->errors & CL_ERR_UINT_ARG)
+    {
+      error ("argument to %qs should be a non-negative integer",
+	     option->opt_text);
+      return;
+    }
+
+  gcc_assert (!decoded->errors);
+
+  if (!handle_option (decoded->opt_index, decoded->arg, decoded->value,
+		      lang_mask, DK_UNSPECIFIED, handlers))
+    error ("unrecognized command line option %qs", opt);
+}
+
+/* Set any variable for option OPT_INDEX according to VALUE and ARG,
+   diagnostic kind KIND.  */
+
+void
+set_option (int opt_index, int value, const char *arg, int kind)
+{
+  const struct cl_option *option = &cl_options[opt_index];
+
+  if (!option->flag_var)
+    return;
+
+  switch (option->var_type)
+    {
+    case CLVC_BOOLEAN:
+	*(int *) option->flag_var = value;
+	break;
+
+    case CLVC_EQUAL:
+	*(int *) option->flag_var = (value
+				     ? option->var_value
+				     : !option->var_value);
+	break;
+
+    case CLVC_BIT_CLEAR:
+    case CLVC_BIT_SET:
+	if ((value != 0) == (option->var_type == CLVC_BIT_SET))
+	  *(int *) option->flag_var |= option->var_value;
+	else
+	  *(int *) option->flag_var &= ~option->var_value;
+	if (option->flag_var == &target_flags)
+	  target_flags_explicit |= option->var_value;
+	break;
+
+    case CLVC_STRING:
+	*(const char **) option->flag_var = arg;
+	break;
+    }
+
+  if ((diagnostic_t) kind != DK_UNSPECIFIED)
+    diagnostic_classify_diagnostic (global_dc, opt_index, (diagnostic_t) kind,
+				    UNKNOWN_LOCATION);
+}

gcc/opts.h

@@ -135,6 +135,47 @@ struct cl_decoded_option
   int errors;
 };
 
+/* Structure describing a single option-handling callback.  */
+
+struct cl_option_handler_func
+{
+  /* The function called to handle the option.  */
+  bool (*handler) (size_t opt_index, const char *arg, int value,
+		   unsigned int lang_mask, int kind,
+		   const struct cl_option_handlers *handlers);
+
+  /* The mask that must have some bit in common with the flags for the
+     option for this particular handler to be used.  */
+  unsigned int mask;
+};
+
+/* Structure describing the callbacks used in handling options.  */
+
+struct cl_option_handlers
+{
+  /* Callback for an unknown option to determine whether to give an
+     error for it, and possibly store information to diagnose the
+     option at a later point.  Return true if an error should be
+     given, false otherwise.  */
+  bool (*unknown_option_callback) (const char *opt);
+
+  /* Callback to handle, and possibly diagnose, an option for another
+     language.  */
+  void (*wrong_lang_callback) (const char *text,
+			       const struct cl_option *option,
+			       unsigned int lang_mask);
+
+  /* Callback to call after the successful handling of any option.  */
+  void (*post_handling_callback) (size_t opt_index, const char *arg,
+				  int value, unsigned int mask);
+
+  /* The number of individual handlers.  */
+  size_t num_handlers;
+
+  /* The handlers themselves.  */
+  struct cl_option_handler_func handlers[3];
+};
+
 /* Input file names.  */
 
 extern const char **in_fnames;
@@ -157,10 +198,15 @@ extern void decode_options (unsigned int argc, const char **argv,
 extern int option_enabled (int opt_idx);
 extern bool get_option_state (int, struct cl_option_state *);
 extern void set_option (int opt_index, int value, const char *arg, int);
-bool handle_option (int opt_index, int value, const char *arg,
-		    unsigned int lang_mask, int kind);
+bool handle_option (size_t opt_index, const char *arg, int value,
+		    unsigned int lang_mask, int kind,
+		    const struct cl_option_handlers *handlers);
+extern void read_cmdline_option (struct cl_decoded_option *decoded,
+				 unsigned int lang_mask,
+				 const struct cl_option_handlers *handlers);
 extern void register_warning_as_error_callback (void (*callback) (int));
 extern void enable_warning_as_error (const char *arg, int value,
-				     unsigned int lang_mask);
+				     unsigned int lang_mask,
+				     const struct cl_option_handlers *handlers);
 extern void print_ignored_options (void);
 #endif