toplev.c (debug_args, [...]): Mark descriptions for translation.
* toplev.c (debug_args, f_options, W_options): Mark descriptions for translation. (display_help): Translate descriptions on output. * cp/lang-options.h, f/lang-options.h, java/lang-options.h, objc/lang-options.h: Mark descriptions for translation. From-SVN: r42618
This commit is contained in:
Zack Weinberg
Zack Weinberg
parent
05e126346a
commit
a63719408d
|
|
@ -1,5 +1,12 @@
|
|||
2001-05-25 Zack Weinberg <zackw@stanford.edu>
|
||||
|
||||
* toplev.c (debug_args, f_options, W_options): Mark
|
||||
descriptions for translation.
|
||||
(display_help): Translate descriptions on output.
|
||||
|
||||
* cp/lang-options.h, f/lang-options.h, java/lang-options.h,
|
||||
objc/lang-options.h: Mark descriptions for translation.
|
||||
|
||||
* aclocal.m4: Quote final argument of patsubst. Use
|
||||
3-argument form of AC_DEFINE. Restore quotes to [] while
|
||||
using AC_FD_CC.
|
||||
|
|
|
|||
|
|
@ -25,97 +25,138 @@ DEFINE_LANG_NAME ("C++")
|
|||
toplev.c for g++. */
|
||||
|
||||
{ "-faccess-control", "" },
|
||||
{ "-fno-access-control", "Do not obey access control semantics" },
|
||||
{ "-falt-external-templates", "Change when template instances are emitted" },
|
||||
{ "-fno-access-control",
|
||||
N_("Do not obey access control semantics") },
|
||||
{ "-falt-external-templates",
|
||||
N_("Change when template instances are emitted") },
|
||||
{ "-fno-alt-external-templates", "" },
|
||||
{ "-fansi-overloading", "" },
|
||||
{ "-fno-ansi-overloading", "" },
|
||||
{ "-fcheck-new", "Check the return value of new" },
|
||||
{ "-fcheck-new",
|
||||
N_("Check the return value of new") },
|
||||
{ "-fno-check-new", "" },
|
||||
{ "-fconserve-space", "Reduce size of object files" },
|
||||
{ "-fconserve-space",
|
||||
N_("Reduce size of object files") },
|
||||
{ "-fno-conserve-space", "" },
|
||||
{ "-fconst-strings", "" },
|
||||
{ "-fno-const-strings", "Make string literals `char[]' instead of `const char[]'" },
|
||||
{ "-fno-const-strings",
|
||||
N_("Make string literals `char[]' instead of `const char[]'") },
|
||||
{ "-fdefault-inline", "" },
|
||||
{ "-fdump-translation-unit-", "Dump the entire translation unit to a file"},
|
||||
{ "-fno-default-inline", "Do not inline member functions by default"},
|
||||
{ "-fdump-translation-unit-",
|
||||
N_("Dump the entire translation unit to a file") },
|
||||
{ "-fno-default-inline",
|
||||
N_("Do not inline member functions by default") },
|
||||
{ "-frtti", "" },
|
||||
{ "-fno-rtti", "Do not generate run time type descriptor information" },
|
||||
{ "-fno-rtti",
|
||||
N_("Do not generate run time type descriptor information") },
|
||||
{ "-felide-constructors", "" },
|
||||
{ "-fno-elide-constructors", "" },
|
||||
{ "-fenforce-eh-specs", "" },
|
||||
{ "-fno-enforce-eh-specs", "Do not generate code to check exception specifications" },
|
||||
{ "-fno-enforce-eh-specs",
|
||||
N_("Do not generate code to check exception specifications") },
|
||||
{ "-fexternal-templates", "" },
|
||||
{ "-fno-external-templates", "" },
|
||||
{ "-ffor-scope", "" },
|
||||
{ "-fno-for-scope", "Scope of for-init-statement vars extends outside" },
|
||||
{ "-fno-for-scope",
|
||||
N_("Scope of for-init-statement vars extends outside") },
|
||||
{ "-fgnu-keywords", "" },
|
||||
{ "-fno-gnu-keywords", "Do not recognise GNU defined keywords" },
|
||||
{ "-fno-gnu-keywords",
|
||||
N_("Do not recognise GNU defined keywords") },
|
||||
{ "-fhandle-exceptions", "" },
|
||||
{ "-fno-handle-exceptions", "" },
|
||||
{ "-fhonor-std", "Treat the namespace `std' as a normal namespace" },
|
||||
{ "-fhonor-std",
|
||||
N_("Treat the namespace `std' as a normal namespace") },
|
||||
{ "-fno-honor-std", "" },
|
||||
{ "-fhuge-objects", "Enable support for huge objects" },
|
||||
{ "-fhuge-objects",
|
||||
N_("Enable support for huge objects") },
|
||||
{ "-fno-huge-objects", "" },
|
||||
{ "-fimplement-inlines", "" },
|
||||
{ "-fno-implement-inlines", "Export functions even if they can be inlined" },
|
||||
{ "-fno-implement-inlines",
|
||||
N_("Export functions even if they can be inlined") },
|
||||
{ "-fimplicit-templates", "" },
|
||||
{ "-fno-implicit-templates", "Only emit explicit template instatiations" },
|
||||
{ "-fno-implicit-templates",
|
||||
N_("Only emit explicit template instatiations") },
|
||||
{ "-fimplicit-inline-templates", "" },
|
||||
{ "-fno-implicit-inline-templates", "Only emit explicit instatiations of inline templates" },
|
||||
{ "-fno-implicit-inline-templates",
|
||||
N_("Only emit explicit instatiations of inline templates") },
|
||||
{ "-finit-priority", "" },
|
||||
{ "-fno-init-priority", "" },
|
||||
{ "-fmemoize-lookups", "" },
|
||||
{ "-fno-memoize-lookups", "" },
|
||||
{ "-fms-extensions", "Don't pedwarn about uses of Microsoft extensions" },
|
||||
{ "-fms-extensions",
|
||||
N_("Don't pedwarn about uses of Microsoft extensions") },
|
||||
{ "-fno-ms-extensions", "" },
|
||||
{ "-foperator-names", "Recognise and/bitand/bitor/compl/not/or/xor" },
|
||||
{ "-foperator-names",
|
||||
N_("Recognise and/bitand/bitor/compl/not/or/xor") },
|
||||
{ "-fno-operator-names", "" },
|
||||
{ "-foptional-diags", "" },
|
||||
{ "-fno-optional-diags", "Disable optional diagnostics" },
|
||||
{ "-fpermissive", "Downgrade conformance errors to warnings" },
|
||||
{ "-fno-optional-diags",
|
||||
N_("Disable optional diagnostics") },
|
||||
{ "-fpermissive",
|
||||
N_("Downgrade conformance errors to warnings") },
|
||||
{ "-fno-permissive", "" },
|
||||
{ "-frepo", "Enable automatic template instantiation" },
|
||||
{ "-frepo",
|
||||
N_("Enable automatic template instantiation") },
|
||||
{ "-fno-repo", "" },
|
||||
{ "-fsave-memoized", "" },
|
||||
{ "-fno-save-memoized", "" },
|
||||
{ "-fstats", "Display statistics accumulated during compilation" },
|
||||
{ "-fstats",
|
||||
N_("Display statistics accumulated during compilation") },
|
||||
{ "-fno-stats", "" },
|
||||
{ "-ftemplate-depth-", "Specify maximum template instantiation depth"},
|
||||
{ "-fuse-cxa-atexit", "Use __cxa_atexit to register destructors." },
|
||||
{ "-ftemplate-depth-",
|
||||
N_("Specify maximum template instantiation depth") },
|
||||
{ "-fuse-cxa-atexit",
|
||||
N_("Use __cxa_atexit to register destructors.") },
|
||||
{ "-fno-use-cxa-atexit", "" },
|
||||
{ "-fvtable-gc", "Discard unused virtual functions" },
|
||||
{ "-fvtable-gc",
|
||||
N_("Discard unused virtual functions") },
|
||||
{ "-fno-vtable-gc", "" },
|
||||
{ "-fvtable-thunks", "Implement vtables using thunks" },
|
||||
{ "-fvtable-thunks",
|
||||
N_("Implement vtables using thunks") },
|
||||
{ "-fno-vtable-thunks", "" },
|
||||
{ "-fweak", "Emit common-like symbols as weak symbols" },
|
||||
{ "-fweak",
|
||||
N_("Emit common-like symbols as weak symbols") },
|
||||
{ "-fno-weak", "" },
|
||||
{ "-fxref", "Emit cross referencing information" },
|
||||
{ "-fxref",
|
||||
N_("Emit cross referencing information") },
|
||||
{ "-fno-xref", "" },
|
||||
|
||||
{ "-Wreturn-type", "Warn about inconsistent return types" },
|
||||
{ "-Wreturn-type",
|
||||
N_("Warn about inconsistent return types") },
|
||||
{ "-Wno-return-type", "" },
|
||||
{ "-Woverloaded-virtual", "Warn about overloaded virtual function names" },
|
||||
{ "-Woverloaded-virtual",
|
||||
N_("Warn about overloaded virtual function names") },
|
||||
{ "-Wno-overloaded-virtual", "" },
|
||||
{ "-Wctor-dtor-privacy", "" },
|
||||
{ "-Wno-ctor-dtor-privacy", "Don't warn when all ctors/dtors are private" },
|
||||
{ "-Wnon-virtual-dtor", "Warn about non virtual destructors" },
|
||||
{ "-Wno-ctor-dtor-privacy",
|
||||
N_("Don't warn when all ctors/dtors are private") },
|
||||
{ "-Wnon-virtual-dtor",
|
||||
N_("Warn about non virtual destructors") },
|
||||
{ "-Wno-non-virtual-dtor", "" },
|
||||
{ "-Wextern-inline", "Warn when a function is declared extern, then inline" },
|
||||
{ "-Wextern-inline",
|
||||
N_("Warn when a function is declared extern, then inline") },
|
||||
{ "-Wno-extern-inline", "" },
|
||||
{ "-Wreorder", "Warn when the compiler reorders code" },
|
||||
{ "-Wreorder",
|
||||
N_("Warn when the compiler reorders code") },
|
||||
{ "-Wno-reorder", "" },
|
||||
{ "-Wsynth", "Warn when synthesis behaviour differs from Cfront" },
|
||||
{ "-Wsynth",
|
||||
N_("Warn when synthesis behaviour differs from Cfront") },
|
||||
{ "-Wno-synth", "" },
|
||||
{ "-Wpmf-conversions", "" },
|
||||
{ "-Wno-pmf-conversions", "Don't warn when type converting pointers to member functions" },
|
||||
{ "-Weffc++", "Warn about violations of Effective C++ style rules" },
|
||||
{ "-Wno-pmf-conversions",
|
||||
N_("Don't warn when type converting pointers to member functions") },
|
||||
{ "-Weffc++",
|
||||
N_("Warn about violations of Effective C++ style rules") },
|
||||
{ "-Wno-effc++", "" },
|
||||
{ "-Wsign-promo", "Warn when overload promotes from unsigned to signed" },
|
||||
{ "-Wsign-promo",
|
||||
N_("Warn when overload promotes from unsigned to signed") },
|
||||
{ "-Wno-sign-promo", "" },
|
||||
{ "-Wold-style-cast", "Warn if a C style cast is used in a program" },
|
||||
{ "-Wold-style-cast",
|
||||
N_("Warn if a C style cast is used in a program") },
|
||||
{ "-Wno-old-style-cast", "" },
|
||||
{ "-Wnon-template-friend", "" },
|
||||
{ "-Wno-non-template-friend", "Don't warn when non-templatized friend functions are declared within a template" },
|
||||
{ "-Wno-non-template-friend",
|
||||
N_("Don't warn when non-templatized friend functions are declared within a template") },
|
||||
{ "-Wdeprecated", "" },
|
||||
{ "-Wno-deprecated", "Don't announce deprecation of compiler features" },
|
||||
{ "-Wno-deprecated",
|
||||
N_("Don't announce deprecation of compiler features") },
|
||||
|
|
|
|||
|
|
@ -29,135 +29,212 @@ the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|||
|
||||
DEFINE_LANG_NAME ("Fortran")
|
||||
|
||||
{ "-fversion", "Print g77-specific compiler version info, run internal tests" },
|
||||
{ "-fversion",
|
||||
N_("Print g77-specific compiler version info, run internal tests") },
|
||||
{ "-fnull-version", "" },
|
||||
/*"-fident",*/
|
||||
/*"-fno-ident",*/
|
||||
{ "-ff66", "Program is written in typical FORTRAN 66 dialect" },
|
||||
{ "-ff66",
|
||||
N_("Program is written in typical FORTRAN 66 dialect") },
|
||||
{ "-fno-f66", "" },
|
||||
{ "-ff77", "Program is written in typical Unix f77 dialect" },
|
||||
{ "-fno-f77", "Program does not use Unix-f77 dialectal features" },
|
||||
{ "-ff90", "Program is written in Fortran-90-ish dialect" },
|
||||
{ "-ff77",
|
||||
N_("Program is written in typical Unix f77 dialect") },
|
||||
{ "-fno-f77",
|
||||
N_("Program does not use Unix-f77 dialectal features") },
|
||||
{ "-ff90",
|
||||
N_("Program is written in Fortran-90-ish dialect") },
|
||||
{ "-fno-f90", "" },
|
||||
{ "-fautomatic", "" },
|
||||
{ "-fno-automatic", "Treat local vars and COMMON blocks as if they were named in SAVE statements" },
|
||||
{ "-fdollar-ok", "Allow $ in symbol names" },
|
||||
{ "-fno-automatic",
|
||||
N_("Treat local vars and COMMON blocks as if they were named in SAVE statements") },
|
||||
{ "-fdollar-ok",
|
||||
N_("Allow $ in symbol names") },
|
||||
{ "-fno-dollar-ok", "" },
|
||||
{ "-ff2c", "" },
|
||||
{ "-fno-f2c", "f2c-compatible code need not be generated" },
|
||||
{ "-fno-f2c",
|
||||
N_("f2c-compatible code need not be generated") },
|
||||
{ "-ff2c-library", "" },
|
||||
{ "-fno-f2c-library", "Unsupported; do not generate libf2c-calling code" },
|
||||
{ "-fflatten-arrays", "Unsupported; affects code-generation of arrays" },
|
||||
{ "-fno-f2c-library",
|
||||
N_("Unsupported; do not generate libf2c-calling code") },
|
||||
{ "-fflatten-arrays",
|
||||
N_("Unsupported; affects code-generation of arrays") },
|
||||
{ "-fno-flatten-arrays", "" },
|
||||
{ "-ffree-form", "Program is written in Fortran-90-ish free form" },
|
||||
{ "-ffree-form",
|
||||
N_("Program is written in Fortran-90-ish free form") },
|
||||
{ "-fno-free-form", "" },
|
||||
{ "-ffixed-form", "" },
|
||||
{ "-fno-fixed-form", "" },
|
||||
{ "-fpedantic", "Warn about use of (only a few for now) Fortran extensions" },
|
||||
{ "-fpedantic",
|
||||
N_("Warn about use of (only a few for now) Fortran extensions") },
|
||||
{ "-fno-pedantic", "" },
|
||||
{ "-fvxt", "Program is written in VXT (Digital-like) FORTRAN" },
|
||||
{ "-fvxt",
|
||||
N_("Program is written in VXT (Digital-like) FORTRAN") },
|
||||
{ "-fno-vxt", "" },
|
||||
{ "-fno-ugly", "Disallow all ugly features" },
|
||||
{ "-fno-ugly",
|
||||
N_("Disallow all ugly features") },
|
||||
{ "-fugly-args", "" },
|
||||
{ "-fno-ugly-args", "Hollerith and typeless constants not passed as arguments" },
|
||||
{ "-fugly-assign", "Allow ordinary copying of ASSIGN'ed vars" },
|
||||
{ "-fno-ugly-args",
|
||||
N_("Hollerith and typeless constants not passed as arguments") },
|
||||
{ "-fugly-assign",
|
||||
N_("Allow ordinary copying of ASSIGN'ed vars") },
|
||||
{ "-fno-ugly-assign", "" },
|
||||
{ "-fugly-assumed", "Dummy array dimensioned to (1) is assumed-size" },
|
||||
{ "-fugly-assumed",
|
||||
N_("Dummy array dimensioned to (1) is assumed-size") },
|
||||
{ "-fno-ugly-assumed", "" },
|
||||
{ "-fugly-comma", "Trailing comma in procedure call denotes null argument" },
|
||||
{ "-fugly-comma",
|
||||
N_("Trailing comma in procedure call denotes null argument") },
|
||||
{ "-fno-ugly-comma", "" },
|
||||
{ "-fugly-complex", "Allow REAL(Z) and AIMAG(Z) given DOUBLE COMPLEX Z" },
|
||||
{ "-fugly-complex",
|
||||
N_("Allow REAL(Z) and AIMAG(Z) given DOUBLE COMPLEX Z") },
|
||||
{ "-fno-ugly-complex", "" },
|
||||
{ "-fugly-init", "" },
|
||||
{ "-fno-ugly-init", "Initialization via DATA and PARAMETER is type-compatible" },
|
||||
{ "-fugly-logint", "Allow INTEGER and LOGICAL interchangeability" },
|
||||
{ "-fno-ugly-init",
|
||||
N_("Initialization via DATA and PARAMETER is type-compatible") },
|
||||
{ "-fugly-logint",
|
||||
N_("Allow INTEGER and LOGICAL interchangeability") },
|
||||
{ "-fno-ugly-logint", "" },
|
||||
{ "-fxyzzy", "Print internal debugging-related info" },
|
||||
{ "-fxyzzy",
|
||||
N_("Print internal debugging-related info") },
|
||||
{ "-fno-xyzzy", "" },
|
||||
{ "-finit-local-zero", "Initialize local vars and arrays to zero" },
|
||||
{ "-finit-local-zero",
|
||||
N_("Initialize local vars and arrays to zero") },
|
||||
{ "-fno-init-local-zero", "" },
|
||||
{ "-fbackslash", "" },
|
||||
{ "-fno-backslash", "Backslashes in character/hollerith constants not special (C-style)" },
|
||||
{ "-femulate-complex", "Have front end emulate COMPLEX arithmetic to avoid bugs" },
|
||||
{ "-fno-backslash",
|
||||
N_("Backslashes in character/hollerith constants not special (C-style)") },
|
||||
{ "-femulate-complex",
|
||||
N_("Have front end emulate COMPLEX arithmetic to avoid bugs") },
|
||||
{ "-fno-emulate-complex", "" },
|
||||
{ "-funderscoring", "" },
|
||||
{ "-fno-underscoring", "Disable the appending of underscores to externals" },
|
||||
{ "-fno-underscoring",
|
||||
N_("Disable the appending of underscores to externals") },
|
||||
{ "-fsecond-underscore", "" },
|
||||
{ "-fno-second-underscore", "Never append a second underscore to externals" },
|
||||
{ "-fintrin-case-initcap", "Intrinsics spelled as e.g. SqRt" },
|
||||
{ "-fintrin-case-upper", "Intrinsics in uppercase" },
|
||||
{ "-fno-second-underscore",
|
||||
N_("Never append a second underscore to externals") },
|
||||
{ "-fintrin-case-initcap",
|
||||
N_("Intrinsics spelled as e.g. SqRt") },
|
||||
{ "-fintrin-case-upper",
|
||||
N_("Intrinsics in uppercase") },
|
||||
{ "-fintrin-case-lower", "" },
|
||||
{ "-fintrin-case-any", "Intrinsics letters in arbitrary cases" },
|
||||
{ "-fmatch-case-initcap", "Language keywords spelled as e.g. IOStat" },
|
||||
{ "-fmatch-case-upper", "Language keywords in uppercase" },
|
||||
{ "-fintrin-case-any",
|
||||
N_("Intrinsics letters in arbitrary cases") },
|
||||
{ "-fmatch-case-initcap",
|
||||
N_("Language keywords spelled as e.g. IOStat") },
|
||||
{ "-fmatch-case-upper",
|
||||
N_("Language keywords in uppercase") },
|
||||
{ "-fmatch-case-lower", "" },
|
||||
{ "-fmatch-case-any", "Language keyword letters in arbitrary cases" },
|
||||
{ "-fsource-case-upper", "Internally convert most source to uppercase" },
|
||||
{ "-fmatch-case-any",
|
||||
N_("Language keyword letters in arbitrary cases") },
|
||||
{ "-fsource-case-upper",
|
||||
N_("Internally convert most source to uppercase") },
|
||||
{ "-fsource-case-lower", "" },
|
||||
{ "-fsource-case-preserve", "Internally preserve source case" },
|
||||
{ "-fsymbol-case-initcap", "Symbol names spelled in mixed case" },
|
||||
{ "-fsymbol-case-upper", "Symbol names in uppercase" },
|
||||
{ "-fsymbol-case-lower", "Symbol names in lowercase" },
|
||||
{ "-fsource-case-preserve",
|
||||
N_("Internally preserve source case") },
|
||||
{ "-fsymbol-case-initcap",
|
||||
N_("Symbol names spelled in mixed case") },
|
||||
{ "-fsymbol-case-upper",
|
||||
N_("Symbol names in uppercase") },
|
||||
{ "-fsymbol-case-lower",
|
||||
N_("Symbol names in lowercase") },
|
||||
{ "-fsymbol-case-any", "" },
|
||||
{ "-fcase-strict-upper", "Program written in uppercase" },
|
||||
{ "-fcase-strict-lower", "Program written in lowercase" },
|
||||
{ "-fcase-initcap", "Program written in strict mixed-case" },
|
||||
{ "-fcase-upper", "Compile as if program written in uppercase" },
|
||||
{ "-fcase-lower", "Compile as if program written in lowercase" },
|
||||
{ "-fcase-preserve", "Preserve all spelling (case) used in program" },
|
||||
{ "-fbadu77-intrinsics-delete", "Delete libU77 intrinsics with bad interfaces" },
|
||||
{ "-fbadu77-intrinsics-disable", "Disable libU77 intrinsics with bad interfaces" },
|
||||
{ "-fcase-strict-upper",
|
||||
N_("Program written in uppercase") },
|
||||
{ "-fcase-strict-lower",
|
||||
N_("Program written in lowercase") },
|
||||
{ "-fcase-initcap",
|
||||
N_("Program written in strict mixed-case") },
|
||||
{ "-fcase-upper",
|
||||
N_("Compile as if program written in uppercase") },
|
||||
{ "-fcase-lower",
|
||||
N_("Compile as if program written in lowercase") },
|
||||
{ "-fcase-preserve",
|
||||
N_("Preserve all spelling (case) used in program") },
|
||||
{ "-fbadu77-intrinsics-delete",
|
||||
N_("Delete libU77 intrinsics with bad interfaces") },
|
||||
{ "-fbadu77-intrinsics-disable",
|
||||
N_("Disable libU77 intrinsics with bad interfaces") },
|
||||
{ "-fbadu77-intrinsics-enable", "" },
|
||||
{ "-fbadu77-intrinsics-hide", "Hide libU77 intrinsics with bad interfaces" },
|
||||
{ "-ff2c-intrinsics-delete", "Delete non-FORTRAN-77 intrinsics f2c supports" },
|
||||
{ "-ff2c-intrinsics-disable", "Disable non-FORTRAN-77 intrinsics f2c supports" },
|
||||
{ "-fbadu77-intrinsics-hide",
|
||||
N_("Hide libU77 intrinsics with bad interfaces") },
|
||||
{ "-ff2c-intrinsics-delete",
|
||||
N_("Delete non-FORTRAN-77 intrinsics f2c supports") },
|
||||
{ "-ff2c-intrinsics-disable",
|
||||
N_("Disable non-FORTRAN-77 intrinsics f2c supports") },
|
||||
{ "-ff2c-intrinsics-enable", "" },
|
||||
{ "-ff2c-intrinsics-hide", "Hide non-FORTRAN-77 intrinsics f2c supports" },
|
||||
{ "-ff90-intrinsics-delete", "Delete non-FORTRAN-77 intrinsics F90 supports" },
|
||||
{ "-ff90-intrinsics-disable", "Disable non-FORTRAN-77 intrinsics F90 supports" },
|
||||
{ "-ff2c-intrinsics-hide",
|
||||
N_("Hide non-FORTRAN-77 intrinsics f2c supports") },
|
||||
{ "-ff90-intrinsics-delete",
|
||||
N_("Delete non-FORTRAN-77 intrinsics F90 supports") },
|
||||
{ "-ff90-intrinsics-disable",
|
||||
N_("Disable non-FORTRAN-77 intrinsics F90 supports") },
|
||||
{ "-ff90-intrinsics-enable", "" },
|
||||
{ "-ff90-intrinsics-hide", "Hide non-FORTRAN-77 intrinsics F90 supports" },
|
||||
{ "-fgnu-intrinsics-delete", "Delete non-FORTRAN-77 intrinsics g77 supports" },
|
||||
{ "-fgnu-intrinsics-disable", "Disable non-FORTRAN 77 intrinsics F90 supports" },
|
||||
{ "-ff90-intrinsics-hide",
|
||||
N_("Hide non-FORTRAN-77 intrinsics F90 supports") },
|
||||
{ "-fgnu-intrinsics-delete",
|
||||
N_("Delete non-FORTRAN-77 intrinsics g77 supports") },
|
||||
{ "-fgnu-intrinsics-disable",
|
||||
N_("Disable non-FORTRAN 77 intrinsics F90 supports") },
|
||||
{ "-fgnu-intrinsics-enable", "" },
|
||||
{ "-fgnu-intrinsics-hide", "Hide non-FORTRAN 77 intrinsics F90 supports" },
|
||||
{ "-fmil-intrinsics-delete", "Delete MIL-STD 1753 intrinsics" },
|
||||
{ "-fmil-intrinsics-disable", "Disable MIL-STD 1753 intrinsics" },
|
||||
{ "-fgnu-intrinsics-hide",
|
||||
N_("Hide non-FORTRAN 77 intrinsics F90 supports") },
|
||||
{ "-fmil-intrinsics-delete",
|
||||
N_("Delete MIL-STD 1753 intrinsics") },
|
||||
{ "-fmil-intrinsics-disable",
|
||||
N_("Disable MIL-STD 1753 intrinsics") },
|
||||
{ "-fmil-intrinsics-enable", "" },
|
||||
{ "-fmil-intrinsics-hide", "Hide MIL-STD 1753 intrinsics" },
|
||||
{ "-funix-intrinsics-delete", "Delete libU77 intrinsics" },
|
||||
{ "-funix-intrinsics-disable", "Disable libU77 intrinsics" },
|
||||
{ "-fmil-intrinsics-hide",
|
||||
N_("Hide MIL-STD 1753 intrinsics") },
|
||||
{ "-funix-intrinsics-delete",
|
||||
N_("Delete libU77 intrinsics") },
|
||||
{ "-funix-intrinsics-disable",
|
||||
N_("Disable libU77 intrinsics") },
|
||||
{ "-funix-intrinsics-enable", "" },
|
||||
{ "-funix-intrinsics-hide", "Hide libU77 intrinsics" },
|
||||
{ "-fvxt-intrinsics-delete", "Delete non-FORTRAN-77 intrinsics VXT FORTRAN supports" },
|
||||
{ "-fvxt-intrinsics-disable", "Disable non-FORTRAN-77 intrinsics VXT FORTRAN supports" },
|
||||
{ "-funix-intrinsics-hide",
|
||||
N_("Hide libU77 intrinsics") },
|
||||
{ "-fvxt-intrinsics-delete",
|
||||
N_("Delete non-FORTRAN-77 intrinsics VXT FORTRAN supports") },
|
||||
{ "-fvxt-intrinsics-disable",
|
||||
N_("Disable non-FORTRAN-77 intrinsics VXT FORTRAN supports") },
|
||||
{ "-fvxt-intrinsics-enable", "" },
|
||||
{ "-fvxt-intrinsics-hide", "Hide non-FORTRAN-77 intrinsics VXT FORTRAN supports" },
|
||||
{ "-fzeros", "Treat initial values of 0 like non-zero values" },
|
||||
{ "-fvxt-intrinsics-hide",
|
||||
N_("Hide non-FORTRAN-77 intrinsics VXT FORTRAN supports") },
|
||||
{ "-fzeros",
|
||||
N_("Treat initial values of 0 like non-zero values") },
|
||||
{ "-fno-zeros", "" },
|
||||
{ "-fdebug-kludge", "Emit special debugging information for COMMON and EQUIVALENCE (disabled)" },
|
||||
{ "-fdebug-kludge",
|
||||
N_("Emit special debugging information for COMMON and EQUIVALENCE (disabled)") },
|
||||
{ "-fno-debug-kludge", "" },
|
||||
{ "-fonetrip", "Take at least one trip through each iterative DO loop" },
|
||||
{ "-fonetrip",
|
||||
N_("Take at least one trip through each iterative DO loop") },
|
||||
{ "-fno-onetrip", "" },
|
||||
{ "-fsilent", "" },
|
||||
{ "-fno-silent", "Print names of program units as they are compiled" },
|
||||
{ "-fno-silent",
|
||||
N_("Print names of program units as they are compiled") },
|
||||
{ "-fglobals", "" },
|
||||
{ "-fno-globals", "Disable fatal diagnostics about inter-procedural problems" },
|
||||
{ "-ftypeless-boz", "Make prefix-radix non-decimal constants be typeless" },
|
||||
{ "-fno-globals",
|
||||
N_("Disable fatal diagnostics about inter-procedural problems") },
|
||||
{ "-ftypeless-boz",
|
||||
N_("Make prefix-radix non-decimal constants be typeless") },
|
||||
{ "-fno-typeless-boz", "" },
|
||||
{ "-fbounds-check", "Generate code to check subscript and substring bounds" },
|
||||
{ "-fbounds-check",
|
||||
N_("Generate code to check subscript and substring bounds") },
|
||||
{ "-fno-bounds-check", "" },
|
||||
{ "-ffortran-bounds-check", "Fortran-specific form of -fbounds-check" },
|
||||
{ "-ffortran-bounds-check",
|
||||
N_("Fortran-specific form of -fbounds-check") },
|
||||
{ "-fno-fortran-bounds-check", "" },
|
||||
{ "-Wglobals", "" },
|
||||
{ "-Wno-globals", "Disable warnings about inter-procedural problems" },
|
||||
{ "-Wno-globals",
|
||||
N_("Disable warnings about inter-procedural problems") },
|
||||
/*"-Wimplicit",*/
|
||||
/*"-Wno-implicit",*/
|
||||
{ "-Wsurprising", "Warn about constructs with surprising meanings" },
|
||||
{ "-Wsurprising",
|
||||
N_("Warn about constructs with surprising meanings") },
|
||||
{ "-Wno-surprising", "" },
|
||||
/*"-Wall",*/
|
||||
/* Prefix options. */
|
||||
{ "-I", "Add a directory for INCLUDE searching" },
|
||||
{ "-ffixed-line-length-", "Set the maximum line length" },
|
||||
{ "-I",
|
||||
N_("Add a directory for INCLUDE searching") },
|
||||
{ "-ffixed-line-length-",
|
||||
N_("Set the maximum line length") },
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -28,27 +28,44 @@ The Free Software Foundation is independent of Sun Microsystems, Inc. */
|
|||
DEFINE_LANG_NAME ("Java")
|
||||
|
||||
{ "-fbounds-check", "" },
|
||||
{ "-fno-bounds-check", "Disable automatic array bounds checking" },
|
||||
{ "-fassume-compiled", "Make is_compiled_class return 1"},
|
||||
{ "-fno-bounds-check",
|
||||
N_("Disable automatic array bounds checking") },
|
||||
{ "-fassume-compiled",
|
||||
N_("Make is_compiled_class return 1") },
|
||||
{ "-fno-assume-compiled", "" },
|
||||
{ "-femit-class-file", "" },
|
||||
{ "-femit-class-files", "Dump class files to <name>.class" },
|
||||
{ "-ffilelist-file", "input file is list of file names to compile" },
|
||||
{ "-fuse-boehm-gc", "Generate code for Boehm GC" },
|
||||
{ "-fhash-synchronization", "Don't put synchronization structure in each object" },
|
||||
{ "-fjni", "Assume native functions are implemented using JNI" },
|
||||
{ "--classpath", "Set class path and suppress system path" },
|
||||
{ "--CLASSPATH", "Set class path" },
|
||||
{ "--main", "Choose class whose main method should be used" },
|
||||
{ "--encoding", "Choose input encoding (default is UTF-8)" },
|
||||
{ "-I", "Add directory to class path" },
|
||||
{ "-foutput-class-dir", "Directory where class files should be written" },
|
||||
{ "-femit-class-files",
|
||||
N_("Dump class files to <name>.class") },
|
||||
{ "-ffilelist-file",
|
||||
N_("input file is list of file names to compile") },
|
||||
{ "-fuse-boehm-gc",
|
||||
N_("Generate code for Boehm GC") },
|
||||
{ "-fhash-synchronization",
|
||||
N_("Don't put synchronization structure in each object") },
|
||||
{ "-fjni",
|
||||
N_("Assume native functions are implemented using JNI") },
|
||||
{ "--classpath",
|
||||
N_("Set class path and suppress system path") },
|
||||
{ "--CLASSPATH",
|
||||
N_("Set class path") },
|
||||
{ "--main",
|
||||
N_("Choose class whose main method should be used") },
|
||||
{ "--encoding",
|
||||
N_("Choose input encoding (default is UTF-8)") },
|
||||
{ "-I",
|
||||
N_("Add directory to class path") },
|
||||
{ "-foutput-class-dir",
|
||||
N_("Directory where class files should be written") },
|
||||
{ "-fuse-divide-subroutine", "" },
|
||||
{ "-fno-use-divide-subroutine", "Use built-in instructions for division" },
|
||||
{ "-fcheck-references", "Generate null pointer checks inline" },
|
||||
{ "-fno-use-divide-subroutine",
|
||||
N_("Use built-in instructions for division") },
|
||||
{ "-fcheck-references",
|
||||
N_("Generate null pointer checks inline") },
|
||||
{ "-Wredundant-modifiers",
|
||||
"Warn if modifiers are specified when not necessary"},
|
||||
{ "-Wextraneous-semicolon", "Warn if deprecated empty statements are found"},
|
||||
{ "-Wout-of-date", "Warn if .class files are out of date" },
|
||||
N_("Warn if modifiers are specified when not necessary") },
|
||||
{ "-Wextraneous-semicolon",
|
||||
N_("Warn if deprecated empty statements are found") },
|
||||
{ "-Wout-of-date",
|
||||
N_("Warn if .class files are out of date") },
|
||||
{ "-fforce-classes-archive-check",
|
||||
"Always check for non gcj generated classes archives" },
|
||||
N_("Always check for non gcj generated classes archives") },
|
||||
|
|
|
|||
|
|
@ -23,16 +23,21 @@ Boston, MA 02111-1307, USA. */
|
|||
|
||||
DEFINE_LANG_NAME ("Objective C")
|
||||
|
||||
{ "-gen-decls", "Dump decls to a .decl file" },
|
||||
{ "-fgnu-runtime", "Generate code for GNU runtime environment" },
|
||||
{ "-gen-decls",
|
||||
N_("Dump decls to a .decl file") },
|
||||
{ "-fgnu-runtime",
|
||||
N_("Generate code for GNU runtime environment") },
|
||||
{ "-fno-gnu-runtime", "" },
|
||||
{ "-fnext-runtime", "Generate code for NeXT runtime environment" },
|
||||
{ "-fnext-runtime",
|
||||
N_("Generate code for NeXT runtime environment") },
|
||||
{ "-fno-next-runtime", "" },
|
||||
{ "-Wselector", "Warn if a selector has multiple methods" },
|
||||
{ "-Wselector",
|
||||
N_("Warn if a selector has multiple methods") },
|
||||
{ "-Wno-selector", "" },
|
||||
{ "-Wprotocol", "" },
|
||||
{ "-Wno-protocol", "Do not warn if inherited methods are unimplemented"},
|
||||
{ "-Wno-protocol",
|
||||
N_("Do not warn if inherited methods are unimplemented") },
|
||||
{ "-print-objc-runtime-info",
|
||||
"Generate C header of platform specific features" },
|
||||
N_("Generate C header of platform specific features") },
|
||||
{ "-fconstant-string-class",
|
||||
"Specify the name of the class for constant strings" },
|
||||
N_("Specify the name of the class for constant strings") },
|
||||
|
|
|
|||
400
gcc/toplev.c
400
gcc/toplev.c
|
|
@ -928,26 +928,26 @@ static struct
|
|||
debug_args[] =
|
||||
{
|
||||
{ "", NO_DEBUG, DEFAULT_GDB_EXTENSIONS,
|
||||
"Generate default debug format output" },
|
||||
{ "gdb", NO_DEBUG, 1, "Generate default extended debug format output" },
|
||||
N_("Generate debugging info in default format") },
|
||||
{ "gdb", NO_DEBUG, 1, N_("Generate debugging info in default extended format") },
|
||||
#ifdef DBX_DEBUGGING_INFO
|
||||
{ "stabs", DBX_DEBUG, 0, "Generate STABS format debug output" },
|
||||
{ "stabs+", DBX_DEBUG, 1, "Generate extended STABS format debug output" },
|
||||
{ "stabs", DBX_DEBUG, 0, N_("Generate STABS format debug info") },
|
||||
{ "stabs+", DBX_DEBUG, 1, N_("Generate extended STABS format debug info") },
|
||||
#endif
|
||||
#ifdef DWARF_DEBUGGING_INFO
|
||||
{ "dwarf", DWARF_DEBUG, 0, "Generate DWARF-1 format debug output"},
|
||||
{ "dwarf", DWARF_DEBUG, 0, N_("Generate DWARF-1 format debug info") },
|
||||
{ "dwarf+", DWARF_DEBUG, 1,
|
||||
"Generated extended DWARF-1 format debug output" },
|
||||
N_("Generate extended DWARF-1 format debug info") },
|
||||
#endif
|
||||
#ifdef DWARF2_DEBUGGING_INFO
|
||||
{ "dwarf-2", DWARF2_DEBUG, 0, "Enable DWARF-2 debug output" },
|
||||
{ "dwarf-2", DWARF2_DEBUG, 0, N_("Generate DWARF-2 debug info") },
|
||||
#endif
|
||||
#ifdef XCOFF_DEBUGGING_INFO
|
||||
{ "xcoff", XCOFF_DEBUG, 0, "Generate XCOFF format debug output" },
|
||||
{ "xcoff+", XCOFF_DEBUG, 1, "Generate extended XCOFF format debug output" },
|
||||
{ "xcoff", XCOFF_DEBUG, 0, N_("Generate XCOFF format debug info") },
|
||||
{ "xcoff+", XCOFF_DEBUG, 1, N_("Generate extended XCOFF format debug info") },
|
||||
#endif
|
||||
#ifdef SDB_DEBUGGING_INFO
|
||||
{ "coff", SDB_DEBUG, 0, "Generate COFF format debug output" },
|
||||
{ "coff", SDB_DEBUG, 0, N_("Generate COFF format debug info") },
|
||||
#endif
|
||||
{ 0, 0, 0, 0 }
|
||||
};
|
||||
|
|
@ -991,190 +991,190 @@ static const param_info lang_independent_params[] = {
|
|||
lang_independent_options f_options[] =
|
||||
{
|
||||
{"eliminate-dwarf2-dups", &flag_eliminate_dwarf2_dups, 1,
|
||||
"Perform DWARF2 duplicate elimination"},
|
||||
N_("Perform DWARF2 duplicate elimination") },
|
||||
{"float-store", &flag_float_store, 1,
|
||||
"Do not store floats in registers" },
|
||||
N_("Do not store floats in registers") },
|
||||
{"volatile", &flag_volatile, 1,
|
||||
"Consider all mem refs through pointers as volatile"},
|
||||
N_("Consider all mem refs through pointers as volatile") },
|
||||
{"volatile-global", &flag_volatile_global, 1,
|
||||
"Consider all mem refs to global data to be volatile" },
|
||||
N_("Consider all mem refs to global data to be volatile") },
|
||||
{"volatile-static", &flag_volatile_static, 1,
|
||||
"Consider all mem refs to static data to be volatile" },
|
||||
N_("Consider all mem refs to static data to be volatile") },
|
||||
{"defer-pop", &flag_defer_pop, 1,
|
||||
"Defer popping functions args from stack until later" },
|
||||
N_("Defer popping functions args from stack until later") },
|
||||
{"omit-frame-pointer", &flag_omit_frame_pointer, 1,
|
||||
"When possible do not generate stack frames"},
|
||||
N_("When possible do not generate stack frames") },
|
||||
{"optimize-sibling-calls", &flag_optimize_sibling_calls, 1,
|
||||
"Optimize sibling and tail recursive calls" },
|
||||
N_("Optimize sibling and tail recursive calls") },
|
||||
{"cse-follow-jumps", &flag_cse_follow_jumps, 1,
|
||||
"When running CSE, follow jumps to their targets" },
|
||||
N_("When running CSE, follow jumps to their targets") },
|
||||
{"cse-skip-blocks", &flag_cse_skip_blocks, 1,
|
||||
"When running CSE, follow conditional jumps" },
|
||||
N_("When running CSE, follow conditional jumps") },
|
||||
{"expensive-optimizations", &flag_expensive_optimizations, 1,
|
||||
"Perform a number of minor, expensive optimisations" },
|
||||
N_("Perform a number of minor, expensive optimisations") },
|
||||
{"thread-jumps", &flag_thread_jumps, 1,
|
||||
"Perform jump threading optimisations"},
|
||||
N_("Perform jump threading optimisations") },
|
||||
{"strength-reduce", &flag_strength_reduce, 1,
|
||||
"Perform strength reduction optimisations" },
|
||||
N_("Perform strength reduction optimisations") },
|
||||
{"unroll-loops", &flag_unroll_loops, 1,
|
||||
"Perform loop unrolling when iteration count is known" },
|
||||
N_("Perform loop unrolling when iteration count is known") },
|
||||
{"unroll-all-loops", &flag_unroll_all_loops, 1,
|
||||
"Perform loop unrolling for all loops" },
|
||||
N_("Perform loop unrolling for all loops") },
|
||||
{"move-all-movables", &flag_move_all_movables, 1,
|
||||
"Force all loop invariant computations out of loops" },
|
||||
N_("Force all loop invariant computations out of loops") },
|
||||
{"reduce-all-givs", &flag_reduce_all_givs, 1,
|
||||
"Strength reduce all loop general induction variables" },
|
||||
N_("Strength reduce all loop general induction variables") },
|
||||
{"writable-strings", &flag_writable_strings, 1,
|
||||
"Store strings in writable data section" },
|
||||
N_("Store strings in writable data section") },
|
||||
{"peephole", &flag_no_peephole, 0,
|
||||
"Enable machine specific peephole optimisations" },
|
||||
N_("Enable machine specific peephole optimisations") },
|
||||
{"force-mem", &flag_force_mem, 1,
|
||||
"Copy memory operands into registers before using" },
|
||||
N_("Copy memory operands into registers before using") },
|
||||
{"force-addr", &flag_force_addr, 1,
|
||||
"Copy memory address constants into regs before using" },
|
||||
N_("Copy memory address constants into regs before using") },
|
||||
{"function-cse", &flag_no_function_cse, 0,
|
||||
"Allow function addresses to be held in registers" },
|
||||
N_("Allow function addresses to be held in registers") },
|
||||
{"inline-functions", &flag_inline_functions, 1,
|
||||
"Integrate simple functions into their callers" },
|
||||
N_("Integrate simple functions into their callers") },
|
||||
{"keep-inline-functions", &flag_keep_inline_functions, 1,
|
||||
"Generate code for funcs even if they are fully inlined" },
|
||||
N_("Generate code for funcs even if they are fully inlined") },
|
||||
{"inline", &flag_no_inline, 0,
|
||||
"Pay attention to the 'inline' keyword"},
|
||||
N_("Pay attention to the 'inline' keyword") },
|
||||
{"keep-static-consts", &flag_keep_static_consts, 1,
|
||||
"Emit static const variables even if they are not used" },
|
||||
N_("Emit static const variables even if they are not used") },
|
||||
{"syntax-only", &flag_syntax_only, 1,
|
||||
"Check for syntax errors, then stop" },
|
||||
N_("Check for syntax errors, then stop") },
|
||||
{"shared-data", &flag_shared_data, 1,
|
||||
"Mark data as shared rather than private" },
|
||||
N_("Mark data as shared rather than private") },
|
||||
{"caller-saves", &flag_caller_saves, 1,
|
||||
"Enable saving registers around function calls" },
|
||||
N_("Enable saving registers around function calls") },
|
||||
{"pcc-struct-return", &flag_pcc_struct_return, 1,
|
||||
"Return 'short' aggregates in memory, not registers" },
|
||||
N_("Return 'short' aggregates in memory, not registers") },
|
||||
{"reg-struct-return", &flag_pcc_struct_return, 0,
|
||||
"Return 'short' aggregates in registers" },
|
||||
N_("Return 'short' aggregates in registers") },
|
||||
{"delayed-branch", &flag_delayed_branch, 1,
|
||||
"Attempt to fill delay slots of branch instructions" },
|
||||
N_("Attempt to fill delay slots of branch instructions") },
|
||||
{"gcse", &flag_gcse, 1,
|
||||
"Perform the global common subexpression elimination" },
|
||||
N_("Perform the global common subexpression elimination") },
|
||||
{"gcse-lm", &flag_gcse_lm, 1,
|
||||
"Perform enhanced load motion during global subexpression elimination" },
|
||||
N_("Perform enhanced load motion during global subexpression elimination") },
|
||||
{"gcse-sm", &flag_gcse_sm, 1,
|
||||
"Perform store motion after global subexpression elimination" },
|
||||
N_("Perform store motion after global subexpression elimination") },
|
||||
{"rerun-cse-after-loop", &flag_rerun_cse_after_loop, 1,
|
||||
"Run CSE pass after loop optimisations"},
|
||||
N_("Run CSE pass after loop optimisations") },
|
||||
{"rerun-loop-opt", &flag_rerun_loop_opt, 1,
|
||||
"Run the loop optimiser twice"},
|
||||
N_("Run the loop optimiser twice") },
|
||||
{"delete-null-pointer-checks", &flag_delete_null_pointer_checks, 1,
|
||||
"Delete useless null pointer checks" },
|
||||
N_("Delete useless null pointer checks") },
|
||||
{"pretend-float", &flag_pretend_float, 1,
|
||||
"Pretend that host and target use the same FP format"},
|
||||
N_("Pretend that host and target use the same FP format") },
|
||||
{"schedule-insns", &flag_schedule_insns, 1,
|
||||
"Reschedule instructions before register allocation"},
|
||||
N_("Reschedule instructions before register allocation") },
|
||||
{"schedule-insns2", &flag_schedule_insns_after_reload, 1,
|
||||
"Reschedule instructions after register allocation"},
|
||||
N_("Reschedule instructions after register allocation") },
|
||||
{"sched-interblock",&flag_schedule_interblock, 1,
|
||||
"Enable scheduling across basic blocks" },
|
||||
N_("Enable scheduling across basic blocks") },
|
||||
{"sched-spec",&flag_schedule_speculative, 1,
|
||||
"Allow speculative motion of non-loads" },
|
||||
N_("Allow speculative motion of non-loads") },
|
||||
{"sched-spec-load",&flag_schedule_speculative_load, 1,
|
||||
"Allow speculative motion of some loads" },
|
||||
N_("Allow speculative motion of some loads") },
|
||||
{"sched-spec-load-dangerous",&flag_schedule_speculative_load_dangerous, 1,
|
||||
"Allow speculative motion of more loads" },
|
||||
N_("Allow speculative motion of more loads") },
|
||||
{"branch-count-reg",&flag_branch_on_count_reg, 1,
|
||||
"Replace add,compare,branch with branch on count reg"},
|
||||
N_("Replace add,compare,branch with branch on count reg") },
|
||||
{"pic", &flag_pic, 1,
|
||||
"Generate position independent code, if possible"},
|
||||
N_("Generate position independent code, if possible") },
|
||||
{"PIC", &flag_pic, 2, ""},
|
||||
{"exceptions", &flag_exceptions, 1,
|
||||
"Enable exception handling" },
|
||||
N_("Enable exception handling") },
|
||||
{"unwind-tables", &flag_unwind_tables, 1,
|
||||
"Just generate unwind tables for exception handling" },
|
||||
N_("Just generate unwind tables for exception handling") },
|
||||
{"non-call-exceptions", &flag_non_call_exceptions, 1,
|
||||
"Support synchronous non-call exceptions" },
|
||||
N_("Support synchronous non-call exceptions") },
|
||||
{"profile-arcs", &profile_arc_flag, 1,
|
||||
"Insert arc based program profiling code" },
|
||||
N_("Insert arc based program profiling code") },
|
||||
{"test-coverage", &flag_test_coverage, 1,
|
||||
"Create data files needed by gcov" },
|
||||
N_("Create data files needed by gcov") },
|
||||
{"branch-probabilities", &flag_branch_probabilities, 1,
|
||||
"Use profiling information for branch probabilities" },
|
||||
N_("Use profiling information for branch probabilities") },
|
||||
{"reorder-blocks", &flag_reorder_blocks, 1,
|
||||
"Reorder basic blocks to improve code placement" },
|
||||
N_("Reorder basic blocks to improve code placement") },
|
||||
{"rename-registers", &flag_rename_registers, 1,
|
||||
"Do the register renaming optimization pass"},
|
||||
N_("Do the register renaming optimization pass") },
|
||||
{"common", &flag_no_common, 0,
|
||||
"Do not put unitialised globals in the common section" },
|
||||
N_("Do not put unitialised globals in the common section") },
|
||||
{"inhibit-size-directive", &flag_inhibit_size_directive, 1,
|
||||
"Do not generate .size directives" },
|
||||
N_("Do not generate .size directives") },
|
||||
{"function-sections", &flag_function_sections, 1,
|
||||
"place each function into its own section" },
|
||||
N_("place each function into its own section") },
|
||||
{"data-sections", &flag_data_sections, 1,
|
||||
"place data items into their own section" },
|
||||
N_("place data items into their own section") },
|
||||
{"verbose-asm", &flag_verbose_asm, 1,
|
||||
"Add extra commentry to assembler output"},
|
||||
N_("Add extra commentry to assembler output") },
|
||||
{"gnu-linker", &flag_gnu_linker, 1,
|
||||
"Output GNU ld formatted global initialisers"},
|
||||
N_("Output GNU ld formatted global initialisers") },
|
||||
{"regmove", &flag_regmove, 1,
|
||||
"Enables a register move optimisation"},
|
||||
N_("Enables a register move optimisation") },
|
||||
{"optimize-register-move", &flag_regmove, 1,
|
||||
"Do the full regmove optimization pass"},
|
||||
N_("Do the full regmove optimization pass") },
|
||||
{"pack-struct", &flag_pack_struct, 1,
|
||||
"Pack structure members together without holes" },
|
||||
N_("Pack structure members together without holes") },
|
||||
{"stack-check", &flag_stack_check, 1,
|
||||
"Insert stack checking code into the program" },
|
||||
N_("Insert stack checking code into the program") },
|
||||
{"argument-alias", &flag_argument_noalias, 0,
|
||||
"Specify that arguments may alias each other & globals"},
|
||||
N_("Specify that arguments may alias each other & globals") },
|
||||
{"argument-noalias", &flag_argument_noalias, 1,
|
||||
"Assume arguments may alias globals but not each other"},
|
||||
N_("Assume arguments may alias globals but not each other") },
|
||||
{"argument-noalias-global", &flag_argument_noalias, 2,
|
||||
"Assume arguments do not alias each other or globals" },
|
||||
N_("Assume arguments do not alias each other or globals") },
|
||||
{"strict-aliasing", &flag_strict_aliasing, 1,
|
||||
"Assume strict aliasing rules apply" },
|
||||
N_("Assume strict aliasing rules apply") },
|
||||
{"align-loops", &align_loops, 0,
|
||||
"Align the start of loops" },
|
||||
N_("Align the start of loops") },
|
||||
{"align-jumps", &align_jumps, 0,
|
||||
"Align labels which are only reached by jumping" },
|
||||
N_("Align labels which are only reached by jumping") },
|
||||
{"align-labels", &align_labels, 0,
|
||||
"Align all labels" },
|
||||
N_("Align all labels") },
|
||||
{"align-functions", &align_functions, 0,
|
||||
"Align the start of functions" },
|
||||
N_("Align the start of functions") },
|
||||
{"check-memory-usage", &flag_check_memory_usage, 1,
|
||||
"Generate code to check every memory access" },
|
||||
N_("Generate code to check every memory access") },
|
||||
{"prefix-function-name", &flag_prefix_function_name, 1,
|
||||
"Add a prefix to all function names" },
|
||||
N_("Add a prefix to all function names") },
|
||||
{"dump-unnumbered", &flag_dump_unnumbered, 1,
|
||||
"Suppress output of instruction numbers and line number notes in debugging dumps"},
|
||||
N_("Suppress output of instruction numbers and line number notes in debugging dumps") },
|
||||
{"instrument-functions", &flag_instrument_function_entry_exit, 1,
|
||||
"Instrument function entry/exit with profiling calls"},
|
||||
N_("Instrument function entry/exit with profiling calls") },
|
||||
{"ssa", &flag_ssa, 1,
|
||||
"Enable SSA optimizations" },
|
||||
N_("Enable SSA optimizations") },
|
||||
{"dce", &flag_dce, 1,
|
||||
"Enable dead code elimination" },
|
||||
N_("Enable dead code elimination") },
|
||||
{"leading-underscore", &flag_leading_underscore, 1,
|
||||
"External symbols have a leading underscore" },
|
||||
N_("External symbols have a leading underscore") },
|
||||
{"ident", &flag_no_ident, 0,
|
||||
"Process #ident directives"},
|
||||
N_("Process #ident directives") },
|
||||
{ "peephole2", &flag_peephole2, 1,
|
||||
"Enables an rtl peephole pass run before sched2" },
|
||||
N_("Enables an rtl peephole pass run before sched2") },
|
||||
{ "guess-branch-probability", &flag_guess_branch_prob, 1,
|
||||
"Enables guessing of branch probabilities" },
|
||||
N_("Enables guessing of branch probabilities") },
|
||||
{"math-errno", &flag_errno_math, 1,
|
||||
"Set errno after built-in math functions"},
|
||||
N_("Set errno after built-in math functions") },
|
||||
{"trapping-math", &flag_trapping_math, 1,
|
||||
"Floating-point operations can trap"},
|
||||
N_("Floating-point operations can trap") },
|
||||
{"unsafe-math-optimizations", &flag_unsafe_math_optimizations, 1,
|
||||
"Allow math optimizations that may violate IEEE or ANSI standards"},
|
||||
N_("Allow math optimizations that may violate IEEE or ANSI standards") },
|
||||
{"bounded-pointers", &flag_bounded_pointers, 1,
|
||||
"Compile pointers as triples: value, base & end" },
|
||||
N_("Compile pointers as triples: value, base & end") },
|
||||
{"bounds-check", &flag_bounds_check, 1,
|
||||
"Generate code to check bounds before dereferencing pointers and arrays" },
|
||||
N_("Generate code to check bounds before dereferencing pointers and arrays") },
|
||||
{"single-precision-constant", &flag_single_precision_constant, 1,
|
||||
"Convert floating point constant to single precision constant"},
|
||||
N_("Convert floating point constant to single precision constant") },
|
||||
{"time-report", &time_report, 1,
|
||||
"Report time taken by each compiler pass at end of run"},
|
||||
N_("Report time taken by each compiler pass at end of run") },
|
||||
{"mem-report", &mem_report, 1,
|
||||
"Report on permanent memory allocation at end of run"},
|
||||
N_("Report on permanent memory allocation at end of run") },
|
||||
{ "trapv", &flag_trapv, 1,
|
||||
"Trap for signed overflow in addition / subtraction / multiplication." },
|
||||
N_("Trap for signed overflow in addition / subtraction / multiplication.") },
|
||||
};
|
||||
|
||||
/* Table of language-specific options. */
|
||||
|
|
@ -1190,129 +1190,167 @@ documented_lang_options[] =
|
|||
used here is to only describe those options which are not
|
||||
enabled by default. */
|
||||
|
||||
{ "-ansi", "Compile just for ISO C89" },
|
||||
{ "-ansi",
|
||||
N_("Compile just for ISO C89") },
|
||||
{ "-fallow-single-precision",
|
||||
"Do not promote floats to double if using -traditional" },
|
||||
{ "-std= ", "Determine language standard"},
|
||||
N_("Do not promote floats to double if using -traditional") },
|
||||
{ "-std= ",
|
||||
N_("Determine language standard") },
|
||||
|
||||
{ "-fsigned-bitfields", "" },
|
||||
{ "-funsigned-bitfields","Make bitfields by unsigned by default" },
|
||||
{ "-funsigned-bitfields",
|
||||
N_("Make bitfields by unsigned by default") },
|
||||
{ "-fno-signed-bitfields", "" },
|
||||
{ "-fno-unsigned-bitfields","" },
|
||||
{ "-fsigned-char", "Make 'char' be signed by default"},
|
||||
{ "-funsigned-char", "Make 'char' be unsigned by default"},
|
||||
{ "-fsigned-char",
|
||||
N_("Make 'char' be signed by default") },
|
||||
{ "-funsigned-char",
|
||||
N_("Make 'char' be unsigned by default") },
|
||||
{ "-fno-signed-char", "" },
|
||||
{ "-fno-unsigned-char", "" },
|
||||
|
||||
{ "-ftraditional", "" },
|
||||
{ "-traditional", "Attempt to support traditional K&R style C"},
|
||||
{ "-traditional",
|
||||
N_("Attempt to support traditional K&R style C") },
|
||||
{ "-fnotraditional", "" },
|
||||
{ "-fno-traditional", "" },
|
||||
|
||||
{ "-fasm", "" },
|
||||
{ "-fno-asm", "Do not recognise the 'asm' keyword" },
|
||||
{ "-fno-asm",
|
||||
N_("Do not recognise the 'asm' keyword") },
|
||||
{ "-fbuiltin", "" },
|
||||
{ "-fno-builtin", "Do not recognise any built in functions" },
|
||||
{ "-fhosted", "Assume normal C execution environment" },
|
||||
{ "-fno-builtin",
|
||||
N_("Do not recognise any built in functions") },
|
||||
{ "-fhosted",
|
||||
N_("Assume normal C execution environment") },
|
||||
{ "-fno-hosted", "" },
|
||||
{ "-ffreestanding",
|
||||
"Assume that standard libraries & main might not exist" },
|
||||
N_("Assume that standard libraries & main might not exist") },
|
||||
{ "-fno-freestanding", "" },
|
||||
{ "-fcond-mismatch", "Allow different types as args of ? operator"},
|
||||
{ "-fcond-mismatch",
|
||||
N_("Allow different types as args of ? operator") },
|
||||
{ "-fno-cond-mismatch", "" },
|
||||
{ "-fdollars-in-identifiers", "Allow the use of $ inside identifiers" },
|
||||
{ "-fdollars-in-identifiers",
|
||||
N_("Allow the use of $ inside identifiers") },
|
||||
{ "-fno-dollars-in-identifiers", "" },
|
||||
{ "-fpreprocessed", "" },
|
||||
{ "-fno-preprocessed", "" },
|
||||
{ "-fshort-double", "Use the same size for double as for float" },
|
||||
{ "-fshort-double",
|
||||
N_("Use the same size for double as for float") },
|
||||
{ "-fno-short-double", "" },
|
||||
{ "-fshort-enums", "Use the smallest fitting integer to hold enums"},
|
||||
{ "-fshort-enums",
|
||||
N_("Use the smallest fitting integer to hold enums") },
|
||||
{ "-fno-short-enums", "" },
|
||||
{ "-fshort-wchar", "Override the underlying type for wchar_t to `unsigned short'" },
|
||||
{ "-fshort-wchar",
|
||||
N_("Override the underlying type for wchar_t to `unsigned short'") },
|
||||
{ "-fno-short-wchar", "" },
|
||||
|
||||
{ "-Wall", "Enable most warning messages" },
|
||||
{ "-Wall",
|
||||
N_("Enable most warning messages") },
|
||||
{ "-Wbad-function-cast",
|
||||
"Warn about casting functions to incompatible types" },
|
||||
N_("Warn about casting functions to incompatible types") },
|
||||
{ "-Wno-bad-function-cast", "" },
|
||||
{ "-Wno-missing-noreturn", "" },
|
||||
{ "-Wmissing-format-attribute",
|
||||
"Warn about functions which might be candidates for format attributes" },
|
||||
N_("Warn about functions which might be candidates for format attributes") },
|
||||
{ "-Wno-missing-format-attribute", "" },
|
||||
{ "-Wcast-qual", "Warn about casts which discard qualifiers"},
|
||||
{ "-Wcast-qual",
|
||||
N_("Warn about casts which discard qualifiers") },
|
||||
{ "-Wno-cast-qual", "" },
|
||||
{ "-Wchar-subscripts", "Warn about subscripts whose type is 'char'"},
|
||||
{ "-Wchar-subscripts",
|
||||
N_("Warn about subscripts whose type is 'char'") },
|
||||
{ "-Wno-char-subscripts", "" },
|
||||
{ "-Wcomment", "Warn if nested comments are detected" },
|
||||
{ "-Wcomment",
|
||||
N_("Warn if nested comments are detected") },
|
||||
{ "-Wno-comment", "" },
|
||||
{ "-Wcomments", "Warn if nested comments are detected" },
|
||||
{ "-Wcomments",
|
||||
N_("Warn if nested comments are detected") },
|
||||
{ "-Wno-comments", "" },
|
||||
{ "-Wconversion", "Warn about possibly confusing type conversions" },
|
||||
{ "-Wconversion",
|
||||
N_("Warn about possibly confusing type conversions") },
|
||||
{ "-Wno-conversion", "" },
|
||||
{ "-Wformat", "Warn about printf/scanf/strftime/strfmon format anomalies" },
|
||||
{ "-Wformat",
|
||||
N_("Warn about printf/scanf/strftime/strfmon format anomalies") },
|
||||
{ "-Wno-format", "" },
|
||||
{ "-Wformat-y2k", "" },
|
||||
{ "-Wno-format-y2k",
|
||||
"Don't warn about strftime formats yielding 2 digit years" },
|
||||
N_("Don't warn about strftime formats yielding 2 digit years") },
|
||||
{ "-Wformat-extra-args", "" },
|
||||
{ "-Wno-format-extra-args",
|
||||
"Don't warn about too many arguments to format functions" },
|
||||
{ "-Wformat-nonliteral", "Warn about non-string-literal format strings" },
|
||||
N_("Don't warn about too many arguments to format functions") },
|
||||
{ "-Wformat-nonliteral",
|
||||
N_("Warn about non-string-literal format strings") },
|
||||
{ "-Wno-format-nonliteral", "" },
|
||||
{ "-Wformat-security",
|
||||
"Warn about possible security problems with format functions" },
|
||||
N_("Warn about possible security problems with format functions") },
|
||||
{ "-Wno-format-security", "" },
|
||||
{ "-Wimplicit-function-declaration",
|
||||
"Warn about implicit function declarations" },
|
||||
N_("Warn about implicit function declarations") },
|
||||
{ "-Wno-implicit-function-declaration", "" },
|
||||
{ "-Werror-implicit-function-declaration", "" },
|
||||
{ "-Wimplicit-int", "Warn when a declaration does not specify a type" },
|
||||
{ "-Wimplicit-int",
|
||||
N_("Warn when a declaration does not specify a type") },
|
||||
{ "-Wno-implicit-int", "" },
|
||||
{ "-Wimplicit", "" },
|
||||
{ "-Wno-implicit", "" },
|
||||
{ "-Wimport", "Warn about the use of the #import directive" },
|
||||
{ "-Wimport",
|
||||
N_("Warn about the use of the #import directive") },
|
||||
{ "-Wno-import", "" },
|
||||
{ "-Wlong-long","" },
|
||||
{ "-Wno-long-long", "Do not warn about using 'long long' when -pedantic" },
|
||||
{ "-Wmain", "Warn about suspicious declarations of main" },
|
||||
{ "-Wno-long-long",
|
||||
N_("Do not warn about using 'long long' when -pedantic") },
|
||||
{ "-Wmain",
|
||||
N_("Warn about suspicious declarations of main") },
|
||||
{ "-Wno-main", "" },
|
||||
{ "-Wmissing-braces",
|
||||
"Warn about possibly missing braces around initialisers" },
|
||||
N_("Warn about possibly missing braces around initialisers") },
|
||||
{ "-Wno-missing-braces", "" },
|
||||
{ "-Wmissing-declarations",
|
||||
"Warn about global funcs without previous declarations"},
|
||||
N_("Warn about global funcs without previous declarations") },
|
||||
{ "-Wno-missing-declarations", "" },
|
||||
{ "-Wmissing-prototypes", "Warn about global funcs without prototypes" },
|
||||
{ "-Wmissing-prototypes",
|
||||
N_("Warn about global funcs without prototypes") },
|
||||
{ "-Wno-missing-prototypes", "" },
|
||||
{ "-Wmultichar", "Warn about use of multicharacter literals"},
|
||||
{ "-Wmultichar",
|
||||
N_("Warn about use of multicharacter literals") },
|
||||
{ "-Wno-multichar", "" },
|
||||
{ "-Wnested-externs", "Warn about externs not at file scope level" },
|
||||
{ "-Wnested-externs",
|
||||
N_("Warn about externs not at file scope level") },
|
||||
{ "-Wno-nested-externs", "" },
|
||||
{ "-Wparentheses", "Warn about possible missing parentheses" },
|
||||
{ "-Wparentheses",
|
||||
N_("Warn about possible missing parentheses") },
|
||||
{ "-Wno-parentheses", "" },
|
||||
{ "-Wsequence-point",
|
||||
"Warn about possible violations of sequence point rules" },
|
||||
N_("Warn about possible violations of sequence point rules") },
|
||||
{ "-Wno-sequence-point", "" },
|
||||
{ "-Wpointer-arith", "Warn about function pointer arithmetic" },
|
||||
{ "-Wpointer-arith",
|
||||
N_("Warn about function pointer arithmetic") },
|
||||
{ "-Wno-pointer-arith", "" },
|
||||
{ "-Wredundant-decls",
|
||||
"Warn about multiple declarations of the same object" },
|
||||
N_("Warn about multiple declarations of the same object") },
|
||||
{ "-Wno-redundant-decls", "" },
|
||||
{ "-Wsign-compare", "Warn about signed/unsigned comparisons" },
|
||||
{ "-Wsign-compare",
|
||||
N_("Warn about signed/unsigned comparisons") },
|
||||
{ "-Wno-sign-compare", "" },
|
||||
{ "-Wfloat-equal", "Warn about testing equality of floating point numbers" },
|
||||
{ "-Wfloat-equal",
|
||||
N_("Warn about testing equality of floating point numbers") },
|
||||
{ "-Wno-float-equal", "" },
|
||||
{ "-Wunknown-pragmas", "Warn about unrecognized pragmas" },
|
||||
{ "-Wunknown-pragmas",
|
||||
N_("Warn about unrecognized pragmas") },
|
||||
{ "-Wno-unknown-pragmas", "" },
|
||||
{ "-Wstrict-prototypes", "Warn about non-prototyped function decls" },
|
||||
{ "-Wstrict-prototypes",
|
||||
N_("Warn about non-prototyped function decls") },
|
||||
{ "-Wno-strict-prototypes", "" },
|
||||
{ "-Wtraditional", "Warn about constructs whose meaning change in ISO C"},
|
||||
{ "-Wtraditional",
|
||||
N_("Warn about constructs whose meaning change in ISO C") },
|
||||
{ "-Wno-traditional", "" },
|
||||
{ "-Wtrigraphs", "Warn when trigraphs are encountered" },
|
||||
{ "-Wtrigraphs",
|
||||
N_("Warn when trigraphs are encountered") },
|
||||
{ "-Wno-trigraphs", "" },
|
||||
{ "-Wundef", "" },
|
||||
{ "-Wno-undef", "" },
|
||||
{ "-Wwrite-strings", "Mark strings as 'const char *'"},
|
||||
{ "-Wwrite-strings",
|
||||
N_("Mark strings as 'const char *'") },
|
||||
{ "-Wno-write-strings", "" },
|
||||
|
||||
#define DEFINE_LANG_NAME(NAME) { NULL, NAME },
|
||||
|
|
@ -1459,34 +1497,42 @@ int warn_missing_noreturn;
|
|||
|
||||
lang_independent_options W_options[] =
|
||||
{
|
||||
{"unused-function", &warn_unused_function, 1, "Warn when a function is unused" },
|
||||
{"unused-label", &warn_unused_label, 1, "Warn when a label is unused" },
|
||||
{"unused-parameter", &warn_unused_parameter, 1, "Warn when a function parameter is unused" },
|
||||
{"unused-variable", &warn_unused_variable, 1, "Warn when a variable is unused" },
|
||||
{"unused-value", &warn_unused_value, 1, "Warn when an expression value is unused" },
|
||||
{"system-headers", &warn_system_headers, 1, "Do not suppress warnings from system headers"},
|
||||
{"error", &warnings_are_errors, 1, ""},
|
||||
{"shadow", &warn_shadow, 1, "Warn when one local variable shadows another" },
|
||||
{"unused-function", &warn_unused_function, 1,
|
||||
N_("Warn when a function is unused") },
|
||||
{"unused-label", &warn_unused_label, 1,
|
||||
N_("Warn when a label is unused") },
|
||||
{"unused-parameter", &warn_unused_parameter, 1,
|
||||
N_("Warn when a function parameter is unused") },
|
||||
{"unused-variable", &warn_unused_variable, 1,
|
||||
N_("Warn when a variable is unused") },
|
||||
{"unused-value", &warn_unused_value, 1,
|
||||
N_("Warn when an expression value is unused") },
|
||||
{"system-headers", &warn_system_headers, 1,
|
||||
N_("Do not suppress warnings from system headers") },
|
||||
{"error", &warnings_are_errors, 1,
|
||||
N_("Treat all warnings as errors") },
|
||||
{"shadow", &warn_shadow, 1,
|
||||
N_("Warn when one local variable shadows another") },
|
||||
{"switch", &warn_switch, 1,
|
||||
"Warn about enumerated switches missing a specific case" },
|
||||
N_("Warn about enumerated switches missing a specific case") },
|
||||
{"aggregate-return", &warn_aggregate_return, 1,
|
||||
"Warn about returning structures, unions or arrays" },
|
||||
N_("Warn about returning structures, unions or arrays") },
|
||||
{"cast-align", &warn_cast_align, 1,
|
||||
"Warn about pointer casts which increase alignment" },
|
||||
N_("Warn about pointer casts which increase alignment") },
|
||||
{"unreachable-code", &warn_notreached, 1,
|
||||
"Warn about code that will never be executed" },
|
||||
N_("Warn about code that will never be executed") },
|
||||
{"uninitialized", &warn_uninitialized, 1,
|
||||
"Warn about unitialized automatic variables"},
|
||||
N_("Warn about unitialized automatic variables") },
|
||||
{"inline", &warn_inline, 1,
|
||||
"Warn when an inlined function cannot be inlined"},
|
||||
N_("Warn when an inlined function cannot be inlined") },
|
||||
{"packed", &warn_packed, 1,
|
||||
"Warn when the packed attribute has no effect on struct layout"},
|
||||
N_("Warn when the packed attribute has no effect on struct layout") },
|
||||
{"padded", &warn_padded, 1,
|
||||
"Warn when padding is required to align struct members"},
|
||||
N_("Warn when padding is required to align struct members") },
|
||||
{"disabled-optimization", &warn_disabled_optimization, 1,
|
||||
"Warn when an optimization pass is disabled"},
|
||||
N_("Warn when an optimization pass is disabled") },
|
||||
{"missing-noreturn", &warn_missing_noreturn, 1,
|
||||
"Warn about functions which might be candidates for attribute noreturn"}
|
||||
N_("Warn about functions which might be candidates for attribute noreturn") }
|
||||
};
|
||||
|
||||
/* The following routines are useful in setting all the flags that
|
||||
|
|
@ -3828,7 +3874,7 @@ display_help ()
|
|||
|
||||
if (description != NULL && * description != 0)
|
||||
printf (" -f%-21s %s\n",
|
||||
f_options[i].string, description);
|
||||
f_options[i].string, _(description));
|
||||
}
|
||||
|
||||
printf (_(" -O[number] Set optimisation level to [number]\n"));
|
||||
|
|
@ -3842,7 +3888,7 @@ display_help ()
|
|||
printf (" --param %s=<value>%.*s%s\n",
|
||||
compiler_params[i].option,
|
||||
length > 0 ? length : 1, " ",
|
||||
description);
|
||||
_(description));
|
||||
}
|
||||
printf (_(" -pedantic Issue warnings needed by strict compliance to ISO C\n"));
|
||||
printf (_(" -pedantic-errors Like -pedantic except that errors are produced\n"));
|
||||
|
|
@ -3855,7 +3901,7 @@ display_help ()
|
|||
|
||||
if (description != NULL && * description != 0)
|
||||
printf (" -W%-21s %s\n",
|
||||
W_options[i].string, description);
|
||||
W_options[i].string, _(description));
|
||||
}
|
||||
|
||||
printf (_(" -Wunused Enable unused warnings\n"));
|
||||
|
|
@ -3877,7 +3923,7 @@ display_help ()
|
|||
{
|
||||
if (debug_args[i].description != NULL)
|
||||
printf (" -g%-21s %s\n",
|
||||
debug_args[i].arg, debug_args[i].description);
|
||||
debug_args[i].arg, _(debug_args[i].description));
|
||||
}
|
||||
|
||||
printf (_(" -aux-info <file> Emit declaration info into <file>.X\n"));
|
||||
|
|
@ -3932,7 +3978,7 @@ display_help ()
|
|||
lang = description;
|
||||
}
|
||||
else
|
||||
printf (" %-23.23s %s\n", option, description);
|
||||
printf (" %-23.23s %s\n", option, _(description));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3975,7 +4021,7 @@ display_target_options ()
|
|||
printf (_(" -m%-23.23s [undocumented]\n"), option);
|
||||
}
|
||||
else if (* description != 0)
|
||||
doc += printf (" -m%-23.23s %s\n", option, description);
|
||||
doc += printf (" -m%-23.23s %s\n", option, _(description));
|
||||
}
|
||||
|
||||
#ifdef TARGET_OPTIONS
|
||||
|
|
@ -3994,7 +4040,7 @@ display_target_options ()
|
|||
printf (_(" -m%-23.23s [undocumented]\n"), option);
|
||||
}
|
||||
else if (* description != 0)
|
||||
doc += printf (" -m%-23.23s %s\n", option, description);
|
||||
doc += printf (" -m%-23.23s %s\n", option, _(description));
|
||||
}
|
||||
#endif
|
||||
if (undoc)
|
||||
|
|
|
|||
Loading…
Reference in New Issue