diff --git a/gcc/ChangeLog b/gcc/ChangeLog index e0b9ec58bea..563c3291373 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,17 @@ +2003-06-16 Neil Booth + + * c-opts.c (c_common_handle_option): s/on/value/. + (OPT_fabi_version_, OPT_ftabstop_, OPT_ftemplate_depth_): Use value + directly rather than converting the argument. + * c.opt: Update docs. Use UInteger where appropriate. + * common.opt: Use UInteger where appropriate. + * opts.c (integral_argument): New. + (handle_argument): Handle integral arguments, and optional + joined arguments. + (common_handle_option): Update. + * opts.h (CL_MISSING_OK, CL_UINTEGER): New. + * opts.sh: Handle JoinedOrMissing and UInteger flags. + 2003-06-16 Neil Booth * config/rs6000/sysv4.h (ASM_OUTPUT_ALIGNED_LOCAL): Remove diff --git a/gcc/c-opts.c b/gcc/c-opts.c index 680c3cbb722..9f0cde5e4d6 100644 --- a/gcc/c-opts.c +++ b/gcc/c-opts.c @@ -244,7 +244,7 @@ c_common_init_options (lang) invalid, a negative number to prevent language-independent processing in toplev.c (a hack necessary for the short-term). */ int -c_common_handle_option (size_t scode, const char *arg, int on) +c_common_handle_option (size_t scode, const char *arg, int value) { const struct cl_option *option = &cl_options[scode]; enum opt_code code = (enum opt_code) scode; @@ -265,7 +265,7 @@ c_common_handle_option (size_t scode, const char *arg, int on) lang_mask = lang_flags[(c_language << 1) + flag_objc]; if (!(option->flags & lang_mask)) { - complain_wrong_lang (code, on); + complain_wrong_lang (code, value); return 1; } @@ -372,95 +372,95 @@ c_common_handle_option (size_t scode, const char *arg, int on) break; case OPT_Wabi: - warn_abi = on; + warn_abi = value; break; case OPT_Wall: - set_Wunused (on); - set_Wformat (on); - set_Wimplicit (on); - warn_char_subscripts = on; - warn_missing_braces = on; - warn_parentheses = on; - warn_return_type = on; - warn_sequence_point = on; /* Was C only. */ + set_Wunused (value); + set_Wformat (value); + set_Wimplicit (value); + warn_char_subscripts = value; + warn_missing_braces = value; + warn_parentheses = value; + warn_return_type = value; + warn_sequence_point = value; /* Was C only. */ if (c_language == clk_cplusplus) - warn_sign_compare = on; - warn_switch = on; - warn_strict_aliasing = on; + warn_sign_compare = value; + warn_switch = value; + warn_strict_aliasing = value; /* Only warn about unknown pragmas that are not in system headers. */ - warn_unknown_pragmas = on; + warn_unknown_pragmas = value; /* We save the value of warn_uninitialized, since if they put -Wuninitialized on the command line, we need to generate a warning about not using it without also specifying -O. */ if (warn_uninitialized != 1) - warn_uninitialized = (on ? 2 : 0); + warn_uninitialized = (value ? 2 : 0); if (c_language == clk_c) /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding can turn it off only if it's not explicit. */ - warn_main = on * 2; + warn_main = value * 2; else { /* C++-specific warnings. */ - warn_nonvdtor = on; - warn_reorder = on; - warn_nontemplate_friend = on; + warn_nonvdtor = value; + warn_reorder = value; + warn_nontemplate_friend = value; } - cpp_opts->warn_trigraphs = on; - cpp_opts->warn_comments = on; - cpp_opts->warn_num_sign_change = on; - cpp_opts->warn_multichar = on; /* Was C++ only. */ + cpp_opts->warn_trigraphs = value; + cpp_opts->warn_comments = value; + cpp_opts->warn_num_sign_change = value; + cpp_opts->warn_multichar = value; /* Was C++ only. */ break; case OPT_Wbad_function_cast: - warn_bad_function_cast = on; + warn_bad_function_cast = value; break; case OPT_Wcast_qual: - warn_cast_qual = on; + warn_cast_qual = value; break; case OPT_Wchar_subscripts: - warn_char_subscripts = on; + warn_char_subscripts = value; break; case OPT_Wcomment: case OPT_Wcomments: - cpp_opts->warn_comments = on; + cpp_opts->warn_comments = value; break; case OPT_Wconversion: - warn_conversion = on; + warn_conversion = value; break; case OPT_Wctor_dtor_privacy: - warn_ctor_dtor_privacy = on; + warn_ctor_dtor_privacy = value; break; case OPT_Wdeprecated: - warn_deprecated = on; - cpp_opts->warn_deprecated = on; + warn_deprecated = value; + cpp_opts->warn_deprecated = value; break; case OPT_Wdiv_by_zero: - warn_div_by_zero = on; + warn_div_by_zero = value; break; case OPT_Weffc__: - warn_ecpp = on; + warn_ecpp = value; break; case OPT_Wendif_labels: - cpp_opts->warn_endif_labels = on; + cpp_opts->warn_endif_labels = value; break; case OPT_Werror: - cpp_opts->warnings_are_errors = on; + cpp_opts->warnings_are_errors = value; break; case OPT_Werror_implicit_function_declaration: @@ -468,11 +468,11 @@ c_common_handle_option (size_t scode, const char *arg, int on) break; case OPT_Wfloat_equal: - warn_float_equal = on; + warn_float_equal = value; break; case OPT_Wformat: - set_Wformat (on); + set_Wformat (value); break; case OPT_Wformat_: @@ -480,192 +480,192 @@ c_common_handle_option (size_t scode, const char *arg, int on) break; case OPT_Wformat_extra_args: - warn_format_extra_args = on; + warn_format_extra_args = value; break; case OPT_Wformat_nonliteral: - warn_format_nonliteral = on; + warn_format_nonliteral = value; break; case OPT_Wformat_security: - warn_format_security = on; + warn_format_security = value; break; case OPT_Wformat_y2k: - warn_format_y2k = on; + warn_format_y2k = value; break; case OPT_Wformat_zero_length: - warn_format_zero_length = on; + warn_format_zero_length = value; break; case OPT_Wimplicit: - set_Wimplicit (on); + set_Wimplicit (value); break; case OPT_Wimplicit_function_declaration: - mesg_implicit_function_declaration = on; + mesg_implicit_function_declaration = value; break; case OPT_Wimplicit_int: - warn_implicit_int = on; + warn_implicit_int = value; break; case OPT_Wimport: - cpp_opts->warn_import = on; + cpp_opts->warn_import = value; break; case OPT_Winvalid_offsetof: - warn_invalid_offsetof = on; + warn_invalid_offsetof = value; break; case OPT_Winvalid_pch: - cpp_opts->warn_invalid_pch = on; + cpp_opts->warn_invalid_pch = value; break; case OPT_Wlong_long: - warn_long_long = on; + warn_long_long = value; break; case OPT_Wmain: - if (on) + if (value) warn_main = 1; else warn_main = -1; break; case OPT_Wmissing_braces: - warn_missing_braces = on; + warn_missing_braces = value; break; case OPT_Wmissing_declarations: - warn_missing_declarations = on; + warn_missing_declarations = value; break; case OPT_Wmissing_format_attribute: - warn_missing_format_attribute = on; + warn_missing_format_attribute = value; break; case OPT_Wmissing_prototypes: - warn_missing_prototypes = on; + warn_missing_prototypes = value; break; case OPT_Wmultichar: - cpp_opts->warn_multichar = on; + cpp_opts->warn_multichar = value; break; case OPT_Wnested_externs: - warn_nested_externs = on; + warn_nested_externs = value; break; case OPT_Wnon_template_friend: - warn_nontemplate_friend = on; + warn_nontemplate_friend = value; break; case OPT_Wnon_virtual_dtor: - warn_nonvdtor = on; + warn_nonvdtor = value; break; case OPT_Wnonnull: - warn_nonnull = on; + warn_nonnull = value; break; case OPT_Wold_style_cast: - warn_old_style_cast = on; + warn_old_style_cast = value; break; case OPT_Woverloaded_virtual: - warn_overloaded_virtual = on; + warn_overloaded_virtual = value; break; case OPT_Wparentheses: - warn_parentheses = on; + warn_parentheses = value; break; case OPT_Wpmf_conversions: - warn_pmf2ptr = on; + warn_pmf2ptr = value; break; case OPT_Wpointer_arith: - warn_pointer_arith = on; + warn_pointer_arith = value; break; case OPT_Wprotocol: - warn_protocol = on; + warn_protocol = value; break; case OPT_Wselector: - warn_selector = on; + warn_selector = value; break; case OPT_Wredundant_decls: - warn_redundant_decls = on; + warn_redundant_decls = value; break; case OPT_Wreorder: - warn_reorder = on; + warn_reorder = value; break; case OPT_Wreturn_type: - warn_return_type = on; + warn_return_type = value; break; case OPT_Wsequence_point: - warn_sequence_point = on; + warn_sequence_point = value; break; case OPT_Wsign_compare: - warn_sign_compare = on; + warn_sign_compare = value; break; case OPT_Wsign_promo: - warn_sign_promo = on; + warn_sign_promo = value; break; case OPT_Wstrict_prototypes: - warn_strict_prototypes = on; + warn_strict_prototypes = value; break; case OPT_Wsynth: - warn_synth = on; + warn_synth = value; break; case OPT_Wsystem_headers: - cpp_opts->warn_system_headers = on; + cpp_opts->warn_system_headers = value; break; case OPT_Wtraditional: - warn_traditional = on; - cpp_opts->warn_traditional = on; + warn_traditional = value; + cpp_opts->warn_traditional = value; break; case OPT_Wtrigraphs: - cpp_opts->warn_trigraphs = on; + cpp_opts->warn_trigraphs = value; break; case OPT_Wundeclared_selector: - warn_undeclared_selector = on; + warn_undeclared_selector = value; break; case OPT_Wundef: - cpp_opts->warn_undef = on; + cpp_opts->warn_undef = value; break; case OPT_Wunknown_pragmas: /* Set to greater than 1, so that even unknown pragmas in system headers will be warned about. */ - warn_unknown_pragmas = on * 2; + warn_unknown_pragmas = value * 2; break; case OPT_Wunused_macros: - warn_unused_macros = on; + warn_unused_macros = value; break; case OPT_Wwrite_strings: if (c_language == clk_c) - flag_const_strings = on; + flag_const_strings = value; else - warn_write_strings = on; + warn_write_strings = value; break; case OPT_ansi: @@ -682,7 +682,7 @@ c_common_handle_option (size_t scode, const char *arg, int on) case OPT_fcond_mismatch: if (c_language == clk_c) { - flag_cond_mismatch = on; + flag_cond_mismatch = value; break; } /* Fall through. */ @@ -705,38 +705,38 @@ c_common_handle_option (size_t scode, const char *arg, int on) break; case OPT_fabi_version_: - flag_abi_version = read_integral_parameter (arg, option->opt_text, 1); + flag_abi_version = value; break; case OPT_faccess_control: - flag_access_control = on; + flag_access_control = value; break; case OPT_falt_external_templates: - flag_alt_external_templates = on; - if (on) + flag_alt_external_templates = value; + if (value) flag_external_templates = true; cp_deprecated: warning ("switch \"%s\" is deprecated, please see documentation for details", option->opt_text); break; case OPT_fasm: - flag_no_asm = !on; + flag_no_asm = !value; break; case OPT_fbuiltin: - flag_no_builtin = !on; + flag_no_builtin = !value; break; case OPT_fbuiltin_: - if (on) + if (value) result = 0; else disable_builtin_function (arg); break; case OPT_fdollars_in_identifiers: - cpp_opts->dollars_in_ident = on; + cpp_opts->dollars_in_ident = value; break; case OPT_fdump_: @@ -745,56 +745,56 @@ c_common_handle_option (size_t scode, const char *arg, int on) break; case OPT_ffreestanding: - on = !on; + value = !value; /* Fall through... */ case OPT_fhosted: - flag_hosted = on; - flag_no_builtin = !on; + flag_hosted = value; + flag_no_builtin = !value; /* warn_main will be 2 if set by -Wall, 1 if set by -Wmain */ - if (!on && warn_main == 2) + if (!value && warn_main == 2) warn_main = 0; break; case OPT_fshort_double: - flag_short_double = on; + flag_short_double = value; break; case OPT_fshort_enums: - flag_short_enums = on; + flag_short_enums = value; break; case OPT_fshort_wchar: - flag_short_wchar = on; + flag_short_wchar = value; break; case OPT_fsigned_bitfields: - flag_signed_bitfields = on; + flag_signed_bitfields = value; explicit_flag_signed_bitfields = 1; break; case OPT_fsigned_char: - flag_signed_char = on; + flag_signed_char = value; break; case OPT_funsigned_bitfields: - flag_signed_bitfields = !on; + flag_signed_bitfields = !value; explicit_flag_signed_bitfields = 1; break; case OPT_funsigned_char: - flag_signed_char = !on; + flag_signed_char = !value; break; case OPT_fcheck_new: - flag_check_new = on; + flag_check_new = value; break; case OPT_fconserve_space: - flag_conserve_space = on; + flag_conserve_space = value; break; case OPT_fconst_strings: - flag_const_strings = on; + flag_const_strings = value; break; case OPT_fconstant_string_class_: @@ -802,19 +802,19 @@ c_common_handle_option (size_t scode, const char *arg, int on) break; case OPT_fdefault_inline: - flag_default_inline = on; + flag_default_inline = value; break; case OPT_felide_constructors: - flag_elide_constructors = on; + flag_elide_constructors = value; break; case OPT_fenforce_eh_specs: - flag_enforce_eh_specs = on; + flag_enforce_eh_specs = value; break; case OPT_fexternal_templates: - flag_external_templates = on; + flag_external_templates = value; goto cp_deprecated; case OPT_ffixed_form: @@ -825,108 +825,104 @@ c_common_handle_option (size_t scode, const char *arg, int on) break; case OPT_ffor_scope: - flag_new_for_scope = on; + flag_new_for_scope = value; break; case OPT_fgnu_keywords: - flag_no_gnu_keywords = !on; + flag_no_gnu_keywords = !value; break; case OPT_fgnu_runtime: - flag_next_runtime = !on; + flag_next_runtime = !value; break; case OPT_fhandle_exceptions: warning ("-fhandle-exceptions has been renamed -fexceptions (and is now on by default)"); - flag_exceptions = on; + flag_exceptions = value; break; case OPT_fimplement_inlines: - flag_implement_inlines = on; + flag_implement_inlines = value; break; case OPT_fimplicit_inline_templates: - flag_implicit_inline_templates = on; + flag_implicit_inline_templates = value; break; case OPT_fimplicit_templates: - flag_implicit_templates = on; + flag_implicit_templates = value; break; case OPT_fms_extensions: - flag_ms_extensions = on; + flag_ms_extensions = value; break; case OPT_fnext_runtime: - flag_next_runtime = on; + flag_next_runtime = value; break; case OPT_fnonansi_builtins: - flag_no_nonansi_builtin = !on; + flag_no_nonansi_builtin = !value; break; case OPT_foperator_names: - cpp_opts->operator_names = on; + cpp_opts->operator_names = value; break; case OPT_foptional_diags: - flag_optional_diags = on; + flag_optional_diags = value; break; case OPT_fpch_deps: - cpp_opts->restore_pch_deps = on; + cpp_opts->restore_pch_deps = value; break; case OPT_fpermissive: - flag_permissive = on; + flag_permissive = value; break; case OPT_fpreprocessed: - cpp_opts->preprocessed = on; + cpp_opts->preprocessed = value; break; case OPT_frepo: - flag_use_repository = on; - if (on) + flag_use_repository = value; + if (value) flag_implicit_templates = 0; break; case OPT_frtti: - flag_rtti = on; + flag_rtti = value; break; case OPT_fshow_column: - cpp_opts->show_column = on; + cpp_opts->show_column = value; break; case OPT_fstats: - flag_detailed_statistics = on; + flag_detailed_statistics = value; break; case OPT_ftabstop_: /* It is documented that we silently ignore silly values. */ - { - char *endptr; - long tabstop = strtol (arg, &endptr, 10); - if (*endptr == '\0' && tabstop >= 1 && tabstop <= 100) - cpp_opts->tabstop = tabstop; - } + if (value >= 1 && value <= 100) + cpp_opts->tabstop = value; break; case OPT_ftemplate_depth_: - max_tinst_depth = read_integral_parameter (arg, option->opt_text, 0); + max_tinst_depth = value; break; case OPT_fvtable_gc: - flag_vtable_gc = on; + flag_vtable_gc = value; break; case OPT_fuse_cxa_atexit: - flag_use_cxa_atexit = on; + flag_use_cxa_atexit = value; break; case OPT_fweak: - flag_weak = on; + flag_weak = value; break; case OPT_gen_decls: diff --git a/gcc/c.opt b/gcc/c.opt index f277512efbc..15c344b887e 100644 --- a/gcc/c.opt +++ b/gcc/c.opt @@ -32,7 +32,11 @@ ; compiler recognize the switch, as declared by "Language" entries. ; If the switch takes an argument, then you should also specify ; "Joined" and/or "Separate" to indicate where the argument can -; appear. +; appear. If a Joined argument can legitimately be omitted, specify +; "JoinedOrMissing" instead of "Joined". If the argument to a switch +; is a non-negative integer, you can specify "UInteger" and the switch +; decoder will convert the argument for you, or complain to the user +; if the argument is invalid. ; Comments can appear on their own line anwhere in the file, preceded ; by a semicolon. Whitespace is permitted before the semicolon. @@ -311,7 +315,7 @@ d C ObjC C++ ObjC++ Joined fabi-version= -C++ ObjC++ Joined +C++ ObjC++ Joined UInteger faccess-control C++ ObjC++ @@ -479,10 +483,10 @@ fstrict-prototype C++ ObjC++ ftabstop= -C ObjC C++ ObjC++ Joined RejectNegative +C ObjC C++ ObjC++ Joined RejectNegative UInteger ftemplate-depth- -C++ ObjC++ Joined +C++ ObjC++ Joined RejectNegative UInteger fthis-is-variable C++ ObjC++ diff --git a/gcc/common.opt b/gcc/common.opt index 6c936210ae5..d34be3a263a 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -18,26 +18,7 @@ ; Software Foundation, 59 Temple Place - Suite 330, Boston, MA ; 02111-1307, USA. - -; This file is processed by the script opts.sh. It is a database of -; command line options, with each record separated by a blank line, -; and each field appearing on its own line. The first field is the -; command-line switch with the leading "-" removed. All options -; beginning with "f" or "W" are implicitly assumed to take a "no-" -; form; this form should not be listed. If you do not want this -; negative form and you want it to be automatically rejected, add -; RejectNegative to the second field. - -; The second field should contain "Common". If the switch takes an -; argument, then you should also specify "Joined" and/or "Separate" to -; indicate where the argument can appear. - -; Comments can appear on their own line anwhere in the file, preceded -; by a semicolon. Whitespace is permitted before the semicolon. - -; For each switch XXX below, an enumeration constant is created by the -; script opts.sh spelt OPT_XXX, but with all non-alphanumeric -; characters replaced with an underscore. +; See c.opt for a description of this file's format. ; Please try to keep this file in ASCII collating order. @@ -51,7 +32,7 @@ Common Common G -Common Joined Separate +Common Joined Separate UInteger aux-info Common Separate diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index e2c58664bd3..634aca69617 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,3 +1,9 @@ +2003-06-16 Neil Booth + + * lang.c (java_handle_option): Special-casing of optional + joined arguments no longer needed. + * lang.opt: Update switches that take optional argument. + 2003-06-15 Neil Booth * lang.opt: Declare Java. diff --git a/gcc/java/lang.c b/gcc/java/lang.c index ff20985fc50..07d5647ed32 100644 --- a/gcc/java/lang.c +++ b/gcc/java/lang.c @@ -274,17 +274,8 @@ java_handle_option (size_t scode, const char *arg, int value) if (arg == NULL && (option->flags & (CL_JOINED | CL_SEPARATE))) { - /* These can take an empty argument. */ - if (code == OPT_fassume_compiled_ - || code == OPT_fclasspath_ - || code == OPT_fCLASSPATH_ - || code == OPT_fbootclasspath_) - arg = ""; - else - { - error ("missing argument to \"-%s\"", option->opt_text); - return 1; - } + error ("missing argument to \"-%s\"", option->opt_text); + return 1; } switch (code) diff --git a/gcc/java/lang.opt b/gcc/java/lang.opt index e108fb72c2c..ed8d02ee151 100644 --- a/gcc/java/lang.opt +++ b/gcc/java/lang.opt @@ -65,7 +65,7 @@ Wredundant-modifiers Java fCLASSPATH= -Java Joined RejectNegative +Java JoinedOrMissing RejectNegative fassert Java @@ -74,16 +74,16 @@ fassume-compiled Java fassume-compiled= -Java Joined +Java JoinedOrMissing fbootclasspath= -Java Joined RejectNegative +Java JoinedOrMissing RejectNegative fcheck-references Java fclasspath= -Java Joined RejectNegative +Java JoinedOrMissing RejectNegative fcompile-resource= Java Joined RejectNegative diff --git a/gcc/opts.c b/gcc/opts.c index 204cc0d0db3..32620576f9a 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -130,6 +130,22 @@ find_opt (const char *input, int lang_mask) return result; } +/* If ARG is a postive integer made up solely of digits, return its + value, otherwise return -1. */ +static int +integral_argument (const char *arg) +{ + const char *p = arg; + + while (*p && ISDIGIT (*p)) + p++; + + if (*p == '\0') + return atoi (arg); + + return -1; +} + /* Handle the switch beginning at ARGV, with ARGC remaining. */ int handle_option (int argc ATTRIBUTE_UNUSED, char **argv, int lang_mask) @@ -137,7 +153,7 @@ handle_option (int argc ATTRIBUTE_UNUSED, char **argv, int lang_mask) size_t opt_index; const char *opt, *arg = 0; char *dup = 0; - bool on = true; + int value = 1; int result = 0, temp; const struct cl_option *option; @@ -149,7 +165,7 @@ handle_option (int argc ATTRIBUTE_UNUSED, char **argv, int lang_mask) opt_index = cl_options_count; arg = opt; main_input_filename = opt; - result = (*lang_hooks.handle_option) (opt_index, arg, on); + result = (*lang_hooks.handle_option) (opt_index, arg, value); } else { @@ -164,7 +180,7 @@ handle_option (int argc ATTRIBUTE_UNUSED, char **argv, int lang_mask) dup[1] = opt[1]; memcpy (dup + 2, opt + 5, len - 2 + 1); opt = dup; - on = false; + value = 0; } opt_index = find_opt (opt + 1, lang_mask | CL_COMMON); @@ -174,48 +190,62 @@ handle_option (int argc ATTRIBUTE_UNUSED, char **argv, int lang_mask) option = &cl_options[opt_index]; /* Reject negative form of switches that don't take negatives. */ - if (!on && (option->flags & CL_REJECT_NEGATIVE)) + if (!value && (option->flags & CL_REJECT_NEGATIVE)) goto done; /* We've recognized this switch. */ result = 1; /* Sort out any argument the switch takes. */ - if (option->flags & (CL_JOINED | CL_SEPARATE)) + if (option->flags & CL_JOINED) { - if (option->flags & CL_JOINED) - { - /* Have arg point to the original switch. This is because - some code, such as disable_builtin_function, expects its - argument to be persistent until the program exits. */ - arg = argv[0] + cl_options[opt_index].opt_len + 1; - if (!on) - arg += strlen ("no-"); - } + /* Have arg point to the original switch. This is because + some code, such as disable_builtin_function, expects its + argument to be persistent until the program exits. */ + arg = argv[0] + cl_options[opt_index].opt_len + 1; + if (!value) + arg += strlen ("no-"); - /* If we don't have an argument, and CL_SEPARATE, try the next - argument in the vector. */ - if (!arg || (*arg == '\0' && option->flags & CL_SEPARATE)) + if (*arg == '\0' && !(option->flags & CL_MISSING_OK)) { - arg = argv[1]; - result = 2; + if (option->flags & CL_SEPARATE) + { + arg = argv[1]; + result = 2; + } + else + /* Missing argument. */ + arg = NULL; } + } + else if (option->flags & CL_SEPARATE) + { + arg = argv[1]; + result = 2; + } - /* Canonicalize missing arguments as NULL for the handler. */ - if (*arg == '\0') - arg = NULL; + /* If the switch takes an integer, convert it. */ + if (arg && (option->flags & CL_UINTEGER)) + { + value = integral_argument (arg); + if (value == -1) + { + error ("argument to \"-%s\" should be a non-negative integer", + option->opt_text); + goto done; + } } if (option->flags & lang_mask) { - temp = (*lang_hooks.handle_option) (opt_index, arg, on); + temp = (*lang_hooks.handle_option) (opt_index, arg, value); if (temp <= 0) result = temp; } if (result > 0 && (option->flags & CL_COMMON)) { - if (common_handle_option (opt_index, arg, on) == 0) + if (common_handle_option (opt_index, arg, value) == 0) result = 0; } } @@ -262,9 +292,7 @@ common_handle_option (size_t scode, const char *arg, break; case OPT_G: - g_switch_value = read_integral_parameter (arg, 0, -1); - if (g_switch_value == (unsigned HOST_WIDE_INT) -1) - return 0; + g_switch_value = value; g_switch_set = true; break; diff --git a/gcc/opts.h b/gcc/opts.h index 31c6e8e7f31..abb3963e45c 100644 --- a/gcc/opts.h +++ b/gcc/opts.h @@ -36,6 +36,8 @@ extern const unsigned int cl_options_count; #define CL_JOINED (1 << 24) /* If takes joined argument. */ #define CL_SEPARATE (1 << 25) /* If takes a separate argument. */ #define CL_REJECT_NEGATIVE (1 << 26) /* Reject no- form. */ -#define CL_COMMON (1 << 27) /* Language-independent. */ +#define CL_MISSING_OK (1 << 27) /* Missing argument OK (joined). */ +#define CL_UINTEGER (1 << 28) /* Argument is an integer >=0. */ +#define CL_COMMON (1 << 29) /* Language-independent. */ #endif diff --git a/gcc/opts.sh b/gcc/opts.sh index 27dbe4c29de..bbca27265c7 100644 --- a/gcc/opts.sh +++ b/gcc/opts.sh @@ -55,8 +55,11 @@ ${AWK} ' } if (flags ~ " Common ") result = result " | CL_COMMON" if (flags ~ " Joined ") result = result " | CL_JOINED" + if (flags ~ " JoinedOrMissing ") \ + result = result " | CL_JOINED | CL_MISSING_OK" if (flags ~ " Separate ") result = result " | CL_SEPARATE" if (flags ~ " RejectNegative ") result = result " | CL_REJECT_NEGATIVE" + if (flags ~ " UInteger ") result = result " | CL_UINTEGER" sub( "^0 \\| ", "", result ) return result }