From: Zack Weinberg Date: Sat, 26 May 2001 05:28:26 +0000 (+0000) Subject: toplev.c (debug_args, [...]): Mark descriptions for translation. X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a63719408d011cff3a51cdfaceb61c34f1d9c38e;p=platform%2Fupstream%2Fgcc.git 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 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 8f000fb..c06c14f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,12 @@ 2001-05-25 Zack Weinberg + * 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. diff --git a/gcc/cp/lang-options.h b/gcc/cp/lang-options.h index 01b0fc3..d023248 100644 --- a/gcc/cp/lang-options.h +++ b/gcc/cp/lang-options.h @@ -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") }, diff --git a/gcc/f/lang-options.h b/gcc/f/lang-options.h index 7d50193..a740283 100644 --- a/gcc/f/lang-options.h +++ b/gcc/f/lang-options.h @@ -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 diff --git a/gcc/java/lang-options.h b/gcc/java/lang-options.h index e41e8a6..c15946e 100644 --- a/gcc/java/lang-options.h +++ b/gcc/java/lang-options.h @@ -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 .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 .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") }, diff --git a/gcc/objc/lang-options.h b/gcc/objc/lang-options.h index 3d56b96..88e30e5 100644 --- a/gcc/objc/lang-options.h +++ b/gcc/objc/lang-options.h @@ -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") }, diff --git a/gcc/toplev.c b/gcc/toplev.c index 74b43de..2a7f681 100644 --- a/gcc/toplev.c +++ b/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=%.*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 Emit declaration info into .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)