diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog
index 6ecb1bb27a5..458ae8a7549 100644
--- a/gcc/po/ChangeLog
+++ b/gcc/po/ChangeLog
@@ -1,3 +1,9 @@
+2000-06-27  Philipp Thomas  <pthomas@suse.de>
+
+	* POTFILES.in: Add diagnostic.c .
+	* gcc.pot: Regenerate.
+	* cat-id-tbl.c: Regenerate.
+
 2000-06-19  Philipp Thomas  <pthomas@suse.de>
 
 	* POTFILES.in: change entries for dyn-string.[ch]
diff --git a/gcc/po/cat-id-tbl.c b/gcc/po/cat-id-tbl.c
index bf6c2cc011c..82c4a54f008 100644
--- a/gcc/po/cat-id-tbl.c
+++ b/gcc/po/cat-id-tbl.c
@@ -8,859 +8,1805 @@
 
 const struct _msg_ent _msg_tbl[] = {
   {"", 1},
-  {"wrong number of arguments specified for `%s' attribute", 2},
-  {"unknown machine mode `%s'", 3},
-  {"no data type for mode `%s'", 4},
-  {"requested alignment is not a constant", 5},
-  {"requested alignment is not a power of 2", 6},
-  {"requested alignment is too large", 7},
-  {"unrecognized format specifier", 8},
-  {"format string has invalid operand number", 9},
-  {"format string arg follows the args to be formatted", 10},
-  {"format string arg not a string type", 11},
-  {"args to be formatted is not '...'", 12},
-  {"function does not return string type", 13},
-  {"alias arg not a string", 14},
-  {"expression statement has incomplete type", 15},
-  {"case label does not reduce to an integer constant", 16},
-  {"invalid truth-value expression", 17},
-  {"invalid operands to binary %s", 18},
-  {"struct type value used where scalar is required", 19},
-  {"union type value used where scalar is required", 20},
-  {"array type value used where scalar is required", 21},
-  {"invalid use of `restrict'", 22},
-  {"too few arguments to function `%s'", 23},
-  {"too many arguments to function `%s'", 24},
-  {"void value not ignored as it ought to be", 25},
-  {"conversion to non-scalar type requested", 26},
-  {"unknown C standard `%s'", 27},
-  {"`struct %s' incomplete in scope ending here", 28},
-  {"`union %s' incomplete in scope ending here", 29},
-  {"`enum %s' incomplete in scope ending here", 30},
+  {"`%s' attribute directive ignored", 2},
+  {"`%s' attribute does not apply to types", 3},
+  {"wrong number of arguments specified for `%s' attribute", 4},
+  {"`%s' attribute ignored", 5},
+  {"unknown machine mode `%s'", 6},
+  {"no data type for mode `%s'", 7},
+  {"section attribute cannot be specified for local variables", 8},
+  {"section of `%s' conflicts with previous declaration", 9},
+  {"section attribute not allowed for `%s'", 10},
+  {"section attributes are not supported for this target", 11},
+  {"requested alignment is not a constant", 12},
+  {"requested alignment is not a power of 2", 13},
+  {"requested alignment is too large", 14},
+  {"alignment may not be specified for `%s'", 15},
+  {"argument format specified for non-function `%s'", 16},
+  {"unrecognized format specifier", 17},
+  {"`%s' is an unrecognized format function type", 18},
+  {"format string has invalid operand number", 19},
+  {"format string arg follows the args to be formatted", 20},
+  {"format string arg not a string type", 21},
+  {"args to be formatted is not '...'", 22},
+  {"function does not return string type", 23},
+  {"`%s' defined both normally and as an alias", 24},
+  {"alias arg not a string", 25},
+  {"`%s' attribute applies only to functions", 26},
+  {"can't set `%s' attribute after definition", 27},
+  {"too few arguments for format", 28},
+  {"null format string", 29},
+  {"format not a string literal, argument types not checked", 30},
+  {"zero-length format string", 31},
+  {"unterminated format string", 32},
+  {"embedded `\\0' in format", 33},
+  {"too many arguments for format", 34},
+  {"spurious trailing `%%' in format", 35},
+  {"ANSI C does not support the strftime `%c' flag", 36},
+  {"repeated `%c' flag in format", 37},
+  {"ANSI C does not support strftime format width", 38},
+  {"multiple E/O modifiers in format", 39},
+  {"operand number out of range in format", 40},
+  {"use of both ` ' and `+' flags in format", 41},
+  {"use of both `0' and `-' flags in format", 42},
+  {"field width is not type int (arg %d)", 43},
+  {"`.' not followed by `*' or digit in format", 44},
+  {"ANSI C does not support the `%c' length modifier", 45},
+  {"ANSI C does not support the `ll' length modifier", 46},
+  {"ANSI C does not support the `hh' length modifier", 47},
+  {"use of `*' and `%c' together in format", 48},
+  {"conversion lacks type at end of format", 49},
+  {"ANSI C does not support the `%c' format", 50},
+  {"unknown conversion type character `%c' in format", 51},
+  {"unknown conversion type character 0x%x in format", 52},
+  {"ANSI C does not support `%%%c'", 53},
+  {"ANSI C does not support `%%O%c'", 54},
+  {"width used with `%c' format", 55},
+  {"`%%%c' yields only last 2 digits of year", 56},
+  {"`%%%c' yields only last 2 digits of year in some locales", 57},
+  {"precision used with `%c' format", 58},
+  {"`a' flag used with `%c' format", 59},
+  {"ANSI C does not support the `a' flag", 60},
+  {"no closing `]' for `%%[' format", 61},
+  {"suppression of `%c' conversion in format", 62},
+  {"flag `%c' used with type `%c'", 63},
+  {"`0' flag ignored with precision specifier and `%c' format", 64},
+  {"use of `%c' length character with `%c' type character", 65},
+  {"format argument is not a pointer (arg %d)", 66},
+  {"format argument is not a pointer to a pointer (arg %d)", 67},
+  {"writing into constant object (arg %d)", 68},
+  {"%s format, %s arg (arg %d)", 69},
+  {"overflow in constant expression", 70},
+  {"integer overflow in expression", 71},
+  {"floating point overflow in expression", 72},
+  {"large integer implicitly truncated to unsigned type", 73},
+  {"negative integer implicitly converted to unsigned type", 74},
+  {"overflow in implicit constant conversion", 75},
+  {"expression statement has incomplete type", 76},
+  {"case label does not reduce to an integer constant", 77},
+  {"invalid truth-value expression", 78},
+  {"invalid operands to binary %s", 79},
+  {"comparison is always false due to limited range of data type", 80},
+  {"comparison is always true due to limited range of data type", 81},
+  {"comparison of unsigned expression >= 0 is always true", 82},
+  {"comparison of unsigned expression < 0 is always false", 83},
+  {"struct type value used where scalar is required", 84},
+  {"union type value used where scalar is required", 85},
+  {"array type value used where scalar is required", 86},
+  {"suggest parentheses around assignment used as truth value", 87},
+  {"invalid use of `restrict'", 88},
+  {"too few arguments to function `%s'", 89},
+  {"too many arguments to function `%s'", 90},
+  {"void value not ignored as it ought to be", 91},
+  {"conversion to non-scalar type requested", 92},
+  {"unknown C standard `%s'", 93},
+  {"array `%s' assumed to have one element", 94},
+  {"`struct %s' incomplete in scope ending here", 95},
+  {"`union %s' incomplete in scope ending here", 96},
+  {"`enum %s' incomplete in scope ending here", 97},
+  {"label `%s' used but not defined", 98},
+  {"label `%s' defined but not used", 99},
+  {"shadowing built-in function `%s'", 100},
+  {"shadowing library function `%s'", 101},
+  {"library function `%s' declared as non-function", 102},
+  {"built-in function `%s' declared as non-function", 103},
+  {"`%s' redeclared as different kind of symbol", 104},
+  {"previous declaration of `%s'", 105},
+  {"conflicting types for built-in function `%s'", 106},
+  {"conflicting types for `%s'", 107},
   {"\
 A parameter list with an ellipsis can't match an empty parameter name list \
-declaration.", 31},
+declaration.", 108},
   {"\
 An argument type that has a default promotion can't match an empty parameter \
-name list declaration.", 32},
-  {"implicit declaration of function `%s'", 33},
-  {"label %s referenced outside of any function", 34},
-  {"duplicate label declaration `%s'", 35},
-  {"duplicate label `%s'", 36},
-  {"two types specified in one empty declaration", 37},
-  {"typedef `%s' is initialized", 38},
-  {"function `%s' is initialized like a variable", 39},
-  {"parameter `%s' is initialized", 40},
-  {"variable-sized object may not be initialized", 41},
-  {"variable `%s' has initializer but incomplete type", 42},
-  {"elements of array `%s' have incomplete type", 43},
-  {"`long long long' is too long for GCC", 44},
-  {"two or more data types in declaration of `%s'", 45},
-  {"`%s' fails to be a typedef or built in type", 46},
-  {"both long and short specified for `%s'", 47},
-  {"long or short specified with char for `%s'", 48},
-  {"long or short specified with floating type for `%s'", 49},
-  {"the only valid combination is `long double'", 50},
-  {"both signed and unsigned specified for `%s'", 51},
-  {"long, short, signed or unsigned invalid for `%s'", 52},
-  {"complex invalid for `%s'", 53},
-  {"multiple storage classes in declaration of `%s'", 54},
-  {"function definition declared `register'", 55},
-  {"function definition declared `typedef'", 56},
-  {"storage class specified for structure field `%s'", 57},
-  {"storage class specified for parameter `%s'", 58},
-  {"storage class specified for typename", 59},
-  {"`%s' has both `extern' and initializer", 60},
-  {"nested function `%s' declared `extern'", 61},
-  {"top-level declaration of `%s' specifies `auto'", 62},
-  {"iterator `%s' has derived type", 63},
-  {"iterator `%s' has noninteger type", 64},
-  {"declaration of `%s' as array of voids", 65},
-  {"declaration of `%s' as array of functions", 66},
-  {"size of array `%s' has non-integer type", 67},
-  {"size of array `%s' is negative", 68},
-  {"size of array `%s' is too large", 69},
-  {"`%s' declared as function returning a function", 70},
-  {"`%s' declared as function returning an array", 71},
-  {"invalid type modifier within pointer declarator", 72},
-  {"variable or field `%s' declared void", 73},
-  {"field `%s' declared as a function", 74},
-  {"field `%s' has incomplete type", 75},
-  {"invalid storage class for function `%s'", 76},
-  {"parameter `%s' has incomplete type", 77},
-  {"`void' in parameter list must be the entire list", 78},
-  {"redefinition of `%s %s'", 79},
-  {"nested redefinition of `%s'", 80},
-  {"redeclaration of `enum %s'", 81},
-  {"enumerator value for `%s' not integer constant", 82},
-  {"overflow in enumeration values", 83},
-  {"return-type is an incomplete type", 84},
-  {"number of arguments doesn't match prototype", 85},
-  {"argument `%s' doesn't match prototype", 86},
-  {"stray '\\' in program", 87},
-  {"invalid #-line", 88},
-  {"invalid #ident", 89},
-  {"undefined or invalid # directive `%s'", 90},
-  {"invalid #line", 91},
-  {"#-lines for entering and leaving files don't match", 92},
-  {"%s at end of input", 93},
-  {"%s at null character", 94},
-  {"%s before string constant", 95},
-  {"%s before character constant", 96},
-  {"%s before character 0%o", 97},
-  {"%s before `%s'", 98},
-  {"more than one `f' in numeric constant", 99},
-  {"more than one `l' in numeric constant", 100},
-  {"more than one `i' or `j' in numeric constant", 101},
-  {"both `f' and `l' in floating constant", 102},
-  {"`$' in identifier", 103},
-  {"invalid identifier `%s'", 104},
-  {"parse error at `..'", 105},
-  {"malformed floating constant", 106},
-  {"nondigits in number and not hexadecimal", 107},
-  {"numeric constant with no digits", 108},
-  {"numeric constant contains digits beyond the radix", 109},
-  {"floating constant exponent has no digits", 110},
-  {"hexadecimal floating constant has no exponent", 111},
-  {"floating constant out of range", 112},
-  {"two `u's in integer constant", 113},
-  {"three `l's in integer constant", 114},
-  {"complex integer constant is too wide for `complex int'", 115},
-  {"missing white space after number `%s'", 116},
-  {"malformed character constant", 117},
-  {"empty character constant", 118},
-  {"character constant too long", 119},
-  {"Unterminated string constant", 120},
-  {"syntax error", 121},
-  {"syntax error: cannot back up", 122},
-  {"parser stack overflow", 123},
-  {"argument of `asm' is not a constant string", 124},
-  {"ANSI C forbids data definition with no type or storage class", 125},
-  {"`sizeof' applied to a bit-field", 126},
-  {"`%s' undeclared here (not in a function)", 127},
-  {"`%s' undeclared (first use in this function)", 128},
-  {"(Each undeclared identifier is reported only once", 129},
-  {"for each function it appears in.)", 130},
-  {"`%s' implicitly declared as function", 131},
-  {"`[*]' in parameter declaration only allowed in ISO C 99", 132},
-  {"braced-group within expression allowed only inside a function", 133},
-  {"break statement not within loop or switch", 134},
-  {"continue statement not within a loop", 135},
-  {"invalid `for (ITERATOR)' syntax", 136},
-  {"`%s' is not an iterator", 137},
-  {"`for (%s)' inside expansion of same iterator", 138},
-  {"case label not within a switch statement", 139},
-  {"duplicate case value", 140},
-  {"case label within scope of cleanup or variable array", 141},
-  {"default label not within a switch statement", 142},
-  {"multiple default labels in one switch", 143},
-  {"ANSI C requires a named argument before `...'", 144},
-  {"`...' in old-style identifier list", 145},
-  {"parse error; also virtual memory exceeded", 146},
-  {"parse error", 147},
-  {"`%s' has an incomplete type", 148},
-  {"invalid use of void expression", 149},
-  {"invalid use of array with unspecified bounds", 150},
-  {"invalid use of undefined type `%s %s'", 151},
-  {"invalid use of incomplete typedef `%s'", 152},
-  {"sizeof applied to an incomplete type", 153},
-  {"arithmetic on pointer to an incomplete type", 154},
-  {"__alignof__ applied to an incomplete type", 155},
-  {"`__alignof' applied to a bit-field", 156},
-  {"invalid use of non-lvalue array", 157},
-  {"%s has no member named `%s'", 158},
-  {"request for member `%s' in something not a structure or union", 159},
-  {"dereferencing pointer to incomplete type", 160},
-  {"invalid type argument of `%s'", 161},
-  {"subscript missing in array reference", 162},
-  {"array subscript is not an integer", 163},
-  {"subscripted value is neither array nor pointer", 164},
-  {"called object is not a function", 165},
-  {"too many arguments to function", 166},
-  {"type of formal parameter %d is incomplete", 167},
-  {"%s as integer rather than floating due to prototype", 168},
-  {"%s as complex rather than floating due to prototype", 169},
-  {"%s as floating rather than integer due to prototype", 170},
-  {"%s as floating rather than complex due to prototype", 171},
-  {"%s as `float' rather than `double' due to prototype", 172},
-  {"%s with different width due to prototype", 173},
-  {"%s as unsigned due to prototype", 174},
-  {"%s as signed due to prototype", 175},
-  {"too few arguments to function", 176},
-  {"unordered comparison on non-floating point argument", 177},
-  {"wrong type argument to unary plus", 178},
-  {"wrong type argument to unary minus", 179},
-  {"wrong type argument to bit-complement", 180},
-  {"wrong type argument to abs", 181},
-  {"wrong type argument to conjugation", 182},
-  {"wrong type argument to unary exclamation mark", 183},
-  {"wrong type argument to %s", 184},
-  {"%s of pointer to unknown structure", 185},
-  {"invalid lvalue in increment", 186},
-  {"invalid lvalue in decrement", 187},
-  {"increment", 188},
-  {"decrement", 189},
-  {"invalid lvalue in unary `&'", 190},
-  {"attempt to take address of bit-field structure member `%s'", 191},
-  {"%s", 192},
-  {"cannot take address of bitfield `%s'", 193},
-  {"global register variable `%s' used in nested function", 194},
-  {"address of global register variable `%s' requested", 195},
-  {"cannot put object with volatile field into register", 196},
-  {"type mismatch in conditional expression", 197},
-  {"cast specifies array type", 198},
-  {"cast specifies function type", 199},
-  {"cast to union type from type not present in union", 200},
-  {"invalid lvalue in assignment", 201},
-  {"assignment", 202},
-  {"%s makes qualified function pointer from unqualified", 203},
-  {"%s discards qualifiers from pointer target type", 204},
-  {"ANSI forbids %s between function pointer and `void *'", 205},
-  {"pointer targets in %s differ in signedness", 206},
-  {"%s from incompatible pointer type", 207},
-  {"%s makes pointer from integer without a cast", 208},
-  {"%s makes integer from pointer without a cast", 209},
-  {"incompatible type for argument %d of `%s'", 210},
-  {"incompatible type for argument %d of indirect function call", 211},
-  {"incompatible types in %s", 212},
-  {"passing arg %d of `%s'", 213},
-  {"passing arg %d of pointer to function", 214},
-  {"initializer for static variable is not constant", 215},
-  {"initializer for static variable uses complicated arithmetic", 216},
-  {"(near initialization for `%s')", 217},
-  {"char-array initialized from wide string", 218},
-  {"int-array initialized from non-wide string", 219},
-  {"initializer-string for array of chars is too long", 220},
-  {"array initialized from non-constant array expression", 221},
-  {"initializer element is not constant", 222},
-  {"initializer element is not computable at load time", 223},
-  {"initialization", 224},
-  {"invalid initializer", 225},
-  {"extra brace group at end of initializer", 226},
-  {"missing braces around initializer", 227},
-  {"braces around scalar initializer", 228},
-  {"missing initializer", 229},
-  {"empty braces in initializer", 230},
-  {"empty scalar initializer", 231},
-  {"extra elements in scalar initializer", 232},
-  {"nonconstant array index in initializer", 233},
-  {"array index in non-array initializer", 234},
-  {"duplicate array index in initializer", 235},
-  {"empty index range in initializer", 236},
-  {"unknown field `%s' specified in initializer", 237},
-  {"field `%s' already initialized", 238},
-  {"duplicate initializer", 239},
-  {"excess elements in char array initializer", 240},
-  {"excess elements in struct initializer", 241},
-  {"excess elements in union initializer", 242},
-  {"excess elements in array initializer", 243},
-  {"excess elements in scalar initializer", 244},
-  {"asm template is not a string constant", 245},
-  {"invalid lvalue in asm statement", 246},
-  {"modification by `asm'", 247},
-  {"return", 248},
-  {"switch quantity not an integer", 249},
-  {"internal error", 250},
-  {"no arguments", 251},
-  {"fopen %s", 252},
-  {"fclose %s", 253},
-  {"collect2 version %s", 254},
-  {"%d constructor(s) found\n", 255},
-  {"%d destructor(s)  found\n", 256},
-  {"%d frame table(s) found\n", 257},
-  {"%s terminated with signal %d [%s]%s", 258},
-  {"%s returned %d exit status", 259},
-  {"[cannot find %s]", 260},
-  {"cannot find `%s'", 261},
-  {"redirecting stdout: %s", 262},
-  {"[Leaving %s]\n", 263},
+name list declaration.", 109},
+  {"redefinition of `%s'", 110},
+  {"redeclaration of `%s'", 111},
+  {"conflicting declarations of `%s'", 112},
+  {"`%s' previously defined here", 113},
+  {"`%s' previously declared here", 114},
+  {"prototype for `%s' follows", 115},
+  {"non-prototype definition here", 116},
+  {"prototype for `%s' follows and number of arguments doesn't match", 117},
+  {"prototype for `%s' follows and argument %d doesn't match", 118},
+  {"`%s' declared inline after being called", 119},
+  {"`%s' declared inline after its definition", 120},
+  {"static declaration for `%s' follows non-static", 121},
+  {"non-static declaration for `%s' follows static", 122},
+  {"const declaration for `%s' follows non-const", 123},
+  {"type qualifiers for `%s' conflict with previous decl", 124},
+  {"redundant redeclaration of `%s' in same scope", 125},
+  {"nested extern declaration of `%s'", 126},
+  {"`%s' used prior to declaration", 127},
+  {"`%s' was declared implicitly `extern' and later `static'", 128},
+  {"type mismatch with previous external decl", 129},
+  {"previous external decl of `%s'", 130},
+  {"type mismatch with previous implicit declaration", 131},
+  {"previous implicit declaration of `%s'", 132},
+  {"type of external `%s' is not global", 133},
+  {"`%s' was previously implicitly declared to return `int'", 134},
+  {"`%s' was declared `extern' and later `static'", 135},
+  {"extern declaration of `%s' doesn't match global one", 136},
+  {"`%s' locally external but globally static", 137},
+  {"declaration of `%s' shadows a parameter", 138},
+  {"declaration of `%s' shadows a symbol from the parameter list", 139},
+  {"declaration of `%s' shadows previous local", 140},
+  {"declaration of `%s' shadows global declaration", 141},
+  {"implicit declaration of function `%s'", 142},
+  {"function `%s' was previously declared within a block", 143},
+  {"label %s referenced outside of any function", 144},
+  {"duplicate label declaration `%s'", 145},
+  {"this is a previous declaration", 146},
+  {"duplicate label `%s'", 147},
+  {"unnamed struct/union that defines no instances", 148},
+  {"useless keyword or type name in empty declaration", 149},
+  {"two types specified in one empty declaration", 150},
+  {"empty declaration", 151},
+  {"`%s' is usually a function", 152},
+  {"typedef `%s' is initialized", 153},
+  {"function `%s' is initialized like a variable", 154},
+  {"parameter `%s' is initialized", 155},
+  {"variable-sized object may not be initialized", 156},
+  {"variable `%s' has initializer but incomplete type", 157},
+  {"elements of array `%s' have incomplete type", 158},
+  {"declaration of `%s' has `extern' and is initialized", 159},
+  {"iterator has no initial value", 160},
+  {"initializer fails to determine size of `%s'", 161},
+  {"array size missing in `%s'", 162},
+  {"zero or negative size array `%s'", 163},
+  {"storage size of `%s' isn't known", 164},
+  {"storage size of `%s' isn't constant", 165},
+  {"ANSI C forbids parameter `%s' shadowing typedef", 166},
+  {"`long long long' is too long for GCC", 167},
+  {"ANSI C does not support `long long'", 168},
+  {"duplicate `%s'", 169},
+  {"two or more data types in declaration of `%s'", 170},
+  {"`%s' fails to be a typedef or built in type", 171},
+  {"type defaults to `int' in declaration of `%s'", 172},
+  {"both long and short specified for `%s'", 173},
+  {"long or short specified with char for `%s'", 174},
+  {"long or short specified with floating type for `%s'", 175},
+  {"the only valid combination is `long double'", 176},
+  {"both signed and unsigned specified for `%s'", 177},
+  {"long, short, signed or unsigned invalid for `%s'", 178},
+  {"long, short, signed or unsigned used invalidly for `%s'", 179},
+  {"complex invalid for `%s'", 180},
+  {"duplicate `const'", 181},
+  {"duplicate `restrict'", 182},
+  {"duplicate `volatile'", 183},
+  {"multiple storage classes in declaration of `%s'", 184},
+  {"function definition declared `auto'", 185},
+  {"function definition declared `register'", 186},
+  {"function definition declared `typedef'", 187},
+  {"storage class specified for structure field `%s'", 188},
+  {"storage class specified for parameter `%s'", 189},
+  {"storage class specified for typename", 190},
+  {"`%s' initialized and declared `extern'", 191},
+  {"`%s' has both `extern' and initializer", 192},
+  {"nested function `%s' declared `extern'", 193},
+  {"top-level declaration of `%s' specifies `auto'", 194},
+  {"iterator `%s' has derived type", 195},
+  {"iterator `%s' has noninteger type", 196},
+  {"declaration of `%s' as array of voids", 197},
+  {"declaration of `%s' as array of functions", 198},
+  {"size of array `%s' has non-integer type", 199},
+  {"ANSI C forbids zero-size array `%s'", 200},
+  {"size of array `%s' is negative", 201},
+  {"ANSI C forbids array `%s' whose size can't be evaluated", 202},
+  {"ANSI C forbids variable-size array `%s'", 203},
+  {"size of array `%s' is too large", 204},
+  {"array type has incomplete element type", 205},
+  {"ANSI C forbids const or volatile function types", 206},
+  {"`%s' declared as function returning a function", 207},
+  {"`%s' declared as function returning an array", 208},
+  {"ANSI C forbids qualified function types", 209},
+  {"invalid type modifier within pointer declarator", 210},
+  {"variable or field `%s' declared void", 211},
+  {"field `%s' declared as a function", 212},
+  {"field `%s' has incomplete type", 213},
+  {"invalid storage class for function `%s'", 214},
+  {"ANSI C forbids qualified void function return type", 215},
+  {"`noreturn' function returns non-void value", 216},
+  {"cannot inline function `main'", 217},
+  {"variable `%s' declared `inline'", 218},
+  {"function declaration isn't a prototype", 219},
+  {"parameter names (without types) in function declaration", 220},
+  {"parameter `%s' has incomplete type", 221},
+  {"parameter has incomplete type", 222},
+  {"parameter `%s' points to incomplete type", 223},
+  {"parameter points to incomplete type", 224},
+  {"parameter `%s' has just a forward declaration", 225},
+  {"`void' in parameter list must be the entire list", 226},
+  {"`%s %s' declared inside parameter list", 227},
+  {"anonymous struct declared inside parameter list", 228},
+  {"anonymous union declared inside parameter list", 229},
+  {"anonymous enum declared inside parameter list", 230},
+  {"\
+its scope is only this definition or declaration, which is probably not what \
+you want.", 231},
+  {"ANSI C forbids forward references to `enum' types", 232},
+  {"redefinition of `%s %s'", 233},
+  {"%s defined inside parms", 234},
+  {"union defined inside parms", 235},
+  {"structure defined inside parms", 236},
+  {"%s has no %s", 237},
+  {"union", 238},
+  {"struct", 239},
+  {"named members", 240},
+  {"members", 241},
+  {"nested redefinition of `%s'", 242},
+  {"bit-field `%s' width not an integer constant", 243},
+  {"bit-field `%s' has invalid type", 244},
+  {"bit-field `%s' type invalid in ANSI C", 245},
+  {"negative width in bit-field `%s'", 246},
+  {"width of `%s' exceeds its type", 247},
+  {"zero width for bit-field `%s'", 248},
+  {"`%s' is narrower than values of its type", 249},
+  {"duplicate member `%s'", 250},
+  {"union cannot be made transparent", 251},
+  {"redeclaration of `enum %s'", 252},
+  {"enum defined inside parms", 253},
+  {"enumeration values exceed range of largest integer", 254},
+  {"enumerator value for `%s' not integer constant", 255},
+  {"overflow in enumeration values", 256},
+  {"ANSI C restricts enumerator values to range of `int'", 257},
+  {"return type is an incomplete type", 258},
+  {"return type defaults to `int'", 259},
+  {"no previous prototype for `%s'", 260},
+  {"`%s' was used with no prototype before its definition", 261},
+  {"no previous declaration for `%s'", 262},
+  {"`%s' was used with no declaration before its definition", 263},
+  {"return type of `%s' is not `int'", 264},
+  {"first argument of `%s' should be `int'", 265},
+  {"second argument of `%s' should be `char **'", 266},
+  {"third argument of `%s' should probably be `char **'", 267},
+  {"`%s' takes only zero or two arguments", 268},
+  {"third argument of `%s' is deprecated", 269},
+  {"`%s' is normally a non-static function", 270},
+  {"parm types given both in parmlist and separately", 271},
+  {"parameter name omitted", 272},
+  {"parameter `%s' declared void", 273},
+  {"parameter name missing from parameter list", 274},
+  {"multiple parameters named `%s'", 275},
+  {"type of `%s' defaults to `int'", 276},
+  {"declaration for parameter `%s' but no such parameter", 277},
+  {"number of arguments doesn't match prototype", 278},
+  {"promoted argument `%s' doesn't match prototype", 279},
+  {"argument `%s' doesn't match prototype", 280},
+  {"type of parameter `%s' is not declared", 281},
+  {"function might be possible candidate for attribute `noreturn'", 282},
+  {"`noreturn' function does return", 283},
+  {"control reaches end of non-void function", 284},
+  {"this function may return with or without a value", 285},
+  {"size of return value of `%s' is %u bytes", 286},
+  {"size of return value of `%s' is larger than %d bytes", 287},
+  {"`for (%s)' appears within implicit iteration", 288},
+  {"carriage return in source file", 289},
+  {"(we only warn about the first carriage return)", 290},
+  {"stray '\\' in program", 291},
+  {"invalid #-line", 292},
+  {"ignoring pragma: %s", 293},
+  {"invalid #ident", 294},
+  {"undefined or invalid # directive `%s'", 295},
+  {"invalid #line", 296},
+  {"#-lines for entering and leaving files don't match", 297},
+  {"the meaning of `\\x' varies with -traditional", 298},
+  {"\\x used with no following hex digits", 299},
+  {"hex escape out of range", 300},
+  {"the meaning of `\\a' varies with -traditional", 301},
+  {"non-ANSI-standard escape sequence, `\\%c'", 302},
+  {"unknown escape sequence `\\%c'", 303},
+  {"unknown escape sequence: `\\' followed by char code 0x%x", 304},
+  {"%s at end of input", 305},
+  {"%s at null character", 306},
+  {"%s before string constant", 307},
+  {"%s before character constant", 308},
+  {"%s before character 0%o", 309},
+  {"%s before `%s'", 310},
+  {"more than one `f' in numeric constant", 311},
+  {"more than one `l' in numeric constant", 312},
+  {"more than one `i' or `j' in numeric constant", 313},
+  {"ANSI C forbids imaginary numeric constants", 314},
+  {"both `f' and `l' in floating constant", 315},
+  {"floating point number exceeds range of `float'", 316},
+  {"floating point number exceeds range of `long double'", 317},
+  {"floating point number exceeds range of `double'", 318},
+  {"`$' in identifier", 319},
+  {"ANSI does not permit the keyword `%s'", 320},
+  {"invalid identifier `%s'", 321},
+  {"parse error at `..'", 322},
+  {"floating constant may not be in radix 16", 323},
+  {"malformed floating constant", 324},
+  {"nondigits in number and not hexadecimal", 325},
+  {"numeric constant with no digits", 326},
+  {"numeric constant contains digits beyond the radix", 327},
+  {"floating constant exponent has no digits", 328},
+  {"hexadecimal floating constant has no exponent", 329},
+  {"floating constant out of range", 330},
+  {"two `u's in integer constant", 331},
+  {"three `l's in integer constant", 332},
+  {"ANSI C forbids long long integer constants", 333},
+  {"\
+integer constant is too large for this configuration of the compiler - \
+truncated to %d bits", 334},
+  {"width of integer constant changes with -traditional", 335},
+  {"integer constant is unsigned in ANSI C, signed with -traditional", 336},
+  {"width of integer constant may change on other systems with -traditional", 337},
+  {"integer constant larger than the maximum value of an unsigned long int", 338},
+  {"decimal constant is so large that it is unsigned", 339},
+  {"complex integer constant is too wide for `complex int'", 340},
+  {"integer constant is larger than the maximum value for its type", 341},
+  {"missing white space after number `%s'", 342},
+  {"escape sequence out of range for character", 343},
+  {"ANSI C forbids newline in character constant", 344},
+  {"Ignoring invalid multibyte character", 345},
+  {"malformed character constant", 346},
+  {"empty character constant", 347},
+  {"character constant too long", 348},
+  {"multi-character character constant", 349},
+  {"ANSI C forbids newline in string constant", 350},
+  {"Unterminated string constant", 351},
+  {"YYDEBUG not defined.", 352},
+  {"syntax error", 353},
+  {"syntax error: cannot back up", 354},
+  {"parser stack overflow", 355},
+  {"ANSI C forbids an empty source file", 356},
+  {"argument of `asm' is not a constant string", 357},
+  {"ANSI C forbids data definition with no type or storage class", 358},
+  {"data definition has no type or storage class", 359},
+  {"ANSI C does not allow extra `;' outside of a function", 360},
+  {"ANSI C forbids `&&'", 361},
+  {"`sizeof' applied to a bit-field", 362},
+  {"ANSI C forbids constructor expressions", 363},
+  {"ANSI C forbids omitting the middle term of a ?: expression", 364},
+  {"ANSI C forbids braced-groups within expressions", 365},
+  {"Use of ANSI string concatenation", 366},
+  {"ANSI C does not permit use of `varargs.h'", 367},
+  {"`%s' is not at beginning of declaration", 368},
+  {"ANSI C forbids empty initializer braces", 369},
+  {"ANSI C forbids nested functions", 370},
+  {"`[*]' in parameter declaration only allowed in ISO C 99", 371},
+  {"comma at end of enumerator list", 372},
+  {"no semicolon at end of struct or union", 373},
+  {"extra semicolon in struct or union specified", 374},
+  {"ANSI C doesn't support unnamed structs/unions", 375},
+  {"ANSI C forbids member declarations with no members", 376},
+  {"ANSI C forbids label at end of compound statement", 377},
+  {"ANSI C forbids label declarations", 378},
+  {"braced-group within expression allowed only inside a function", 379},
+  {"empty body in an else-statement", 380},
+  {"break statement not within loop or switch", 381},
+  {"continue statement not within a loop", 382},
+  {"ANSI C forbids `goto *expr;'", 383},
+  {"invalid `for (ITERATOR)' syntax", 384},
+  {"`%s' is not an iterator", 385},
+  {"`for (%s)' inside expansion of same iterator", 386},
+  {"label must have integral type in ANSI C", 387},
+  {"case label not within a switch statement", 388},
+  {"duplicate case value", 389},
+  {"this is the first entry for that value", 390},
+  {"case value out of range", 391},
+  {"case label within scope of cleanup or variable array", 392},
+  {"ANSI C forbids case ranges", 393},
+  {"empty case range", 394},
+  {"default label not within a switch statement", 395},
+  {"multiple default labels in one switch", 396},
+  {"this is the first default label", 397},
+  {"ANSI C forbids forward parameter declarations", 398},
+  {"ANSI C requires a named argument before `...'", 399},
+  {"`...' in old-style identifier list", 400},
+  {"parse error; also virtual memory exceeded", 401},
+  {"parse error", 402},
+  {"Alignment must be a small power of two, not %d, in #pragma pack", 403},
+  {"\
+#pragma pack (pop) encountered without matching #pragma pack (push, <n>)", 404},
+  {"\
+#pragma pack(pop, %s) encountered without matching #pragma pack(push, %s, \
+<n>)", 405},
+  {"malformed `#pragma pack'", 406},
+  {"malformed '#pragma pack(push[,id],<n>)'", 407},
+  {"malformed '#pragma pack(pop[,id])'", 408},
+  {"malformed `#pragma weak'", 409},
+  {"`%s' has an incomplete type", 410},
+  {"invalid use of void expression", 411},
+  {"invalid use of array with unspecified bounds", 412},
+  {"invalid use of undefined type `%s %s'", 413},
+  {"invalid use of incomplete typedef `%s'", 414},
+  {"function types not truly compatible in ANSI C", 415},
+  {"types are not quite compatible", 416},
+  {"sizeof applied to a function type", 417},
+  {"sizeof applied to a void type", 418},
+  {"sizeof applied to an incomplete type", 419},
+  {"arithmetic on pointer to an incomplete type", 420},
+  {"__alignof__ applied to an incomplete type", 421},
+  {"`__alignof' applied to a bit-field", 422},
+  {"invalid use of non-lvalue array", 423},
+  {"%s has no member named `%s'", 424},
+  {"request for member `%s' in something not a structure or union", 425},
+  {"dereferencing pointer to incomplete type", 426},
+  {"dereferencing `void *' pointer", 427},
+  {"invalid type argument of `%s'", 428},
+  {"subscript missing in array reference", 429},
+  {"array subscript has type `char'", 430},
+  {"array subscript is not an integer", 431},
+  {"ANSI C forbids subscripting `register' array", 432},
+  {"ANSI C forbids subscripting non-lvalue array", 433},
+  {"subscript has type `char'", 434},
+  {"subscripted value is neither array nor pointer", 435},
+  {"`%s' undeclared here (not in a function)", 436},
+  {"`%s' undeclared (first use in this function)", 437},
+  {"(Each undeclared identifier is reported only once", 438},
+  {"for each function it appears in.)", 439},
+  {"local declaration of `%s' hides instance variable", 440},
+  {"called object is not a function", 441},
+  {"too many arguments to function", 442},
+  {"type of formal parameter %d is incomplete", 443},
+  {"%s as integer rather than floating due to prototype", 444},
+  {"%s as complex rather than floating due to prototype", 445},
+  {"%s as floating rather than integer due to prototype", 446},
+  {"%s as floating rather than complex due to prototype", 447},
+  {"%s as `float' rather than `double' due to prototype", 448},
+  {"%s with different width due to prototype", 449},
+  {"%s as unsigned due to prototype", 450},
+  {"%s as signed due to prototype", 451},
+  {"too few arguments to function", 452},
+  {"suggest parentheses around + or - inside shift", 453},
+  {"suggest parentheses around && within ||", 454},
+  {"suggest parentheses around arithmetic in operand of |", 455},
+  {"suggest parentheses around comparison in operand of |", 456},
+  {"suggest parentheses around arithmetic in operand of ^", 457},
+  {"suggest parentheses around comparison in operand of ^", 458},
+  {"suggest parentheses around + or - in operand of &", 459},
+  {"suggest parentheses around comparison in operand of &", 460},
+  {"comparisons like X<=Y<=Z do not have their mathematical meaning", 461},
+  {"right shift count is negative", 462},
+  {"right shift count >= width of type", 463},
+  {"left shift count is negative", 464},
+  {"left shift count >= width of type", 465},
+  {"shift count is negative", 466},
+  {"shift count >= width of type", 467},
+  {"comparing floating point with == or != is unsafe", 468},
+  {"ANSI C forbids comparison of `void *' with function pointer", 469},
+  {"comparison of distinct pointer types lacks a cast", 470},
+  {"comparison between pointer and integer", 471},
+  {"ANSI C forbids ordered comparisons of pointers to functions", 472},
+  {"comparison of complete and incomplete pointers", 473},
+  {"ordered comparison of pointer with integer zero", 474},
+  {"unordered comparison on non-floating point argument", 475},
+  {"comparison between signed and unsigned", 476},
+  {"comparison of promoted ~unsigned with constant", 477},
+  {"comparison of promoted ~unsigned with unsigned", 478},
+  {"pointer of type `void *' used in arithmetic", 479},
+  {"pointer to a function used in arithmetic", 480},
+  {"pointer of type `void *' used in subtraction", 481},
+  {"pointer to a function used in subtraction", 482},
+  {"wrong type argument to unary plus", 483},
+  {"wrong type argument to unary minus", 484},
+  {"wrong type argument to bit-complement", 485},
+  {"wrong type argument to abs", 486},
+  {"wrong type argument to conjugation", 487},
+  {"wrong type argument to unary exclamation mark", 488},
+  {"wrong type argument to %s", 489},
+  {"%s of pointer to unknown structure", 490},
+  {"invalid lvalue in increment", 491},
+  {"invalid lvalue in decrement", 492},
+  {"increment", 493},
+  {"decrement", 494},
+  {"ANSI C forbids the address of a cast expression", 495},
+  {"invalid lvalue in unary `&'", 496},
+  {"attempt to take address of bit-field structure member `%s'", 497},
+  {"%s", 498},
+  {"ANSI C forbids use of conditional expressions as lvalues", 499},
+  {"ANSI C forbids use of compound expressions as lvalues", 500},
+  {"ANSI C forbids use of cast expressions as lvalues", 501},
+  {"%s of iterator `%s'", 502},
+  {"%s of read-only member `%s'", 503},
+  {"%s of read-only variable `%s'", 504},
+  {"%s of read-only location", 505},
+  {"cannot take address of bitfield `%s'", 506},
+  {"global register variable `%s' used in nested function", 507},
+  {"register variable `%s' used in nested function", 508},
+  {"address of global register variable `%s' requested", 509},
+  {"cannot put object with volatile field into register", 510},
+  {"address of register variable `%s' requested", 511},
+  {"signed and unsigned type in conditional expression", 512},
+  {"ANSI C forbids conditional expr with only one void side", 513},
+  {"ANSI C forbids conditional expr between `void *' and function pointer", 514},
+  {"pointer type mismatch in conditional expression", 515},
+  {"pointer/integer type mismatch in conditional expression", 516},
+  {"ANSI C forbids conditional expr between 0 and function pointer", 517},
+  {"type mismatch in conditional expression", 518},
+  {"left-hand operand of comma expression has no effect", 519},
+  {"cast specifies array type", 520},
+  {"cast specifies function type", 521},
+  {"ANSI C forbids casting nonscalar to the same type", 522},
+  {"ANSI C forbids casts to union type", 523},
+  {"cast to union type from type not present in union", 524},
+  {"cast discards qualifiers from pointer target type", 525},
+  {"cast increases required alignment of target type", 526},
+  {"cast from pointer to integer of different size", 527},
+  {"cast does not match function type", 528},
+  {"cast to pointer from integer of different size", 529},
+  {"invalid lvalue in assignment", 530},
+  {"assignment", 531},
+  {"%s makes qualified function pointer from unqualified", 532},
+  {"%s discards qualifiers from pointer target type", 533},
+  {"ANSI C prohibits argument conversion to union type", 534},
+  {"ANSI forbids %s between function pointer and `void *'", 535},
+  {"pointer targets in %s differ in signedness", 536},
+  {"%s from incompatible pointer type", 537},
+  {"%s makes pointer from integer without a cast", 538},
+  {"%s makes integer from pointer without a cast", 539},
+  {"incompatible type for argument %d of `%s'", 540},
+  {"incompatible type for argument %d of indirect function call", 541},
+  {"incompatible types in %s", 542},
+  {"passing arg %d of `%s'", 543},
+  {"passing arg %d of pointer to function", 544},
+  {"initializer for static variable is not constant", 545},
+  {"initializer for static variable uses complicated arithmetic", 546},
+  {"aggregate initializer is not constant", 547},
+  {"aggregate initializer uses complicated arithmetic", 548},
+  {"(near initialization for `%s')", 549},
+  {"char-array initialized from wide string", 550},
+  {"int-array initialized from non-wide string", 551},
+  {"initializer-string for array of chars is too long", 552},
+  {"array initialized from non-constant array expression", 553},
+  {"initializer element is not constant", 554},
+  {"initializer element is not computable at load time", 555},
+  {"initialization", 556},
+  {"invalid initializer", 557},
+  {"extra brace group at end of initializer", 558},
+  {"missing braces around initializer", 559},
+  {"braces around scalar initializer", 560},
+  {"missing initializer", 561},
+  {"empty braces in initializer", 562},
+  {"empty scalar initializer", 563},
+  {"extra elements in scalar initializer", 564},
+  {"zero or negative array size `%s'", 565},
+  {"nonconstant array index in initializer", 566},
+  {"array index in non-array initializer", 567},
+  {"duplicate array index in initializer", 568},
+  {"empty index range in initializer", 569},
+  {"ANSI C forbids specifying element to initialize", 570},
+  {"unknown field `%s' specified in initializer", 571},
+  {"field `%s' already initialized", 572},
+  {"ANSI C forbids specifying structure member to initialize", 573},
+  {"duplicate initializer", 574},
+  {"excess elements in char array initializer", 575},
+  {"excess elements in struct initializer", 576},
+  {"excess elements in union initializer", 577},
+  {"excess elements in array initializer", 578},
+  {"excess elements in scalar initializer", 579},
+  {"asm template is not a string constant", 580},
+  {"invalid lvalue in asm statement", 581},
+  {"modification by `asm'", 582},
+  {"function declared `noreturn' has a `return' statement", 583},
+  {"`return' with no value, in function returning non-void", 584},
+  {"`return' with a value, in function returning void", 585},
+  {"return", 586},
+  {"function returns address of local variable", 587},
+  {"switch quantity not an integer", 588},
+  {"`long' switch expression not converted to `int' in ANSI C", 589},
+  {"inlining failed in call to `%s'", 590},
+  {"called from here", 591},
+  {"can't inline call to `%s'", 592},
+  {"function call has aggregate value", 593},
+  {"internal error", 594},
+  {"no arguments", 595},
+  {"fopen %s", 596},
+  {"fclose %s", 597},
+  {"collect2 version %s", 598},
+  {"%d constructor(s) found\n", 599},
+  {"%d destructor(s)  found\n", 600},
+  {"%d frame table(s) found\n", 601},
+  {"%s terminated with signal %d [%s]%s", 602},
+  {"%s returned %d exit status", 603},
+  {"[cannot find %s]", 604},
+  {"cannot find `%s'", 605},
+  {"redirecting stdout: %s", 606},
+  {"[Leaving %s]\n", 607},
   {"\
 \n\
-write_c_file - output name is %s, prefix is %s\n", 264},
-  {"cannot find `nm'", 265},
-  {"pipe", 266},
-  {"fdopen", 267},
-  {"dup2 %d 1", 268},
-  {"close %d", 269},
-  {"execvp %s", 270},
-  {"init function found in object %s", 271},
-  {"fini function found in object %s", 272},
-  {"fclose", 273},
-  {"unable to open file '%s'", 274},
-  {"unable to stat file '%s'", 275},
-  {"unable to mmap file '%s'", 276},
-  {"not found\n", 277},
-  {"dynamic dependency %s not found", 278},
-  {"bad magic number in file '%s'", 279},
-  {"dynamic dependencies.\n", 280},
-  {"cannot find `ldd'", 281},
-  {"execv %s", 282},
+write_c_file - output name is %s, prefix is %s\n", 608},
+  {"cannot find `nm'", 609},
+  {"pipe", 610},
+  {"fdopen", 611},
+  {"dup2 %d 1", 612},
+  {"close %d", 613},
+  {"execvp %s", 614},
+  {"init function found in object %s", 615},
+  {"fini function found in object %s", 616},
+  {"fclose", 617},
+  {"unable to open file '%s'", 618},
+  {"unable to stat file '%s'", 619},
+  {"unable to mmap file '%s'", 620},
+  {"not found\n", 621},
+  {"dynamic dependency %s not found", 622},
+  {"bad magic number in file '%s'", 623},
+  {"dynamic dependencies.\n", 624},
+  {"cannot find `ldd'", 625},
+  {"execv %s", 626},
   {"\
 \n\
-ldd output with constructors/destructors.\n", 283},
-  {"unable to open dynamic dependency '%s'", 284},
-  {"%s: not a COFF file", 285},
-  {"%s: cannot open as COFF file", 286},
-  {"Library lib%s not found", 287},
-  {"open %s", 288},
-  {"incompatibilities between object file & expected values", 289},
+ldd output with constructors/destructors.\n", 627},
+  {"unable to open dynamic dependency '%s'", 628},
+  {"%s: not a COFF file", 629},
+  {"%s: cannot open as COFF file", 630},
+  {"Library lib%s not found", 631},
+  {"open %s", 632},
+  {"incompatibilities between object file & expected values", 633},
   {"\
 \n\
-Processing symbol table #%d, offset = 0x%.8lx, kind = %s\n", 290},
-  {"string section missing", 291},
-  {"section pointer missing", 292},
-  {"no symbol table found", 293},
-  {"no cmd_strings found", 294},
+Processing symbol table #%d, offset = 0x%.8lx, kind = %s\n", 634},
+  {"string section missing", 635},
+  {"section pointer missing", 636},
+  {"no symbol table found", 637},
+  {"no cmd_strings found", 638},
   {"\
 \n\
 Updating header and load commands.\n\
-\n", 295},
-  {"load command map, %d cmds, new size %ld.\n", 296},
+\n", 639},
+  {"load command map, %d cmds, new size %ld.\n", 640},
   {"\
 writing load commands.\n\
-\n", 297},
-  {"close %s", 298},
-  {"could not convert 0x%l.8x into a region", 299},
-  {"%s function, region %d, offset = %ld (0x%.8lx)\n", 300},
-  {"bad magic number", 301},
-  {"bad header version", 302},
-  {"bad raw header version", 303},
-  {"raw header buffer too small", 304},
-  {"old raw header file", 305},
-  {"unsupported version", 306},
-  {"unknown {de,en}code_mach_o_hdr return value %d", 307},
-  {"fstat %s", 308},
-  {"lseek %s 0", 309},
-  {"read %s", 310},
-  {"read %ld bytes, expected %ld, from %s", 311},
-  {"msync %s", 312},
-  {"munmap %s", 313},
-  {"write %s", 314},
-  {"wrote %ld bytes, expected %ld, to %s", 315},
+\n", 641},
+  {"close %s", 642},
+  {"could not convert 0x%l.8x into a region", 643},
+  {"%s function, region %d, offset = %ld (0x%.8lx)\n", 644},
+  {"bad magic number", 645},
+  {"bad header version", 646},
+  {"bad raw header version", 647},
+  {"raw header buffer too small", 648},
+  {"old raw header file", 649},
+  {"unsupported version", 650},
+  {"unknown {de,en}code_mach_o_hdr return value %d", 651},
+  {"fstat %s", 652},
+  {"lseek %s 0", 653},
+  {"read %s", 654},
+  {"read %ld bytes, expected %ld, from %s", 655},
+  {"msync %s", 656},
+  {"munmap %s", 657},
+  {"write %s", 658},
+  {"wrote %ld bytes, expected %ld, to %s", 659},
   {"\
 ;; Combiner statistics: %d attempts, %d substitutions (%d requiring new \
 space),\n\
 ;; %d successes.\n\
-\n", 316},
+\n", 660},
   {"\
 \n\
 ;; Combiner totals: %d attempts, %d substitutions (%d requiring new space),\n\
-;; %d successes.\n", 317},
-  {"invalid %%Q value", 318},
-  {"invalid %%C value", 319},
-  {"invalid %%N value", 320},
-  {"invalid %%M value", 321},
-  {"invalid %%m value", 322},
-  {"invalid %%L value", 323},
-  {"invalid %%O value", 324},
-  {"invalid %%P value", 325},
-  {"invalid %%V value", 326},
-  {"bad value `%s' for -mtrap-precision switch", 327},
-  {"bad value `%s' for -mfp-rounding-mode switch", 328},
-  {"bad value `%s' for -mfp-trap-mode switch", 329},
-  {"bad value `%s' for -mcpu switch", 330},
-  {"invalid %%r value", 331},
-  {"invalid %%R value", 332},
-  {"invalid %%h value", 333},
-  {"invalid %%U value", 334},
-  {"invalid %%s value", 335},
-  {"invalid %%E value", 336},
-  {"invalid %%xn code", 337},
-  {"bad value (%s) for -mcpu switch", 338},
-  {"invalid operand to %R code", 339},
-  {"invalid operand to %H/%L code", 340},
-  {"invalid operand to %U code", 341},
-  {"invalid operand to %V code", 342},
-  {"invalid operand output code", 343},
-  {"bad value (%s) for %s switch", 344},
-  {"-fpic and -mapcs-reent are incompatible", 345},
-  {"Invalid floating point emulation option: -mfpe-%s", 346},
-  {"Unable to use '%s' for PIC register", 347},
-  {"No low registers available for popping high registers", 348},
-  {"thumb_load_double_from_address: destination is not a register", 349},
-  {"thumb_load_double_from_address: source is not a computed memory address", 350},
-  {"thumb_load_double_from_address: base is not a register", 351},
-  {"thumb_load_double_from_address: Unhandled address calculation", 352},
-  {"Invalid register class letter %c", 353},
-  {"ACCUM_HIGH_REGS class in limit_reload_class", 354},
-  {"YH_OR_ACCUM_HIGH_REGS found in limit_reload_class", 355},
-  {"YL found in limit_reload_class", 356},
-  {"Stack size > 32k", 357},
-  {"Invalid addressing mode", 358},
-  {"Bad register extension code", 359},
-  {"Invalid offset in ybase addressing", 360},
-  {"Invalid register in ybase addressing", 361},
-  {"inline float constants not supported on this host", 362},
-  {"Invalid shift operator in emit_1600_core_shift", 363},
-  {"Invalid mode for gen_tst_reg", 364},
-  {"Invalid mode for integer comparison in gen_compare_reg", 365},
-  {"Invalid register for compare", 366},
-  {"Profiling not implemented yet.", 367},
-  {"Trampolines not yet implemented", 368},
-  {"Internal gcc abort from %s:%d", 369},
-  {"The local variable `insn' has the value:", 370},
-  {"bad value (%s) for -march= switch", 371},
-  {"bad value (%s) for -mcpu= switch", 372},
-  {"Register '%c' is unknown", 373},
-  {"Register '%c' already specified in allocation order", 374},
-  {"-mregparm=%d is not between 0 and %d", 375},
-  {"-malign-loops=%d is not between 0 and %d", 376},
-  {"-malign-jumps=%d is not between 0 and %d", 377},
-  {"-malign-functions=%d is not between 0 and %d", 378},
-  {"-mpreferred-stack-boundary=%d is not between 2 and 31", 379},
-  {"-mbranch-cost=%d is not between 0 and 5", 380},
-  {"floating constant misused", 381},
-  {"invalid UNSPEC as operand", 382},
-  {"invalid expression as operand", 383},
-  {"half-pic init called on systems that don't support it.", 384},
-  {"Use hardware fp", 385},
-  {"Do not use hardware fp", 386},
-  {"Same as -mcpu=i386", 387},
-  {"Same as -mcpu=i486", 388},
-  {"Same as -mcpu=pentium", 389},
-  {"Same as -mcpu=pentiumpro", 390},
-  {"Alternate calling convention", 391},
-  {"Use normal calling convention", 392},
-  {"Align some doubles on dword boundary", 393},
-  {"Align doubles on word boundary", 394},
-  {"Uninitialized locals in .bss", 395},
-  {"Uninitialized locals in .data", 396},
-  {"Use IEEE math for fp comparisons", 397},
-  {"Do not use IEEE math for fp comparisons", 398},
-  {"Return values of functions in FPU registers", 399},
-  {"Do not return values of functions in FPU registers", 400},
-  {"Do not generate sin, cos, sqrt for FPU", 401},
-  {"Generate sin, cos, sqrt for FPU", 402},
-  {"Omit the frame pointer in leaf functions", 403},
-  {"Enable stack probing", 404},
-  {"Emit Intel syntax assembler opcodes", 405},
-  {"Align destination of the string operations", 406},
-  {"Do not align destination of the string operations", 407},
-  {"Inline all known string operations", 408},
-  {"Do not inline all known string operations", 409},
-  {"Use push instructions to save outgoing arguments", 410},
-  {"Do not use push instructions to save outgoing arguments", 411},
-  {"Schedule code for given CPU", 412},
-  {"Generate code for given CPU", 413},
-  {"Control allocation order of integer registers", 414},
-  {"Number of registers used to pass integer arguments", 415},
-  {"Loop code aligned to this power of 2", 416},
-  {"Jump targets are aligned to this power of 2", 417},
-  {"Function starts are aligned to this power of 2", 418},
-  {"Attempt to keep stack aligned to this power of 2", 419},
-  {"Branches are this expensive (1-5, arbitrary units)", 420},
-  {"`%s' declared as both exported to and imported from a DLL.", 421},
-  {"bad value (%s) for -mmodel switch", 422},
-  {"bad value (%s) for -msdata switch", 423},
-  {"invalid operand to %s code", 424},
-  {"invalid operand to %p code", 425},
-  {"invalid operand to %T/%B code", 426},
-  {"invalid operand to %N code", 427},
-  {"-malign-loops=%d is not between 1 and %d", 428},
-  {"-malign-jumps=%d is not between 1 and %d", 429},
-  {"-malign-functions=%d is not between 1 and %d", 430},
-  {"-fPIC is not currently supported on the 68000 or 68010\n", 431},
-  {"%R not followed by %B/C/D/E", 432},
-  {"invalid %x/X value", 433},
-  {"invalid %H value", 434},
-  {"invalid %h value", 435},
-  {"invalid %Q value", 436},
-  {"invalid %q value", 437},
-  {"invalid %o value", 438},
-  {"invalid %p value", 439},
-  {"invalid %s/S value", 440},
-  {"invalid %P operand", 441},
-  {"invalid %B value", 442},
-  {"invalid %C value", 443},
-  {"invalid %D value", 444},
-  {"invalid %E value", 445},
-  {"`%d' operand isn't a register", 446},
-  {"invalid %r value", 447},
-  {"operand is r0", 448},
-  {"operand is const_double", 449},
-  {"invalid code", 450},
-  {"-mtrap-large-shift and -mhandle-large-shift are incompatible", 451},
-  {"Invalid option `-mshort-data-%s'", 452},
-  {"-mshort-data-%s is too large ", 453},
-  {"-mshort-data-%s and PIC are incompatible", 454},
-  {"-mips%d not supported", 455},
-  {"bad value (%s) for -mips switch", 456},
-  {"bad value (%s) for -mabi= switch", 457},
-  {"-mabi=%s does not support -mips%d", 458},
-  {"The -mabi=32 support does not work yet.", 459},
-  {"This target does not support the -mabi switch.", 460},
-  {"-mcpu=%s does not support -mips%d", 461},
-  {"-mips%d does not support 64 bit fp registers", 462},
-  {"-mips%d does not support 64 bit gp registers", 463},
-  {"Invalid option `entry%s'", 464},
-  {"internal error: %%) found without a %%( in assembler pattern", 465},
-  {"internal error: %%] found without a %%[ in assembler pattern", 466},
-  {"internal error: %%> found without a %%< in assembler pattern", 467},
-  {"internal error: %%} found without a %%{ in assembler pattern", 468},
-  {"PRINT_OPERAND: Unknown punctuation '%c'", 469},
-  {"PRINT_OPERAND null pointer", 470},
-  {"PRINT_OPERAND: letter %c was found & insn was not CONST_INT", 471},
-  {"PRINT_OPERAND_ADDRESS, null pointer", 472},
-  {"gp_offset (%ld) or end_offset (%ld) is less than zero.", 473},
-  {"fp_offset (%ld) or end_offset (%ld) is less than zero.", 474},
-  {"can not handle inconsistent calls to `%s'", 475},
-  {"invalid %%B value", 476},
-  {"invalid %%S value", 477},
-  {"invalid %%b value", 478},
-  {"invalid %%H value", 479},
-  {"invalid %%z value", 480},
-  {"invalid %%Z value", 481},
-  {"invalid %%k value", 482},
-  {"invalid %%j value", 483},
-  {"can't have varargs with -mfp-arg-in-fp-regs", 484},
+;; %d successes.\n", 661},
+  {"invalid %%Q value", 662},
+  {"invalid %%C value", 663},
+  {"invalid %%N value", 664},
+  {"invalid %%M value", 665},
+  {"invalid %%m value", 666},
+  {"invalid %%L value", 667},
+  {"invalid %%O value", 668},
+  {"invalid %%P value", 669},
+  {"invalid %%V value", 670},
+  {"Generate code assuming DW bit is set", 671},
+  {"Generate code assuming DW bit is not set", 672},
+  {"Generate code using byte writes", 673},
+  {"Do not generate byte writes", 674},
+  {"Use small memory model", 675},
+  {"Use normal memory model", 676},
+  {"Use large memory model", 677},
+  {"Generate 29050 code", 678},
+  {"Generate 29000 code", 679},
+  {"Use kernel global registers", 680},
+  {"Use user global registers", 681},
+  {"Emit stack checking code", 682},
+  {"Do not emit stack checking code", 683},
+  {"Work around storem hardware bug", 684},
+  {"Do not work around storem hardware bug", 685},
+  {"Store locals in argument registers", 686},
+  {"Do not store locals in arg registers", 687},
+  {"Use software floating point", 688},
+  {"Do not generate multm instructions", 689},
+  {"bad value `%s' for -mtrap-precision switch", 690},
+  {"bad value `%s' for -mfp-rounding-mode switch", 691},
+  {"bad value `%s' for -mfp-trap-mode switch", 692},
+  {"bad value `%s' for -mcpu switch", 693},
+  {"fp software completion requires -mtrap-precision=i", 694},
+  {"rounding mode not supported for VAX floats", 695},
+  {"trap mode not supported for VAX floats", 696},
+  {"L%d cache latency unknown for %s", 697},
+  {"bad value `%s' for -mmemory-latency", 698},
+  {"invalid %%r value", 699},
+  {"invalid %%R value", 700},
+  {"invalid %%h value", 701},
+  {"invalid %%U value", 702},
+  {"invalid %%s value", 703},
+  {"invalid %%E value", 704},
+  {"invalid %%xn code", 705},
+  {"Use hardware fp", 706},
+  {"Do not use hardware fp", 707},
+  {"Use fp registers", 708},
+  {"Do not use fp registers", 709},
+  {"Do not assume GAS", 710},
+  {"Assume GAS", 711},
+  {"Request IEEE-conformant math library routines (OSF/1)", 712},
+  {"Emit IEEE-conformant code, without inexact exceptions", 713},
+  {"Emit IEEE-conformant code, with inexact exceptions", 714},
+  {"Do not emit complex integer constants to read-only memory", 715},
+  {"Use VAX fp", 716},
+  {"Do not use VAX fp", 717},
+  {"Emit code for the byte/word ISA extension", 718},
+  {"Emit code for the motion video ISA extension", 719},
+  {"Emit code for the fp move and sqrt ISA extension", 720},
+  {"Emit code for the counting ISA extension", 721},
+  {"Generate code for a given CPU", 722},
+  {"Control the generated fp rounding mode", 723},
+  {"Control the IEEE trap mode", 724},
+  {"Control the precision given to fp exceptions", 725},
+  {"Tune expected memory latency", 726},
+  {"bad value (%s) for -mcpu switch", 727},
+  {"invalid operand to %R code", 728},
+  {"invalid operand to %H/%L code", 729},
+  {"invalid operand to %U code", 730},
+  {"invalid operand to %V code", 731},
+  {"invalid operand output code", 732},
+  {"switch -mcpu=%s conflicts with -march= switch", 733},
+  {"bad value (%s) for %s switch", 734},
+  {"target CPU does not support APCS-32", 735},
+  {"target CPU does not support APCS-26", 736},
+  {"target CPU does not support interworking", 737},
+  {"target CPU does not supoport THUMB instructions.", 738},
+  {"\
+enabling backtrace support is only meaningful when compiling for the Thumb.", 739},
+  {"\
+enabling callee interworking support is only meaningful when compiling for \
+the Thumb.", 740},
+  {"\
+enabling caller interworking support is only meaningful when compiling for \
+the Thumb.", 741},
+  {"interworking forces APCS-32 to be used", 742},
+  {"-mapcs-stack-check incompatible with -mno-apcs-frame", 743},
+  {"-fpic and -mapcs-reent are incompatible", 744},
+  {"APCS reentrant code not supported.  Ignored", 745},
+  {"-g with -mno-apcs-frame may not give sensible debugging", 746},
+  {"Passing floating point arguments in fp regs not yet supported", 747},
+  {"Invalid floating point emulation option: -mfpe-%s", 748},
+  {"Structure size boundary can only be set to 8 or 32", 749},
+  {"-mpic-register= is useless without -fpic", 750},
+  {"Unable to use '%s' for PIC register", 751},
+  {"Unable to compute real location of stacked parameter", 752},
+  {"No low registers available for popping high registers", 753},
+  {"thumb_load_double_from_address: destination is not a register", 754},
+  {"thumb_load_double_from_address: source is not a computed memory address", 755},
+  {"thumb_load_double_from_address: base is not a register", 756},
+  {"thumb_load_double_from_address: Unhandled address calculation", 757},
+  {"Generate APCS conformant stack frames", 758},
+  {"Store function names in object code", 759},
+  {"Use the 32bit version of the APCS", 760},
+  {"Use the 26bit version of the APCS", 761},
+  {"Pass FP arguments in FP registers", 762},
+  {"Generate re-entrant, PIC code", 763},
+  {"The MMU will trap on unaligned accesses", 764},
+  {"Use library calls to perform FP operations", 765},
+  {"Use hardware floating point instructions", 766},
+  {"Assume target CPU is configured as big endian", 767},
+  {"Assume target CPU is configured as little endian", 768},
+  {"Assume big endian bytes, little endian words", 769},
+  {"Support calls between THUMB and ARM instructions sets", 770},
+  {"Generate a call to abort if a noreturn function returns", 771},
+  {"Do not move instructions into a function's prologue", 772},
+  {"Do not load the PIC register in function prologues", 773},
+  {"Generate call insns as indirect calls, if necessary", 774},
+  {"Compile for the Thumb not the ARM", 775},
+  {"Thumb: Generate (non-leaf) stack frames even if not needed", 776},
+  {"Thumb: Generate (leaf) stack frames even if not needed", 777},
+  {"Thumb: Assume non-static functions may be called from ARM code", 778},
+  {"Thumb: Assume function pointers may go to non-Thumb aware code", 779},
+  {"Specify the name of the target CPU", 780},
+  {"Specify the name of the target architecture", 781},
+  {"Specify the version of the floating point emulator", 782},
+  {"Specify the minimum bit alignment of structures", 783},
+  {"Specify the register to be used for PIC addressing", 784},
+  {"Do symbol renaming for BSD", 785},
+  {"Do symbol renaming for X/OPEN", 786},
+  {"Don't do symbol renaming", 787},
+  {"Generate code for the C400", 788},
+  {"Generate code for the C300", 789},
+  {"Generate code for c1", 790},
+  {"Generate code for c2", 791},
+  {"Generate code for c32", 792},
+  {"Generate code for c34", 793},
+  {"Use standard calling sequence, with arg count word", 794},
+  {"Place arg count in a nop instruction (faster than push)", 795},
+  {"Don't push arg count, depend on symbol table", 796},
+  {"Use data cache for volatile mem refs (default)", 797},
+  {"Don't use data cache for volatile mem refs", 798},
+  {"Bypass data cache for volatile mem refs", 799},
+  {"Use 64-bit longs", 800},
+  {"Use cc- and libc-compatible 32-bit longs", 801},
+  {"Invalid register class letter %c", 802},
+  {"ACCUM_HIGH_REGS class in limit_reload_class", 803},
+  {"YH_OR_ACCUM_HIGH_REGS found in limit_reload_class", 804},
+  {"YL found in limit_reload_class", 805},
+  {"Stack size > 32k", 806},
+  {"Invalid addressing mode", 807},
+  {"Bad register extension code", 808},
+  {"Invalid offset in ybase addressing", 809},
+  {"Invalid register in ybase addressing", 810},
+  {"inline float constants not supported on this host", 811},
+  {"Invalid shift operator in emit_1600_core_shift", 812},
+  {"Invalid mode for gen_tst_reg", 813},
+  {"Invalid mode for integer comparison in gen_compare_reg", 814},
+  {"Invalid register for compare", 815},
+  {"Profiling not implemented yet.", 816},
+  {"Trampolines not yet implemented", 817},
+  {"Generate code the unix assembler can handle", 818},
+  {"Generate code an embedded assembler can handle", 819},
+  {"Generate code for a mc68020", 820},
+  {"Use bitfield instructions", 821},
+  {"Generate code for a mc68000", 822},
+  {"Generate software FP code", 823},
+  {"Do not generate bitfield insns", 824},
+  {"Use 16bit integers", 825},
+  {"Use 32bit integers", 826},
+  {"Only initialized variables can be placed into the 8-bit area.", 827},
+  {"Generate H8/S code", 828},
+  {"Do not generate H8/S code", 829},
+  {"Make integers 32 bits wide", 830},
+  {"Use registers for argument passing", 831},
+  {"Do not use registers for argument passing", 832},
+  {"Consider access to byte sized memory slow", 833},
+  {"Enable linker relaxing", 834},
+  {"Generate H8/300H code", 835},
+  {"Do not generate H8/300H code", 836},
+  {"Use H8/300 alignment rules", 837},
+  {"Escape value out of range", 838},
+  {"#pragma map alias is too long, truncated", 839},
+  {"#pragma map options are missing or incorrect", 840},
+  {"Generate char instructions", 841},
+  {"Do not generate char instructions", 842},
+  {"Use the Cygwin interface", 843},
+  {"Use the Mingw32 interface", 844},
+  {"Create GUI application", 845},
+  {"Create console application", 846},
+  {"Generate code for a DLL", 847},
+  {"Ignore dllimport for functions", 848},
+  {"Use Mingw-specific thread support", 849},
+  {"-f%s ignored for target (all code is position independent)", 850},
+  {"Internal gcc abort from %s:%d", 851},
+  {"The local variable `insn' has the value:", 852},
+  {"Retain standard MXDB information", 853},
+  {"Retain legend information", 854},
+  {"Generate external legend information", 855},
+  {"Emit identifying info in .s file", 856},
+  {"Warn when a function arg is a structure", 857},
+  {"argument is a structure", 858},
+  {"\
+Enable weak symbol and enhanced C++ template support. Binutils 2.9.5.1 or \
+higher required.", 859},
+  {"Disable weak symbol and enhanced C++ template support.", 860},
+  {"bad value (%s) for -march= switch", 861},
+  {"bad value (%s) for -mcpu= switch", 862},
+  {"Register '%c' is unknown", 863},
+  {"Register '%c' already specified in allocation order", 864},
+  {"-mregparm=%d is not between 0 and %d", 865},
+  {"-malign-loops=%d is not between 0 and %d", 866},
+  {"-malign-jumps=%d is not between 0 and %d", 867},
+  {"-malign-functions=%d is not between 0 and %d", 868},
+  {"-mpreferred-stack-boundary=%d is not between 2 and 31", 869},
+  {"-mbranch-cost=%d is not between 0 and 5", 870},
+  {"floating constant misused", 871},
+  {"invalid UNSPEC as operand", 872},
+  {"invalid expression as operand", 873},
+  {"half-pic init called on systems that don't support it.", 874},
+  {"Same as -mcpu=i386", 875},
+  {"Same as -mcpu=i486", 876},
+  {"Same as -mcpu=pentium", 877},
+  {"Same as -mcpu=pentiumpro", 878},
+  {"Alternate calling convention", 879},
+  {"Use normal calling convention", 880},
+  {"Align some doubles on dword boundary", 881},
+  {"Align doubles on word boundary", 882},
+  {"Uninitialized locals in .bss", 883},
+  {"Uninitialized locals in .data", 884},
+  {"Use IEEE math for fp comparisons", 885},
+  {"Do not use IEEE math for fp comparisons", 886},
+  {"Return values of functions in FPU registers", 887},
+  {"Do not return values of functions in FPU registers", 888},
+  {"Do not generate sin, cos, sqrt for FPU", 889},
+  {"Generate sin, cos, sqrt for FPU", 890},
+  {"Omit the frame pointer in leaf functions", 891},
+  {"Enable stack probing", 892},
+  {"Emit Intel syntax assembler opcodes", 893},
+  {"Align destination of the string operations", 894},
+  {"Do not align destination of the string operations", 895},
+  {"Inline all known string operations", 896},
+  {"Do not inline all known string operations", 897},
+  {"Use push instructions to save outgoing arguments", 898},
+  {"Do not use push instructions to save outgoing arguments", 899},
+  {"Support MMX builtins", 900},
+  {"Do not support MMX builtins", 901},
+  {"Support MMX and SSE builtins", 902},
+  {"Do not support MMX and SSE builtins", 903},
+  {"Schedule code for given CPU", 904},
+  {"Generate code for given CPU", 905},
+  {"Control allocation order of integer registers", 906},
+  {"Number of registers used to pass integer arguments", 907},
+  {"Loop code aligned to this power of 2", 908},
+  {"Jump targets are aligned to this power of 2", 909},
+  {"Function starts are aligned to this power of 2", 910},
+  {"Attempt to keep stack aligned to this power of 2", 911},
+  {"Branches are this expensive (1-5, arbitrary units)", 912},
+  {"Profiling uses mcount", 913},
+  {"Emit half-PIC code", 914},
+  {"Emit ELF object code", 915},
+  {"Emit ROSE object code", 916},
+  {"Symbols have a leading underscore", 917},
+  {"Align to >word boundaries", 918},
+  {"Use mcount for profiling", 919},
+  {"Use mcount_ptr for profiling", 920},
+  {"%s causes a section type conflict", 921},
+  {"Generate COFF output", 922},
+  {"Generate ELF output", 923},
+  {"`%s' declared as both exported to and imported from a DLL.", 924},
+  {"initialized variable `%s' is marked dllimport", 925},
+  {"static variable `%s' is marked dllimport", 926},
+  {"Generate code which uses the FPU", 927},
+  {"Do not generate code which uses the FPU", 928},
+  {"stack limit expression is not supported", 929},
+  {"Generate SA code", 930},
+  {"Generate SB code", 931},
+  {"Generate KA code", 932},
+  {"Generate KB code", 933},
+  {"Generate JA code", 934},
+  {"Generate JD code", 935},
+  {"Generate JF code", 936},
+  {"generate RP code", 937},
+  {"Generate MC code", 938},
+  {"Generate CA code", 939},
+  {"Generate CF code", 940},
+  {"Use alternate leaf function entries", 941},
+  {"Do not use alternate leaf function entries", 942},
+  {"Perform tail call optimization", 943},
+  {"Do not perform tail call optimization", 944},
+  {"Use complex addressing modes", 945},
+  {"Do not use complex addressing modes", 946},
+  {"Align code to 8 byte boundary", 947},
+  {"Do not align code to 8 byte boundary", 948},
+  {"Enable compatibility with iC960 v2.0", 949},
+  {"Enable compatibility with iC960 v3.0", 950},
+  {"Enable compatibility with ic960 assembler", 951},
+  {"Do not permit unaligned accesses", 952},
+  {"Permit unaligned accesses", 953},
+  {"Layout types like Intel's v1.3 gcc", 954},
+  {"Do not layout types like Intel's v1.3 gcc", 955},
+  {"Use 64 bit long doubles", 956},
+  {"Enable linker relaxation", 957},
+  {"Do not enable linker relaxation", 958},
+  {"conflicting architectures defined - using C series", 959},
+  {"conflicting architectures defined - using K series", 960},
+  {"iC2.0 and iC3.0 are incompatible - using iC3.0", 961},
+  {"The -mlong-double-64 option does not work yet.", 962},
+  {"-msystem-v and -p are incompatible", 963},
+  {"-msystem-v and -mthreads are incompatible", 964},
+  {"bad value (%s) for -mmodel switch", 965},
+  {"bad value (%s) for -msdata switch", 966},
+  {"const objects cannot go in .sdata/.sbss", 967},
+  {"invalid operand to %s code", 968},
+  {"invalid operand to %p code", 969},
+  {"invalid operand to %T/%B code", 970},
+  {"invalid operand to %N code", 971},
+  {"Display compile time statistics", 972},
+  {"Align all loops to 32 byte boundary", 973},
+  {"Only issue one instruction per cycle", 974},
+  {"Prefer branches over conditional execution", 975},
+  {"Code size: small, medium or large", 976},
+  {"Small data area: none, sdata, use", 977},
+  {"-malign-loops=%d is not between 1 and %d", 978},
+  {"-malign-jumps=%d is not between 1 and %d", 979},
+  {"-malign-functions=%d is not between 1 and %d", 980},
+  {"-fPIC is not currently supported on the 68000 or 68010\n", 981},
+  {"Internal gcc monitor: short-branch(%x)", 982},
+  {"Internal gcc error: Can't express symbolic location", 983},
+  {"argument #%d is a structure", 984},
+  {"%R not followed by %B/C/D/E", 985},
+  {"invalid %x/X value", 986},
+  {"invalid %H value", 987},
+  {"invalid %h value", 988},
+  {"invalid %Q value", 989},
+  {"invalid %q value", 990},
+  {"invalid %o value", 991},
+  {"invalid %p value", 992},
+  {"invalid %s/S value", 993},
+  {"invalid %P operand", 994},
+  {"invalid %B value", 995},
+  {"invalid %C value", 996},
+  {"invalid %D value", 997},
+  {"invalid %E value", 998},
+  {"`%d' operand isn't a register", 999},
+  {"invalid %r value", 1000},
+  {"operand is r0", 1001},
+  {"operand is const_double", 1002},
+  {"invalid code", 1003},
+  {"-mtrap-large-shift and -mhandle-large-shift are incompatible", 1004},
+  {"Invalid option `-mshort-data-%s'", 1005},
+  {"-mshort-data-%s is too large ", 1006},
+  {"-mshort-data-%s and PIC are incompatible", 1007},
+  {"-mips%d not supported", 1008},
+  {"bad value (%s) for -mips switch", 1009},
+  {"bad value (%s) for -mabi= switch", 1010},
+  {"-mabi=%s does not support -mips%d", 1011},
+  {"The -mabi=32 support does not work yet.", 1012},
+  {"This target does not support the -mabi switch.", 1013},
+  {"-mcpu=%s does not support -mips%d", 1014},
+  {"-mips%d does not support 64 bit fp registers", 1015},
+  {"-mips%d does not support 64 bit gp registers", 1016},
+  {"-G is incompatible with PIC code which is the default", 1017},
+  {"-membedded-pic and -mabicalls are incompatible", 1018},
+  {"-G and -membedded-pic are incompatible", 1019},
+  {"Invalid option `entry%s'", 1020},
+  {"-mentry is only meaningful with -mips-16", 1021},
+  {"internal error: %%) found without a %%( in assembler pattern", 1022},
+  {"internal error: %%] found without a %%[ in assembler pattern", 1023},
+  {"internal error: %%> found without a %%< in assembler pattern", 1024},
+  {"internal error: %%} found without a %%{ in assembler pattern", 1025},
+  {"PRINT_OPERAND: Unknown punctuation '%c'", 1026},
+  {"PRINT_OPERAND null pointer", 1027},
+  {"PRINT_OPERAND: letter %c was found & insn was not CONST_INT", 1028},
+  {"PRINT_OPERAND_ADDRESS, null pointer", 1029},
+  {"\
+MIPS ECOFF format does not allow changing filenames within functions with \
+#line", 1030},
+  {"gp_offset (%ld) or end_offset (%ld) is less than zero.", 1031},
+  {"fp_offset (%ld) or end_offset (%ld) is less than zero.", 1032},
+  {"can not handle inconsistent calls to `%s'", 1033},
+  {"No default crt0.o", 1034},
+  {"Use 64-bit int type", 1035},
+  {"Use 64-bit long type", 1036},
+  {"Use 32-bit long type", 1037},
+  {"Optimize lui/addiu address loads", 1038},
+  {"Don't optimize lui/addiu address loads", 1039},
+  {"Use MIPS as", 1040},
+  {"Use GNU as", 1041},
+  {"Use symbolic register names", 1042},
+  {"Don't use symbolic register names", 1043},
+  {"Use GP relative sdata/sbss sections", 1044},
+  {"Don't use GP relative sdata/sbss sections", 1045},
+  {"Output compiler statistics", 1046},
+  {"Don't output compiler statistics", 1047},
+  {"Don't optimize block moves", 1048},
+  {"Optimize block moves", 1049},
+  {"Use mips-tfile asm postpass", 1050},
+  {"Don't use mips-tfile asm postpass", 1051},
+  {"Use hardware floating point", 1052},
+  {"Use 64-bit FP registers", 1053},
+  {"Use 32-bit FP registers", 1054},
+  {"Use 64-bit general registers", 1055},
+  {"Use 32-bit general registers", 1056},
+  {"Use Irix PIC", 1057},
+  {"Don't use Irix PIC", 1058},
+  {"Use OSF PIC", 1059},
+  {"Don't use OSF PIC", 1060},
+  {"Use indirect calls", 1061},
+  {"Don't use indirect calls", 1062},
+  {"Use embedded PIC", 1063},
+  {"Don't use embedded PIC", 1064},
+  {"Use ROM instead of RAM", 1065},
+  {"Don't use ROM instead of RAM", 1066},
+  {"Put uninitialized constants in ROM (needs -membedded-data)", 1067},
+  {"Don't put uninitialized constants in ROM", 1068},
+  {"Use big-endian byte order", 1069},
+  {"Use little-endian byte order", 1070},
+  {"Use single (32-bit) FP only", 1071},
+  {"Don't use single (32-bit) FP only", 1072},
+  {"Use multiply accumulate", 1073},
+  {"Don't use multiply accumulate", 1074},
+  {"Work around early 4300 hardware bug", 1075},
+  {"Don't work around early 4300 hardware bug", 1076},
+  {"Optimize for 4650", 1077},
+  {"Optimize for 3900", 1078},
+  {"Trap on integer divide by zero", 1079},
+  {"Don't trap on integer divide by zero", 1080},
+  {"Trap on integer divide overflow", 1081},
+  {"Don't trap on integer divide overflow", 1082},
+  {"Specify CPU for scheduling purposes", 1083},
+  {"Specify MIPS ISA", 1084},
+  {"Use mips16 entry/exit psuedo ops", 1085},
+  {"Don't use MIPS16 instructions", 1086},
+  {"mips16 function profiling", 1087},
+  {"Work around hardware multiply bug", 1088},
+  {"Do not work around hardware multiply bug", 1089},
+  {"optimization turned on", 1090},
+  {"optimization turned off", 1091},
+  {"optimization level restored", 1092},
+  {"Don't use hardware fp", 1093},
+  {"Alternative calling convention", 1094},
+  {"Pass some arguments in registers", 1095},
+  {"Pass all arguments on stack", 1096},
+  {"Optimize for 32532 cpu", 1097},
+  {"Optimize for 32332 cpu", 1098},
+  {"Optimize for 32032", 1099},
+  {"Register sb is zero. Use for absolute addressing", 1100},
+  {"Do not use register sb", 1101},
+  {"Do not use bitfield instructions", 1102},
+  {"Generate code for high memory", 1103},
+  {"Generate code for low memory", 1104},
+  {"32381 fpu", 1105},
+  {"Use multiply-accumulate fp instructions", 1106},
+  {"Do not use multiply-accumulate fp instructions", 1107},
+  {"\"Small register classes\" kludge", 1108},
+  {"No \"Small register classes\" kludge", 1109},
+  {"\
+Unknown -mschedule= option (%s).\n\
+Valid options are 700, 7100, 7100LC, 7200, and 8000\n", 1110},
+  {"\
+Unknown -march= option (%s).\n\
+Valid options are 1.0, 1.1, and 2.0\n", 1111},
+  {"PIC code generation is not supported in the portable runtime model\n", 1112},
+  {"PIC code generation is not compatible with fast indirect calls\n", 1113},
+  {"PIC code generation is not compatible with profiling\n", 1114},
+  {"-g is only supported when using GAS on this processor,", 1115},
+  {"-g option disabled.", 1116},
+  {"Do not use hardware floating point", 1117},
+  {"Return floating point results in ac0", 1118},
+  {"Return floating point results in memory", 1119},
+  {"Generate code for an 11/40", 1120},
+  {"Generate code for an 11/45", 1121},
+  {"Generate code for an 11/10", 1122},
+  {"Use 32 bit int", 1123},
+  {"Use 16 bit int", 1124},
+  {"Use 32 bit float", 1125},
+  {"Use 64 bit float", 1126},
+  {"Target has split I&D", 1127},
+  {"Target does not have split I&D", 1128},
+  {"Use UNIX assembler syntax", 1129},
+  {"Use DEC assembler syntax", 1130},
+  {"invalid %%B value", 1131},
+  {"invalid %%S value", 1132},
+  {"invalid %%b value", 1133},
+  {"invalid %%H value", 1134},
+  {"invalid %%z value", 1135},
+  {"invalid %%Z value", 1136},
+  {"invalid %%k value", 1137},
+  {"invalid %%j value", 1138},
+  {"can't have varargs with -mfp-arg-in-fp-regs", 1139},
+  {"Always pass floating-point arguments in memory", 1140},
+  {"Don't always pass floating-point arguments in memory", 1141},
+  {"Support message passing with the Parallel Environment", 1142},
+  {"Compile for 64-bit pointers", 1143},
+  {"Compile for 32-bit pointers", 1144},
+  {"-maix64 and POWER architecture are incompatible.", 1145},
+  {"-maix64 requires PowerPC64 architecture remain enabled.", 1146},
   {"\
 -maix64 required: 64-bit computation with 32-bit addressing not yet \
-supported.", 485},
-  {"Unknown -mdebug-%s switch", 486},
-  {"invalid %%f value", 487},
-  {"invalid %%F value", 488},
-  {"invalid %%G value", 489},
-  {"invalid %%j code", 490},
-  {"invalid %%J code", 491},
-  {"invalid %%K value", 492},
-  {"invalid %%p value", 493},
-  {"invalid %%q value", 494},
-  {"%%S computed all 1's mask", 495},
-  {"%%S computed all 0's mask", 496},
-  {"invalid %%u value", 497},
-  {"invalid %%v value", 498},
-  {"RETURN_ADDRESS_OFFSET not supported", 499},
-  {"Bad value for -mcall-%s", 500},
-  {"Bad value for -msdata=%s", 501},
-  {"-mrelocatable and -msdata=%s are incompatible.", 502},
-  {"-f%s and -msdata=%s are incompatible.", 503},
-  {"-msdata=%s and -mcall-%s are incompatible.", 504},
-  {"-mrelocatable and -mno-minimal-toc are incompatible.", 505},
-  {"-mrelocatable and -mcall-%s are incompatible.", 506},
-  {"-fPIC and -mcall-%s are incompatible.", 507},
-  {"-mcall-aixdesc must be big endian", 508},
-  {"%s is not supported by this configuration", 509},
-  {"-mptr%d not allowed on -m%d", 510},
-  {"-mlong-double-64 not allowed with -m64", 511},
-  {"bad value (%s) for -mcmodel= switch", 512},
-  {"-mcmodel= is not supported on 32 bit systems", 513},
-  {"profiling does not support code models other than medlow", 514},
-  {"Invalid %%Y operand", 515},
-  {"Invalid %%A operand", 516},
-  {"Invalid %%B operand", 517},
-  {"Invalid %%c operand", 518},
-  {"Invalid %%C operand", 519},
-  {"Invalid %%d operand", 520},
-  {"Invalid %%D operand", 521},
-  {"Invalid %%f operand", 522},
-  {"long long constant not a valid immediate operand", 523},
-  {"floating point constant not a valid immediate operand", 524},
-  {"%s=%s is not numeric.", 525},
-  {"%s=%s is too large.", 526},
-  {"Bogus JR construction: %d\n", 527},
-  {"Bad amount of stack space removal: %d", 528},
-  {"Bogus JARL construction: %d\n", 529},
-  {"cannot convert to a pointer type", 530},
-  {"pointer value used where a floating point value was expected", 531},
-  {"aggregate value used where a float was expected", 532},
-  {"conversion to incomplete type", 533},
-  {"aggregate value used where an integer was expected", 534},
-  {"pointer value used where a complex was expected", 535},
-  {"aggregate value used where a complex was expected", 536},
-  {"destructors take no parameters", 537},
-  {"conflicting access specifications for field `%s', ignored", 538},
-  {"trying to finish struct, but kicked out due to previous parse errors.", 539},
-  {"language string `\"%s\"' not recognized", 540},
-  {"not enough type information", 541},
-  {"invalid operation on uninstantiated type", 542},
-  {"parse errors have confused me too much", 543},
-  {"label `%s' referenced outside of any function", 544},
-  {"  enters try block", 545},
-  {"virtual memory exhausted", 546},
-  {"the new ABI requires vtable thunks", 547},
-  {"an anonymous union cannot have function members", 548},
-  {"multiple types in one declaration", 549},
-  {"assignment (not initialization) in declaration", 550},
-  {"invalid catch parameter", 551},
-  {"destructor for alien class `%s' cannot be a member", 552},
-  {"constructor for alien class `%s' cannot be a member", 553},
-  {"cannot declare `::main' to be a template", 554},
-  {"cannot declare `::main' to be inline", 555},
-  {"cannot declare `::main' to be static", 556},
-  {"overflow in array dimension", 557},
-  {"destructors must be member functions", 558},
-  {"`bool' is now a keyword", 559},
-  {"short, signed or unsigned invalid for `%s'", 560},
-  {"long and short specified together for `%s'", 561},
-  {"signed and unsigned given together for `%s'", 562},
-  {"storage class specifiers invalid in parameter declarations", 563},
-  {"typedef declaration invalid in parameter declaration", 564},
-  {"virtual outside class declaration", 565},
-  {"storage class specified for %s `%s'", 566},
-  {"storage class specifiers invalid in friend function declarations", 567},
-  {"destructor cannot be static member function", 568},
-  {"constructor cannot be static member function", 569},
-  {"return value type specifier for constructor ignored", 570},
-  {"can't initialize friend function `%s'", 571},
-  {"virtual functions cannot be friends", 572},
-  {"friend declaration not in class definition", 573},
-  {"cannot declare %s to references", 574},
-  {"invalid type: `void &'", 575},
-  {"only declarations of constructors can be `explicit'", 576},
-  {"non-member `%s' cannot be declared `mutable'", 577},
-  {"non-object member `%s' cannot be declared `mutable'", 578},
-  {"function `%s' cannot be declared `mutable'", 579},
-  {"static `%s' cannot be declared `mutable'", 580},
-  {"const `%s' cannot be declared `mutable'", 581},
-  {"typedef declaration includes an initializer", 582},
-  {"trying to make class `%s' a friend of global scope", 583},
-  {"unnamed variable or field declared void", 584},
-  {"variable or field declared void", 585},
-  {"cannot use `::' in parameter declaration", 586},
-  {"declaration of `%s' as void", 587},
-  {"`%s' is neither function nor member function; cannot be declared friend", 588},
-  {"storage class `auto' invalid for function `%s'", 589},
-  {"storage class `register' invalid for function `%s'", 590},
-  {"virtual non-class function `%s'", 591},
-  {"cannot declare static function inside another function", 592},
-  {"parameter has incomplete type", 593},
+supported.", 1147},
+  {"-mmultiple is not supported on little endian systems", 1148},
+  {"-mstring is not supported on little endian systems", 1149},
+  {"-f%s ignored for AIX (all code is position independent)", 1150},
+  {"Unknown -mdebug-%s switch", 1151},
+  {"invalid %%f value", 1152},
+  {"invalid %%F value", 1153},
+  {"invalid %%G value", 1154},
+  {"invalid %%j code", 1155},
+  {"invalid %%J code", 1156},
+  {"invalid %%K value", 1157},
+  {"invalid %%p value", 1158},
+  {"invalid %%q value", 1159},
+  {"%%S computed all 1's mask", 1160},
+  {"%%S computed all 0's mask", 1161},
+  {"invalid %%u value", 1162},
+  {"invalid %%v value", 1163},
+  {"Use POWER instruction set", 1164},
+  {"Use POWER2 instruction set", 1165},
+  {"Do not use POWER2 instruction set", 1166},
+  {"Do not use POWER instruction set", 1167},
+  {"Use PowerPC instruction set", 1168},
+  {"Do not use PowerPC instruction set", 1169},
+  {"Use PowerPC General Purpose group optional instructions", 1170},
+  {"Don't use PowerPC General Purpose group optional instructions", 1171},
+  {"Use PowerPC Graphics group optional instructions", 1172},
+  {"Don't use PowerPC Graphics group optional instructions", 1173},
+  {"Use PowerPC-64 instruction set", 1174},
+  {"Don't use PowerPC-64 instruction set", 1175},
+  {"Use new mnemonics for PowerPC architecture", 1176},
+  {"Use old mnemonics for PowerPC architecture", 1177},
+  {"Put everything in the regular TOC", 1178},
+  {"Place floating point constants in TOC", 1179},
+  {"Don't place floating point constants in TOC", 1180},
+  {"Place symbol+offset constants in TOC", 1181},
+  {"Don't place symbol+offset constants in TOC", 1182},
+  {"Place variable addresses in the regular TOC", 1183},
+  {"Generate load/store multiple instructions", 1184},
+  {"Do not generate load/store multiple instructions", 1185},
+  {"Generate string instructions for block moves", 1186},
+  {"Do not generate string instructions for block moves", 1187},
+  {"Generate load/store with update instructions", 1188},
+  {"Do not generate load/store with update instructions", 1189},
+  {"Generate fused multiply/add instructions", 1190},
+  {"Don't generate fused multiply/add instructions", 1191},
+  {"Don't schedule the start and end of the procedure", 1192},
+  {"Use features of and schedule code for given CPU", 1193},
+  {"Enable debug output", 1194},
+  {"RETURN_ADDRESS_OFFSET not supported", 1195},
+  {"Select ABI calling convention.", 1196},
+  {"Select method for sdata handling.", 1197},
+  {"Align to the base type of the bitfield.", 1198},
+  {"Don't align to the base type of the bitfield.", 1199},
+  {"Don't assume that unaligned accesses are handled by the system", 1200},
+  {"Assume that unaligned accesses are handled by the system", 1201},
+  {"Produce code relocatable at runtime.", 1202},
+  {"Don't produce code relocatable at runtime.", 1203},
+  {"Produce little endian code.", 1204},
+  {"Produce big endian code.", 1205},
+  {"no description yet", 1206},
+  {"Use EABI.", 1207},
+  {"Don't use EABI.", 1208},
+  {"Use alternate register names.", 1209},
+  {"Don't use alternate register names.", 1210},
+  {"Link with libsim.a, libc.a and sim-crt0.o.", 1211},
+  {"Link with libads.a, libc.a and crt0.o.", 1212},
+  {"Link with libyk.a, libc.a and crt0.o.", 1213},
+  {"Link with libmvme.a, libc.a and crt0.o.", 1214},
+  {"Set the PPC_EMB bit in the ELF flags header", 1215},
+  {"Bad value for -mcall-%s", 1216},
+  {"Bad value for -msdata=%s", 1217},
+  {"-mrelocatable and -msdata=%s are incompatible.", 1218},
+  {"-f%s and -msdata=%s are incompatible.", 1219},
+  {"-msdata=%s and -mcall-%s are incompatible.", 1220},
+  {"-mrelocatable and -mno-minimal-toc are incompatible.", 1221},
+  {"-mrelocatable and -mcall-%s are incompatible.", 1222},
+  {"-fPIC and -mcall-%s are incompatible.", 1223},
+  {"-mcall-aixdesc must be big endian", 1224},
+  {"Use 128 bit long doubles", 1225},
+  {"Generate code for big endian", 1226},
+  {"Generate code for little endian", 1227},
+  {"%s is not supported by this configuration", 1228},
+  {"-mptr%d not allowed on -m%d", 1229},
+  {"-mlong-double-64 not allowed with -m64", 1230},
+  {"bad value (%s) for -mcmodel= switch", 1231},
+  {"-mcmodel= is not supported on 32 bit systems", 1232},
+  {"profiling does not support code models other than medlow", 1233},
+  {"Invalid %%Y operand", 1234},
+  {"Invalid %%A operand", 1235},
+  {"Invalid %%B operand", 1236},
+  {"Invalid %%c operand", 1237},
+  {"Invalid %%C operand", 1238},
+  {"Invalid %%d operand", 1239},
+  {"Invalid %%D operand", 1240},
+  {"Invalid %%f operand", 1241},
+  {"long long constant not a valid immediate operand", 1242},
+  {"floating point constant not a valid immediate operand", 1243},
+  {"%s and profiling conflict: disabling %s", 1244},
+  {"Use FUNCTION_EPILOGUE", 1245},
+  {"Do not use FUNCTION_EPILOGUE", 1246},
+  {"Assume possible double misalignment", 1247},
+  {"Assume all doubles are aligned", 1248},
+  {"Pass -assert pure-text to linker", 1249},
+  {"Do not pass -assert pure-text to linker", 1250},
+  {"Use flat register window model", 1251},
+  {"Do not use flat register window model", 1252},
+  {"Use ABI reserved registers", 1253},
+  {"Do not use ABI reserved registers", 1254},
+  {"Use hardware quad fp instructions", 1255},
+  {"Do not use hardware quad fp instructions", 1256},
+  {"Compile for v8plus ABI", 1257},
+  {"Do not compile for v8plus ABI", 1258},
+  {"Utilize Visual Instruction Set", 1259},
+  {"Do not utilize Visual Instruction Set", 1260},
+  {"Optimize for Cypress processors", 1261},
+  {"Optimize for SparcLite processors", 1262},
+  {"Optimize for F930 processors", 1263},
+  {"Optimize for F934 processors", 1264},
+  {"Use V8 Sparc ISA", 1265},
+  {"Optimize for SuperSparc processors", 1266},
+  {"Pointers are 64-bit", 1267},
+  {"Pointers are 32-bit", 1268},
+  {"Use 32-bit ABI", 1269},
+  {"Use 64-bit ABI", 1270},
+  {"Use stack bias", 1271},
+  {"Do not use stack bias", 1272},
+  {"Use structs on stronger alignment for double-word copies", 1273},
+  {"Do not use structs on stronger alignment for double-word copies", 1274},
+  {"Optimize tail call instructions in assembler and linker", 1275},
+  {"Do not optimize tail call instructions in assembler or linker", 1276},
+  {"Use given Sparc code model", 1277},
+  {"%s=%s is not numeric.", 1278},
+  {"%s=%s is too large.", 1279},
+  {"a data area attribute cannot be specified for local variables", 1280},
+  {"data area of '%s' conflicts with previous declaration", 1281},
+  {"Bogus JR construction: %d\n", 1282},
+  {"Bad amount of stack space removal: %d", 1283},
+  {"Bogus JARL construction: %d\n", 1284},
+  {"#pragma GHS endXXXX found without previous startXXX", 1285},
+  {"#pragma GHS endXXX does not match previous startXXX", 1286},
+  {"Cannot set interrupt attribute: no current function", 1287},
+  {"Cannot set interrupt attribute: no such identifier", 1288},
+  {"Incomplete #pragma ghs", 1289},
+  {"Nothing follows #pragma ghs", 1290},
+  {"Unrecognised GHS pragma: '%s'\n", 1291},
+  {"Extra text after valid #pragma: '%s'", 1292},
+  {"Unrecognised section name '%s' in GHS section pragma", 1293},
+  {"Missing '=' in GHS section pragma", 1294},
+  {"Malformed GHS section pragma: found '%s' instead of a comma", 1295},
+  {"Missing trailing \" in #pragma ghs", 1296},
+  {"Support Green Hills ABI", 1297},
+  {"Prohibit PC relative function calls", 1298},
+  {"Reuse r30 on a per function basis", 1299},
+  {"Use stubs for function prologues", 1300},
+  {"Same as: -mep -mprolog-function", 1301},
+  {"Enable backend debugging", 1302},
+  {"Compile for the v850 processor", 1303},
+  {"Use 4 byte entries in switch tables", 1304},
+  {"Set the max size of data eligible for the TDA area", 1305},
+  {"Set the max size of data eligible for the SDA area", 1306},
+  {"Set the max size of data eligible for the ZDA area", 1307},
+  {"cannot convert to a pointer type", 1308},
+  {"pointer value used where a floating point value was expected", 1309},
+  {"aggregate value used where a float was expected", 1310},
+  {"conversion to incomplete type", 1311},
+  {"can't convert between vector values of different size", 1312},
+  {"aggregate value used where an integer was expected", 1313},
+  {"pointer value used where a complex was expected", 1314},
+  {"aggregate value used where a complex was expected", 1315},
+  {"can't convert value to a vector", 1316},
+  {"unable to call pointer to member function here", 1317},
+  {"destructors take no parameters", 1318},
+  {"ISO C++ forbids omitting the middle term of a ?: expression", 1319},
+  {"internal inconsistency: binfo offset error for rtti", 1320},
+  {"conflicting access specifications for field `%s', ignored", 1321},
+  {"trying to finish struct, but kicked out due to previous parse errors.", 1322},
+  {"language string `\"%s\"' not recognized", 1323},
+  {"not enough type information", 1324},
+  {"invalid operation on uninstantiated type", 1325},
+  {"\
+object size exceeds built-in limit for virtual function table implementation", 1326},
+  {"\
+object size exceeds normal limit for virtual function table implementation, \
+recompile all source and use -fhuge-objects", 1327},
+  {"internal compiler error: debugging info corrupted", 1328},
+  {"parse errors have confused me too much", 1329},
+  {"declaration of `%s' shadows a member of `this'", 1330},
+  {"label `%s' referenced outside of any function", 1331},
+  {"jump to case label", 1332},
+  {"  enters try block", 1333},
+  {"  from here", 1334},
+  {"where case label appears here", 1335},
+  {"(enclose actions of previous case statements requiring", 1336},
+  {"destructors in their own binding contours.)", 1337},
+  {"virtual memory exhausted", 1338},
+  {"the new ABI requires vtable thunks", 1339},
+  {"an anonymous union cannot have function members", 1340},
+  {"multiple types in one declaration", 1341},
+  {"declaration does not declare anything", 1342},
+  {"ISO C++ prohibits anonymous structs", 1343},
+  {"assignment (not initialization) in declaration", 1344},
+  {"invalid catch parameter", 1345},
+  {"destructor for alien class `%s' cannot be a member", 1346},
+  {"constructor for alien class `%s' cannot be a member", 1347},
+  {"cannot declare `::main' to be a template", 1348},
+  {"cannot declare `::main' to be inline", 1349},
+  {"cannot declare `::main' to be static", 1350},
+  {"overflow in array dimension", 1351},
+  {"destructors must be member functions", 1352},
+  {"`bool' is now a keyword", 1353},
+  {"ISO C++ does not support `long long'", 1354},
+  {"short, signed or unsigned invalid for `%s'", 1355},
+  {"long and short specified together for `%s'", 1356},
+  {"signed and unsigned given together for `%s'", 1357},
+  {"storage class specifiers invalid in parameter declarations", 1358},
+  {"typedef declaration invalid in parameter declaration", 1359},
+  {"virtual outside class declaration", 1360},
+  {"storage class specified for %s `%s'", 1361},
+  {"storage class specifiers invalid in friend function declarations", 1362},
+  {"destructor cannot be static member function", 1363},
+  {"constructor cannot be static member function", 1364},
+  {"constructors cannot be declared virtual", 1365},
+  {"return value type specifier for constructor ignored", 1366},
+  {"can't initialize friend function `%s'", 1367},
+  {"virtual functions cannot be friends", 1368},
+  {"friend declaration not in class definition", 1369},
+  {"cannot declare %s to references", 1370},
+  {"invalid type: `void &'", 1371},
+  {"discarding `const' applied to a reference", 1372},
+  {"discarding `volatile' applied to a reference", 1373},
+  {"only declarations of constructors can be `explicit'", 1374},
+  {"non-member `%s' cannot be declared `mutable'", 1375},
+  {"non-object member `%s' cannot be declared `mutable'", 1376},
+  {"function `%s' cannot be declared `mutable'", 1377},
+  {"static `%s' cannot be declared `mutable'", 1378},
+  {"const `%s' cannot be declared `mutable'", 1379},
+  {"typedef declaration includes an initializer", 1380},
+  {"trying to make class `%s' a friend of global scope", 1381},
+  {"unnamed variable or field declared void", 1382},
+  {"variable or field declared void", 1383},
+  {"cannot use `::' in parameter declaration", 1384},
+  {"declaration of `%s' as void", 1385},
+  {"`%s' is neither function nor member function; cannot be declared friend", 1386},
+  {"member functions are implicitly friends of their class", 1387},
+  {"storage class `auto' invalid for function `%s'", 1388},
+  {"storage class `register' invalid for function `%s'", 1389},
+  {"\
+storage class `static' invalid for function `%s' declared out of global scope", 1390},
+  {"\
+storage class `inline' invalid for function `%s' declared out of global scope", 1391},
+  {"virtual non-class function `%s'", 1392},
+  {"cannot declare static function inside another function", 1393},
   {"\
 invalid integer constant in parameter list, did you forget to give parameter \
-name?", 594},
-  {"parameter invalidly declared method type", 595},
-  {"parameter invalidly declared offset type", 596},
-  {"`void' in parameter list must be entire list", 597},
-  {"no file specified with -fdump-translation-unit", 598},
-  {"name missing for member function", 599},
-  {"`__alignof__' applied to a bit-field", 600},
-  {"parser may be lost: is there a '{' missing somewhere?", 601},
-  {"ambiguous conversion for array subscript", 602},
+name?", 1394},
+  {"parameter invalidly declared method type", 1395},
+  {"parameter invalidly declared offset type", 1396},
+  {"`void' in parameter list must be entire list", 1397},
+  {"conversion to %s%s will never use a type conversion operator", 1398},
+  {"return type for `main' changed to `int'", 1399},
+  {"-f%s is no longer supported", 1400},
+  {"\
+-fhandle-exceptions has been renamed to -fexceptions (and is now on by \
+default)", 1401},
+  {"no file specified with -fdump-translation-unit", 1402},
+  {"name missing for member function", 1403},
+  {"`__alignof__' applied to a bit-field", 1404},
+  {"parser may be lost: is there a '{' missing somewhere?", 1405},
+  {"ambiguous conversion for array subscript", 1406},
+  {"anachronistic use of array size in vector delete", 1407},
   {"\
 cannot delete a function.  Only pointer-to-objects are valid arguments to \
-`delete'", 603},
-  {"initializer invalid for static member with constructor", 604},
-  {"(you really want to initialize it separately)", 605},
-  {"field initializer is not constant", 606},
-  {"anonymous struct not inside named type", 607},
-  {"namespace-scope anonymous aggregates must be static", 608},
-  {"`operator new' must return type `void *'", 609},
-  {"`operator new' takes type `size_t' parameter", 610},
-  {"`operator new' takes type `size_t' as first parameter", 611},
-  {"`operator delete' must return type `void'", 612},
-  {"`operator delete' takes type `void *' as first parameter", 613},
-  {"second argument to `operator delete' must be of type `size_t'", 614},
-  {"too many arguments in declaration of `operator delete'", 615},
-  {"`...' invalid in specification of `operator delete'", 616},
-  {"call to Java `catch' or `throw', while `jthrowable' undefined", 617},
-  {"mixing C++ and Java `catch'es in single translation unit", 618},
-  {"  in thrown expression", 619},
-  {"pointers are not permitted as case values", 620},
-  {"duplicate (or overlapping) case value", 621},
-  {"`default' label within scope of cleanup or variable array", 622},
-  {"argument to `%s' missing\n", 623},
-  {"base class initializer specified, but no base class to initialize", 624},
-  {"initializer for unnamed base class ambiguous", 625},
-  {"no base class to initialize", 626},
-  {"bad array initializer", 627},
-  {"object missing in use of pointer-to-member construct", 628},
-  {"at this point in file", 629},
-  {"new of array type fails to specify size", 630},
-  {"new cannot be applied to a reference type", 631},
-  {"new cannot be applied to a function type", 632},
-  {"call to Java constructor, while `jclass' undefined", 633},
-  {"invalid type `void' for new", 634},
-  {"call to Java constructor, while `%s' undefined", 635},
-  {"initializer ends prematurely", 636},
-  {"unknown array size in delete", 637},
-  {"type to vector delete is neither pointer or array type", 638},
-  {"type name expected before `*'", 639},
-  {"cannot declare references to references", 640},
-  {"cannot declare pointers to references", 641},
-  {"type name expected before `&'", 642},
-  {"parse error at end of saved function text", 643},
-  {"end of file encountered inside string constant", 644},
-  {"end of file encountered inside character constant", 645},
-  {"parse error in method specification", 646},
-  {"function body for constructor missing", 647},
-  {"semicolon missing after %s declaration", 648},
-  {"invalid #pragma vtable", 649},
-  {"invalid #pragma unit", 650},
-  {"invalid `#pragma interface'", 651},
-  {"invalid `#pragma implementation'", 652},
-  {"non hex digit '%c' in universal-character-name", 653},
+`delete'", 1408},
+  {"initializer invalid for static member with constructor", 1409},
+  {"(you really want to initialize it separately)", 1410},
+  {"field initializer is not constant", 1411},
+  {"anonymous struct not inside named type", 1412},
+  {"namespace-scope anonymous aggregates must be static", 1413},
+  {"anonymous aggregate with no members", 1414},
+  {"`operator new' must return type `void *'", 1415},
+  {"`operator new' takes type `size_t' parameter", 1416},
+  {"`operator new' takes type `size_t' as first parameter", 1417},
+  {"`operator delete' must return type `void'", 1418},
+  {"`operator delete' takes type `void *' as first parameter", 1419},
+  {"second argument to `operator delete' must be of type `size_t'", 1420},
+  {"too many arguments in declaration of `operator delete'", 1421},
+  {"`...' invalid in specification of `operator delete'", 1422},
+  {"too many initialization functions required", 1423},
+  {"use of old-style cast", 1424},
+  {"`%s' not supported by dump_type", 1425},
+  {"`%s' not supported by dump_type_prefix", 1426},
+  {"`%s' not supported by dump_type_suffix", 1427},
+  {"`%s' not supported by dump_decl", 1428},
+  {"`%s' not supported by dump_expr", 1429},
+  {"call to Java `catch' or `throw', while `jthrowable' undefined", 1430},
+  {"mixing C++ and Java `catch'es in single translation unit", 1431},
+  {"  in thrown expression", 1432},
+  {"pointers are not permitted as case values", 1433},
+  {"ISO C++ forbids range expressions in switch statement", 1434},
+  {"duplicate (or overlapping) case value", 1435},
+  {"empty range specified", 1436},
+  {"`default' label within scope of cleanup or variable array", 1437},
+  {"class `%s' is implicitly friends with itself", 1438},
+  {"  declares a non-template function", 1439},
+  {"\
+  (if this is not what you intended, make sure the function template has \
+already been declared and add <> after the function name here) \
+-Wno-non-template-friend disables this warning.", 1440},
+  {"argument to `%s' missing\n", 1441},
+  {"initializer list treated as compound expression", 1442},
+  {"  will be re-ordered to match declaration order", 1443},
+  {"  will be re-ordered to match inheritance order", 1444},
+  {"base class initializer specified, but no base class to initialize", 1445},
+  {"initializer for unnamed base class ambiguous", 1446},
+  {"no base class to initialize", 1447},
+  {"bad array initializer", 1448},
+  {"object missing in use of pointer-to-member construct", 1449},
+  {"at this point in file", 1450},
+  {"new of array type fails to specify size", 1451},
+  {"size in array new must have integral type", 1452},
+  {"zero size array reserves no space", 1453},
+  {"new cannot be applied to a reference type", 1454},
+  {"new cannot be applied to a function type", 1455},
+  {"call to Java constructor, while `jclass' undefined", 1456},
+  {"invalid type `void' for new", 1457},
+  {"call to Java constructor, while `%s' undefined", 1458},
+  {"initializer list being treated as compound expression", 1459},
+  {"initializer list appears where operand should be used", 1460},
+  {"initialization of array from dissimilar array type", 1461},
+  {"initializer ends prematurely", 1462},
+  {"cannot initialize multi-dimensional array with initializer", 1463},
+  {"unknown array size in delete", 1464},
+  {"type to vector delete is neither pointer or array type", 1465},
+  {"type name expected before `*'", 1466},
+  {"cannot declare references to references", 1467},
+  {"cannot declare pointers to references", 1468},
+  {"type name expected before `&'", 1469},
+  {"parse error at end of saved function text", 1470},
+  {"end of file encountered inside string constant", 1471},
+  {"end of file encountered inside character constant", 1472},
+  {"ISO C++ forbids newline in string constant", 1473},
+  {"parse error in method specification", 1474},
+  {"function body for constructor missing", 1475},
+  {"semicolon missing after %s declaration", 1476},
+  {"\
+carriage return in source file (we only warn about the first carriage return)", 1477},
+  {"badly nested C headers from preprocessor", 1478},
+  {"invalid #pragma vtable", 1479},
+  {"trailing characters ignored", 1480},
+  {"invalid #pragma unit", 1481},
+  {"invalid `#pragma interface'", 1482},
+  {"garbage after `#pragma interface' ignored", 1483},
+  {"invalid `#pragma implementation'", 1484},
+  {"garbage after `#pragma implementation' ignored", 1485},
+  {"non hex digit '%c' in universal-character-name", 1486},
+  {"universal-character-name on EBCDIC target", 1487},
   {"\
 universal-character-name designates `%c', part of the basic source character \
-set", 654},
-  {"invalid universal-character-name", 655},
-  {"universal-character-name `\\U%08x' not valid in identifier", 656},
-  {"universal-character-name `\\u%04x' not valid in identifier", 657},
-  {"\\x used with no following hex digits", 658},
-  {"%s at end of saved text", 659},
+set", 1488},
+  {"invalid universal-character-name", 1489},
+  {"universal-character-name `\\U%08x' not valid in identifier", 1490},
+  {"universal-character-name `\\u%04x' not valid in identifier", 1491},
+  {"non-ISO-standard escape sequence, `\\%c'", 1492},
+  {"%s at end of saved text", 1493},
   {"\
 (Each undeclared identifier is reported only once for each function it \
-appears in.)", 660},
-  {"name lookup of `%s' changed for new ISO `for' scoping", 661},
-  {"complex integer constant is too wide for `__complex int'", 662},
-  {"malformatted character constant", 663},
-  {"ambiguous request for method pointer `%s'", 664},
-  {"request for member `%s' is ambiguous in multiple inheritance lattice", 665},
-  {"invalid default template argument", 666},
-  {"no base initializers given following ':'", 667},
-  {"base initializers not allowed for non-member functions", 668},
-  {"only constructors take base initializers", 669},
-  {"ISO C++ forbids an empty condition for `%s'", 670},
-  {"`sigof' applied to non-aggregate expression", 671},
-  {"`sigof' applied to non-aggregate type", 672},
-  {"storage class specifier `%s' not allowed after struct or class", 673},
-  {"type specifier `%s' not allowed after struct or class", 674},
-  {"type qualifier `%s' not allowed after struct or class", 675},
-  {"no body nor ';' separates two class, struct or union declarations", 676},
-  {"multiple access specifiers", 677},
-  {"multiple `virtual' specifiers", 678},
-  {"missing ';' before right brace", 679},
-  {"label must be followed by statement", 680},
-  {"possibly missing ')'", 681},
-  {"type specifier omitted for parameter", 682},
-  {"  a template type parameter must begin with `class' or `typename'", 683},
-  {"incomplete type unification", 684},
-  {"mysterious repository information in %s", 685},
-  {"can't create repository information file `%s'", 686},
-  {"taking dynamic typeid of object with -fno-rtti", 687},
-  {"cannot use typeid with -fno-rtti", 688},
-  {"must #include <typeinfo> before using typeid", 689},
-  {"non-lvalue in %s", 690},
-  {"`com_interface' only supported with -fvtable-thunks", 691},
-  {"requested init_priority is not an integer constant", 692},
+appears in.)", 1494},
+  {"name lookup of `%s' changed", 1495},
+  {"name lookup of `%s' changed for new ISO `for' scoping", 1496},
+  {"ISO C++ forbids imaginary numeric constants", 1497},
+  {"universal characters in identifiers", 1498},
+  {"identifier name `%s' conflicts with GNU C++ internal naming strategy", 1499},
+  {"ISO C++ forbids long long integer constants", 1500},
+  {"complex integer constant is too wide for `__complex int'", 1501},
+  {"ISO C++ forbids newline in character constant", 1502},
+  {"malformatted character constant", 1503},
+  {"use of `operator %s' is not standard C++", 1504},
+  {"conversion of %s as template parameter", 1505},
+  {"methods cannot be converted to function pointers", 1506},
+  {"ambiguous request for method pointer `%s'", 1507},
+  {"request for member `%s' is ambiguous in multiple inheritance lattice", 1508},
+  {"invalid default template argument", 1509},
+  {"no base or member initializers given following ':'", 1510},
+  {"base initializers not allowed for non-member functions", 1511},
+  {"only constructors take base initializers", 1512},
+  {"anachronistic old style base class initializer", 1513},
+  {"`>>' should be `> >' in template class name", 1514},
+  {"ISO C++ forbids an empty condition for `%s'", 1515},
+  {"ISO C++ forbids `&&'", 1516},
+  {"ISO C++ forbids initialization of new expression with `='", 1517},
+  {"ISO C++ forbids constructor-expressions", 1518},
+  {"ISO C++ forbids braced-groups within expressions", 1519},
+  {"sigof type specifier", 1520},
+  {"`sigof' applied to non-aggregate expression", 1521},
+  {"`sigof' applied to non-aggregate type", 1522},
+  {"storage class specifier `%s' not allowed after struct or class", 1523},
+  {"type specifier `%s' not allowed after struct or class", 1524},
+  {"type qualifier `%s' not allowed after struct or class", 1525},
+  {"no body nor ';' separates two class, struct or union declarations", 1526},
+  {"multiple access specifiers", 1527},
+  {"multiple `virtual' specifiers", 1528},
+  {"missing ';' before right brace", 1529},
+  {"ISO C++ forbids array dimensions with parenthesized type in new", 1530},
+  {"ISO C++ forbids label declarations", 1531},
+  {"ISO C++ forbids computed gotos", 1532},
+  {"label must be followed by statement", 1533},
+  {"ISO C++ forbids compound statements inside for initializations", 1534},
+  {"possibly missing ')'", 1535},
+  {"type specifier omitted for parameter", 1536},
+  {"  a template type parameter must begin with `class' or `typename'", 1537},
+  {"creating array with size zero", 1538},
+  {"use of `%s' in template", 1539},
+  {"incomplete type unification", 1540},
+  {"use of `%s' in template type unification", 1541},
+  {"-frepo must be used with -c", 1542},
+  {"mysterious repository information in %s", 1543},
+  {"can't create repository information file `%s'", 1544},
+  {"taking dynamic typeid of object with -fno-rtti", 1545},
+  {"cannot use typeid with -fno-rtti", 1546},
+  {"must #include <typeinfo> before using typeid", 1547},
+  {"adjusting pointers for covariant returns", 1548},
+  {"recoverable compiler error, fixups for virtual function", 1549},
+  {"keyword 'export' not implemented and will be ignored", 1550},
+  {"non-lvalue in %s", 1551},
+  {"`com_interface' only supported with -fvtable-thunks", 1552},
+  {"`com_interface' attribute can only be applied to class definitions", 1553},
+  {"requested init_priority is not an integer constant", 1554},
   {"\
 can only use init_priority attribute on file-scope definitions of objects of \
-class type", 693},
-  {"requested init_priority is out of range", 694},
-  {"sizeof applied to a bit-field", 695},
-  {"invalid reference to NULL ptr, use ptr-to-member instead", 696},
-  {"invalid use of `%s' on pointer to member", 697},
-  {"invalid type argument", 698},
-  {"pointer to member function called, but not in class scope", 699},
+class type", 1555},
+  {"requested init_priority is out of range", 1556},
+  {"requested init_priority is reserved for internal use", 1557},
+  {"\
+ISO C++ forbids %s between pointer of type `void *' and pointer-to-function", 1558},
+  {"ISO C++ forbids applying `sizeof' to a function type", 1559},
+  {"ISO C++ forbids applying `sizeof' to a member function", 1560},
+  {"\
+ISO C++ forbids applying `sizeof' to type `void' which is an incomplete type", 1561},
+  {"sizeof applied to a bit-field", 1562},
+  {"ISO C++ forbids applying `sizeof' to an expression of function type", 1563},
+  {"invalid reference to NULL ptr, use ptr-to-member instead", 1564},
+  {"invalid use of `%s' on pointer to member", 1565},
+  {"invalid type argument", 1566},
+  {"ISO C++ forbids subscripting non-lvalue array", 1567},
+  {"subscripting array declared `register'", 1568},
+  {"pointer to member function called, but not in class scope", 1569},
   {"\
 invalid call to member function needing `this' in static member function \
-scope", 700},
-  {"parameter type of called function is incomplete", 701},
-  {"ISO C++ forbids comparison between pointer and integer", 702},
-  {"invalid use of a pointer to an incomplete type in pointer arithmetic", 703},
-  {"unary `&'", 704},
-  {"cannot take the address of `this', which is an ravlue expression", 705},
-  {"ISO C++ forbids casting to an array type", 706},
-  {"   in pointer to member function conversion", 707},
-  {"   in pointer to member conversion", 708},
-  {"returning a value from a destructor", 709},
-  {"cannot return from a handler of a function-try-block of a constructor", 710},
-  {"returning a value from a constructor", 711},
-  {"  since the following virtual functions are abstract:", 712},
-  {"confused by earlier errors, bailing out", 713},
-  {"Internal compiler error.", 714},
-  {"Internal compiler error %d.", 715},
-  {"Please submit a full bug report.", 716},
-  {"See %s for instructions.", 717},
-  {"due to the presence of a constructor", 718},
-  {"cannot initialize arrays using this syntax", 719},
-  {"initializing array with parameter list", 720},
-  {"initializer for scalar variable requires one element", 721},
-  {"non-empty initializer for array of empty elements", 722},
-  {"index value instead of field name in union initializer", 723},
-  {"circular pointer delegation detected", 724},
-  {"result of `operator->()' yields non-pointer result", 725},
-  {"base operand of `->' is not a pointer", 726},
-  {"duplicate label `%s' in switch statement", 727},
-  {"duplicate label (%d) in switch statement", 728},
-  {"range values `%s' and `%s' reversed", 729},
-  {"range values reversed", 730},
-  {"Can't create cross-reference file `%s'", 731},
-  {"Internal gcc abort.", 732},
-  {"In file included from %s:%u", 733},
+scope", 1570},
+  {"ISO C++ forbids calling `::main' from within program", 1571},
+  {"parameter type of called function is incomplete", 1572},
+  {"%s rotate count is negative", 1573},
+  {"%s rotate count >= width of type", 1574},
+  {"ISO C++ forbids comparison of `void *' with function pointer", 1575},
+  {"ISO C++ forbids conversion of a pointer to member to `void *'", 1576},
+  {"ISO C++ forbids comparison between pointer and integer", 1577},
+  {"comparison between a signed and an unsigned integer expressions", 1578},
+  {"ISO C++ forbids using pointer of type `void *' in pointer arithmetic", 1579},
+  {"ISO C++ forbids using a pointer-to-function in pointer arithmetic", 1580},
+  {"\
+ISO C++ forbids using a pointer to member function in pointer arithmetic", 1581},
+  {"ISO C++ forbids using pointer to a member in pointer arithmetic", 1582},
+  {"ISO C++ forbids using pointer of type `void *' in subtraction", 1583},
+  {"ISO C++ forbids using pointer to a function in subtraction", 1584},
+  {"ISO C++ forbids using pointer to a method in subtraction", 1585},
+  {"ISO C++ forbids using pointer to a member in subtraction", 1586},
+  {"invalid use of a pointer to an incomplete type in pointer arithmetic", 1587},
+  {"taking address of temporary", 1588},
+  {"ISO C++ forbids %sing an enum", 1589},
+  {"cast to non-reference type used as lvalue", 1590},
+  {"ISO C++ forbids taking address of function `::main'", 1591},
+  {"ISO C++ forbids taking the address of a cast to a non-lvalue expression", 1592},
+  {"unary `&'", 1593},
+  {"cannot take the address of `this', which is an ravlue expression", 1594},
+  {"\
+ISO C++ forbids casting between pointer-to-function and pointer-to-object", 1595},
+  {"ISO C++ forbids casting to an array type", 1596},
+  {"ISO C++ forbids cast to non-reference type used as lvalue", 1597},
+  {"ISO C++ forbids assignment of arrays", 1598},
+  {"return value from function receives multiple initializations", 1599},
+  {"   in pointer to member function conversion", 1600},
+  {"   in pointer to member conversion", 1601},
+  {"returning reference to temporary", 1602},
+  {"reference to non-lvalue returned", 1603},
+  {"returning a value from a destructor", 1604},
+  {"cannot return from a handler of a function-try-block of a constructor", 1605},
+  {"returning a value from a constructor", 1606},
+  {"\
+return-statement with no value, in function declared with a non-void return \
+type", 1607},
+  {"\
+return-statement with a value, in function declared with a void return type", 1608},
+  {"  since the following virtual functions are abstract:", 1609},
+  {"confused by earlier errors, bailing out", 1610},
+  {"Internal compiler error.", 1611},
+  {"Internal compiler error %d.", 1612},
+  {"Please submit a full bug report.", 1613},
+  {"See %s for instructions.", 1614},
+  {"due to the presence of a constructor", 1615},
+  {"comma expression used to initialize return value", 1616},
+  {"cannot initialize arrays using this syntax", 1617},
+  {"ANSI C++ forbids non-constant aggregate initializer expressions", 1618},
+  {"initializing array with parameter list", 1619},
+  {"initializer for scalar variable requires one element", 1620},
+  {"aggregate has a partly bracketed initializer", 1621},
+  {"non-trivial labeled initializers", 1622},
+  {"non-empty initializer for array of empty elements", 1623},
+  {"initializer list for object of class with virtual base classes", 1624},
+  {"initializer list for object of class with base classes", 1625},
+  {"initializer list for object using virtual functions", 1626},
+  {"index value instead of field name in union initializer", 1627},
+  {"excess elements in aggregate initializer", 1628},
+  {"circular pointer delegation detected", 1629},
+  {"result of `operator->()' yields non-pointer result", 1630},
+  {"base operand of `->' is not a pointer", 1631},
+  {"duplicate label `%s' in switch statement", 1632},
+  {"duplicate label (%d) in switch statement", 1633},
+  {"case value out of range for enum %s", 1634},
+  {"range values `%s' and `%s' reversed", 1635},
+  {"range values reversed", 1636},
+  {"ISO C++ forbids defining types within %s", 1637},
+  {"Can't create cross-reference file `%s'", 1638},
+  {"Internal gcc abort.", 1639},
+  {"In file included from %s:%u", 1640},
   {"\
 ,\n\
-                 from %s:%u", 734},
-  {"<command line>: ", 735},
-  {"warning: ", 736},
-  {"internal error: ", 737},
-  {"bad is_error(%d) in v_message", 738},
-  {"%s: %s", 739},
-  {"floating point numbers are not allowed in #if expressions", 740},
-  {"invalid number in #if expression", 741},
-  {"too many 'l' suffixes in integer constant", 742},
-  {"too many 'u' suffixes in integer constant", 743},
-  {"integer constant contains digits beyond the radix", 744},
-  {"integer constant out of range", 745},
-  {"integer constant is so large that it is unsigned", 746},
-  {"escape sequence out of range for character", 747},
-  {"multi-character character constant", 748},
-  {"'defined' without an identifier", 749},
-  {"string constants are not allowed in #if expressions", 750},
-  {"'%.*s' is not defined", 751},
-  {"'%.*s' is not allowed in #if expressions", 752},
-  {"non-ANSI-standard escape sequence, '\\%c'", 753},
-  {"octal escape sequence out of range", 754},
-  {"hex escape sequence out of range", 755},
-  {"integer overflow in preprocessor expression", 756},
-  {"comma operator in operand of #if", 757},
-  {"included file `%s' exists but is not readable", 758},
-  {"No include path in which to find %s", 759},
-  {"%s is too large", 760},
-  {"%s is shorter than expected\n", 761},
-  {"%s is a block device", 762},
-  {"%s is a directory", 763},
-  {"macro argument \"%s\" would be stringified in traditional C", 764},
-  {"macro argument \"%s\" is stringified", 765},
-  {"`##' at start of macro definition", 766},
-  {"`##' at end of macro definition", 767},
-  {"empty object-like macro went through full #define", 768},
-  {"# is not followed by a macro argument name", 769},
-  {"`#' is not followed by a macro argument name", 770},
-  {"first token = %d not %d in collect_formal_parameters", 771},
-  {"impossible token in macro argument list", 772},
-  {"illegal token in macro argument list", 773},
-  {"another parameter follows \"...\"", 774},
-  {"missing right paren in macro argument list", 775},
-  {"collect_params: argc=%d argslen=0", 776},
-  {"duplicate macro argument name \"%s\"", 777},
-  {"C99 does not permit use of __VA_ARGS__ as a macro argument name", 778},
-  {"C89 does not permit varargs macros", 779},
-  {"ISO C does not permit named varargs macros", 780},
-  {"collect_params: impossible token type %d", 781},
-  {"The C standard requires whitespace after #define %s", 782},
-  {"\"%s\" redefined", 783},
-  {"this is the location of the previous definition", 784},
-  {"attempt to use poisoned `%s'.", 785},
-  {"invalid special hash type", 786},
-  {"macroexpand: unexpected token %d (wanted LPAREN)", 787},
-  {"unterminated macro call", 788},
-  {"arguments given to macro `%s'", 789},
-  {"macro `%s' used without args", 790},
-  {"macro `%s' used with just one arg", 791},
-  {"macro `%s' used with only %d args", 792},
-  {"macro `%s' used with too many (%d) args", 793},
-  {"invalid hash type %d in dump_definition", 794},
-  {"ignoring nonexistent directory `%s'\n", 795},
-  {"%s: Not a directory", 796},
-  {"ignoring duplicate directory `%s'\n", 797},
-  {"-MG must be specified with one of -M or -MM", 798},
-  {"-lang-chill and -trigraphs are mutually exclusive", 799},
-  {"#include \"...\" search starts here:\n", 800},
-  {"#include <...> search starts here:\n", 801},
-  {"End of search list.\n", 802},
-  {"buffers still stacked in cpp_finish", 803},
-  {"I/O error on output", 804},
-  {"Argument missing after %s", 805},
-  {"Assertion missing after %s", 806},
-  {"Directory name missing after %s", 807},
-  {"File name missing after %s", 808},
-  {"Macro name missing after %s", 809},
-  {"Path name missing after %s", 810},
-  {"Number missing after %s", 811},
-  {"Too many arguments. Type %s --help for usage info", 812},
-  {"GNU CPP version %s (cpplib)\n", 813},
-  {"Output filename specified twice", 814},
-  {"-I- specified twice", 815},
-  {"Usage: %s [switches] input output\n", 816},
+                 from %s:%u", 1641},
+  {"<command line>: ", 1642},
+  {"warning: ", 1643},
+  {"internal error: ", 1644},
+  {"bad is_error(%d) in v_message", 1645},
+  {"%s: %s", 1646},
+  {"floating point numbers are not allowed in #if expressions", 1647},
+  {"invalid number in #if expression", 1648},
+  {"too many 'l' suffixes in integer constant", 1649},
+  {"too many 'u' suffixes in integer constant", 1650},
+  {"integer constant contains digits beyond the radix", 1651},
+  {"integer constant out of range", 1652},
+  {"integer constant is so large that it is unsigned", 1653},
+  {"'defined' without an identifier", 1654},
+  {"string constants are not allowed in #if expressions", 1655},
+  {"'%.*s' is not defined", 1656},
+  {"'%.*s' is not allowed in #if expressions", 1657},
+  {"non-ANSI-standard escape sequence, '\\%c'", 1658},
+  {"octal escape sequence out of range", 1659},
+  {"hex escape sequence out of range", 1660},
+  {"integer overflow in preprocessor expression", 1661},
+  {"comma operator in operand of #if", 1662},
+  {"included file `%s' exists but is not readable", 1663},
+  {"node for '%s' exists, open failed, error '%s', value %lx\n", 1664},
+  {"cpp_make_system_header: bad flag %d\n", 1665},
+  {"cpp_make_system_header called on non-file buffer", 1666},
+  {"No include path in which to find %s", 1667},
+  {"%s is too large", 1668},
+  {"%s is shorter than expected\n", 1669},
+  {"%s is a block device", 1670},
+  {"%s is a directory", 1671},
+  {"macro argument \"%s\" would be stringified in traditional C", 1672},
+  {"macro argument \"%s\" is stringified", 1673},
+  {"`##' at start of macro definition", 1674},
+  {"`##' at end of macro definition", 1675},
+  {"empty object-like macro went through full #define", 1676},
+  {"# is not followed by a macro argument name", 1677},
+  {"`#' is not followed by a macro argument name", 1678},
+  {"first token = %d not %d in collect_formal_parameters", 1679},
+  {"impossible token in macro argument list", 1680},
+  {"illegal token in macro argument list", 1681},
+  {"another parameter follows \"...\"", 1682},
+  {"missing right paren in macro argument list", 1683},
+  {"collect_params: argc=%d argslen=0", 1684},
+  {"duplicate macro argument name \"%s\"", 1685},
+  {"C99 does not permit use of __VA_ARGS__ as a macro argument name", 1686},
+  {"C89 does not permit varargs macros", 1687},
+  {"ISO C does not permit named varargs macros", 1688},
+  {"collect_params: impossible token type %d", 1689},
+  {"The C standard requires whitespace after #define %s", 1690},
+  {"\"%s\" redefined", 1691},
+  {"this is the location of the previous definition", 1692},
+  {"attempt to use poisoned `%s'.", 1693},
+  {"invalid special hash type", 1694},
+  {"macroexpand: unexpected token %d (wanted LPAREN)", 1695},
+  {"unterminated macro call", 1696},
+  {"arguments given to macro `%s'", 1697},
+  {"macro `%s' used without args", 1698},
+  {"macro `%s' used with just one arg", 1699},
+  {"macro `%s' used with only %d args", 1700},
+  {"macro `%s' used with too many (%d) args", 1701},
+  {"invalid hash type %d in dump_definition", 1702},
+  {"ignoring nonexistent directory `%s'\n", 1703},
+  {"%s: Not a directory", 1704},
+  {"ignoring duplicate directory `%s'\n", 1705},
+  {"-MG must be specified with one of -M or -MM", 1706},
+  {"-lang-chill and -trigraphs are mutually exclusive", 1707},
+  {"#include \"...\" search starts here:\n", 1708},
+  {"#include <...> search starts here:\n", 1709},
+  {"End of search list.\n", 1710},
+  {"buffers still stacked in cpp_finish", 1711},
+  {"I/O error on output", 1712},
+  {"Argument missing after %s", 1713},
+  {"Assertion missing after %s", 1714},
+  {"Directory name missing after %s", 1715},
+  {"File name missing after %s", 1716},
+  {"Macro name missing after %s", 1717},
+  {"Path name missing after %s", 1718},
+  {"Number missing after %s", 1719},
+  {"Too many arguments. Type %s --help for usage info", 1720},
+  {"GNU CPP version %s (cpplib)\n", 1721},
+  {"Output filename specified twice", 1722},
+  {"-I- specified twice", 1723},
+  {"Usage: %s [switches] input output\n", 1724},
   {"\
 Switches:\n\
   -include <file>           Include the contents of <file> before other \
@@ -939,416 +1885,555 @@ end\n\
   -$                        Do not allow '$' in identifiers\n\
   -remap                    Remap file names when including files.\n\
   --version                 Display version information\n\
-  -h or --help              Display this information\n", 817},
-  {"macro or `#include' recursion too deep", 818},
-  {"mark active in cpp_pop_buffer", 819},
-  {"length < 0 in cpp_expand_to_buffer", 820},
-  {"'/*' within comment", 821},
-  {"unterminated comment", 822},
-  {"backslash-newline within line comment", 823},
-  {"C++ style comments are not allowed in traditional C", 824},
-  {"C++ style comments are not allowed in ISO C89", 825},
-  {"(this will be reported only once per input file)", 826},
-  {"embedded null character ignored", 827},
-  {"embedded null characters ignored", 828},
-  {"%s in preprocessing directive", 829},
-  {"unterminated string or character constant", 830},
-  {"possible real start of unterminated constant", 831},
-  {"unterminated character constant", 832},
-  {"string constant runs past end of line", 833},
-  {"\\r escape inside string constant", 834},
-  {"null character in string or character constant", 835},
-  {"null characters in string or character constant", 836},
-  {"missing '>' in `#include <FILENAME>'", 837},
-  {"unrecognized escape \\r%c", 838},
-  {"function macro %s must be used with arguments in traditional C", 839},
-  {"vertical tab in preprocessing directive", 840},
-  {"form feed in preprocessing directive", 841},
-  {"trigraph ??%c converted to %c", 842},
-  {"trigraph ??%c ignored", 843},
-  {"no newline at end of file", 844},
-  {"'$' character in identifier", 845},
-  {"multi-line string constant", 846},
-  {"missing terminating %c character", 847},
-  {"possible start of unterminated string literal", 848},
-  {"null characters preserved", 849},
-  {"null character preserved", 850},
-  {"comment start split across lines", 851},
-  {"multi-line comment", 852},
-  {"comment start '/*' split across lines", 853},
-  {"comment end '*/' split across lines", 854},
-  {"backslash and newline separated by space", 855},
-  {"Unspellable token", 856},
-  {"handle_directive called on macro buffer", 857},
-  {"# followed by integer", 858},
-  {"invalid preprocessing directive #%s", 859},
-  {"ignoring #%s because of its indented #", 860},
-  {"#%s may not be used inside a macro argument", 861},
-  {"ISO C does not allow #%s", 862},
-  {"traditional C ignores #%s with the # indented", 863},
-  {"suggest hiding #%s from traditional C with an indented #", 864},
-  {"#define must be followed by an identifier", 865},
-  {"\"defined\" is not a legal macro name", 866},
-  {"redefining poisoned `%.*s'", 867},
-  {"#%s expects \"FILENAME\" or <FILENAME>", 868},
-  {"junk at end of #%s", 869},
-  {"empty file name in #%s", 870},
-  {"#import is obsolete, use an #ifndef wrapper in the header file", 871},
-  {"#include_next in primary source file", 872},
-  {"invalid format #line", 873},
-  {"token after #line is not an integer", 874},
-  {"line number out of range in #line", 875},
-  {"garbage at end of #line", 876},
-  {"second token after #line is not a string", 877},
-  {"token after #undef is not an identifier", 878},
-  {"junk on line after #undef", 879},
-  {"cannot undefine poisoned \"%s\"", 880},
-  {"undefining `%s'", 881},
-  {"#error %.*s", 882},
-  {"#warning %.*s", 883},
-  {"malformed #pragma directive", 884},
-  {"#pragma once is obsolete", 885},
-  {"#pragma once outside include file", 886},
-  {"malformed #pragma implementation", 887},
-  {"#pragma implementation for %s appears after file is included", 888},
-  {"invalid #pragma poison directive", 889},
-  {"poisoning existing macro `%s'", 890},
-  {"#pragma system_header outside include file", 891},
-  {"#%s with no argument", 892},
-  {"#%s with invalid argument", 893},
-  {"garbage at end of #%s", 894},
-  {"attempt to use poisoned `%s'", 895},
-  {"#else without #if", 896},
-  {"#else after #else", 897},
-  {"the conditional began here", 898},
-  {"#elif without #if", 899},
-  {"#elif after #else", 900},
-  {"#endif without #if", 901},
-  {"ISO C forbids text after #%s", 902},
-  {"unterminated #%s", 903},
-  {"Invalid option %s", 904},
-  {"`%s' is not a legal option to the preprocessor", 905},
-  {"too many input files", 906},
-  {";; Processing block from %d to %d, %d sets.\n", 907},
+  -h or --help              Display this information\n", 1725},
+  {"macro or `#include' recursion too deep", 1726},
+  {"mark active in cpp_pop_buffer", 1727},
+  {"length < 0 in cpp_expand_to_buffer", 1728},
+  {"'/*' within comment", 1729},
+  {"unterminated comment", 1730},
+  {"backslash-newline within line comment", 1731},
+  {"C++ style comments are not allowed in traditional C", 1732},
+  {"C++ style comments are not allowed in ISO C89", 1733},
+  {"(this will be reported only once per input file)", 1734},
+  {"embedded null character ignored", 1735},
+  {"embedded null characters ignored", 1736},
+  {"%s in preprocessing directive", 1737},
+  {"unterminated string or character constant", 1738},
+  {"possible real start of unterminated constant", 1739},
+  {"unterminated character constant", 1740},
+  {"string constant runs past end of line", 1741},
+  {"\\r escape inside string constant", 1742},
+  {"null character in string or character constant", 1743},
+  {"null characters in string or character constant", 1744},
+  {"missing '>' in `#include <FILENAME>'", 1745},
+  {"unrecognized escape \\r%c", 1746},
+  {"function macro %s must be used with arguments in traditional C", 1747},
+  {"vertical tab in preprocessing directive", 1748},
+  {"form feed in preprocessing directive", 1749},
+  {"trigraph ??%c converted to %c", 1750},
+  {"trigraph ??%c ignored", 1751},
+  {"no newline at end of file", 1752},
+  {"'$' character in identifier", 1753},
+  {"multi-line string constant", 1754},
+  {"missing terminating %c character", 1755},
+  {"possible start of unterminated string literal", 1756},
+  {"null characters preserved", 1757},
+  {"null character preserved", 1758},
+  {"comment start split across lines", 1759},
+  {"multi-line comment", 1760},
+  {"comment start '/*' split across lines", 1761},
+  {"comment end '*/' split across lines", 1762},
+  {"backslash and newline separated by space", 1763},
+  {"Unspellable token", 1764},
+  {"handle_directive called on macro buffer", 1765},
+  {"# followed by integer", 1766},
+  {"invalid preprocessing directive #%.*s", 1767},
+  {"ignoring #%s because of its indented #", 1768},
+  {"#%s may not be used inside a macro argument", 1769},
+  {"ISO C does not allow #%s", 1770},
+  {"traditional C ignores #%s with the # indented", 1771},
+  {"suggest hiding #%s from traditional C with an indented #", 1772},
+  {"#define must be followed by an identifier", 1773},
+  {"\"defined\" is not a legal macro name", 1774},
+  {"redefining poisoned `%.*s'", 1775},
+  {"#%s expects \"FILENAME\" or <FILENAME>", 1776},
+  {"junk at end of #%s", 1777},
+  {"empty file name in #%s", 1778},
+  {"#import is obsolete, use an #ifndef wrapper in the header file", 1779},
+  {"#include_next in primary source file", 1780},
+  {"invalid format #line", 1781},
+  {"token after #line is not an integer", 1782},
+  {"line number out of range in #line", 1783},
+  {"garbage at end of #line", 1784},
+  {"second token after #line is not a string", 1785},
+  {"token after #undef is not an identifier", 1786},
+  {"junk on line after #undef", 1787},
+  {"cannot undefine poisoned \"%s\"", 1788},
+  {"undefining `%s'", 1789},
+  {"#error %.*s", 1790},
+  {"#warning %.*s", 1791},
+  {"malformed #pragma directive", 1792},
+  {"#pragma once is obsolete", 1793},
+  {"#pragma once outside include file", 1794},
+  {"malformed #pragma implementation", 1795},
+  {"#pragma implementation for %s appears after file is included", 1796},
+  {"invalid #pragma poison directive", 1797},
+  {"poisoning existing macro `%s'", 1798},
+  {"#pragma system_header outside include file", 1799},
+  {"#%s with no argument", 1800},
+  {"#%s with invalid argument", 1801},
+  {"garbage at end of #%s", 1802},
+  {"attempt to use poisoned `%s'", 1803},
+  {"#else without #if", 1804},
+  {"#else after #else", 1805},
+  {"the conditional began here", 1806},
+  {"#elif without #if", 1807},
+  {"#elif after #else", 1808},
+  {"#endif without #if", 1809},
+  {"ISO C forbids text after #%s", 1810},
+  {"unterminated #%s", 1811},
+  {"Invalid option %s", 1812},
+  {"`%s' is not a legal option to the preprocessor", 1813},
+  {"too many input files", 1814},
+  {";; Processing block from %d to %d, %d sets.\n", 1815},
+  {"%s:%d: warning: ", 1816},
+  {"%s:%d: ", 1817},
+  {"%s: warning: ", 1818},
+  {"%s: ", 1819},
+  {"%.*s", 1820},
+  {"sorry, not implemented: ", 1821},
+  {"%s: warnings being treated as errors\n", 1822},
+  {"%s: %s: I/O error\n", 1823},
+  {" %s", 1824},
+  {"At top level:\n", 1825},
+  {"In method `%s':\n", 1826},
+  {"In function `%s':\n", 1827},
+  {"In file included from %s:%d", 1828},
   {"\
-Unable to access real part of complex value in a hard register on this target", 908},
+,\n\
+                 from %s:%d", 1829},
+  {"Unrecognizable insn:", 1830},
+  {"Insn does not satisfy its constraints:", 1831},
+  {"DW_LOC_OP %s not implememnted yet.\n", 1832},
+  {"internal regno botch: regno = %d\n", 1833},
+  {"\
+Unable to access real part of complex value in a hard register on this target", 1834},
   {"\
 Unable to access imaginary part of complex value in a hard register on this \
-target", 909},
-  {"Cannot duplicate non-existant exception region.", 910},
-  {"exception handling disabled, use -fexceptions to enable", 911},
-  {"Never issued previous false_label", 912},
-  {"Duplicate call to __builtin_eh_return", 913},
-  {"function uses __builtin_eh_return", 914},
-  {"stack limits not supported on this target", 915},
-  {"function using short complex types cannot be inline", 916},
-  {"unsupported wide integer operation", 917},
-  {"output_operand: %s", 918},
-  {"operand number missing after %-letter", 919},
-  {"operand number out of range", 920},
-  {"invalid %%-code", 921},
-  {"`%l' operand isn't a label", 922},
-  {"Head insn %d for block %d not found in the insn stream.", 923},
-  {"Insn %d is in multiple basic blocks (%d and %d)", 924},
-  {"End insn %d for block %d not found in the insn stream.", 925},
-  {"Basic block %i edge lists are corrupted", 926},
-  {"Basic block %d pred edge is corrupted", 927},
-  {"NOTE_INSN_BASIC_BLOCK is missing for block %d", 928},
-  {"NOTE_INSN_BASIC_BLOCK is missing for block %d\n", 929},
-  {"NOTE_INSN_BASIC_BLOCK %d in the middle of basic block %d", 930},
-  {"In basic block %d:", 931},
-  {"Basic blocks not numbered consecutively", 932},
-  {"number of bb notes in insn chain (%d) != n_basic_blocks (%d)", 933},
-  {"Ambiguous abbreviation %s", 934},
-  {"Incomplete `%s' option", 935},
-  {"Missing argument to `%s' option", 936},
-  {"Extraneous argument to `%s' option", 937},
-  {"Using builtin specs.\n", 938},
+target", 1835},
+  {"ICE: emit_insn used where emit_jump_insn needed:\n", 1836},
+  {"additional handler after ...", 1837},
+  {"Cannot duplicate non-existant exception region.", 1838},
+  {"exception handling disabled, use -fexceptions to enable", 1839},
+  {"Never issued previous false_label", 1840},
+  {"Counted %d copies of EH region %d in list.\n", 1841},
+  {"Duplicate call to __builtin_eh_return", 1842},
+  {"function uses __builtin_eh_return", 1843},
+  {"stack limits not supported on this target", 1844},
+  {"function using short complex types cannot be inline", 1845},
+  {"unsupported wide integer operation", 1846},
+  {"prior parameter's size depends on `%s'", 1847},
+  {"returned value in block_exit_expr", 1848},
+  {"invalid `asm': %s", 1849},
+  {"output_operand: %s", 1850},
+  {"operand number missing after %-letter", 1851},
+  {"operand number out of range", 1852},
+  {"invalid %%-code", 1853},
+  {"`%l' operand isn't a label", 1854},
+  {"ICE: would have deleted prologue/epilogue insn", 1855},
+  {"Head insn %d for block %d not found in the insn stream.", 1856},
+  {"Insn %d is in multiple basic blocks (%d and %d)", 1857},
+  {"End insn %d for block %d not found in the insn stream.", 1858},
+  {"Basic block %i edge lists are corrupted", 1859},
+  {"Basic block %d pred edge is corrupted", 1860},
+  {"NOTE_INSN_BASIC_BLOCK is missing for block %d", 1861},
+  {"NOTE_INSN_BASIC_BLOCK is missing for block %d\n", 1862},
+  {"NOTE_INSN_BASIC_BLOCK %d in the middle of basic block %d", 1863},
+  {"In basic block %d:", 1864},
+  {"Basic blocks not numbered consecutively", 1865},
+  {"number of bb notes in insn chain (%d) != n_basic_blocks (%d)", 1866},
+  {"comparison is always %d due to width of bitfield", 1867},
+  {"comparison is always %d", 1868},
+  {"`or' of unmatched not-equal tests is always 1", 1869},
+  {"`and' of mutually exclusive equal-tests is always 0", 1870},
+  {"`%s' might be used uninitialized in this function", 1871},
+  {"variable `%s' might be clobbered by `longjmp' or `vfork'", 1872},
+  {"argument `%s' might be clobbered by `longjmp' or `vfork'", 1873},
+  {"function returns an aggregate", 1874},
+  {"unused parameter `%s'", 1875},
+  {"Ambiguous abbreviation %s", 1876},
+  {"Incomplete `%s' option", 1877},
+  {"Missing argument to `%s' option", 1878},
+  {"Extraneous argument to `%s' option", 1879},
+  {"Using builtin specs.\n", 1880},
   {"\
 Setting spec %s to '%s'\n\
-\n", 939},
-  {"Reading specs from %s\n", 940},
-  {"specs %%include syntax malformed after %ld characters", 941},
-  {"Could not find specs file %s\n", 942},
-  {"specs %%rename syntax malformed after %ld characters", 943},
-  {"specs %s spec was not found to be renamed", 944},
-  {"rename spec %s to %s\n", 945},
+\n", 1881},
+  {"Reading specs from %s\n", 1882},
+  {"specs %%include syntax malformed after %ld characters", 1883},
+  {"Could not find specs file %s\n", 1884},
+  {"specs %%rename syntax malformed after %ld characters", 1885},
+  {"specs %s spec was not found to be renamed", 1886},
+  {"rename spec %s to %s\n", 1887},
   {"\
 spec is '%s'\n\
-\n", 946},
-  {"specs unknown %% command after %ld characters", 947},
-  {"specs file malformed after %ld characters", 948},
-  {"spec file has no spec for linking", 949},
-  {"file path prefix `%s%s' never used", 950},
-  {"file path prefix `%s' never used", 951},
-  {"-pipe not supported", 952},
+\n", 1888},
+  {"specs unknown %% command after %ld characters", 1889},
+  {"specs file malformed after %ld characters", 1890},
+  {"spec file has no spec for linking", 1891},
+  {"file path prefix `%s%s' never used", 1892},
+  {"file path prefix `%s' never used", 1893},
+  {"-pipe not supported", 1894},
   {"\
 \n\
-Go ahead? (y or n) ", 953},
-  {"Internal compiler error: program %s got fatal signal %d", 954},
-  {"# %s %.2f %.2f\n", 955},
-  {"argument to `-Xlinker' is missing", 956},
-  {"argument to `-specs' is missing", 957},
-  {"argument to `-specs=' is missing", 958},
-  {"argument to `-b' is missing", 959},
-  {"argument to `-B' is missing", 960},
-  {"argument to `-V' is missing", 961},
-  {"invalid version number format", 962},
-  {"cannot specify -o with -c or -S and multiple compilations", 963},
-  {"Warning: -pipe ignored since -save-temps specified", 964},
-  {"Warning: -pipe ignored since -time specified", 965},
-  {"argument to `-x' is missing", 966},
-  {"argument to `-%s' is missing", 967},
-  {"Warning: `-x %s' after last input file has no effect", 968},
-  {"Invalid specification!  Bug in cc.", 969},
-  {"Spec failure: '%%*' has not been initialised by pattern match", 970},
-  {"Warning: use of obsolete %%[ operator in specs", 971},
-  {"Processing spec %c%s%c, which is '%s'\n", 972},
-  {"Spec failure: Unrecognised spec option '%c'", 973},
-  {"unrecognized option `-%s'", 974},
-  {"gcc version %s\n", 975},
-  {"gcc driver version %s executing gcc version %s\n", 976},
-  {"No input files", 977},
-  {"%s: %s compiler not installed on this system", 978},
-  {"%s: linker input file unused since linking not done", 979},
-  {"language %s not recognized", 980},
-  {"Internal gcov abort.\n", 981},
-  {"gcov [-b] [-v] [-n] [-l] [-f] [-o OBJDIR] file\n", 982},
-  {"Could not open basic block file %s.\n", 983},
-  {"Could not open data file %s.\n", 984},
-  {"Assuming that all execution counts are zero.\n", 985},
-  {"Could not open program flow graph file %s.\n", 986},
-  {"No executable code associated with file %s.\n", 987},
-  {".da file contents exhausted too early\n", 988},
-  {".da file contents not exhausted\n", 989},
-  {"%6.2f%% of %d source lines executed in function %s\n", 990},
-  {"No executable source lines in function %s\n", 991},
-  {"%6.2f%% of %d branches executed in function %s\n", 992},
-  {"%6.2f%% of %d branches taken at least once in function %s\n", 993},
-  {"No branches in function %s\n", 994},
-  {"%6.2f%% of %d calls executed in function %s\n", 995},
-  {"No calls in function %s\n", 996},
-  {"didn't use all bb entries of graph, function %s\n", 997},
-  {"block_num = %ld, num_blocks = %d\n", 998},
-  {"ERROR: too many basic blocks in .bb file %s\n", 999},
-  {"%6.2f%% of %d source lines executed in file %s\n", 1000},
-  {"No executable source lines in file %s\n", 1001},
-  {"%6.2f%% of %d branches executed in file %s\n", 1002},
-  {"%6.2f%% of %d branches taken at least once in file %s\n", 1003},
-  {"No branches in file %s\n", 1004},
-  {"%6.2f%% of %d calls executed in file %s\n", 1005},
-  {"No calls in file %s\n", 1006},
-  {"Could not open source file %s.\n", 1007},
-  {"Could not open output file %s.\n", 1008},
-  {"Creating %s.\n", 1009},
-  {"call %d never executed\n", 1010},
-  {"call %d returns = %d\n", 1011},
-  {"call %d returns = %d%%\n", 1012},
-  {"branch %d never executed\n", 1013},
-  {"branch %d taken = %d\n", 1014},
-  {"branch %d taken = %d%%\n", 1015},
-  {"Unexpected EOF while reading source file %s.\n", 1016},
-  {"%s: option `%s' is ambiguous\n", 1017},
-  {"%s: option `--%s' doesn't allow an argument\n", 1018},
-  {"%s: option `%c%s' doesn't allow an argument\n", 1019},
-  {"%s: option `%s' requires an argument\n", 1020},
-  {"%s: unrecognized option `--%s'\n", 1021},
-  {"%s: unrecognized option `%c%s'\n", 1022},
-  {"%s: illegal option -- %c\n", 1023},
-  {"%s: invalid option -- %c\n", 1024},
-  {"%s: option requires an argument -- %c\n", 1025},
-  {"%s: option `-W %s' is ambiguous\n", 1026},
-  {"%s: option `-W %s' doesn't allow an argument\n", 1027},
-  {"varargs function cannot be inline", 1028},
-  {"function using alloca cannot be inline", 1029},
-  {"function using setjmp cannot be inline", 1030},
-  {"function with nested functions cannot be inline", 1031},
-  {"function with label addresses used in initializers cannot inline", 1032},
-  {"function too large to be inline", 1033},
-  {"no prototype, and parameter address used; cannot be inline", 1034},
-  {"inline functions not supported for this return value type", 1035},
-  {"function with varying-size return value cannot be inline", 1036},
-  {"function with varying-size parameter cannot be inline", 1037},
-  {"function with transparent unit parameter cannot be inline", 1038},
-  {"function with computed jump cannot inline", 1039},
-  {"function with nonlocal goto cannot be inline", 1040},
-  {"function with complex parameters cannot be inline", 1041},
-  {"function with target specific attribute(s) cannot be inlined", 1042},
-  {"Objective-C text in C source file", 1043},
-  {"statically allocated objects not supported", 1044},
-  {"Undefined type `id', please import <objc/objc.h>", 1045},
-  {"Cannot find protocol declaration for `%s'", 1046},
-  {"Cannot find interface declaration for `%s'", 1047},
-  {"`%s' redeclared as different kind of symbol", 1048},
-  {"Cannot find interface declaration for `%s', superclass of `%s'", 1049},
-  {"Circular inheritance in interface declaration for `%s'", 1050},
-  {"inconsistent instance variable specification", 1051},
-  {"no super class declared in interface for `%s'", 1052},
-  {"duplicate definition of class method `%s'.", 1053},
-  {"duplicate declaration of class method `%s'.", 1054},
-  {"duplicate definition of instance method `%s'.", 1055},
-  {"duplicate declaration of instance method `%s'.", 1056},
-  {"instance variable `%s' is declared private", 1057},
-  {"instance variable `%s' is declared %s", 1058},
-  {"reimplementation of class `%s'", 1059},
-  {"conflicting super class name `%s'", 1060},
-  {"previous declaration of `%s'", 1061},
-  {"[super ...] must appear in a method context", 1062},
-  {"Instance variable `%s' implicitly declared as function", 1063},
-  {"method definition not in class context", 1064},
-  {"%s: internal abort\n", 1065},
-  {"%s: error writing file `%s': %s\n", 1066},
-  {"%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ filename ... ]'\n", 1067},
-  {"%s: usage '%s [ -VqfnkNlgC ] [ -B <dirname> ] [ filename ... ]'\n", 1068},
-  {"%s: warning: no read access for file `%s'\n", 1069},
-  {"%s: warning: no write access for file `%s'\n", 1070},
-  {"%s: warning: no write access for dir containing `%s'\n", 1071},
-  {"%s: invalid file name: %s\n", 1072},
-  {"%s: %s: can't get status: %s\n", 1073},
+Go ahead? (y or n) ", 1895},
+  {"Internal compiler error: program %s got fatal signal %d", 1896},
+  {"# %s %.2f %.2f\n", 1897},
+  {"argument to `-Xlinker' is missing", 1898},
+  {"argument to `-specs' is missing", 1899},
+  {"argument to `-specs=' is missing", 1900},
+  {"argument to `-b' is missing", 1901},
+  {"argument to `-B' is missing", 1902},
+  {"argument to `-V' is missing", 1903},
+  {"invalid version number format", 1904},
+  {"cannot specify -o with -c or -S and multiple compilations", 1905},
+  {"Warning: -pipe ignored since -save-temps specified", 1906},
+  {"Warning: -pipe ignored since -time specified", 1907},
+  {"argument to `-x' is missing", 1908},
+  {"argument to `-%s' is missing", 1909},
+  {"Warning: `-x %s' after last input file has no effect", 1910},
+  {"Invalid specification!  Bug in cc.", 1911},
+  {"Spec failure: '%%*' has not been initialised by pattern match", 1912},
+  {"Warning: use of obsolete %%[ operator in specs", 1913},
+  {"Processing spec %c%s%c, which is '%s'\n", 1914},
+  {"Spec failure: Unrecognised spec option '%c'", 1915},
+  {"unrecognized option `-%s'", 1916},
+  {"gcc version %s\n", 1917},
+  {"gcc driver version %s executing gcc version %s\n", 1918},
+  {"No input files", 1919},
+  {"%s: %s compiler not installed on this system", 1920},
+  {"%s: linker input file unused since linking not done", 1921},
+  {"language %s not recognized", 1922},
+  {"Internal gcov abort.\n", 1923},
+  {"gcov [-b] [-v] [-n] [-l] [-f] [-o OBJDIR] file\n", 1924},
+  {"Could not open basic block file %s.\n", 1925},
+  {"Could not open data file %s.\n", 1926},
+  {"Assuming that all execution counts are zero.\n", 1927},
+  {"Could not open program flow graph file %s.\n", 1928},
+  {"No executable code associated with file %s.\n", 1929},
+  {".da file contents exhausted too early\n", 1930},
+  {".da file contents not exhausted\n", 1931},
+  {"%6.2f%% of %d source lines executed in function %s\n", 1932},
+  {"No executable source lines in function %s\n", 1933},
+  {"%6.2f%% of %d branches executed in function %s\n", 1934},
+  {"%6.2f%% of %d branches taken at least once in function %s\n", 1935},
+  {"No branches in function %s\n", 1936},
+  {"%6.2f%% of %d calls executed in function %s\n", 1937},
+  {"No calls in function %s\n", 1938},
+  {"didn't use all bb entries of graph, function %s\n", 1939},
+  {"block_num = %ld, num_blocks = %d\n", 1940},
+  {"ERROR: too many basic blocks in .bb file %s\n", 1941},
+  {"%6.2f%% of %d source lines executed in file %s\n", 1942},
+  {"No executable source lines in file %s\n", 1943},
+  {"%6.2f%% of %d branches executed in file %s\n", 1944},
+  {"%6.2f%% of %d branches taken at least once in file %s\n", 1945},
+  {"No branches in file %s\n", 1946},
+  {"%6.2f%% of %d calls executed in file %s\n", 1947},
+  {"No calls in file %s\n", 1948},
+  {"Could not open source file %s.\n", 1949},
+  {"Could not open output file %s.\n", 1950},
+  {"Creating %s.\n", 1951},
+  {"call %d never executed\n", 1952},
+  {"call %d returns = %d\n", 1953},
+  {"call %d returns = %d%%\n", 1954},
+  {"branch %d never executed\n", 1955},
+  {"branch %d taken = %d\n", 1956},
+  {"branch %d taken = %d%%\n", 1957},
+  {"Unexpected EOF while reading source file %s.\n", 1958},
+  {"%s: option `%s' is ambiguous\n", 1959},
+  {"%s: option `--%s' doesn't allow an argument\n", 1960},
+  {"%s: option `%c%s' doesn't allow an argument\n", 1961},
+  {"%s: option `%s' requires an argument\n", 1962},
+  {"%s: unrecognized option `--%s'\n", 1963},
+  {"%s: unrecognized option `%c%s'\n", 1964},
+  {"%s: illegal option -- %c\n", 1965},
+  {"%s: invalid option -- %c\n", 1966},
+  {"%s: option requires an argument -- %c\n", 1967},
+  {"%s: option `-W %s' is ambiguous\n", 1968},
+  {"%s: option `-W %s' doesn't allow an argument\n", 1969},
+  {"varargs function cannot be inline", 1970},
+  {"function using alloca cannot be inline", 1971},
+  {"function using setjmp cannot be inline", 1972},
+  {"function with nested functions cannot be inline", 1973},
+  {"function with label addresses used in initializers cannot inline", 1974},
+  {"function too large to be inline", 1975},
+  {"no prototype, and parameter address used; cannot be inline", 1976},
+  {"inline functions not supported for this return value type", 1977},
+  {"function with varying-size return value cannot be inline", 1978},
+  {"function with varying-size parameter cannot be inline", 1979},
+  {"function with transparent unit parameter cannot be inline", 1980},
+  {"function with computed jump cannot inline", 1981},
+  {"function with nonlocal goto cannot be inline", 1982},
+  {"function with complex parameters cannot be inline", 1983},
+  {"function with target specific attribute(s) cannot be inlined", 1984},
+  {"Objective-C text in C source file", 1985},
+  {"object does not conform to the `%s' protocol", 1986},
+  {"class `%s' does not implement the `%s' protocol", 1987},
+  {"`%s' cannot be statically allocated", 1988},
+  {"statically allocated objects not supported", 1989},
+  {"Unexpected type for `id' (%s)", 1990},
+  {"Undefined type `id', please import <objc/objc.h>", 1991},
+  {"Cannot find protocol declaration for `%s'", 1992},
+  {"Cannot find interface declaration for `%s'", 1993},
+  {"Cannot find class `%s'", 1994},
+  {"Class `%s' already exists", 1995},
+  {"Cannot find interface declaration for `%s', superclass of `%s'", 1996},
+  {"Circular inheritance in interface declaration for `%s'", 1997},
+  {"inconsistent instance variable specification", 1998},
+  {"multiple declarations for method `%s'", 1999},
+  {"invalid receiver type `%s'", 2000},
+  {"`%s' does not respond to `%s'", 2001},
+  {"no super class declared in interface for `%s'", 2002},
+  {"cannot find class (factory) method.", 2003},
+  {"return type for `%s' defaults to id", 2004},
+  {"method `%s' not implemented by protocol.", 2005},
+  {"return type defaults to id", 2006},
+  {"cannot find method.", 2007},
+  {"instance variable `%s' accessed in class method", 2008},
+  {"duplicate definition of class method `%s'.", 2009},
+  {"duplicate declaration of class method `%s'.", 2010},
+  {"duplicate definition of instance method `%s'.", 2011},
+  {"duplicate declaration of instance method `%s'.", 2012},
+  {"duplicate interface declaration for category `%s(%s)'", 2013},
+  {"instance variable `%s' is declared private", 2014},
+  {"instance variable `%s' is declared %s", 2015},
+  {"static access to object of type `id'", 2016},
+  {"incomplete implementation of class `%s'", 2017},
+  {"incomplete implementation of category `%s'", 2018},
+  {"method definition for `%c%s' not found", 2019},
+  {"%s `%s' does not fully implement the `%s' protocol", 2020},
+  {"reimplementation of class `%s'", 2021},
+  {"conflicting super class name `%s'", 2022},
+  {"duplicate interface declaration for class `%s'", 2023},
+  {"duplicate declaration for protocol `%s'", 2024},
+  {"[super ...] must appear in a method context", 2025},
+  {"potential selector conflict for method `%s'", 2026},
+  {"`@end' must appear in an implementation context", 2027},
+  {"method definition not in class context", 2028},
+  {"Arc profiling: some edge counts were bad.", 2029},
+  {"file %s not found, execution counts assumed to be zero.", 2030},
+  {"%s: internal abort\n", 2031},
+  {"%s: error writing file `%s': %s\n", 2032},
+  {"%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ filename ... ]'\n", 2033},
+  {"%s: usage '%s [ -VqfnkNlgC ] [ -B <dirname> ] [ filename ... ]'\n", 2034},
+  {"%s: warning: no read access for file `%s'\n", 2035},
+  {"%s: warning: no write access for file `%s'\n", 2036},
+  {"%s: warning: no write access for dir containing `%s'\n", 2037},
+  {"%s: invalid file name: %s\n", 2038},
+  {"%s: %s: can't get status: %s\n", 2039},
   {"\
 \n\
-%s: fatal error: aux info file corrupted at line %d\n", 1074},
-  {"%s:%d: declaration of function `%s' takes different forms\n", 1075},
-  {"%s: compiling `%s'\n", 1076},
-  {"%s: wait: %s\n", 1077},
-  {"%s: subprocess got fatal signal %d\n", 1078},
-  {"%s: %s exited with status %d\n", 1079},
-  {"%s: warning: missing SYSCALLS file `%s'\n", 1080},
-  {"%s: can't read aux info file `%s': %s\n", 1081},
-  {"%s: can't get status of aux info file `%s': %s\n", 1082},
-  {"%s: can't open aux info file `%s' for reading: %s\n", 1083},
-  {"%s: error reading aux info file `%s': %s\n", 1084},
-  {"%s: error closing aux info file `%s': %s\n", 1085},
-  {"%s: can't delete aux info file `%s': %s\n", 1086},
-  {"%s: can't delete file `%s': %s\n", 1087},
-  {"%s: warning: can't rename file `%s' to `%s': %s\n", 1088},
-  {"%s: conflicting extern definitions of '%s'\n", 1089},
-  {"%s: declarations of '%s' will not be converted\n", 1090},
-  {"%s: conflict list for '%s' follows:\n", 1091},
-  {"%s: warning: using formals list from %s(%d) for function `%s'\n", 1092},
-  {"%s: %d: `%s' used but missing from SYSCALLS\n", 1093},
-  {"%s: %d: warning: no extern definition for `%s'\n", 1094},
-  {"%s: warning: no static definition for `%s' in file `%s'\n", 1095},
-  {"%s: multiple static defs of `%s' in file `%s'\n", 1096},
-  {"%s: %d: warning: source too confusing\n", 1097},
-  {"%s: %d: warning: varargs function declaration not converted\n", 1098},
-  {"%s: declaration of function `%s' not converted\n", 1099},
-  {"%s: warning: too many parameter lists in declaration of `%s'\n", 1100},
+%s: fatal error: aux info file corrupted at line %d\n", 2040},
+  {"%s:%d: declaration of function `%s' takes different forms\n", 2041},
+  {"%s: compiling `%s'\n", 2042},
+  {"%s: wait: %s\n", 2043},
+  {"%s: subprocess got fatal signal %d\n", 2044},
+  {"%s: %s exited with status %d\n", 2045},
+  {"%s: warning: missing SYSCALLS file `%s'\n", 2046},
+  {"%s: can't read aux info file `%s': %s\n", 2047},
+  {"%s: can't get status of aux info file `%s': %s\n", 2048},
+  {"%s: can't open aux info file `%s' for reading: %s\n", 2049},
+  {"%s: error reading aux info file `%s': %s\n", 2050},
+  {"%s: error closing aux info file `%s': %s\n", 2051},
+  {"%s: can't delete aux info file `%s': %s\n", 2052},
+  {"%s: can't delete file `%s': %s\n", 2053},
+  {"%s: warning: can't rename file `%s' to `%s': %s\n", 2054},
+  {"%s: conflicting extern definitions of '%s'\n", 2055},
+  {"%s: declarations of '%s' will not be converted\n", 2056},
+  {"%s: conflict list for '%s' follows:\n", 2057},
+  {"%s: warning: using formals list from %s(%d) for function `%s'\n", 2058},
+  {"%s: %d: `%s' used but missing from SYSCALLS\n", 2059},
+  {"%s: %d: warning: no extern definition for `%s'\n", 2060},
+  {"%s: warning: no static definition for `%s' in file `%s'\n", 2061},
+  {"%s: multiple static defs of `%s' in file `%s'\n", 2062},
+  {"%s: %d: warning: source too confusing\n", 2063},
+  {"%s: %d: warning: varargs function declaration not converted\n", 2064},
+  {"%s: declaration of function `%s' not converted\n", 2065},
+  {"%s: warning: too many parameter lists in declaration of `%s'\n", 2066},
   {"\
 \n\
-%s: warning: too few parameter lists in declaration of `%s'\n", 1101},
-  {"%s: %d: warning: found `%s' but expected `%s'\n", 1102},
-  {"%s: local declaration for function `%s' not inserted\n", 1103},
+%s: warning: too few parameter lists in declaration of `%s'\n", 2067},
+  {"%s: %d: warning: found `%s' but expected `%s'\n", 2068},
+  {"%s: local declaration for function `%s' not inserted\n", 2069},
   {"\
 \n\
-%s: %d: warning: can't add declaration of `%s' into macro call\n", 1104},
-  {"%s: global declarations for file `%s' not inserted\n", 1105},
-  {"%s: definition of function `%s' not converted\n", 1106},
-  {"%s: %d: warning: definition of %s not converted\n", 1107},
-  {"%s: found definition of `%s' at %s(%d)\n", 1108},
-  {"%s: %d: warning: `%s' excluded by preprocessing\n", 1109},
-  {"%s: function definition not converted\n", 1110},
-  {"%s: `%s' not converted\n", 1111},
-  {"%s: would convert file `%s'\n", 1112},
-  {"%s: converting file `%s'\n", 1113},
-  {"%s: can't get status for file `%s': %s\n", 1114},
-  {"%s: can't open file `%s' for reading: %s\n", 1115},
+%s: %d: warning: can't add declaration of `%s' into macro call\n", 2070},
+  {"%s: global declarations for file `%s' not inserted\n", 2071},
+  {"%s: definition of function `%s' not converted\n", 2072},
+  {"%s: %d: warning: definition of %s not converted\n", 2073},
+  {"%s: found definition of `%s' at %s(%d)\n", 2074},
+  {"%s: %d: warning: `%s' excluded by preprocessing\n", 2075},
+  {"%s: function definition not converted\n", 2076},
+  {"%s: `%s' not converted\n", 2077},
+  {"%s: would convert file `%s'\n", 2078},
+  {"%s: converting file `%s'\n", 2079},
+  {"%s: can't get status for file `%s': %s\n", 2080},
+  {"%s: can't open file `%s' for reading: %s\n", 2081},
   {"\
 \n\
-%s: error reading input file `%s': %s\n", 1116},
-  {"%s: can't create/open clean file `%s': %s\n", 1117},
-  {"%s: warning: file `%s' already saved in `%s'\n", 1118},
-  {"%s: can't link file `%s' to `%s': %s\n", 1119},
-  {"%s: can't create/open output file `%s': %s\n", 1120},
-  {"%s: can't change mode of file `%s': %s\n", 1121},
-  {"%s: cannot get working directory: %s\n", 1122},
-  {"%s: input file names must have .c suffixes: %s\n", 1123},
-  {"can't use '%s' as a %s register", 1124},
-  {"global register variable follows a function definition", 1125},
-  {"Unable to find a register to spill in class `%s'.", 1126},
-  {"RTL check: access of elt %d of `%s' with last elt %d", 1127},
-  {"RTL check: expected elt %d type '%c', have '%c' (rtx %s)", 1128},
-  {"RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s)", 1129},
-  {"RTL check: expected code `%s', have `%s'", 1130},
-  {"RTL check: expected code `%s' or `%s', have `%s'", 1131},
-  {"RTL check: access of elt %d of vector with last elt %d", 1132},
+%s: error reading input file `%s': %s\n", 2082},
+  {"%s: can't create/open clean file `%s': %s\n", 2083},
+  {"%s: warning: file `%s' already saved in `%s'\n", 2084},
+  {"%s: can't link file `%s' to `%s': %s\n", 2085},
+  {"%s: can't create/open output file `%s': %s\n", 2086},
+  {"%s: can't change mode of file `%s': %s\n", 2087},
+  {"%s: cannot get working directory: %s\n", 2088},
+  {"%s: input file names must have .c suffixes: %s\n", 2089},
+  {"conversion from NaN to int", 2090},
+  {"conversion from NaN to unsigned int", 2091},
+  {"floating point overflow", 2092},
+  {"overflow on truncation to integer", 2093},
+  {"overflow on truncation to unsigned integer", 2094},
+  {"%s: argument domain error", 2095},
+  {"%s: function singularity", 2096},
+  {"%s: overflow range error", 2097},
+  {"%s: underflow range error", 2098},
+  {"%s: total loss of precision", 2099},
+  {"%s: partial loss of precision", 2100},
+  {"%s: NaN - producing operation", 2101},
+  {"Output constraint %d must specify a single register", 2102},
+  {"Output regs must be grouped at top of stack", 2103},
+  {"Implicitly popped regs must be grouped at top of stack", 2104},
+  {"Output operand %d must use `&' constraint", 2105},
+  {"can't use '%s' as a %s register", 2106},
+  {"unknown register name: %s", 2107},
+  {"global register variable follows a function definition", 2108},
+  {"register used for two global register variables", 2109},
+  {"call-clobbered register used for global register variable", 2110},
+  {"cannot reload integer constant operand in `asm'", 2111},
+  {"impossible register constraint in `asm'", 2112},
+  {"`&' constraint used with no register class", 2113},
+  {"inconsistent operand constraints in an `asm'", 2114},
+  {"frame size too large for reliable stack checking", 2115},
+  {"try reducing the number of local variables", 2116},
+  {"Can't find a register in class `%s' while reloading `asm'.", 2117},
+  {"Unable to find a register to spill in class `%s'.", 2118},
+  {"`asm' operand requires impossible reload", 2119},
+  {"`asm' operand constraint incompatible with operand size", 2120},
+  {"output operand is constant in `asm'", 2121},
+  {"RTL check: access of elt %d of `%s' with last elt %d", 2122},
+  {"RTL check: expected elt %d type '%c', have '%c' (rtx %s)", 2123},
+  {"RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s)", 2124},
+  {"RTL check: expected code `%s', have `%s'", 2125},
+  {"RTL check: expected code `%s' or `%s', have `%s'", 2126},
+  {"RTL check: access of elt %d of vector with last elt %d", 2127},
   {"\
 Internal compiler error in `%s', at %s:%d\n\
 Please submit a full bug report.\n\
-See %s for instructions.", 1133},
-  {"jump to `%s' invalidly jumps into binding contour", 1134},
-  {"`asm' cannot be used in function where memory usage is checked", 1135},
-  {"`asm' cannot be used with `-fcheck-memory-usage'", 1136},
-  {"unknown register name `%s' in `asm'", 1137},
-  {"too many alternatives in `asm'", 1138},
-  {"operand constraints for `asm' differ in number of alternatives", 1139},
-  {"output operand constraint lacks `='", 1140},
-  {"output operand constraint %d contains `+'", 1141},
-  {"operand constraint contains '+' or '=' at illegal position.", 1142},
-  {"`%%' constraint used with last operand", 1143},
-  {"matching constraint not valid in output operand", 1144},
-  {"output number %d not directly addressable", 1145},
-  {"more than %d operands in `asm'", 1146},
-  {"hard register `%s' listed as input operand to `asm'", 1147},
-  {"input operand constraint contains `%c'", 1148},
-  {"matching constraint references invalid operand number", 1149},
-  {"type size can't be explicitly evaluated", 1150},
-  {"variable-size type declared outside of any function", 1151},
-  {"Invalid option `%s'", 1152},
-  {"output pipe has been closed", 1153},
-  {"Errors detected in input file (your bison.simple is out of date)\n", 1154},
-  {"invalid register name `%s' for register variable", 1155},
-  {"unrecognized register name `%s'", 1156},
-  {"Unrecognized option `%s'", 1157},
-  {"use -gdwarf -g%d for DWARF v1, level %d", 1158},
-  {"use -gdwarf-2   for DWARF v2", 1159},
-  {"Data size %ld.\n", 1160},
+See %s for instructions.", 2128},
+  {"jump to `%s' invalidly jumps into binding contour", 2129},
+  {"label `%s' used before containing binding contour", 2130},
+  {"`asm' cannot be used in function where memory usage is checked", 2131},
+  {"`asm' cannot be used with `-fcheck-memory-usage'", 2132},
+  {"unknown register name `%s' in `asm'", 2133},
+  {"too many alternatives in `asm'", 2134},
+  {"operand constraints for `asm' differ in number of alternatives", 2135},
+  {"output operand constraint lacks `='", 2136},
+  {"output constraint `%c' for operand %d is not at the beginning", 2137},
+  {"output operand constraint %d contains `+'", 2138},
+  {"operand constraint contains '+' or '=' at illegal position.", 2139},
+  {"`%%' constraint used with last operand", 2140},
+  {"matching constraint not valid in output operand", 2141},
+  {"output number %d not directly addressable", 2142},
+  {"more than %d operands in `asm'", 2143},
+  {"hard register `%s' listed as input operand to `asm'", 2144},
+  {"input operand constraint contains `%c'", 2145},
+  {"matching constraint references invalid operand number", 2146},
+  {"asm operand %d probably doesn't match constraints", 2147},
+  {"unused variable `%s'", 2148},
+  {"enumeration value `%s' not handled in switch", 2149},
+  {"case value `%ld' not in enumerated type", 2150},
+  {"case value `%ld' not in enumerated type `%s'", 2151},
+  {"type size can't be explicitly evaluated", 2152},
+  {"variable-size type declared outside of any function", 2153},
+  {"size of `%s' is %d bytes", 2154},
+  {"size of `%s' is larger than %d bytes", 2155},
+  {"packed attribute causes inefficient alignment for `%s'", 2156},
+  {"packed attribute is unnecessary for `%s'", 2157},
+  {"padding struct to align `%s'", 2158},
+  {"padding struct size to alignment boundary", 2159},
+  {"packed attribute causes inefficient alignment", 2160},
+  {"packed attribute is unnecessary", 2161},
+  {"Invalid option `%s'", 2162},
+  {"output pipe has been closed", 2163},
+  {"`%s' used but never defined", 2164},
+  {"`%s' declared `static' but never defined", 2165},
+  {"`%s' defined but not used", 2166},
+  {"-ffunction-sections not supported for this target.", 2167},
+  {"-fdata-sections not supported for this target.", 2168},
+  {"-ffunction-sections disabled; it makes profiling impossible.", 2169},
+  {"-ffunction-sections may affect debugging on some targets.", 2170},
+  {"Errors detected in input file (your bison.simple is out of date)\n", 2171},
+  {"invalid register name `%s' for register variable", 2172},
+  {"unrecognized gcc debugging option: %c", 2173},
+  {"unrecognized register name `%s'", 2174},
+  {"Unrecognized option `%s'", 2175},
+  {"use -gdwarf -g%d for DWARF v1, level %d", 2176},
+  {"use -gdwarf-2   for DWARF v2", 2177},
+  {"ignoring option `%s' due to invalid debug level specification", 2178},
+  {"`%s': unknown or unsupported -g option", 2179},
+  {"`%s' ignored, conflicts with `-g%s'", 2180},
+  {"`-a' option (basic block profile) not supported", 2181},
+  {"`-ax' option (jump profiling) not supported", 2182},
+  {"Ignoring command line option '%s'", 2183},
+  {"(It is valid for %s but not the selected language)", 2184},
+  {"-Wuninitialized is not supported without -O", 2185},
+  {"`-ax' and `-a' are conflicting options. `-a' ignored.", 2186},
+  {"instruction scheduling not supported on this target machine", 2187},
+  {"this target machine does not have delayed branches", 2188},
+  {"-f%sleading-underscore not supported on this target machine", 2189},
+  {"Data size %ld.\n", 2190},
   {"\
 %s%s%s version %s (%s) compiled by GNU C version %s.\n\
-%s%s%s version %s (%s) compiled by CC.\n", 1161},
-  {"options passed: ", 1162},
-  {"options enabled: ", 1163},
-  {"arrays of functions are not meaningful", 1164},
-  {"function return type cannot be function", 1165},
-  {"invalid initializer for bit string", 1166},
-  {"Tree check: expected %s, have %s", 1167},
-  {"Tree check: expected class '%c', have '%c' (%s)", 1168},
-  {"global register variable has initial value", 1169},
-  {"floating point trap outputting a constant", 1170},
-  {"initializer for integer value is too complicated", 1171},
-  {"initializer for floating value is not a floating constant", 1172},
-  {"unknown set constructor type", 1173},
-  {"invalid initial value for member `%s'", 1174},
-  {"Unknown stab %s: : 0x%x\n", 1175},
-  {"may not use both -EB and -EL", 1176},
-  {"-mapcs-26 and -mapcs-32 may not be used together", 1177},
-  {"-msoft-float and -mhard_float may not be used together", 1178},
-  {"-mbig-endian and -mlittle-endian may not be used together", 1179},
-  {"-mbsd and -pedantic incompatible", 1180},
-  {"-mbsd and -mxopen incompatible", 1181},
-  {"-mxopen and -pedantic incompatible", 1182},
-  {"A -ifile option requires a -map option", 1183},
-  {"`-p' not supported; use `-pg' and gprof(1)", 1184},
-  {"-static not valid with -mcoff", 1185},
-  {"-shared not valid with -mcoff", 1186},
-  {"-symbolic not valid with -mcoff", 1187},
-  {"-fpic is not valid with -mcoff", 1188},
-  {"-fPIC is not valid with -mcoff", 1189},
-  {"-fpic not valid with -mcoff", 1190},
-  {"-fPIC not valid with -mcoff", 1191},
-  {"-p option not supported: use -pg instead", 1192},
-  {"-pipe is not supported.", 1193},
-  {"may not use both -mfp64 and -msingle-float", 1194},
-  {"may not use both -mfp64 and -m4650", 1195},
-  {"-mhard-float not supported.", 1196},
-  {"-msingle-float and -msoft-float can not both be specified.", 1197},
-  {"-p profiling is no longer supported.  Use -pg instead.", 1198},
-  {"profiling not supported with -mg\n", 1199},
-  {"GNU C++ does not support -C without using -E", 1200},
-  {"-pg and -fomit-frame-pointer are incompatible", 1201},
-  {"GNU C does not support -C without using -E", 1202},
-  {"-E required when input is from standard input", 1203},
-  {"Compilation of header file requested", 1204},
+%s%s%s version %s (%s) compiled by CC.\n", 2191},
+  {"options passed: ", 2192},
+  {"options enabled: ", 2193},
+  {"`%s' and `%s' identical in first %d characters", 2194},
+  {"arrays of functions are not meaningful", 2195},
+  {"function return type cannot be function", 2196},
+  {"invalid initializer for bit string", 2197},
+  {"Tree check: expected %s, have %s", 2198},
+  {"Tree check: expected class '%c', have '%c' (%s)", 2199},
+  {"register name not specified for `%s'", 2200},
+  {"invalid register name for `%s'", 2201},
+  {"register name given for non-register variable `%s'", 2202},
+  {"data type of `%s' isn't suitable for a register", 2203},
+  {"register number for `%s' isn't suitable for data type", 2204},
+  {"global register variable has initial value", 2205},
+  {"volatile register variables don't work as you might wish", 2206},
+  {"size of variable `%s' is too large", 2207},
+  {"\
+alignment of `%s' is greater than maximum object file alignment. Using %d.", 2208},
+  {"requested alignment for %s is greater than implemented alignment of %d.", 2209},
+  {"floating point trap outputting a constant", 2210},
+  {"initializer for integer value is too complicated", 2211},
+  {"initializer for floating value is not a floating constant", 2212},
+  {"unknown set constructor type", 2213},
+  {"invalid initial value for member `%s'", 2214},
+  {"weak declaration of `%s' must be public", 2215},
+  {"weak declaration of `%s' must precede definition", 2216},
+  {"only weak aliases are supported in this configuration", 2217},
+  {"alias definitions not supported in this configuration; ignored", 2218},
+  {"Unknown stab %s: : 0x%x\n", 2219},
+  {"may not use both -EB and -EL", 2220},
+  {"-mapcs-26 and -mapcs-32 may not be used together", 2221},
+  {"-msoft-float and -mhard_float may not be used together", 2222},
+  {"-mbig-endian and -mlittle-endian may not be used together", 2223},
+  {"-mbsd and -pedantic incompatible", 2224},
+  {"-mbsd and -mxopen incompatible", 2225},
+  {"-mxopen and -pedantic incompatible", 2226},
+  {"A -ifile option requires a -map option", 2227},
+  {"`-p' not supported; use `-pg' and gprof(1)", 2228},
+  {"-static not valid with -mcoff", 2229},
+  {"-shared not valid with -mcoff", 2230},
+  {"-symbolic not valid with -mcoff", 2231},
+  {"-fpic is not valid with -mcoff", 2232},
+  {"-fPIC is not valid with -mcoff", 2233},
+  {"-fpic not valid with -mcoff", 2234},
+  {"-fPIC not valid with -mcoff", 2235},
+  {"-p option not supported: use -pg instead", 2236},
+  {"-pipe is not supported.", 2237},
+  {"may not use both -mfp64 and -msingle-float", 2238},
+  {"may not use both -mfp64 and -m4650", 2239},
+  {"-mhard-float not supported.", 2240},
+  {"-msingle-float and -msoft-float can not both be specified.", 2241},
+  {"-p profiling is no longer supported.  Use -pg instead.", 2242},
+  {"profiling not supported with -mg\n", 2243},
+  {"GNU C++ does not support -C without using -E", 2244},
+  {"-pg and -fomit-frame-pointer are incompatible", 2245},
+  {"GNU C does not support -C without using -E", 2246},
+  {"-E required when input is from standard input", 2247},
+  {"Compilation of header file requested", 2248},
 };
 
-int _msg_tbl_length = 1204;
+int _msg_tbl_length = 2248;
diff --git a/gcc/po/gcc.pot b/gcc/po/gcc.pot
index bf60859c8cb..5dcf68060d5 100644
--- a/gcc/po/gcc.pot
+++ b/gcc/po/gcc.pot
@@ -6,7 +6,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
-"POT-Creation-Date: 2000-06-07 14:16+0200\n"
+"POT-Creation-Date: 2000-06-27 21:20+0200\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -14,11 +14,28 @@ msgstr ""
 "Content-Type: text/plain; charset=CHARSET\n"
 "Content-Transfer-Encoding: ENCODING\n"
 
+#: c-common.c:535
+#, c-format
+msgid "`%s' attribute directive ignored"
+msgstr ""
+
+#: c-common.c:543
+#, c-format
+msgid "`%s' attribute does not apply to types"
+msgstr ""
+
 #: c-common.c:550
 #, c-format
 msgid "wrong number of arguments specified for `%s' attribute"
 msgstr ""
 
+#: c-common.c:566 c-common.c:573 c-common.c:580 c-common.c:593 c-common.c:601
+#: c-common.c:616 c-common.c:629 c-common.c:637 c-common.c:653 c-common.c:665
+#: c-common.c:677 c-common.c:682 c-common.c:1002 c-common.c:1154
+#, c-format
+msgid "`%s' attribute ignored"
+msgstr ""
+
 #: c-common.c:715
 #, c-format
 msgid "unknown machine mode `%s'"
@@ -29,6 +46,24 @@ msgstr ""
 msgid "no data type for mode `%s'"
 msgstr ""
 
+#: c-common.c:738
+msgid "section attribute cannot be specified for local variables"
+msgstr ""
+
+#: c-common.c:745
+#, c-format
+msgid "section of `%s' conflicts with previous declaration"
+msgstr ""
+
+#: c-common.c:751
+#, c-format
+msgid "section attribute not allowed for `%s'"
+msgstr ""
+
+#: c-common.c:754
+msgid "section attributes are not supported for this target"
+msgstr ""
+
 #: c-common.c:773
 msgid "requested alignment is not a constant"
 msgstr ""
@@ -41,1099 +76,2606 @@ msgstr ""
 msgid "requested alignment is too large"
 msgstr ""
 
-#: c-common.c:812
+#: c-common.c:789
+#, c-format
+msgid "alignment may not be specified for `%s'"
+msgstr ""
+
+#: c-common.c:812 c-common.c:918
+#, c-format
+msgid "argument format specified for non-function `%s'"
+msgstr ""
+
+#: c-common.c:818
 msgid "unrecognized format specifier"
 msgstr ""
 
-#: c-common.c:850 c-common.c:926
+#: c-common.c:834
+#, c-format
+msgid "`%s' is an unrecognized format function type"
+msgstr ""
+
+#: c-common.c:856 c-common.c:932
 msgid "format string has invalid operand number"
 msgstr ""
 
-#: c-common.c:858
+#: c-common.c:864
 msgid "format string arg follows the args to be formatted"
 msgstr ""
 
-#: c-common.c:877 c-common.c:947
+#: c-common.c:883 c-common.c:953
 msgid "format string arg not a string type"
 msgstr ""
 
-#: c-common.c:890
+#: c-common.c:896
 msgid "args to be formatted is not '...'"
 msgstr ""
 
-#: c-common.c:956
+#: c-common.c:962
 msgid "function does not return string type"
 msgstr ""
 
-#: c-common.c:982
+#: c-common.c:980
+#, c-format
+msgid "`%s' defined both normally and as an alias"
+msgstr ""
+
+#: c-common.c:988
 msgid "alias arg not a string"
 msgstr ""
 
-#: c-common.c:2158
+#: c-common.c:1009 c-common.c:1026 c-common.c:1043
+#, c-format
+msgid "`%s' attribute applies only to functions"
+msgstr ""
+
+#: c-common.c:1015 c-common.c:1032 c-common.c:1049
+#, c-format
+msgid "can't set `%s' attribute after definition"
+msgstr ""
+
+#: c-common.c:1409
+msgid "too few arguments for format"
+msgstr ""
+
+#: c-common.c:1518
+msgid "null format string"
+msgstr ""
+
+#: c-common.c:1529 c-common.c:1541
+msgid "format not a string literal, argument types not checked"
+msgstr ""
+
+#: c-common.c:1547
+msgid "zero-length format string"
+msgstr ""
+
+#: c-common.c:1550
+msgid "unterminated format string"
+msgstr ""
+
+#: c-common.c:1569
+msgid "embedded `\\0' in format"
+msgstr ""
+
+#: c-common.c:1571
+msgid "too many arguments for format"
+msgstr ""
+
+#: c-common.c:1578
+#, ycp-format
+msgid "spurious trailing `%%' in format"
+msgstr ""
+
+#: c-common.c:1601
+#, c-format
+msgid "ANSI C does not support the strftime `%c' flag"
+msgstr ""
+
+#: c-common.c:1605 c-common.c:1669
+#, c-format
+msgid "repeated `%c' flag in format"
+msgstr ""
+
+#: c-common.c:1622
+msgid "ANSI C does not support strftime format width"
+msgstr ""
+
+#: c-common.c:1630
+msgid "multiple E/O modifiers in format"
+msgstr ""
+
+#: c-common.c:1660
+msgid "operand number out of range in format"
+msgstr ""
+
+#: c-common.c:1681
+msgid "use of both ` ' and `+' flags in format"
+msgstr ""
+
+#: c-common.c:1686
+msgid "use of both `0' and `-' flags in format"
+msgstr ""
+
+#: c-common.c:1712 c-common.c:1746
+#, c-format
+msgid "field width is not type int (arg %d)"
+msgstr ""
+
+#: c-common.c:1728
+msgid "`.' not followed by `*' or digit in format"
+msgstr ""
+
+#: c-common.c:1768 c-common.c:1775
+#, c-format
+msgid "ANSI C does not support the `%c' length modifier"
+msgstr ""
+
+#: c-common.c:1784
+msgid "ANSI C does not support the `ll' length modifier"
+msgstr ""
+
+#: c-common.c:1790
+msgid "ANSI C does not support the `hh' length modifier"
+msgstr ""
+
+#: c-common.c:1803
+#, c-format
+msgid "use of `*' and `%c' together in format"
+msgstr ""
+
+#: c-common.c:1809
+msgid "conversion lacks type at end of format"
+msgstr ""
+
+#: c-common.c:1815 c-common.c:1820
+#, c-format
+msgid "ANSI C does not support the `%c' format"
+msgstr ""
+
+#: c-common.c:1842
+#, c-format
+msgid "unknown conversion type character `%c' in format"
+msgstr ""
+
+#: c-common.c:1845
+#, c-format
+msgid "unknown conversion type character 0x%x in format"
+msgstr ""
+
+#: c-common.c:1852
+msgid "ANSI C does not support `%%%c'"
+msgstr ""
+
+#: c-common.c:1855
+msgid "ANSI C does not support `%%O%c'"
+msgstr ""
+
+#: c-common.c:1858
+#, c-format
+msgid "width used with `%c' format"
+msgstr ""
+
+#: c-common.c:1860
+msgid "`%%%c' yields only last 2 digits of year"
+msgstr ""
+
+#: c-common.c:1862
+msgid "`%%%c' yields only last 2 digits of year in some locales"
+msgstr ""
+
+#: c-common.c:1865
+#, c-format
+msgid "precision used with `%c' format"
+msgstr ""
+
+#: c-common.c:1868
+#, c-format
+msgid "`a' flag used with `%c' format"
+msgstr ""
+
+#: c-common.c:1874
+msgid "ANSI C does not support the `a' flag"
+msgstr ""
+
+#. The end of the format string was reached.
+#: c-common.c:1888
+#, ycp-format
+msgid "no closing `]' for `%%[' format"
+msgstr ""
+
+#: c-common.c:1893
+#, c-format
+msgid "suppression of `%c' conversion in format"
+msgstr ""
+
+#: c-common.c:1899
+#, c-format
+msgid "flag `%c' used with type `%c'"
+msgstr ""
+
+#: c-common.c:1908
+#, c-format
+msgid "`0' flag ignored with precision specifier and `%c' format"
+msgstr ""
+
+#: c-common.c:1921
+#, c-format
+msgid "use of `%c' length character with `%c' type character"
+msgstr ""
+
+#: c-common.c:1960
+#, c-format
+msgid "format argument is not a pointer (arg %d)"
+msgstr ""
+
+#: c-common.c:1962
+#, c-format
+msgid "format argument is not a pointer to a pointer (arg %d)"
+msgstr ""
+
+#: c-common.c:1979
+#, c-format
+msgid "writing into constant object (arg %d)"
+msgstr ""
+
+#: c-common.c:2039
+#, c-format
+msgid "%s format, %s arg (arg %d)"
+msgstr ""
+
+#: c-common.c:2057
+msgid "overflow in constant expression"
+msgstr ""
+
+#: c-common.c:2078
+msgid "integer overflow in expression"
+msgstr ""
+
+#: c-common.c:2087
+msgid "floating point overflow in expression"
+msgstr ""
+
+#. This detects cases like converting -129 or 256 to unsigned char.
+#: c-common.c:2108
+msgid "large integer implicitly truncated to unsigned type"
+msgstr ""
+
+#: c-common.c:2110
+msgid "negative integer implicitly converted to unsigned type"
+msgstr ""
+
+#: c-common.c:2143
+msgid "overflow in implicit constant conversion"
+msgstr ""
+
+#: c-common.c:2164
 msgid "expression statement has incomplete type"
 msgstr ""
 
-#: c-common.c:2178
+#: c-common.c:2184
 msgid "case label does not reduce to an integer constant"
 msgstr ""
 
-#: c-common.c:2435
+#: c-common.c:2454
 msgid "invalid truth-value expression"
 msgstr ""
 
-#: c-common.c:2486
+#: c-common.c:2505
 #, c-format
 msgid "invalid operands to binary %s"
 msgstr ""
 
-#: c-common.c:2858
+#: c-common.c:2740 c-common.c:2749
+msgid "comparison is always false due to limited range of data type"
+msgstr ""
+
+#: c-common.c:2742 c-common.c:2751
+msgid "comparison is always true due to limited range of data type"
+msgstr ""
+
+#: c-common.c:2817
+msgid "comparison of unsigned expression >= 0 is always true"
+msgstr ""
+
+#: c-common.c:2826
+msgid "comparison of unsigned expression < 0 is always false"
+msgstr ""
+
+#: c-common.c:2877
 msgid "struct type value used where scalar is required"
 msgstr ""
 
-#: c-common.c:2862
+#: c-common.c:2881
 msgid "union type value used where scalar is required"
 msgstr ""
 
-#: c-common.c:2866
+#: c-common.c:2885
 msgid "array type value used where scalar is required"
 msgstr ""
 
-#: c-common.c:3204 c-common.c:3236
+#: c-common.c:3000
+msgid "suggest parentheses around assignment used as truth value"
+msgstr ""
+
+#: c-common.c:3223 c-common.c:3255
 msgid "invalid use of `restrict'"
 msgstr ""
 
-#: c-common.c:3929 c-typeck.c:1655
+#: c-common.c:3952 c-typeck.c:1747
 #, c-format
 msgid "too few arguments to function `%s'"
 msgstr ""
 
-#: c-common.c:3935 c-typeck.c:1514
+#: c-common.c:3958 c-typeck.c:1606
 #, c-format
 msgid "too many arguments to function `%s'"
 msgstr ""
 
-#: c-convert.c:78 c-typeck.c:938 c-typeck.c:3956 cp/typeck.c:1724
-#: cp/typeck.c:6480
+#: c-convert.c:78 c-typeck.c:941 c-typeck.c:4048 cp/typeck.c:1725
+#: cp/typeck.c:6481
 msgid "void value not ignored as it ought to be"
 msgstr ""
 
-#: c-convert.c:98
+#: c-convert.c:100
 msgid "conversion to non-scalar type requested"
 msgstr ""
 
-#: c-decl.c:563
+#: c-decl.c:567
 #, c-format
 msgid "unknown C standard `%s'"
 msgstr ""
 
-#: c-decl.c:1001
+#: c-decl.c:828
+#, c-format
+msgid "array `%s' assumed to have one element"
+msgstr ""
+
+#: c-decl.c:1005
 #, c-format
 msgid "`struct %s' incomplete in scope ending here"
 msgstr ""
 
-#: c-decl.c:1004
+#: c-decl.c:1008
 #, c-format
 msgid "`union %s' incomplete in scope ending here"
 msgstr ""
 
-#: c-decl.c:1007
+#: c-decl.c:1011
 #, c-format
 msgid "`enum %s' incomplete in scope ending here"
 msgstr ""
 
-#: c-decl.c:1598
+#: c-decl.c:1125 c-decl.c:1286
+#, c-format
+msgid "label `%s' used but not defined"
+msgstr ""
+
+#: c-decl.c:1131 c-decl.c:1293
+#, c-format
+msgid "label `%s' defined but not used"
+msgstr ""
+
+#: c-decl.c:1415 c-decl.c:1468
+#, c-format
+msgid "shadowing built-in function `%s'"
+msgstr ""
+
+#: c-decl.c:1417
+#, c-format
+msgid "shadowing library function `%s'"
+msgstr ""
+
+#: c-decl.c:1423
+#, c-format
+msgid "library function `%s' declared as non-function"
+msgstr ""
+
+#: c-decl.c:1427 c-decl.c:1430
+#, c-format
+msgid "built-in function `%s' declared as non-function"
+msgstr ""
+
+#: c-decl.c:1434 objc/objc-act.c:2507 objc/objc-act.c:6178
+#, c-format
+msgid "`%s' redeclared as different kind of symbol"
+msgstr ""
+
+#: c-decl.c:1435 c-decl.c:1613 c-decl.c:1759 objc/objc-act.c:2509
+#: objc/objc-act.c:6180 objc/objc-act.c:6235
+#, c-format
+msgid "previous declaration of `%s'"
+msgstr ""
+
+#. If types don't match for a built-in, throw away the built-in.
+#: c-decl.c:1517
+#, c-format
+msgid "conflicting types for built-in function `%s'"
+msgstr ""
+
+#: c-decl.c:1560 c-decl.c:1579
+#, c-format
+msgid "conflicting types for `%s'"
+msgstr ""
+
+#: c-decl.c:1602
 msgid ""
 "A parameter list with an ellipsis can't match an empty parameter name list "
 "declaration."
 msgstr ""
 
-#: c-decl.c:1604
+#: c-decl.c:1608
 msgid ""
 "An argument type that has a default promotion can't match an empty parameter "
 "name list declaration."
 msgstr ""
 
-#: c-decl.c:2496
+#: c-decl.c:1623 c-decl.c:1645
+#, c-format
+msgid "redefinition of `%s'"
+msgstr ""
+
+#: c-decl.c:1626
+#, c-format
+msgid "redeclaration of `%s'"
+msgstr ""
+
+#: c-decl.c:1629
+#, c-format
+msgid "conflicting declarations of `%s'"
+msgstr ""
+
+#: c-decl.c:1638 c-decl.c:1650
+#, c-format
+msgid "`%s' previously defined here"
+msgstr ""
+
+#: c-decl.c:1639 c-decl.c:1651
+#, c-format
+msgid "`%s' previously declared here"
+msgstr ""
+
+#: c-decl.c:1672
+#, c-format
+msgid "prototype for `%s' follows"
+msgstr ""
+
+#: c-decl.c:1673 c-decl.c:1680 c-decl.c:1696
+msgid "non-prototype definition here"
+msgstr ""
+
+#: c-decl.c:1679
+#, c-format
+msgid "prototype for `%s' follows and number of arguments doesn't match"
+msgstr ""
+
+#: c-decl.c:1694
+#, c-format
+msgid "prototype for `%s' follows and argument %d doesn't match"
+msgstr ""
+
+#: c-decl.c:1711
+#, c-format
+msgid "`%s' declared inline after being called"
+msgstr ""
+
+#: c-decl.c:1716
+#, c-format
+msgid "`%s' declared inline after its definition"
+msgstr ""
+
+#: c-decl.c:1723
+#, c-format
+msgid "static declaration for `%s' follows non-static"
+msgstr ""
+
+#: c-decl.c:1731
+#, c-format
+msgid "non-static declaration for `%s' follows static"
+msgstr ""
+
+#: c-decl.c:1738
+#, c-format
+msgid "const declaration for `%s' follows non-const"
+msgstr ""
+
+#: c-decl.c:1745
+#, c-format
+msgid "type qualifiers for `%s' conflict with previous decl"
+msgstr ""
+
+#: c-decl.c:1758
+#, c-format
+msgid "redundant redeclaration of `%s' in same scope"
+msgstr ""
+
+#: c-decl.c:2027
+#, c-format
+msgid "nested extern declaration of `%s'"
+msgstr ""
+
+#: c-decl.c:2052
+#, c-format
+msgid "`%s' used prior to declaration"
+msgstr ""
+
+#: c-decl.c:2073 c-decl.c:2288
+#, c-format
+msgid "`%s' was declared implicitly `extern' and later `static'"
+msgstr ""
+
+#: c-decl.c:2183
+msgid "type mismatch with previous external decl"
+msgstr ""
+
+#: c-decl.c:2184
+#, c-format
+msgid "previous external decl of `%s'"
+msgstr ""
+
+#: c-decl.c:2197
+msgid "type mismatch with previous implicit declaration"
+msgstr ""
+
+#: c-decl.c:2199
+#, c-format
+msgid "previous implicit declaration of `%s'"
+msgstr ""
+
+#: c-decl.c:2216
+#, c-format
+msgid "type of external `%s' is not global"
+msgstr ""
+
+#: c-decl.c:2267
+#, c-format
+msgid "`%s' was previously implicitly declared to return `int'"
+msgstr ""
+
+#: c-decl.c:2292
+#, c-format
+msgid "`%s' was declared `extern' and later `static'"
+msgstr ""
+
+#: c-decl.c:2315
+#, c-format
+msgid "extern declaration of `%s' doesn't match global one"
+msgstr ""
+
+#: c-decl.c:2353
+#, c-format
+msgid "`%s' locally external but globally static"
+msgstr ""
+
+#: c-decl.c:2389 c-decl.c:2414 cp/decl.c:4194
+#, c-format
+msgid "declaration of `%s' shadows a parameter"
+msgstr ""
+
+#: c-decl.c:2392
+#, c-format
+msgid "declaration of `%s' shadows a symbol from the parameter list"
+msgstr ""
+
+#: c-decl.c:2416 cp/decl.c:4202
+#, c-format
+msgid "declaration of `%s' shadows previous local"
+msgstr ""
+
+#. XXX shadow warnings in outer-more namespaces
+#: c-decl.c:2419 cp/decl.c:4206
+#, c-format
+msgid "declaration of `%s' shadows global declaration"
+msgstr ""
+
+#. Implicit declaration of built-in function.  Don't
+#. change the built-in declaration, but don't let this
+#. go by silently, either.
+#: c-decl.c:2507 c-decl.c:2510 c-typeck.c:1420
 #, c-format
 msgid "implicit declaration of function `%s'"
 msgstr ""
 
-#: c-decl.c:2598
+#: c-decl.c:2514
+#, c-format
+msgid "function `%s' was previously declared within a block"
+msgstr ""
+
+#: c-decl.c:2609
 #, c-format
 msgid "label %s referenced outside of any function"
 msgstr ""
 
-#: c-decl.c:2658
+#: c-decl.c:2669
 #, c-format
 msgid "duplicate label declaration `%s'"
 msgstr ""
 
-#: c-decl.c:2695
+#: c-decl.c:2672
+msgid "this is a previous declaration"
+msgstr ""
+
+#: c-decl.c:2706
 #, c-format
 msgid "duplicate label `%s'"
 msgstr ""
 
-#: c-decl.c:3302
+#: c-decl.c:3287
+msgid "unnamed struct/union that defines no instances"
+msgstr ""
+
+#: c-decl.c:3306
+msgid "useless keyword or type name in empty declaration"
+msgstr ""
+
+#: c-decl.c:3313
 msgid "two types specified in one empty declaration"
 msgstr ""
 
-#: c-decl.c:3378
+#: c-decl.c:3318 c-parse.y:291 c-parse.y:694 c-parse.y:696 c-parse.y:753
+#: objc-parse.y:320 objc-parse.y:756 objc-parse.y:758 objc-parse.y:815
+#: objc-parse.y:2621 parse.y:703 parse.y:1719
+msgid "empty declaration"
+msgstr ""
+
+#: c-decl.c:3375
+#, c-format
+msgid "`%s' is usually a function"
+msgstr ""
+
+#: c-decl.c:3389
 #, c-format
 msgid "typedef `%s' is initialized"
 msgstr ""
 
-#: c-decl.c:3385
+#: c-decl.c:3396
 #, c-format
 msgid "function `%s' is initialized like a variable"
 msgstr ""
 
 #. DECL_INITIAL in a PARM_DECL is really DECL_ARG_TYPE.
-#: c-decl.c:3392
+#: c-decl.c:3403
 #, c-format
 msgid "parameter `%s' is initialized"
 msgstr ""
 
-#: c-decl.c:3407 c-typeck.c:4671
+#: c-decl.c:3418 c-typeck.c:4765
 msgid "variable-sized object may not be initialized"
 msgstr ""
 
-#: c-decl.c:3413
+#: c-decl.c:3424
 #, c-format
 msgid "variable `%s' has initializer but incomplete type"
 msgstr ""
 
-#: c-decl.c:3419
+#: c-decl.c:3430
 #, c-format
 msgid "elements of array `%s' have incomplete type"
 msgstr ""
 
-#: c-decl.c:3944 cp/decl.c:10079
+#: c-decl.c:3442
+#, c-format
+msgid "declaration of `%s' has `extern' and is initialized"
+msgstr ""
+
+#: c-decl.c:3526
+msgid "iterator has no initial value"
+msgstr ""
+
+#: c-decl.c:3562
+#, c-format
+msgid "initializer fails to determine size of `%s'"
+msgstr ""
+
+#: c-decl.c:3567
+#, c-format
+msgid "array size missing in `%s'"
+msgstr ""
+
+#: c-decl.c:3583
+#, c-format
+msgid "zero or negative size array `%s'"
+msgstr ""
+
+#: c-decl.c:3611
+#, c-format
+msgid "storage size of `%s' isn't known"
+msgstr ""
+
+#: c-decl.c:3621
+#, c-format
+msgid "storage size of `%s' isn't constant"
+msgstr ""
+
+#: c-decl.c:3720
+#, c-format
+msgid "ANSI C forbids parameter `%s' shadowing typedef"
+msgstr ""
+
+#: c-decl.c:3955 cp/decl.c:10101
 msgid "`long long long' is too long for GCC"
 msgstr ""
 
-#: c-decl.c:3959 cp/decl.c:10104
+#: c-decl.c:3960
+msgid "ANSI C does not support `long long'"
+msgstr ""
+
+#: c-decl.c:3965 cp/decl.c:10106
+#, c-format
+msgid "duplicate `%s'"
+msgstr ""
+
+#: c-decl.c:3971 cp/decl.c:10126
 #, c-format
 msgid "two or more data types in declaration of `%s'"
 msgstr ""
 
-#: c-decl.c:3974 cp/decl.c:10109
+#: c-decl.c:3986 cp/decl.c:10131
 #, c-format
 msgid "`%s' fails to be a typedef or built in type"
 msgstr ""
 
-#: c-decl.c:4038
+#: c-decl.c:4022
+#, c-format
+msgid "type defaults to `int' in declaration of `%s'"
+msgstr ""
+
+#: c-decl.c:4050
 #, c-format
 msgid "both long and short specified for `%s'"
 msgstr ""
 
-#: c-decl.c:4042 cp/decl.c:10209
+#: c-decl.c:4054 cp/decl.c:10231
 #, c-format
 msgid "long or short specified with char for `%s'"
 msgstr ""
 
-#: c-decl.c:4049 cp/decl.c:10213
+#: c-decl.c:4061 cp/decl.c:10235
 #, c-format
 msgid "long or short specified with floating type for `%s'"
 msgstr ""
 
-#: c-decl.c:4052
+#: c-decl.c:4064
 msgid "the only valid combination is `long double'"
 msgstr ""
 
-#: c-decl.c:4058
+#: c-decl.c:4070
 #, c-format
 msgid "both signed and unsigned specified for `%s'"
 msgstr ""
 
-#: c-decl.c:4060 cp/decl.c:10202
+#: c-decl.c:4072 cp/decl.c:10224
 #, c-format
 msgid "long, short, signed or unsigned invalid for `%s'"
 msgstr ""
 
-#: c-decl.c:4085 cp/decl.c:10243
+#: c-decl.c:4078 cp/decl.c:10244
+#, c-format
+msgid "long, short, signed or unsigned used invalidly for `%s'"
+msgstr ""
+
+#: c-decl.c:4097 cp/decl.c:10265
 #, c-format
 msgid "complex invalid for `%s'"
 msgstr ""
 
-#: c-decl.c:4188 cp/decl.c:10392
+#: c-decl.c:4173 c-decl.c:4531 cp/decl.c:10867
+msgid "duplicate `const'"
+msgstr ""
+
+#: c-decl.c:4175 c-decl.c:4535 cp/decl.c:10871
+msgid "duplicate `restrict'"
+msgstr ""
+
+#: c-decl.c:4177 c-decl.c:4533 cp/decl.c:10869
+msgid "duplicate `volatile'"
+msgstr ""
+
+#: c-decl.c:4200 cp/decl.c:10414
 #, c-format
 msgid "multiple storage classes in declaration of `%s'"
 msgstr ""
 
-#: c-decl.c:4199
+#: c-decl.c:4209
+msgid "function definition declared `auto'"
+msgstr ""
+
+#: c-decl.c:4211
 msgid "function definition declared `register'"
 msgstr ""
 
-#: c-decl.c:4201
+#: c-decl.c:4213
 msgid "function definition declared `typedef'"
 msgstr ""
 
-#: c-decl.c:4214
+#: c-decl.c:4226
 #, c-format
 msgid "storage class specified for structure field `%s'"
 msgstr ""
 
-#: c-decl.c:4217 cp/decl.c:10439
+#: c-decl.c:4229 cp/decl.c:10461
 #, c-format
 msgid "storage class specified for parameter `%s'"
 msgstr ""
 
-#: c-decl.c:4220 cp/decl.c:10441
+#: c-decl.c:4232 cp/decl.c:10463
 msgid "storage class specified for typename"
 msgstr ""
 
-#: c-decl.c:4234 cp/decl.c:10458
+#: c-decl.c:4244 cp/decl.c:10477
+#, c-format
+msgid "`%s' initialized and declared `extern'"
+msgstr ""
+
+#: c-decl.c:4246 cp/decl.c:10480
 #, c-format
 msgid "`%s' has both `extern' and initializer"
 msgstr ""
 
-#: c-decl.c:4238 cp/decl.c:10462
+#: c-decl.c:4250 cp/decl.c:10484
 #, c-format
 msgid "nested function `%s' declared `extern'"
 msgstr ""
 
-#: c-decl.c:4241 cp/decl.c:10466
+#: c-decl.c:4253 cp/decl.c:10488
 #, c-format
 msgid "top-level declaration of `%s' specifies `auto'"
 msgstr ""
 
-#: c-decl.c:4245
+#: c-decl.c:4257
 #, c-format
 msgid "iterator `%s' has derived type"
 msgstr ""
 
-#: c-decl.c:4251
+#: c-decl.c:4263
 #, c-format
 msgid "iterator `%s' has noninteger type"
 msgstr ""
 
-#: c-decl.c:4295
+#: c-decl.c:4307
 #, c-format
 msgid "declaration of `%s' as array of voids"
 msgstr ""
 
-#: c-decl.c:4301
+#: c-decl.c:4313
 #, c-format
 msgid "declaration of `%s' as array of functions"
 msgstr ""
 
-#: c-decl.c:4323
+#: c-decl.c:4335
 #, c-format
 msgid "size of array `%s' has non-integer type"
 msgstr ""
 
-#: c-decl.c:4335
+#: c-decl.c:4340
+#, c-format
+msgid "ANSI C forbids zero-size array `%s'"
+msgstr ""
+
+#: c-decl.c:4347
 #, c-format
 msgid "size of array `%s' is negative"
 msgstr ""
 
-#: c-decl.c:4367 c-decl.c:4544
+#: c-decl.c:4360
+#, c-format
+msgid "ANSI C forbids array `%s' whose size can't be evaluated"
+msgstr ""
+
+#: c-decl.c:4362
+#, c-format
+msgid "ANSI C forbids variable-size array `%s'"
+msgstr ""
+
+#: c-decl.c:4379 c-decl.c:4556
 #, c-format
 msgid "size of array `%s' is too large"
 msgstr ""
 
-#: c-decl.c:4428 cp/decl.c:10602
+#: c-decl.c:4398
+msgid "array type has incomplete element type"
+msgstr ""
+
+#: c-decl.c:4405 c-decl.c:4601
+msgid "ANSI C forbids const or volatile function types"
+msgstr ""
+
+#: c-decl.c:4440 cp/decl.c:10624
 #, c-format
 msgid "`%s' declared as function returning a function"
 msgstr ""
 
-#: c-decl.c:4433 cp/decl.c:10607
+#: c-decl.c:4445 cp/decl.c:10629
 #, c-format
 msgid "`%s' declared as function returning an array"
 msgstr ""
 
-#: c-decl.c:4515 cp/decl.c:10841
+#: c-decl.c:4494 c-decl.c:4567 c-decl.c:4651 c-decl.c:4737
+msgid "ANSI C forbids qualified function types"
+msgstr ""
+
+#: c-decl.c:4527 cp/decl.c:10863
 msgid "invalid type modifier within pointer declarator"
 msgstr ""
 
-#: c-decl.c:4608 cp/decl.c:11321
+#: c-decl.c:4620 cp/decl.c:11343
 #, c-format
 msgid "variable or field `%s' declared void"
 msgstr ""
 
-#: c-decl.c:4673
+#: c-decl.c:4685
 #, c-format
 msgid "field `%s' declared as a function"
 msgstr ""
 
-#: c-decl.c:4679
+#: c-decl.c:4691
 #, c-format
 msgid "field `%s' has incomplete type"
 msgstr ""
 
-#: c-decl.c:4712
+#: c-decl.c:4722 c-decl.c:4724 c-decl.c:4731
 #, c-format
 msgid "invalid storage class for function `%s'"
 msgstr ""
 
-#: c-decl.c:4890 cp/decl.c:11831
+#: c-decl.c:4743
+msgid "ANSI C forbids qualified void function return type"
+msgstr ""
+
+#: c-decl.c:4749
+msgid "`noreturn' function returns non-void value"
+msgstr ""
+
+#: c-decl.c:4761
+msgid "cannot inline function `main'"
+msgstr ""
+
+#: c-decl.c:4792
+#, c-format
+msgid "variable `%s' declared `inline'"
+msgstr ""
+
+#: c-decl.c:4866 c-decl.c:5799
+msgid "function declaration isn't a prototype"
+msgstr ""
+
+#: c-decl.c:4872 cp/decl.c:12033
+msgid "parameter names (without types) in function declaration"
+msgstr ""
+
+#: c-decl.c:4902 c-decl.c:6184 c-decl.c:6472 cp/decl.c:11853
 #, c-format
 msgid "parameter `%s' has incomplete type"
 msgstr ""
 
-#: c-decl.c:5015
+#: c-decl.c:4905 cp/decl.c:11856
+msgid "parameter has incomplete type"
+msgstr ""
+
+#: c-decl.c:4924
+#, c-format
+msgid "parameter `%s' points to incomplete type"
+msgstr ""
+
+#: c-decl.c:4927
+msgid "parameter points to incomplete type"
+msgstr ""
+
+#: c-decl.c:4985
+#, c-format
+msgid "parameter `%s' has just a forward declaration"
+msgstr ""
+
+#: c-decl.c:5027
 msgid "`void' in parameter list must be the entire list"
 msgstr ""
 
-#: c-decl.c:5129
+#: c-decl.c:5056
+#, c-format
+msgid "`%s %s' declared inside parameter list"
+msgstr ""
+
+#: c-decl.c:5065
+msgid "anonymous struct declared inside parameter list"
+msgstr ""
+
+#: c-decl.c:5067
+msgid "anonymous union declared inside parameter list"
+msgstr ""
+
+#: c-decl.c:5069
+msgid "anonymous enum declared inside parameter list"
+msgstr ""
+
+#: c-decl.c:5073
+msgid ""
+"its scope is only this definition or declaration, which is probably not what "
+"you want."
+msgstr ""
+
+#: c-decl.c:5108
+msgid "ANSI C forbids forward references to `enum' types"
+msgstr ""
+
+#: c-decl.c:5146
 #, c-format
 msgid "redefinition of `%s %s'"
 msgstr ""
 
-#: c-decl.c:5250
+#: c-decl.c:5213
+#, c-format
+msgid "%s defined inside parms"
+msgstr ""
+
+#: c-decl.c:5219
+msgid "union defined inside parms"
+msgstr ""
+
+#: c-decl.c:5221
+msgid "structure defined inside parms"
+msgstr ""
+
+#: c-decl.c:5232
+#, c-format
+msgid "%s has no %s"
+msgstr ""
+
+#: c-decl.c:5233
+msgid "union"
+msgstr ""
+
+#: c-decl.c:5233
+msgid "struct"
+msgstr ""
+
+#: c-decl.c:5234
+msgid "named members"
+msgstr ""
+
+#: c-decl.c:5234
+msgid "members"
+msgstr ""
+
+#: c-decl.c:5272
 #, c-format
 msgid "nested redefinition of `%s'"
 msgstr ""
 
+#: c-decl.c:5285
+#, c-format
+msgid "bit-field `%s' width not an integer constant"
+msgstr ""
+
+#: c-decl.c:5295
+#, c-format
+msgid "bit-field `%s' has invalid type"
+msgstr ""
+
+#: c-decl.c:5306
+#, c-format
+msgid "bit-field `%s' type invalid in ANSI C"
+msgstr ""
+
+#: c-decl.c:5313
+#, c-format
+msgid "negative width in bit-field `%s'"
+msgstr ""
+
+#: c-decl.c:5316
+#, c-format
+msgid "width of `%s' exceeds its type"
+msgstr ""
+
+#: c-decl.c:5318
+#, c-format
+msgid "zero width for bit-field `%s'"
+msgstr ""
+
+#: c-decl.c:5332
+#, c-format
+msgid "`%s' is narrower than values of its type"
+msgstr ""
+
+#: c-decl.c:5389
+#, c-format
+msgid "duplicate member `%s'"
+msgstr ""
+
+#: c-decl.c:5432
+msgid "union cannot be made transparent"
+msgstr ""
+
 #. This enum is a named one that has been declared already.
-#: c-decl.c:5485
+#: c-decl.c:5513
 #, c-format
 msgid "redeclaration of `enum %s'"
 msgstr ""
 
-#: c-decl.c:5637
+#: c-decl.c:5547
+msgid "enum defined inside parms"
+msgstr ""
+
+#: c-decl.c:5579
+msgid "enumeration values exceed range of largest integer"
+msgstr ""
+
+#: c-decl.c:5667
 #, c-format
 msgid "enumerator value for `%s' not integer constant"
 msgstr ""
 
-#: c-decl.c:5650
+#: c-decl.c:5680
 msgid "overflow in enumeration values"
 msgstr ""
 
-#: c-decl.c:5726
-msgid "return-type is an incomplete type"
+#: c-decl.c:5685
+msgid "ANSI C restricts enumerator values to range of `int'"
 msgstr ""
 
-#: c-decl.c:6208
+#: c-decl.c:5756
+msgid "return type is an incomplete type"
+msgstr ""
+
+#: c-decl.c:5764
+msgid "return type defaults to `int'"
+msgstr ""
+
+#: c-decl.c:5805
+#, c-format
+msgid "no previous prototype for `%s'"
+msgstr ""
+
+#: c-decl.c:5812
+#, c-format
+msgid "`%s' was used with no prototype before its definition"
+msgstr ""
+
+#: c-decl.c:5818
+#, c-format
+msgid "no previous declaration for `%s'"
+msgstr ""
+
+#: c-decl.c:5825
+#, c-format
+msgid "`%s' was used with no declaration before its definition"
+msgstr ""
+
+#: c-decl.c:5854 c-decl.c:6559
+#, c-format
+msgid "return type of `%s' is not `int'"
+msgstr ""
+
+#: c-decl.c:5870
+#, c-format
+msgid "first argument of `%s' should be `int'"
+msgstr ""
+
+#: c-decl.c:5879
+#, c-format
+msgid "second argument of `%s' should be `char **'"
+msgstr ""
+
+#: c-decl.c:5888
+#, c-format
+msgid "third argument of `%s' should probably be `char **'"
+msgstr ""
+
+#: c-decl.c:5897
+#, c-format
+msgid "`%s' takes only zero or two arguments"
+msgstr ""
+
+#: c-decl.c:5900
+#, c-format
+msgid "third argument of `%s' is deprecated"
+msgstr ""
+
+#: c-decl.c:5903
+#, c-format
+msgid "`%s' is normally a non-static function"
+msgstr ""
+
+#: c-decl.c:6003
+msgid "parm types given both in parmlist and separately"
+msgstr ""
+
+#: c-decl.c:6024
+msgid "parameter name omitted"
+msgstr ""
+
+#: c-decl.c:6028 c-decl.c:6131 c-decl.c:6429
+#, c-format
+msgid "parameter `%s' declared void"
+msgstr ""
+
+#: c-decl.c:6105
+msgid "parameter name missing from parameter list"
+msgstr ""
+
+#: c-decl.c:6124 c-decl.c:6422
+#, c-format
+msgid "multiple parameters named `%s'"
+msgstr ""
+
+#: c-decl.c:6155
+#, c-format
+msgid "type of `%s' defaults to `int'"
+msgstr ""
+
+#: c-decl.c:6191 c-decl.c:6479
+#, c-format
+msgid "declaration for parameter `%s' but no such parameter"
+msgstr ""
+
+#: c-decl.c:6238
 msgid "number of arguments doesn't match prototype"
 msgstr ""
 
-#: c-decl.c:6251
+#: c-decl.c:6267
+#, c-format
+msgid "promoted argument `%s' doesn't match prototype"
+msgstr ""
+
+#: c-decl.c:6281
 #, c-format
 msgid "argument `%s' doesn't match prototype"
 msgstr ""
 
-#: c-lex.c:482 cp/lex.c:1897
+#: c-decl.c:6452
+#, c-format
+msgid "type of parameter `%s' is not declared"
+msgstr ""
+
+#: c-decl.c:6594
+msgid "function might be possible candidate for attribute `noreturn'"
+msgstr ""
+
+#: c-decl.c:6597
+msgid "`noreturn' function does return"
+msgstr ""
+
+#. If this function returns non-void and control can drop through,
+#. complain.
+#: c-decl.c:6602
+msgid "control reaches end of non-void function"
+msgstr ""
+
+#: c-decl.c:6607 cp/decl.c:14562
+msgid "this function may return with or without a value"
+msgstr ""
+
+#: c-decl.c:6626
+#, c-format
+msgid "size of return value of `%s' is %u bytes"
+msgstr ""
+
+#: c-decl.c:6630
+#, c-format
+msgid "size of return value of `%s' is larger than %d bytes"
+msgstr ""
+
+#: c-iterate.c:475
+#, c-format
+msgid "`for (%s)' appears within implicit iteration"
+msgstr ""
+
+#: c-lex.c:416
+msgid "carriage return in source file"
+msgstr ""
+
+#: c-lex.c:417
+msgid "(we only warn about the first carriage return)"
+msgstr ""
+
+#: c-lex.c:474 cp/lex.c:1891
 msgid "stray '\\' in program"
 msgstr ""
 
-#: c-lex.c:559 c-lex.c:726 cp/lex.c:1961 cp/lex.c:2137
+#: c-lex.c:551 c-lex.c:718 cp/lex.c:1955 cp/lex.c:2131
 msgid "invalid #-line"
 msgstr ""
 
-#: c-lex.c:694 cp/lex.c:2105 cpplib.c:771
+#: c-lex.c:653 cp/lex.c:2066
+#, c-format
+msgid "ignoring pragma: %s"
+msgstr ""
+
+#: c-lex.c:686 cp/lex.c:2099 cpplib.c:772
 msgid "invalid #ident"
 msgstr ""
 
-#: c-lex.c:710 cp/lex.c:2121
+#: c-lex.c:702 cp/lex.c:2115
 #, c-format
 msgid "undefined or invalid # directive `%s'"
 msgstr ""
 
-#: c-lex.c:762 cp/lex.c:2174
+#: c-lex.c:754 cp/lex.c:2168
 msgid "invalid #line"
 msgstr ""
 
-#: c-lex.c:842 cp/lex.c:2291
+#: c-lex.c:834 cp/lex.c:2285
 msgid "#-lines for entering and leaving files don't match"
 msgstr ""
 
-#: c-lex.c:1050 cp/lex.c:2970
+#: c-lex.c:909
+msgid "the meaning of `\\x' varies with -traditional"
+msgstr ""
+
+#: c-lex.c:942 cp/lex.c:2866 cppexp.c:685
+msgid "\\x used with no following hex digits"
+msgstr ""
+
+#: c-lex.c:954 cp/lex.c:2876
+msgid "hex escape out of range"
+msgstr ""
+
+#: c-lex.c:994
+msgid "the meaning of `\\a' varies with -traditional"
+msgstr ""
+
+#: c-lex.c:1010
+#, c-format
+msgid "non-ANSI-standard escape sequence, `\\%c'"
+msgstr ""
+
+#: c-lex.c:1023 c-lex.c:1027 cp/lex.c:2941 cp/lex.c:2945
+#, c-format
+msgid "unknown escape sequence `\\%c'"
+msgstr ""
+
+#: c-lex.c:1029 cp/lex.c:2947
+#, c-format
+msgid "unknown escape sequence: `\\' followed by char code 0x%x"
+msgstr ""
+
+#: c-lex.c:1042 cp/lex.c:2964
 #, c-format
 msgid "%s at end of input"
 msgstr ""
 
-#: c-lex.c:1052 cp/lex.c:2973
+#: c-lex.c:1044 cp/lex.c:2967
 #, c-format
 msgid "%s at null character"
 msgstr ""
 
-#: c-lex.c:1054 cp/lex.c:2975
+#: c-lex.c:1046 cp/lex.c:2969
 #, c-format
 msgid "%s before string constant"
 msgstr ""
 
-#: c-lex.c:1056 cp/lex.c:2977
+#: c-lex.c:1048 cp/lex.c:2971
 #, c-format
 msgid "%s before character constant"
 msgstr ""
 
-#: c-lex.c:1058 cp/lex.c:2979
+#: c-lex.c:1050 cp/lex.c:2973
 #, c-format
 msgid "%s before character 0%o"
 msgstr ""
 
-#: c-lex.c:1060 cp/lex.c:2981
+#: c-lex.c:1052 cp/lex.c:2975
 #, c-format
 msgid "%s before `%s'"
 msgstr ""
 
-#: c-lex.c:1122 cp/lex.c:3379
+#: c-lex.c:1114 cp/lex.c:3373
 msgid "more than one `f' in numeric constant"
 msgstr ""
 
-#: c-lex.c:1128 cp/lex.c:3385
+#: c-lex.c:1120 cp/lex.c:3379
 msgid "more than one `l' in numeric constant"
 msgstr ""
 
-#: c-lex.c:1134 c-lex.c:1799 cp/lex.c:3391 cp/lex.c:4104
+#: c-lex.c:1126 c-lex.c:1794 cp/lex.c:3385 cp/lex.c:4098
 msgid "more than one `i' or `j' in numeric constant"
 msgstr ""
 
-#: c-lex.c:1161 cp/lex.c:3418
+#: c-lex.c:1128 c-lex.c:1796
+msgid "ANSI C forbids imaginary numeric constants"
+msgstr ""
+
+#: c-lex.c:1153 cp/lex.c:3412
 msgid "both `f' and `l' in floating constant"
 msgstr ""
 
-#: c-lex.c:1372 cp/lex.c:3612 cpplex.c:1100
+#: c-lex.c:1166 cp/lex.c:3425
+msgid "floating point number exceeds range of `float'"
+msgstr ""
+
+#: c-lex.c:1178 cp/lex.c:3437
+msgid "floating point number exceeds range of `long double'"
+msgstr ""
+
+#: c-lex.c:1189 c-lex.c:1742 cp/lex.c:3448 cp/lex.c:4047
+msgid "floating point number exceeds range of `double'"
+msgstr ""
+
+#: c-lex.c:1364 c-lex.c:1366 cp/lex.c:3606 cp/lex.c:3608 cpplex.c:1110
 msgid "`$' in identifier"
 msgstr ""
 
-#: c-lex.c:1428
+#: c-lex.c:1409
+#, c-format
+msgid "ANSI does not permit the keyword `%s'"
+msgstr ""
+
+#: c-lex.c:1422
 #, c-format
 msgid "invalid identifier `%s'"
 msgstr ""
 
-#: c-lex.c:1486 cp/lex.c:3791
+#: c-lex.c:1480 cp/lex.c:3785
 msgid "parse error at `..'"
 msgstr ""
 
-#: c-lex.c:1586 cp/lex.c:3891
+#: c-lex.c:1574 cp/lex.c:3879
+msgid "floating constant may not be in radix 16"
+msgstr ""
+
+#: c-lex.c:1580 cp/lex.c:3885
 msgid "malformed floating constant"
 msgstr ""
 
-#: c-lex.c:1620 cp/lex.c:3925
+#: c-lex.c:1614 cp/lex.c:3919
 msgid "nondigits in number and not hexadecimal"
 msgstr ""
 
-#: c-lex.c:1672 cp/lex.c:3977
+#: c-lex.c:1666 cp/lex.c:3971
 msgid "numeric constant with no digits"
 msgstr ""
 
-#: c-lex.c:1675 cp/lex.c:3980
+#: c-lex.c:1669 cp/lex.c:3974
 msgid "numeric constant contains digits beyond the radix"
 msgstr ""
 
-#: c-lex.c:1704 cp/lex.c:4009
+#: c-lex.c:1698 cp/lex.c:4003
 msgid "floating constant exponent has no digits"
 msgstr ""
 
-#: c-lex.c:1714 cp/lex.c:4019
+#: c-lex.c:1708 cp/lex.c:4013
 msgid "hexadecimal floating constant has no exponent"
 msgstr ""
 
 #. We got an exception from parse_float()
-#: c-lex.c:1732 cp/lex.c:4037
+#: c-lex.c:1726 cp/lex.c:4031
 msgid "floating constant out of range"
 msgstr ""
 
-#: c-lex.c:1781 cp/lex.c:4086
+#: c-lex.c:1775 cp/lex.c:4080
 msgid "two `u's in integer constant"
 msgstr ""
 
-#: c-lex.c:1789 cp/lex.c:4094
+#: c-lex.c:1783 cp/lex.c:4088
 msgid "three `l's in integer constant"
 msgstr ""
 
-#: c-lex.c:1941
+#: c-lex.c:1786
+msgid "ANSI C forbids long long integer constants"
+msgstr ""
+
+#: c-lex.c:1811 cp/lex.c:4115
+#, c-format
+msgid ""
+"integer constant is too large for this configuration of the compiler - "
+"truncated to %d bits"
+msgstr ""
+
+#: c-lex.c:1908
+msgid "width of integer constant changes with -traditional"
+msgstr ""
+
+#: c-lex.c:1911
+msgid "integer constant is unsigned in ANSI C, signed with -traditional"
+msgstr ""
+
+#: c-lex.c:1913
+msgid "width of integer constant may change on other systems with -traditional"
+msgstr ""
+
+#: c-lex.c:1921 cp/lex.c:4167
+msgid "integer constant larger than the maximum value of an unsigned long int"
+msgstr ""
+
+#: c-lex.c:1925 cp/lex.c:4171
+msgid "decimal constant is so large that it is unsigned"
+msgstr ""
+
+#: c-lex.c:1936
 msgid "complex integer constant is too wide for `complex int'"
 msgstr ""
 
-#: c-lex.c:1972 cp/lex.c:4209
+#: c-lex.c:1958 cp/lex.c:4194
+msgid "integer constant is larger than the maximum value for its type"
+msgstr ""
+
+#: c-lex.c:1967 cp/lex.c:4203
 #, c-format
 msgid "missing white space after number `%s'"
 msgstr ""
 
-#: c-lex.c:2108
+#: c-lex.c:2006 c-lex.c:2167 cp/lex.c:4242 cp/lex.c:4408 cppexp.c:290
+msgid "escape sequence out of range for character"
+msgstr ""
+
+#: c-lex.c:2015
+msgid "ANSI C forbids newline in character constant"
+msgstr ""
+
+#: c-lex.c:2065 c-lex.c:2194 cp/lex.c:4301 cp/lex.c:4435
+msgid "Ignoring invalid multibyte character"
+msgstr ""
+
+#: c-lex.c:2103
 msgid "malformed character constant"
 msgstr ""
 
-#: c-lex.c:2110 cp/lex.c:4347 cppexp.c:305
+#: c-lex.c:2105 cp/lex.c:4341 cppexp.c:305
 msgid "empty character constant"
 msgstr ""
 
-#: c-lex.c:2114 cp/lex.c:4351 cppexp.c:317
+#: c-lex.c:2109 cp/lex.c:4345 cppexp.c:317
 msgid "character constant too long"
 msgstr ""
 
-#: c-lex.c:2272 cp/lex.c:4514
+#: c-lex.c:2112 cp/lex.c:4348 cppexp.c:321
+msgid "multi-character character constant"
+msgstr ""
+
+#: c-lex.c:2172
+msgid "ANSI C forbids newline in string constant"
+msgstr ""
+
+#: c-lex.c:2267 cp/lex.c:4508
 msgid "Unterminated string constant"
 msgstr ""
 
+#: c-lex.c:2450 cp/lex.c:899
+msgid "YYDEBUG not defined."
+msgstr ""
+
 #. Like YYERROR but do call yyerror.
 #: c-parse.y:57 objc-parse.y:58 parse.y:57
 msgid "syntax error"
 msgstr ""
 
-#: /usr/lib/bison.simple:107
+#: /usr/lib/bison.simple:107 /usr/share/misc/bison.simple:107
 msgid "syntax error: cannot back up"
 msgstr ""
 
-#: /usr/lib/bison.simple:358
+#: /usr/lib/bison.simple:358 /usr/share/misc/bison.simple:358
 msgid "parser stack overflow"
 msgstr ""
 
-#: c-parse.y:270 c-parse.y:1831 objc-parse.y:299 objc-parse.y:1966
+#: c-parse.y:235 objc-parse.y:263
+msgid "ANSI C forbids an empty source file"
+msgstr ""
+
+#: c-parse.y:267 c-parse.y:1737 objc-parse.y:296 objc-parse.y:1811
 msgid "argument of `asm' is not a constant string"
 msgstr ""
 
-#: c-parse.y:278 objc-parse.y:307
+#: c-parse.y:275 objc-parse.y:304
 msgid "ANSI C forbids data definition with no type or storage class"
 msgstr ""
 
-#: c-parse.y:437 objc-parse.y:468
+#: c-parse.y:277 objc-parse.y:306
+msgid "data definition has no type or storage class"
+msgstr ""
+
+#: c-parse.y:298 objc-parse.y:327
+msgid "ANSI C does not allow extra `;' outside of a function"
+msgstr ""
+
+#: c-parse.y:405 objc-parse.y:436
+msgid "ANSI C forbids `&&'"
+msgstr ""
+
+#: c-parse.y:434 objc-parse.y:465
 msgid "`sizeof' applied to a bit-field"
 msgstr ""
 
-#: c-parse.y:595 objc-parse.y:642
+#: c-parse.y:477 objc-parse.y:508
+msgid "ANSI C forbids constructor expressions"
+msgstr ""
+
+#: c-parse.y:546 objc-parse.y:577
+msgid "ANSI C forbids omitting the middle term of a ?: expression"
+msgstr ""
+
+#: c-parse.y:594 objc-parse.y:625
+msgid "ANSI C forbids braced-groups within expressions"
+msgstr ""
+
+#: c-parse.y:649
+msgid "Use of ANSI string concatenation"
+msgstr ""
+
+#: c-parse.y:661 objc-parse.y:723
+msgid "ANSI C does not permit use of `varargs.h'"
+msgstr ""
+
+#: c-parse.y:776 c-parse.y:797 c-parse.y:829 objc-parse.y:838 objc-parse.y:859
+#: objc-parse.y:891 parse.y:1799 parse.y:1806 parse.y:1845
 #, c-format
-msgid "`%s' undeclared here (not in a function)"
+msgid "`%s' is not at beginning of declaration"
 msgstr ""
 
-#: c-parse.y:605 objc-parse.y:667
-#, c-format
-msgid "`%s' undeclared (first use in this function)"
+#: c-parse.y:993 objc-parse.y:1064
+msgid "ANSI C forbids empty initializer braces"
 msgstr ""
 
-#: c-parse.y:610 objc-parse.y:672
-msgid "(Each undeclared identifier is reported only once"
+#: c-parse.y:1043 c-parse.y:1069 objc-parse.y:1110 objc-parse.y:1136
+msgid "ANSI C forbids nested functions"
 msgstr ""
 
-#: c-parse.y:611 objc-parse.y:673
-msgid "for each function it appears in.)"
-msgstr ""
-
-#: c-parse.y:638 objc-parse.y:705
-#, c-format
-msgid "`%s' implicitly declared as function"
-msgstr ""
-
-#: c-parse.y:1234 c-parse.y:1268
+#: c-parse.y:1140 c-parse.y:1174
 msgid "`[*]' in parameter declaration only allowed in ISO C 99"
 msgstr ""
 
-#: c-parse.y:1604 objc-parse.y:1739 parse.y:1471
+#: c-parse.y:1257 objc-parse.y:1315 parse.y:2256
+msgid "comma at end of enumerator list"
+msgstr ""
+
+#: c-parse.y:1265 objc-parse.y:1323
+msgid "no semicolon at end of struct or union"
+msgstr ""
+
+#: c-parse.y:1274 objc-parse.y:1332 objc-parse.y:2406
+msgid "extra semicolon in struct or union specified"
+msgstr ""
+
+#: c-parse.y:1298 objc-parse.y:1370
+msgid "ANSI C doesn't support unnamed structs/unions"
+msgstr ""
+
+#: c-parse.y:1312 objc-parse.y:1384
+msgid "ANSI C forbids member declarations with no members"
+msgstr ""
+
+#: c-parse.y:1426 objc-parse.y:1498
+msgid "ANSI C forbids label at end of compound statement"
+msgstr ""
+
+#: c-parse.y:1460 objc-parse.y:1534
+msgid "ANSI C forbids label declarations"
+msgstr ""
+
+#: c-parse.y:1510 objc-parse.y:1584 parse.y:1501
 msgid "braced-group within expression allowed only inside a function"
 msgstr ""
 
-#: c-parse.y:1808 objc-parse.y:1943
+#: c-parse.y:1622 objc-parse.y:1696
+msgid "empty body in an else-statement"
+msgstr ""
+
+#: c-parse.y:1714 objc-parse.y:1788
 msgid "break statement not within loop or switch"
 msgstr ""
 
-#: c-parse.y:1813 objc-parse.y:1948
+#: c-parse.y:1719 objc-parse.y:1793
 msgid "continue statement not within a loop"
 msgstr ""
 
-#: c-parse.y:1888 objc-parse.y:2023
+#: c-parse.y:1773 objc-parse.y:1847
+msgid "ANSI C forbids `goto *expr;'"
+msgstr ""
+
+#: c-parse.y:1794 objc-parse.y:1868
 msgid "invalid `for (ITERATOR)' syntax"
 msgstr ""
 
-#: c-parse.y:1890 objc-parse.y:2025
+#: c-parse.y:1796 objc-parse.y:1870
 #, c-format
 msgid "`%s' is not an iterator"
 msgstr ""
 
-#: c-parse.y:1893 objc-parse.y:2028
+#: c-parse.y:1799 objc-parse.y:1873
 #, c-format
 msgid "`for (%s)' inside expansion of same iterator"
 msgstr ""
 
-#: c-parse.y:1951 c-parse.y:1980 cp/expr.c:245 cp/typeck2.c:1340
-#: objc-parse.y:2086 objc-parse.y:2115
+#: c-parse.y:1851 objc-parse.y:1925
+msgid "label must have integral type in ANSI C"
+msgstr ""
+
+#: c-parse.y:1857 c-parse.y:1886 cp/expr.c:245 cp/typeck2.c:1340
+#: objc-parse.y:1931 objc-parse.y:1960
 msgid "case label not within a switch statement"
 msgstr ""
 
-#: c-parse.y:1954 c-parse.y:1983 objc-parse.y:2089 objc-parse.y:2118
+#: c-parse.y:1860 c-parse.y:1889 objc-parse.y:1934 objc-parse.y:1963
 msgid "duplicate case value"
 msgstr ""
 
-#: c-parse.y:1960 c-parse.y:1991 cp/expr.c:277 objc-parse.y:2095
-#: objc-parse.y:2126
+#: c-parse.y:1861 c-parse.y:1890 objc-parse.y:1935 objc-parse.y:1964
+msgid "this is the first entry for that value"
+msgstr ""
+
+#: c-parse.y:1864 c-parse.y:1893 cp/expr.c:271 cp/typeck2.c:1415
+#: objc-parse.y:1938 objc-parse.y:1967
+msgid "case value out of range"
+msgstr ""
+
+#: c-parse.y:1866 c-parse.y:1897 cp/expr.c:277 objc-parse.y:1940
+#: objc-parse.y:1971
 msgid "case label within scope of cleanup or variable array"
 msgstr ""
 
-#: c-parse.y:2002 cp/expr.c:249 cp/typeck2.c:1342 objc-parse.y:2137
+#: c-parse.y:1876 objc-parse.y:1950
+msgid "ANSI C forbids case ranges"
+msgstr ""
+
+#: c-parse.y:1895 objc-parse.y:1969
+msgid "empty case range"
+msgstr ""
+
+#: c-parse.y:1908 cp/expr.c:249 cp/typeck2.c:1342 objc-parse.y:1982
 msgid "default label not within a switch statement"
 msgstr ""
 
-#: c-parse.y:2005 cp/expr.c:266 cp/typeck2.c:1348 objc-parse.y:2140
+#: c-parse.y:1911 cp/expr.c:266 cp/typeck2.c:1348 objc-parse.y:1985
 msgid "multiple default labels in one switch"
 msgstr ""
 
+#: c-parse.y:1912 objc-parse.y:1986
+msgid "this is the first default label"
+msgstr ""
+
+#: c-parse.y:1985 objc-parse.y:2059
+msgid "ANSI C forbids forward parameter declarations"
+msgstr ""
+
 #. Gcc used to allow this as an extension.  However, it does
 #. not work for all targets, and thus has been disabled.
 #. Also, since func (...) and func () are indistinguishable,
 #. it caused problems with the code in expand_builtin which
 #. tries to verify that BUILT_IN_NEXT_ARG is being used
 #. correctly.
-#: c-parse.y:2102 objc-parse.y:2237
+#: c-parse.y:2008 objc-parse.y:2082
 msgid "ANSI C requires a named argument before `...'"
 msgstr ""
 
-#: c-parse.y:2182 objc-parse.y:2317
+#: c-parse.y:2088 objc-parse.y:2162
 msgid "`...' in old-style identifier list"
 msgstr ""
 
-#: /usr/lib/bison.simple:639
+#: /usr/lib/bison.simple:639 /usr/share/misc/bison.simple:639
 msgid "parse error; also virtual memory exceeded"
 msgstr ""
 
-#: /usr/lib/bison.simple:643
+#: /usr/lib/bison.simple:643 /usr/share/misc/bison.simple:643
 msgid "parse error"
 msgstr ""
 
-#: c-typeck.c:117
+#: c-pragma.c:74
+#, c-format
+msgid "Alignment must be a small power of two, not %d, in #pragma pack"
+msgstr ""
+
+#: c-pragma.c:118
+msgid ""
+"#pragma pack (pop) encountered without matching #pragma pack (push, <n>)"
+msgstr ""
+
+#: c-pragma.c:136
+#, c-format
+msgid ""
+"#pragma pack(pop, %s) encountered without matching #pragma pack(push, %s, "
+"<n>)"
+msgstr ""
+
+#: c-pragma.c:216
+msgid "malformed `#pragma pack'"
+msgstr ""
+
+#: c-pragma.c:225
+msgid "malformed '#pragma pack(push[,id],<n>)'"
+msgstr ""
+
+#: c-pragma.c:232
+msgid "malformed '#pragma pack(pop[,id])'"
+msgstr ""
+
+#: c-pragma.c:245
+msgid "malformed `#pragma weak'"
+msgstr ""
+
+#: c-typeck.c:120
 #, c-format
 msgid "`%s' has an incomplete type"
 msgstr ""
 
-#: c-typeck.c:139 cp/call.c:2517
+#: c-typeck.c:142 cp/call.c:2517
 msgid "invalid use of void expression"
 msgstr ""
 
-#: c-typeck.c:148
+#: c-typeck.c:151
 msgid "invalid use of array with unspecified bounds"
 msgstr ""
 
-#: c-typeck.c:156
+#: c-typeck.c:159
 #, c-format
 msgid "invalid use of undefined type `%s %s'"
 msgstr ""
 
 #. If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.
-#: c-typeck.c:160
+#: c-typeck.c:163
 #, c-format
 msgid "invalid use of incomplete typedef `%s'"
 msgstr ""
 
-#: c-typeck.c:717
+#: c-typeck.c:391 c-typeck.c:405
+msgid "function types not truly compatible in ANSI C"
+msgstr ""
+
+#: c-typeck.c:554
+msgid "types are not quite compatible"
+msgstr ""
+
+#: c-typeck.c:705
+msgid "sizeof applied to a function type"
+msgstr ""
+
+#: c-typeck.c:711
+msgid "sizeof applied to a void type"
+msgstr ""
+
+#: c-typeck.c:720
 msgid "sizeof applied to an incomplete type"
 msgstr ""
 
-#: c-typeck.c:758 c-typeck.c:2656
+#: c-typeck.c:761 c-typeck.c:2748
 msgid "arithmetic on pointer to an incomplete type"
 msgstr ""
 
-#: c-typeck.c:785
+#: c-typeck.c:788
 msgid "__alignof__ applied to an incomplete type"
 msgstr ""
 
-#: c-typeck.c:807
+#: c-typeck.c:810
 msgid "`__alignof' applied to a bit-field"
 msgstr ""
 
-#: c-typeck.c:980 cp/typeck.c:1762
+#: c-typeck.c:983 cp/typeck.c:1763
 msgid "invalid use of non-lvalue array"
 msgstr ""
 
-#: c-typeck.c:1155
+#: c-typeck.c:1158
 #, c-format
 msgid "%s has no member named `%s'"
 msgstr ""
 
-#: c-typeck.c:1186
+#: c-typeck.c:1189
 #, c-format
 msgid "request for member `%s' in something not a structure or union"
 msgstr ""
 
-#: c-typeck.c:1219
+#: c-typeck.c:1222
 msgid "dereferencing pointer to incomplete type"
 msgstr ""
 
-#: c-typeck.c:1240 cp/typeck.c:2368
+#: c-typeck.c:1226
+msgid "dereferencing `void *' pointer"
+msgstr ""
+
+#: c-typeck.c:1243 cp/typeck.c:2369
 #, c-format
 msgid "invalid type argument of `%s'"
 msgstr ""
 
-#: c-typeck.c:1259 cp/typeck.c:2394
+#: c-typeck.c:1262 cp/typeck.c:2395
 msgid "subscript missing in array reference"
 msgstr ""
 
-#: c-typeck.c:1288 c-typeck.c:1383 cp/typeck.c:2422 cp/typeck.c:2500
+#: c-typeck.c:1283 cp/typeck.c:2416
+msgid "array subscript has type `char'"
+msgstr ""
+
+#: c-typeck.c:1291 c-typeck.c:1386 cp/typeck.c:2423 cp/typeck.c:2501
 msgid "array subscript is not an integer"
 msgstr ""
 
-#: c-typeck.c:1378 cp/typeck.c:2495
+#: c-typeck.c:1321
+msgid "ANSI C forbids subscripting `register' array"
+msgstr ""
+
+#: c-typeck.c:1323 c-typeck.c:1332
+msgid "ANSI C forbids subscripting non-lvalue array"
+msgstr ""
+
+#: c-typeck.c:1365
+msgid "subscript has type `char'"
+msgstr ""
+
+#: c-typeck.c:1381 cp/typeck.c:2496
 msgid "subscripted value is neither array nor pointer"
 msgstr ""
 
-#: c-typeck.c:1434
+#: c-typeck.c:1431
+#, c-format
+msgid "`%s' undeclared here (not in a function)"
+msgstr ""
+
+#: c-typeck.c:1438
+#, c-format
+msgid "`%s' undeclared (first use in this function)"
+msgstr ""
+
+#: c-typeck.c:1443
+msgid "(Each undeclared identifier is reported only once"
+msgstr ""
+
+#: c-typeck.c:1444
+msgid "for each function it appears in.)"
+msgstr ""
+
+#: c-typeck.c:1461
+#, c-format
+msgid "local declaration of `%s' hides instance variable"
+msgstr ""
+
+#: c-typeck.c:1526
 msgid "called object is not a function"
 msgstr ""
 
-#: c-typeck.c:1517 cp/typeck.c:3128
+#: c-typeck.c:1609 cp/typeck.c:3129
 msgid "too many arguments to function"
 msgstr ""
 
-#: c-typeck.c:1540
+#: c-typeck.c:1632
 #, c-format
 msgid "type of formal parameter %d is incomplete"
 msgstr ""
 
-#: c-typeck.c:1553
+#: c-typeck.c:1645
 #, c-format
 msgid "%s as integer rather than floating due to prototype"
 msgstr ""
 
-#: c-typeck.c:1556
+#: c-typeck.c:1648
 #, c-format
 msgid "%s as complex rather than floating due to prototype"
 msgstr ""
 
-#: c-typeck.c:1559
+#: c-typeck.c:1651
 #, c-format
 msgid "%s as floating rather than integer due to prototype"
 msgstr ""
 
-#: c-typeck.c:1562
+#: c-typeck.c:1654
 #, c-format
 msgid "%s as floating rather than complex due to prototype"
 msgstr ""
 
-#: c-typeck.c:1572
+#: c-typeck.c:1664
 #, c-format
 msgid "%s as `float' rather than `double' due to prototype"
 msgstr ""
 
-#: c-typeck.c:1587
+#: c-typeck.c:1679
 #, c-format
 msgid "%s with different width due to prototype"
 msgstr ""
 
-#: c-typeck.c:1621
+#: c-typeck.c:1713
 #, c-format
 msgid "%s as unsigned due to prototype"
 msgstr ""
 
-#: c-typeck.c:1623
+#: c-typeck.c:1715
 #, c-format
 msgid "%s as signed due to prototype"
 msgstr ""
 
-#: c-typeck.c:1658 cp/typeck.c:3230
+#: c-typeck.c:1750 cp/typeck.c:3231
 msgid "too few arguments to function"
 msgstr ""
 
-#: c-typeck.c:2228 cp/typeck.c:3781
+#: c-typeck.c:1791
+msgid "suggest parentheses around + or - inside shift"
+msgstr ""
+
+#: c-typeck.c:1798
+msgid "suggest parentheses around && within ||"
+msgstr ""
+
+#: c-typeck.c:1807
+msgid "suggest parentheses around arithmetic in operand of |"
+msgstr ""
+
+#: c-typeck.c:1810
+msgid "suggest parentheses around comparison in operand of |"
+msgstr ""
+
+#: c-typeck.c:1819
+msgid "suggest parentheses around arithmetic in operand of ^"
+msgstr ""
+
+#: c-typeck.c:1822
+msgid "suggest parentheses around comparison in operand of ^"
+msgstr ""
+
+#: c-typeck.c:1829
+msgid "suggest parentheses around + or - in operand of &"
+msgstr ""
+
+#: c-typeck.c:1832
+msgid "suggest parentheses around comparison in operand of &"
+msgstr ""
+
+#: c-typeck.c:1839
+msgid "comparisons like X<=Y<=Z do not have their mathematical meaning"
+msgstr ""
+
+#: c-typeck.c:2093 cp/typeck.c:3509
+msgid "right shift count is negative"
+msgstr ""
+
+#: c-typeck.c:2100 cp/typeck.c:3515
+msgid "right shift count >= width of type"
+msgstr ""
+
+#: c-typeck.c:2125 cp/typeck.c:3534
+msgid "left shift count is negative"
+msgstr ""
+
+#: c-typeck.c:2128 cp/typeck.c:3536
+msgid "left shift count >= width of type"
+msgstr ""
+
+#: c-typeck.c:2153
+msgid "shift count is negative"
+msgstr ""
+
+#: c-typeck.c:2155
+msgid "shift count >= width of type"
+msgstr ""
+
+#: c-typeck.c:2176 cp/typeck.c:3571
+msgid "comparing floating point with == or != is unsafe"
+msgstr ""
+
+#: c-typeck.c:2200 c-typeck.c:2206
+msgid "ANSI C forbids comparison of `void *' with function pointer"
+msgstr ""
+
+#: c-typeck.c:2209 c-typeck.c:2251 c-typeck.c:2279
+msgid "comparison of distinct pointer types lacks a cast"
+msgstr ""
+
+#: c-typeck.c:2224 c-typeck.c:2230 c-typeck.c:2300 c-typeck.c:2306
+msgid "comparison between pointer and integer"
+msgstr ""
+
+#: c-typeck.c:2246 c-typeck.c:2274
+msgid "ANSI C forbids ordered comparisons of pointers to functions"
+msgstr ""
+
+#: c-typeck.c:2271
+msgid "comparison of complete and incomplete pointers"
+msgstr ""
+
+#: c-typeck.c:2287 c-typeck.c:2294
+msgid "ordered comparison of pointer with integer zero"
+msgstr ""
+
+#: c-typeck.c:2320 cp/typeck.c:3782
 msgid "unordered comparison on non-floating point argument"
 msgstr ""
 
-#: c-typeck.c:2702
+#: c-typeck.c:2534
+msgid "comparison between signed and unsigned"
+msgstr ""
+
+#: c-typeck.c:2580 cp/typeck.c:4027
+msgid "comparison of promoted ~unsigned with constant"
+msgstr ""
+
+#: c-typeck.c:2588 cp/typeck.c:4035
+msgid "comparison of promoted ~unsigned with unsigned"
+msgstr ""
+
+#: c-typeck.c:2650
+msgid "pointer of type `void *' used in arithmetic"
+msgstr ""
+
+#: c-typeck.c:2656
+msgid "pointer to a function used in arithmetic"
+msgstr ""
+
+#: c-typeck.c:2734
+msgid "pointer of type `void *' used in subtraction"
+msgstr ""
+
+#: c-typeck.c:2736
+msgid "pointer to a function used in subtraction"
+msgstr ""
+
+#: c-typeck.c:2794
 msgid "wrong type argument to unary plus"
 msgstr ""
 
-#: c-typeck.c:2713
+#: c-typeck.c:2805
 msgid "wrong type argument to unary minus"
 msgstr ""
 
-#: c-typeck.c:2729
+#: c-typeck.c:2821
 msgid "wrong type argument to bit-complement"
 msgstr ""
 
-#: c-typeck.c:2740
+#: c-typeck.c:2832
 msgid "wrong type argument to abs"
 msgstr ""
 
-#: c-typeck.c:2752
+#: c-typeck.c:2844
 msgid "wrong type argument to conjugation"
 msgstr ""
 
-#: c-typeck.c:2766
+#: c-typeck.c:2858
 msgid "wrong type argument to unary exclamation mark"
 msgstr ""
 
-#: c-typeck.c:2820
+#: c-typeck.c:2912 c-typeck.c:2938
 #, c-format
 msgid "wrong type argument to %s"
 msgstr ""
 
-#: c-typeck.c:2840
+#: c-typeck.c:2932
 #, c-format
 msgid "%s of pointer to unknown structure"
 msgstr ""
 
-#: c-typeck.c:2905
+#: c-typeck.c:2997
 msgid "invalid lvalue in increment"
 msgstr ""
 
-#: c-typeck.c:2906
+#: c-typeck.c:2998
 msgid "invalid lvalue in decrement"
 msgstr ""
 
-#: c-typeck.c:2914 cp/typeck.c:4573
+#: c-typeck.c:3006 cp/typeck.c:4574
 msgid "increment"
 msgstr ""
 
-#: c-typeck.c:2914 cp/typeck.c:4573
+#: c-typeck.c:3006 cp/typeck.c:4574
 msgid "decrement"
 msgstr ""
 
-#: c-typeck.c:2981
+#: c-typeck.c:3059
+msgid "ANSI C forbids the address of a cast expression"
+msgstr ""
+
+#: c-typeck.c:3073
 msgid "invalid lvalue in unary `&'"
 msgstr ""
 
-#: c-typeck.c:3013
+#: c-typeck.c:3105
 #, c-format
 msgid "attempt to take address of bit-field structure member `%s'"
 msgstr ""
 
-#: c-typeck.c:3121 c-typeck.c:4468 collect2.c:1318 cp/typeck.c:4775 gcc.c:4012
+#: c-typeck.c:3213 c-typeck.c:4560 c-typeck.c:4576 c-typeck.c:4592
+#: collect2.c:1318 cp/typeck.c:4776 diagnostic.c:1411 gcc.c:4012
 #, c-format
 msgid "%s"
 msgstr ""
 
-#: c-typeck.c:3231
+#: c-typeck.c:3270
+msgid "ANSI C forbids use of conditional expressions as lvalues"
+msgstr ""
+
+#: c-typeck.c:3273
+msgid "ANSI C forbids use of compound expressions as lvalues"
+msgstr ""
+
+#: c-typeck.c:3276
+msgid "ANSI C forbids use of cast expressions as lvalues"
+msgstr ""
+
+#: c-typeck.c:3290
+#, c-format
+msgid "%s of iterator `%s'"
+msgstr ""
+
+#: c-typeck.c:3298
+#, c-format
+msgid "%s of read-only member `%s'"
+msgstr ""
+
+#: c-typeck.c:3302
+#, c-format
+msgid "%s of read-only variable `%s'"
+msgstr ""
+
+#: c-typeck.c:3305
+#, c-format
+msgid "%s of read-only location"
+msgstr ""
+
+#: c-typeck.c:3323
 #, c-format
 msgid "cannot take address of bitfield `%s'"
 msgstr ""
 
-#: c-typeck.c:3258
+#: c-typeck.c:3350
 #, c-format
 msgid "global register variable `%s' used in nested function"
 msgstr ""
 
-#: c-typeck.c:3269
+#: c-typeck.c:3354
+#, c-format
+msgid "register variable `%s' used in nested function"
+msgstr ""
+
+#: c-typeck.c:3361
 #, c-format
 msgid "address of global register variable `%s' requested"
 msgstr ""
 
-#: c-typeck.c:3281
+#: c-typeck.c:3373
 msgid "cannot put object with volatile field into register"
 msgstr ""
 
-#: c-typeck.c:3466
+#: c-typeck.c:3377
+#, c-format
+msgid "address of register variable `%s' requested"
+msgstr ""
+
+#: c-typeck.c:3485
+msgid "signed and unsigned type in conditional expression"
+msgstr ""
+
+#: c-typeck.c:3492
+msgid "ANSI C forbids conditional expr with only one void side"
+msgstr ""
+
+#: c-typeck.c:3508 c-typeck.c:3514
+msgid "ANSI C forbids conditional expr between `void *' and function pointer"
+msgstr ""
+
+#: c-typeck.c:3519
+msgid "pointer type mismatch in conditional expression"
+msgstr ""
+
+#: c-typeck.c:3526 c-typeck.c:3540
+msgid "pointer/integer type mismatch in conditional expression"
+msgstr ""
+
+#: c-typeck.c:3532 c-typeck.c:3546
+msgid "ANSI C forbids conditional expr between 0 and function pointer"
+msgstr ""
+
+#: c-typeck.c:3558
 msgid "type mismatch in conditional expression"
 msgstr ""
 
-#: c-typeck.c:3578
+#: c-typeck.c:3631 cp/typeck.c:5063
+msgid "left-hand operand of comma expression has no effect"
+msgstr ""
+
+#: c-typeck.c:3670
 msgid "cast specifies array type"
 msgstr ""
 
-#: c-typeck.c:3584
+#: c-typeck.c:3676
 msgid "cast specifies function type"
 msgstr ""
 
-#: c-typeck.c:3631
+#: c-typeck.c:3686
+msgid "ANSI C forbids casting nonscalar to the same type"
+msgstr ""
+
+#: c-typeck.c:3707
+msgid "ANSI C forbids casts to union type"
+msgstr ""
+
+#: c-typeck.c:3723
 msgid "cast to union type from type not present in union"
 msgstr ""
 
+#. There are qualifiers present in IN_OTYPE that are not
+#. present in IN_TYPE.
+#: c-typeck.c:3768
+msgid "cast discards qualifiers from pointer target type"
+msgstr ""
+
+#: c-typeck.c:3783
+msgid "cast increases required alignment of target type"
+msgstr ""
+
+#: c-typeck.c:3789 cp/typeck.c:5478
+msgid "cast from pointer to integer of different size"
+msgstr ""
+
+#: c-typeck.c:3794
+msgid "cast does not match function type"
+msgstr ""
+
+#: c-typeck.c:3801 cp/typeck.c:5485
+msgid "cast to pointer from integer of different size"
+msgstr ""
+
 #. Now we have handled acceptable kinds of LHS that are not truly lvalues.
 #. Reject anything strange now.
-#: c-typeck.c:3851
+#: c-typeck.c:3943
 msgid "invalid lvalue in assignment"
 msgstr ""
 
 #. Convert new value to destination type.
-#: c-typeck.c:3860 c-typeck.c:3884 c-typeck.c:3899 cp/typeck.c:5599
-#: cp/typeck.c:5748
+#: c-typeck.c:3952 c-typeck.c:3976 c-typeck.c:3991 cp/typeck.c:5600
+#: cp/typeck.c:5749
 msgid "assignment"
 msgstr ""
 
-#: c-typeck.c:4064 c-typeck.c:4131
+#: c-typeck.c:4156 c-typeck.c:4223
 #, c-format
 msgid "%s makes qualified function pointer from unqualified"
 msgstr ""
 
-#: c-typeck.c:4068 c-typeck.c:4111
+#: c-typeck.c:4160 c-typeck.c:4203
 #, c-format
 msgid "%s discards qualifiers from pointer target type"
 msgstr ""
 
-#: c-typeck.c:4103
+#: c-typeck.c:4166
+msgid "ANSI C prohibits argument conversion to union type"
+msgstr ""
+
+#: c-typeck.c:4195
 #, c-format
 msgid "ANSI forbids %s between function pointer and `void *'"
 msgstr ""
 
-#: c-typeck.c:4120
+#: c-typeck.c:4212
 #, c-format
 msgid "pointer targets in %s differ in signedness"
 msgstr ""
 
-#: c-typeck.c:4136
+#: c-typeck.c:4228
 #, c-format
 msgid "%s from incompatible pointer type"
 msgstr ""
 
-#: c-typeck.c:4152
+#: c-typeck.c:4244
 #, c-format
 msgid "%s makes pointer from integer without a cast"
 msgstr ""
 
-#: c-typeck.c:4160
+#: c-typeck.c:4252
 #, c-format
 msgid "%s makes integer from pointer without a cast"
 msgstr ""
 
-#: c-typeck.c:4172 c-typeck.c:4175
+#: c-typeck.c:4264 c-typeck.c:4267
 #, c-format
 msgid "incompatible type for argument %d of `%s'"
 msgstr ""
 
-#: c-typeck.c:4179
+#: c-typeck.c:4271
 #, c-format
 msgid "incompatible type for argument %d of indirect function call"
 msgstr ""
 
-#: c-typeck.c:4183
+#: c-typeck.c:4275
 #, c-format
 msgid "incompatible types in %s"
 msgstr ""
 
 #. Function name is known; supply it.
-#: c-typeck.c:4214
+#: c-typeck.c:4306
 #, c-format
 msgid "passing arg %d of `%s'"
 msgstr ""
 
 #. Function name unknown (call through ptr); just give arg number.
-#: c-typeck.c:4224
+#: c-typeck.c:4316
 #, c-format
 msgid "passing arg %d of pointer to function"
 msgstr ""
 
-#: c-typeck.c:4291
+#: c-typeck.c:4383
 msgid "initializer for static variable is not constant"
 msgstr ""
 
-#: c-typeck.c:4297
+#: c-typeck.c:4389
 msgid "initializer for static variable uses complicated arithmetic"
 msgstr ""
 
-#: c-typeck.c:4471
+#: c-typeck.c:4397
+msgid "aggregate initializer is not constant"
+msgstr ""
+
+#: c-typeck.c:4399
+msgid "aggregate initializer uses complicated arithmetic"
+msgstr ""
+
+#: c-typeck.c:4563 c-typeck.c:4579 c-typeck.c:4595
 #, c-format
 msgid "(near initialization for `%s')"
 msgstr ""
 
-#: c-typeck.c:4551 cp/typeck2.c:590
+#: c-typeck.c:4645 cp/typeck2.c:590
 msgid "char-array initialized from wide string"
 msgstr ""
 
-#: c-typeck.c:4558 cp/typeck2.c:597
+#: c-typeck.c:4652 cp/typeck2.c:597
 msgid "int-array initialized from non-wide string"
 msgstr ""
 
-#: c-typeck.c:4575
+#: c-typeck.c:4669 cp/typeck2.c:613
 msgid "initializer-string for array of chars is too long"
 msgstr ""
 
-#: c-typeck.c:4602
+#: c-typeck.c:4696
 msgid "array initialized from non-constant array expression"
 msgstr ""
 
-#: c-typeck.c:4619 c-typeck.c:4621 c-typeck.c:4627 c-typeck.c:4654
-#: c-typeck.c:5840
+#: c-typeck.c:4713 c-typeck.c:4715 c-typeck.c:4721 c-typeck.c:4748
+#: c-typeck.c:5934
 msgid "initializer element is not constant"
 msgstr ""
 
-#: c-typeck.c:4633 c-typeck.c:4660 c-typeck.c:5846
+#: c-typeck.c:4727 c-typeck.c:4754 c-typeck.c:5940
 msgid "initializer element is not computable at load time"
 msgstr ""
 
-#: c-typeck.c:4649
+#: c-typeck.c:4743
 msgid "initialization"
 msgstr ""
 
-#: c-typeck.c:4697 c-typeck.c:4713 cp/typeck2.c:689
+#: c-typeck.c:4791 c-typeck.c:4807 cp/typeck2.c:689
 msgid "invalid initializer"
 msgstr ""
 
-#: c-typeck.c:5177
+#: c-typeck.c:5271
 msgid "extra brace group at end of initializer"
 msgstr ""
 
-#: c-typeck.c:5189
+#: c-typeck.c:5283
 msgid "missing braces around initializer"
 msgstr ""
 
-#: c-typeck.c:5223
+#: c-typeck.c:5317
 msgid "braces around scalar initializer"
 msgstr ""
 
-#: c-typeck.c:5304
+#: c-typeck.c:5398
 msgid "missing initializer"
 msgstr ""
 
-#: c-typeck.c:5317
+#: c-typeck.c:5411
 msgid "empty braces in initializer"
 msgstr ""
 
-#: c-typeck.c:5367
+#: c-typeck.c:5461
 msgid "empty scalar initializer"
 msgstr ""
 
-#: c-typeck.c:5372
+#: c-typeck.c:5466
 msgid "extra elements in scalar initializer"
 msgstr ""
 
-#: c-typeck.c:5497 c-typeck.c:5499
+#: c-typeck.c:5518
+#, c-format
+msgid "zero or negative array size `%s'"
+msgstr ""
+
+#: c-typeck.c:5591 c-typeck.c:5593
 msgid "nonconstant array index in initializer"
 msgstr ""
 
-#: c-typeck.c:5501
+#: c-typeck.c:5595
 msgid "array index in non-array initializer"
 msgstr ""
 
-#: c-typeck.c:5503
+#: c-typeck.c:5597
 msgid "duplicate array index in initializer"
 msgstr ""
 
-#: c-typeck.c:5509
+#: c-typeck.c:5603
 msgid "empty index range in initializer"
 msgstr ""
 
-#: c-typeck.c:5544
+#: c-typeck.c:5607
+msgid "ANSI C forbids specifying element to initialize"
+msgstr ""
+
+#: c-typeck.c:5638
 #, c-format
 msgid "unknown field `%s' specified in initializer"
 msgstr ""
 
-#: c-typeck.c:5547
+#: c-typeck.c:5641
 #, c-format
 msgid "field `%s' already initialized"
 msgstr ""
 
-#: c-typeck.c:5862
+#: c-typeck.c:5647
+msgid "ANSI C forbids specifying structure member to initialize"
+msgstr ""
+
+#: c-typeck.c:5956
 msgid "duplicate initializer"
 msgstr ""
 
-#: c-typeck.c:6186
+#: c-typeck.c:6280
 msgid "excess elements in char array initializer"
 msgstr ""
 
-#: c-typeck.c:6193 c-typeck.c:6228
+#: c-typeck.c:6287 c-typeck.c:6322
 msgid "excess elements in struct initializer"
 msgstr ""
 
-#: c-typeck.c:6295
+#: c-typeck.c:6389
 msgid "excess elements in union initializer"
 msgstr ""
 
-#: c-typeck.c:6365 c-typeck.c:6376
+#: c-typeck.c:6459 c-typeck.c:6470
 msgid "excess elements in array initializer"
 msgstr ""
 
-#: c-typeck.c:6415
+#: c-typeck.c:6509
 msgid "excess elements in scalar initializer"
 msgstr ""
 
-#: c-typeck.c:6449
+#: c-typeck.c:6543
 msgid "asm template is not a string constant"
 msgstr ""
 
-#: c-typeck.c:6473
+#: c-typeck.c:6567
 msgid "invalid lvalue in asm statement"
 msgstr ""
 
-#: c-typeck.c:6508
+#: c-typeck.c:6602
 msgid "modification by `asm'"
 msgstr ""
 
-#: c-typeck.c:6545
+#: c-typeck.c:6621 cp/typeck.c:6766
+msgid "function declared `noreturn' has a `return' statement"
+msgstr ""
+
+#: c-typeck.c:6628
+msgid "`return' with no value, in function returning non-void"
+msgstr ""
+
+#: c-typeck.c:6635
+msgid "`return' with a value, in function returning void"
+msgstr ""
+
+#: c-typeck.c:6640
 msgid "return"
 msgstr ""
 
-#: c-typeck.c:6631
+#: c-typeck.c:6691
+msgid "function returns address of local variable"
+msgstr ""
+
+#: c-typeck.c:6726
 msgid "switch quantity not an integer"
 msgstr ""
 
+#: c-typeck.c:6738
+msgid "`long' switch expression not converted to `int' in ANSI C"
+msgstr ""
+
+#: calls.c:1857
+#, c-format
+msgid "inlining failed in call to `%s'"
+msgstr ""
+
+#: calls.c:1858 calls.c:2072
+msgid "called from here"
+msgstr ""
+
+#: calls.c:2071
+#, c-format
+msgid "can't inline call to `%s'"
+msgstr ""
+
+#: calls.c:2104
+msgid "function call has aggregate value"
+msgstr ""
+
 #: collect2.c:455
 msgid "internal error"
 msgstr ""
@@ -1452,7 +2994,7 @@ msgstr ""
 msgid "wrote %ld bytes, expected %ld, to %s"
 msgstr ""
 
-#: combine.c:12603
+#: combine.c:12605
 #, c-format
 msgid ""
 ";; Combiner statistics: %d attempts, %d substitutions (%d requiring new "
@@ -1461,7 +3003,7 @@ msgid ""
 "\n"
 msgstr ""
 
-#: combine.c:12613
+#: combine.c:12615
 #, c-format
 msgid ""
 "\n"
@@ -1480,19 +3022,19 @@ msgid "invalid %%C value"
 msgstr ""
 
 #: config/a29k/a29k.c:1019 config/alpha/alpha.c:3510
-#: config/rs6000/rs6000.c:3605
+#: config/rs6000/rs6000.c:3621
 #, ycp-format
 msgid "invalid %%N value"
 msgstr ""
 
 #: config/a29k/a29k.c:1025 config/alpha/alpha.c:3581
-#: config/rs6000/rs6000.c:3567
+#: config/rs6000/rs6000.c:3583
 #, ycp-format
 msgid "invalid %%M value"
 msgstr ""
 
 #: config/a29k/a29k.c:1031 config/alpha/alpha.c:3573
-#: config/rs6000/rs6000.c:3532
+#: config/rs6000/rs6000.c:3548
 #, ycp-format
 msgid "invalid %%m value"
 msgstr ""
@@ -1502,13 +3044,13 @@ msgstr ""
 msgid "invalid %%L value"
 msgstr ""
 
-#: config/a29k/a29k.c:1136 config/rs6000/rs6000.c:3613
+#: config/a29k/a29k.c:1136 config/rs6000/rs6000.c:3629
 #, ycp-format
 msgid "invalid %%O value"
 msgstr ""
 
 #: config/a29k/a29k.c:1142 config/alpha/alpha.c:3518
-#: config/rs6000/rs6000.c:3632
+#: config/rs6000/rs6000.c:3648
 #, ycp-format
 msgid "invalid %%P value"
 msgstr ""
@@ -1518,6 +3060,82 @@ msgstr ""
 msgid "invalid %%V value"
 msgstr ""
 
+#: config/a29k/a29k.h:101
+msgid "Generate code assuming DW bit is set"
+msgstr ""
+
+#: config/a29k/a29k.h:102
+msgid "Generate code assuming DW bit is not set"
+msgstr ""
+
+#: config/a29k/a29k.h:103
+msgid "Generate code using byte writes"
+msgstr ""
+
+#: config/a29k/a29k.h:104
+msgid "Do not generate byte writes"
+msgstr ""
+
+#: config/a29k/a29k.h:105
+msgid "Use small memory model"
+msgstr ""
+
+#: config/a29k/a29k.h:106
+msgid "Use normal memory model"
+msgstr ""
+
+#: config/a29k/a29k.h:107
+msgid "Use large memory model"
+msgstr ""
+
+#: config/a29k/a29k.h:108
+msgid "Generate 29050 code"
+msgstr ""
+
+#: config/a29k/a29k.h:109
+msgid "Generate 29000 code"
+msgstr ""
+
+#: config/a29k/a29k.h:110
+msgid "Use kernel global registers"
+msgstr ""
+
+#: config/a29k/a29k.h:111
+msgid "Use user global registers"
+msgstr ""
+
+#: config/a29k/a29k.h:112
+msgid "Emit stack checking code"
+msgstr ""
+
+#: config/a29k/a29k.h:113
+msgid "Do not emit stack checking code"
+msgstr ""
+
+#: config/a29k/a29k.h:114
+msgid "Work around storem hardware bug"
+msgstr ""
+
+#: config/a29k/a29k.h:115
+msgid "Do not work around storem hardware bug"
+msgstr ""
+
+#: config/a29k/a29k.h:116
+msgid "Store locals in argument registers"
+msgstr ""
+
+#: config/a29k/a29k.h:117
+msgid "Do not store locals in arg registers"
+msgstr ""
+
+#: config/a29k/a29k.h:118 config/i960/i960.h:281 config/mips/mips.h:373
+msgid "Use software floating point"
+msgstr ""
+
+#: config/a29k/a29k.h:119
+msgid "Do not generate multm instructions"
+msgstr ""
+
 #: config/alpha/alpha.c:174
 #, c-format
 msgid "bad value `%s' for -mtrap-precision switch"
@@ -1538,12 +3156,34 @@ msgstr ""
 msgid "bad value `%s' for -mcpu switch"
 msgstr ""
 
+#: config/alpha/alpha.c:262
+msgid "fp software completion requires -mtrap-precision=i"
+msgstr ""
+
+#: config/alpha/alpha.c:278
+msgid "rounding mode not supported for VAX floats"
+msgstr ""
+
+#: config/alpha/alpha.c:283
+msgid "trap mode not supported for VAX floats"
+msgstr ""
+
+#: config/alpha/alpha.c:312
+#, c-format
+msgid "L%d cache latency unknown for %s"
+msgstr ""
+
+#: config/alpha/alpha.c:327
+#, c-format
+msgid "bad value `%s' for -mmemory-latency"
+msgstr ""
+
 #: config/alpha/alpha.c:3492
 #, ycp-format
 msgid "invalid %%r value"
 msgstr ""
 
-#: config/alpha/alpha.c:3503 config/rs6000/rs6000.c:3677
+#: config/alpha/alpha.c:3503 config/rs6000/rs6000.c:3692
 #, ycp-format
 msgid "invalid %%R value"
 msgstr ""
@@ -1559,22 +3199,136 @@ msgid "invalid %%U value"
 msgstr ""
 
 #: config/alpha/alpha.c:3624 config/alpha/alpha.c:3635 config/romp/romp.c:691
-#: config/rs6000/rs6000.c:3685
+#: config/rs6000/rs6000.c:3700
 #, ycp-format
 msgid "invalid %%s value"
 msgstr ""
 
-#: config/alpha/alpha.c:3683 config/rs6000/rs6000.c:3396
+#: config/alpha/alpha.c:3683 config/rs6000/rs6000.c:3412
 #, ycp-format
 msgid "invalid %%E value"
 msgstr ""
 
 #: config/alpha/alpha.c:3704 config/romp/romp.c:966
-#: config/rs6000/rs6000.c:3937
+#: config/rs6000/rs6000.c:3952
 #, ycp-format
 msgid "invalid %%xn code"
 msgstr ""
 
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/alpha/alpha.h:199 config/i386/i386.h:227 config/i386/i386.h:229
+#: config/i386/i386.h:231 config/ns32k/ns32k.h:103 config/rs6000/rs6000.h:304
+#: config/sparc/sparc.h:578 config/sparc/sparc.h:583
+msgid "Use hardware fp"
+msgstr ""
+
+#: config/alpha/alpha.h:200 config/i386/i386.h:228 config/i386/i386.h:230
+#: config/rs6000/rs6000.h:306 config/sparc/sparc.h:580
+#: config/sparc/sparc.h:585
+msgid "Do not use hardware fp"
+msgstr ""
+
+#: config/alpha/alpha.h:201
+msgid "Use fp registers"
+msgstr ""
+
+#: config/alpha/alpha.h:203
+msgid "Do not use fp registers"
+msgstr ""
+
+#: config/alpha/alpha.h:204
+msgid "Do not assume GAS"
+msgstr ""
+
+#: config/alpha/alpha.h:205
+msgid "Assume GAS"
+msgstr ""
+
+#: config/alpha/alpha.h:207
+msgid "Request IEEE-conformant math library routines (OSF/1)"
+msgstr ""
+
+#: config/alpha/alpha.h:209
+msgid "Emit IEEE-conformant code, without inexact exceptions"
+msgstr ""
+
+#: config/alpha/alpha.h:211
+msgid "Emit IEEE-conformant code, with inexact exceptions"
+msgstr ""
+
+#: config/alpha/alpha.h:213
+msgid "Do not emit complex integer constants to read-only memory"
+msgstr ""
+
+#: config/alpha/alpha.h:214
+msgid "Use VAX fp"
+msgstr ""
+
+#: config/alpha/alpha.h:215
+msgid "Do not use VAX fp"
+msgstr ""
+
+#: config/alpha/alpha.h:216
+msgid "Emit code for the byte/word ISA extension"
+msgstr ""
+
+#: config/alpha/alpha.h:219
+msgid "Emit code for the motion video ISA extension"
+msgstr ""
+
+#: config/alpha/alpha.h:222
+msgid "Emit code for the fp move and sqrt ISA extension"
+msgstr ""
+
+#: config/alpha/alpha.h:224
+msgid "Emit code for the counting ISA extension"
+msgstr ""
+
+#. This macro is similar to `TARGET_SWITCHES' but defines names of
+#. command options that have values.  Its definition is an initializer
+#. with a subgrouping for each command option.
+#.
+#. Each subgrouping contains a string constant, that defines the fixed
+#. part of the option name, and the address of a variable.  The
+#. variable, type `char *', is set to the variable part of the given
+#. option if the fixed part matches.  The actual option name is made
+#. by appending `-m' to the specified name.
+#.
+#. Here is an example which defines `-mshort-data-NUMBER'.  If the
+#. given option is `-mshort-data-512', the variable `m88k_short_data'
+#. will be set to the string `"512"'.
+#.
+#. extern char *m88k_short_data;
+#. #define TARGET_OPTIONS { { "short-data-", &m88k_short_data } }
+#. For -mcpu=
+#. For -mfp-rounding-mode=[n|m|c|d]
+#. For -mfp-trap-mode=[n|u|su|sui]
+#. For -mtrap-precision=[p|f|i]
+#. For -mmemory-latency=
+#: config/alpha/alpha.h:260
+msgid "Generate code for a given CPU"
+msgstr ""
+
+#: config/alpha/alpha.h:262
+msgid "Control the generated fp rounding mode"
+msgstr ""
+
+#: config/alpha/alpha.h:264
+msgid "Control the IEEE trap mode"
+msgstr ""
+
+#: config/alpha/alpha.h:266
+msgid "Control the precision given to fp exceptions"
+msgstr ""
+
+#: config/alpha/alpha.h:268
+msgid "Tune expected memory latency"
+msgstr ""
+
 #: config/arc/arc.c:109
 #, c-format
 msgid "bad value (%s) for -mcpu switch"
@@ -1597,29 +3351,99 @@ msgid "invalid operand to %V code"
 msgstr ""
 
 #. Unknown flag.
-#: config/arc/arc.c:1741 config/m32r/m32r.c:2357 config/sparc/sparc.c:5849
+#: config/arc/arc.c:1741 config/m32r/m32r.c:2357 config/sparc/sparc.c:5859
 msgid "invalid operand output code"
 msgstr ""
 
+#: config/arm/arm.c:339
+#, c-format
+msgid "switch -mcpu=%s conflicts with -march= switch"
+msgstr ""
+
 #: config/arm/arm.c:349 config/rs6000/rs6000.c:315 config/sparc/sparc.c:332
 #, c-format
 msgid "bad value (%s) for %s switch"
 msgstr ""
 
+#: config/arm/arm.c:484
+msgid "target CPU does not support APCS-32"
+msgstr ""
+
+#: config/arm/arm.c:489
+msgid "target CPU does not support APCS-26"
+msgstr ""
+
+#: config/arm/arm.c:495
+msgid "target CPU does not support interworking"
+msgstr ""
+
+#: config/arm/arm.c:501
+msgid "target CPU does not supoport THUMB instructions."
+msgstr ""
+
+#: config/arm/arm.c:515
+msgid ""
+"enabling backtrace support is only meaningful when compiling for the Thumb."
+msgstr ""
+
+#: config/arm/arm.c:518
+msgid ""
+"enabling callee interworking support is only meaningful when compiling for "
+"the Thumb."
+msgstr ""
+
+#: config/arm/arm.c:521
+msgid ""
+"enabling caller interworking support is only meaningful when compiling for "
+"the Thumb."
+msgstr ""
+
+#: config/arm/arm.c:527
+msgid "interworking forces APCS-32 to be used"
+msgstr ""
+
+#: config/arm/arm.c:533
+msgid "-mapcs-stack-check incompatible with -mno-apcs-frame"
+msgstr ""
+
 #: config/arm/arm.c:541
 msgid "-fpic and -mapcs-reent are incompatible"
 msgstr ""
 
+#: config/arm/arm.c:544
+msgid "APCS reentrant code not supported.  Ignored"
+msgstr ""
+
+#: config/arm/arm.c:552
+msgid "-g with -mno-apcs-frame may not give sensible debugging"
+msgstr ""
+
+#: config/arm/arm.c:560
+msgid "Passing floating point arguments in fp regs not yet supported"
+msgstr ""
+
 #: config/arm/arm.c:587
 #, c-format
 msgid "Invalid floating point emulation option: -mfpe-%s"
 msgstr ""
 
+#: config/arm/arm.c:611
+msgid "Structure size boundary can only be set to 8 or 32"
+msgstr ""
+
+#: config/arm/arm.c:619
+msgid "-mpic-register= is useless without -fpic"
+msgstr ""
+
 #: config/arm/arm.c:628
 #, c-format
 msgid "Unable to use '%s' for PIC register"
 msgstr ""
 
+#: config/arm/arm.c:8105
+msgid "Unable to compute real location of stacked parameter"
+msgstr ""
+
 #. Oh dear!  We have no low registers into which we can pop
 #. high registers!
 #: config/arm/arm.c:8704
@@ -1642,6 +3466,191 @@ msgstr ""
 msgid "thumb_load_double_from_address: Unhandled address calculation"
 msgstr ""
 
+#: config/arm/arm.h:394
+msgid "Generate APCS conformant stack frames"
+msgstr ""
+
+#: config/arm/arm.h:397
+msgid "Store function names in object code"
+msgstr ""
+
+#: config/arm/arm.h:401
+msgid "Use the 32bit version of the APCS"
+msgstr ""
+
+#: config/arm/arm.h:403
+msgid "Use the 26bit version of the APCS"
+msgstr ""
+
+#: config/arm/arm.h:407
+msgid "Pass FP arguments in FP registers"
+msgstr ""
+
+#: config/arm/arm.h:410
+msgid "Generate re-entrant, PIC code"
+msgstr ""
+
+#: config/arm/arm.h:413
+msgid "The MMU will trap on unaligned accesses"
+msgstr ""
+
+#: config/arm/arm.h:420
+msgid "Use library calls to perform FP operations"
+msgstr ""
+
+#: config/arm/arm.h:422 config/i960/i960.h:279
+msgid "Use hardware floating point instructions"
+msgstr ""
+
+#: config/arm/arm.h:424
+msgid "Assume target CPU is configured as big endian"
+msgstr ""
+
+#: config/arm/arm.h:426
+msgid "Assume target CPU is configured as little endian"
+msgstr ""
+
+#: config/arm/arm.h:428
+msgid "Assume big endian bytes, little endian words"
+msgstr ""
+
+#: config/arm/arm.h:430
+msgid "Support calls between THUMB and ARM instructions sets"
+msgstr ""
+
+#: config/arm/arm.h:433
+msgid "Generate a call to abort if a noreturn function returns"
+msgstr ""
+
+#: config/arm/arm.h:436
+msgid "Do not move instructions into a function's prologue"
+msgstr ""
+
+#: config/arm/arm.h:439
+msgid "Do not load the PIC register in function prologues"
+msgstr ""
+
+#: config/arm/arm.h:442
+msgid "Generate call insns as indirect calls, if necessary"
+msgstr ""
+
+#: config/arm/arm.h:445
+msgid "Compile for the Thumb not the ARM"
+msgstr ""
+
+#: config/arm/arm.h:449
+msgid "Thumb: Generate (non-leaf) stack frames even if not needed"
+msgstr ""
+
+#: config/arm/arm.h:452
+msgid "Thumb: Generate (leaf) stack frames even if not needed"
+msgstr ""
+
+#: config/arm/arm.h:455
+msgid "Thumb: Assume non-static functions may be called from ARM code"
+msgstr ""
+
+#: config/arm/arm.h:459
+msgid "Thumb: Assume function pointers may go to non-Thumb aware code"
+msgstr ""
+
+#: config/arm/arm.h:469
+msgid "Specify the name of the target CPU"
+msgstr ""
+
+#: config/arm/arm.h:471
+msgid "Specify the name of the target architecture"
+msgstr ""
+
+#: config/arm/arm.h:475
+msgid "Specify the version of the floating point emulator"
+msgstr ""
+
+#: config/arm/arm.h:477
+msgid "Specify the minimum bit alignment of structures"
+msgstr ""
+
+#: config/arm/arm.h:479
+msgid "Specify the register to be used for PIC addressing"
+msgstr ""
+
+#. None of these is actually used in cc1.  If we don't define them in target
+#. switches cc1 complains about them.  For the sake of argument lets allocate
+#. bit 31 of target flags for such options.
+#: config/arm/riscix.h:84
+msgid "Do symbol renaming for BSD"
+msgstr ""
+
+#: config/arm/riscix.h:85
+msgid "Do symbol renaming for X/OPEN"
+msgstr ""
+
+#: config/arm/riscix.h:86
+msgid "Don't do symbol renaming"
+msgstr ""
+
+#. Macros used in the machine description to test the flags.
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/clipper/clipper.h:40
+msgid "Generate code for the C400"
+msgstr ""
+
+#: config/clipper/clipper.h:41
+msgid "Generate code for the C300"
+msgstr ""
+
+#: config/convex/convex.h:52
+msgid "Generate code for c1"
+msgstr ""
+
+#: config/convex/convex.h:53
+msgid "Generate code for c2"
+msgstr ""
+
+#: config/convex/convex.h:54
+msgid "Generate code for c32"
+msgstr ""
+
+#: config/convex/convex.h:55 config/convex/convex.h:56
+msgid "Generate code for c34"
+msgstr ""
+
+#: config/convex/convex.h:58
+msgid "Use standard calling sequence, with arg count word"
+msgstr ""
+
+#: config/convex/convex.h:60
+msgid "Place arg count in a nop instruction (faster than push)"
+msgstr ""
+
+#: config/convex/convex.h:62
+msgid "Don't push arg count, depend on symbol table"
+msgstr ""
+
+#: config/convex/convex.h:64
+msgid "Use data cache for volatile mem refs (default)"
+msgstr ""
+
+#: config/convex/convex.h:66
+msgid "Don't use data cache for volatile mem refs"
+msgstr ""
+
+#: config/convex/convex.h:68
+msgid "Bypass data cache for volatile mem refs"
+msgstr ""
+
+#: config/convex/convex.h:69
+msgid "Use 64-bit longs"
+msgstr ""
+
+#: config/convex/convex.h:70
+msgid "Use cc- and libc-compatible 32-bit longs"
+msgstr ""
+
 #: config/dsp16xx/dsp16xx.c:271
 #, c-format
 msgid "Invalid register class letter %c"
@@ -1716,6 +3725,158 @@ msgstr ""
 msgid "Trampolines not yet implemented"
 msgstr ""
 
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/elxsi/elxsi.h:50
+msgid "Generate code the unix assembler can handle"
+msgstr ""
+
+#: config/elxsi/elxsi.h:51
+msgid "Generate code an embedded assembler can handle"
+msgstr ""
+
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/fx80/fx80.h:113 config/fx80/fx80.h:114
+msgid "Generate code for a mc68020"
+msgstr ""
+
+#: config/fx80/fx80.h:115 config/ns32k/ns32k.h:117
+msgid "Use bitfield instructions"
+msgstr ""
+
+#: config/fx80/fx80.h:116 config/fx80/fx80.h:117
+msgid "Generate code for a mc68000"
+msgstr ""
+
+#: config/fx80/fx80.h:118
+msgid "Generate software FP code"
+msgstr ""
+
+#: config/fx80/fx80.h:119
+msgid "Do not generate bitfield insns"
+msgstr ""
+
+#: config/fx80/fx80.h:120
+msgid "Use 16bit integers"
+msgstr ""
+
+#: config/fx80/fx80.h:121
+msgid "Use 32bit integers"
+msgstr ""
+
+#: config/h8300/h8300.c:2946 config/h8300/h8300.c:2958
+msgid "Only initialized variables can be placed into the 8-bit area."
+msgstr ""
+
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/h8300/h8300.h:102
+msgid "Generate H8/S code"
+msgstr ""
+
+#: config/h8300/h8300.h:103
+msgid "Do not generate H8/S code"
+msgstr ""
+
+#: config/h8300/h8300.h:104
+msgid "Make integers 32 bits wide"
+msgstr ""
+
+#: config/h8300/h8300.h:107
+msgid "Use registers for argument passing"
+msgstr ""
+
+#: config/h8300/h8300.h:109
+msgid "Do not use registers for argument passing"
+msgstr ""
+
+#: config/h8300/h8300.h:111
+msgid "Consider access to byte sized memory slow"
+msgstr ""
+
+#: config/h8300/h8300.h:112
+msgid "Enable linker relaxing"
+msgstr ""
+
+#: config/h8300/h8300.h:114
+msgid "Generate H8/300H code"
+msgstr ""
+
+#: config/h8300/h8300.h:115
+msgid "Do not generate H8/300H code"
+msgstr ""
+
+#: config/h8300/h8300.h:116
+msgid "Use H8/300 alignment rules"
+msgstr ""
+
+#: config/i370/i370.c:1007
+msgid "Escape value out of range"
+msgstr ""
+
+#: config/i370/i370.c:1020
+msgid "#pragma map alias is too long, truncated"
+msgstr ""
+
+#: config/i370/i370.c:1044
+msgid "#pragma map options are missing or incorrect"
+msgstr ""
+
+#. Macro to define tables used to set the flags.  This is a list in braces
+#. of pairs in braces, each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/i370/i370.h:63
+msgid "Generate char instructions"
+msgstr ""
+
+#: config/i370/i370.h:64
+msgid "Do not generate char instructions"
+msgstr ""
+
+#: config/i386/cygwin.h:50
+msgid "Use the Cygwin interface"
+msgstr ""
+
+#: config/i386/cygwin.h:52
+msgid "Use the Mingw32 interface"
+msgstr ""
+
+#: config/i386/cygwin.h:53
+msgid "Create GUI application"
+msgstr ""
+
+#: config/i386/cygwin.h:55
+msgid "Create console application"
+msgstr ""
+
+#: config/i386/cygwin.h:56
+msgid "Generate code for a DLL"
+msgstr ""
+
+#: config/i386/cygwin.h:58
+msgid "Ignore dllimport for functions"
+msgstr ""
+
+#: config/i386/cygwin.h:60
+msgid "Use Mingw-specific thread support"
+msgstr ""
+
+#: config/i386/cygwin.h:265
+#, c-format
+msgid "-f%s ignored for target (all code is position independent)"
+msgstr ""
+
 #: config/i386/dgux.c:185
 #, c-format
 msgid "Internal gcc abort from %s:%d"
@@ -1725,67 +3886,101 @@ msgstr ""
 msgid "The local variable `insn' has the value:"
 msgstr ""
 
-#: config/i386/i386.c:504
+#: config/i386/dgux.h:62
+msgid "Retain standard MXDB information"
+msgstr ""
+
+#: config/i386/dgux.h:64
+msgid "Retain legend information"
+msgstr ""
+
+#: config/i386/dgux.h:67
+msgid "Generate external legend information"
+msgstr ""
+
+#: config/i386/dgux.h:69
+msgid "Emit identifying info in .s file"
+msgstr ""
+
+#: config/i386/dgux.h:71
+msgid "Warn when a function arg is a structure"
+msgstr ""
+
+#: config/i386/dgux.h:249
+msgid "argument is a structure"
+msgstr ""
+
+#: config/i386/djgpp.h:225
+msgid ""
+"Enable weak symbol and enhanced C++ template support. Binutils 2.9.5.1 or "
+"higher required."
+msgstr ""
+
+#: config/i386/djgpp.h:226
+msgid "Disable weak symbol and enhanced C++ template support."
+msgstr ""
+
+#: config/i386/i386.c:512
 #, c-format
 msgid "bad value (%s) for -march= switch"
 msgstr ""
 
-#: config/i386/i386.c:517 config/mips/mips.c:4864
+#: config/i386/i386.c:525 config/mips/mips.c:4864
 #, c-format
 msgid "bad value (%s) for -mcpu= switch"
 msgstr ""
 
-#: config/i386/i386.c:546
+#: config/i386/i386.c:554
 #, c-format
 msgid "Register '%c' is unknown"
 msgstr ""
 
-#: config/i386/i386.c:550
+#: config/i386/i386.c:558
 #, c-format
 msgid "Register '%c' already specified in allocation order"
 msgstr ""
 
-#: config/i386/i386.c:561
+#: config/i386/i386.c:569
 #, c-format
 msgid "-mregparm=%d is not between 0 and %d"
 msgstr ""
 
-#: config/i386/i386.c:571
+#: config/i386/i386.c:579
 #, c-format
 msgid "-malign-loops=%d is not between 0 and %d"
 msgstr ""
 
-#: config/i386/i386.c:581
+#: config/i386/i386.c:589
 #, c-format
 msgid "-malign-jumps=%d is not between 0 and %d"
 msgstr ""
 
-#: config/i386/i386.c:591
+#: config/i386/i386.c:599
 #, c-format
 msgid "-malign-functions=%d is not between 0 and %d"
 msgstr ""
 
-#: config/i386/i386.c:602
+#: config/i386/i386.c:610
 #, c-format
 msgid "-mpreferred-stack-boundary=%d is not between 2 and 31"
 msgstr ""
 
-#: config/i386/i386.c:612
+#: config/i386/i386.c:620
 #, c-format
 msgid "-mbranch-cost=%d is not between 0 and 5"
 msgstr ""
 
 #. We can't handle floating point constants;
 #. PRINT_OPERAND must handle them.
-#: config/i386/i386.c:2890 config/pdp11/pdp11.c:1478 final.c:3686
+#: config/i386/i386.c:2914 config/pdp11/pdp11.c:1478 final.c:3704
 msgid "floating constant misused"
 msgstr ""
 
-#: config/i386/i386.c:2935
+#: config/i386/i386.c:2959
 msgid "invalid UNSPEC as operand"
 msgstr ""
 
-#: config/i386/i386.c:2941 config/pdp11/pdp11.c:1525 final.c:3733
+#: config/i386/i386.c:2965 config/pdp11/pdp11.c:1525 final.c:3751
 msgid "invalid expression as operand"
 msgstr ""
 
@@ -1793,79 +3988,71 @@ msgstr ""
 msgid "half-pic init called on systems that don't support it."
 msgstr ""
 
-#: config/i386/i386.h:222 config/i386/i386.h:224 config/i386/i386.h:226
-msgid "Use hardware fp"
-msgstr ""
-
-#: config/i386/i386.h:223 config/i386/i386.h:225
-msgid "Do not use hardware fp"
-msgstr ""
-
-#: config/i386/i386.h:227
+#: config/i386/i386.h:232
 msgid "Same as -mcpu=i386"
 msgstr ""
 
-#: config/i386/i386.h:228
+#: config/i386/i386.h:233
 msgid "Same as -mcpu=i486"
 msgstr ""
 
-#: config/i386/i386.h:229
+#: config/i386/i386.h:234
 msgid "Same as -mcpu=pentium"
 msgstr ""
 
-#: config/i386/i386.h:230
+#: config/i386/i386.h:235
 msgid "Same as -mcpu=pentiumpro"
 msgstr ""
 
-#: config/i386/i386.h:231
+#: config/i386/i386.h:237
 msgid "Alternate calling convention"
 msgstr ""
 
-#: config/i386/i386.h:232
+#: config/i386/i386.h:239 config/ns32k/ns32k.h:106
 msgid "Use normal calling convention"
 msgstr ""
 
-#: config/i386/i386.h:234
+#: config/i386/i386.h:241
 msgid "Align some doubles on dword boundary"
 msgstr ""
 
-#: config/i386/i386.h:236
+#: config/i386/i386.h:243
 msgid "Align doubles on word boundary"
 msgstr ""
 
-#: config/i386/i386.h:238
+#: config/i386/i386.h:245
 msgid "Uninitialized locals in .bss"
 msgstr ""
 
-#: config/i386/i386.h:240
+#: config/i386/i386.h:247
 msgid "Uninitialized locals in .data"
 msgstr ""
 
-#: config/i386/i386.h:242
+#: config/i386/i386.h:249
 msgid "Use IEEE math for fp comparisons"
 msgstr ""
 
-#: config/i386/i386.h:244
+#: config/i386/i386.h:251
 msgid "Do not use IEEE math for fp comparisons"
 msgstr ""
 
-#: config/i386/i386.h:246
+#: config/i386/i386.h:253
 msgid "Return values of functions in FPU registers"
 msgstr ""
 
-#: config/i386/i386.h:248
+#: config/i386/i386.h:255
 msgid "Do not return values of functions in FPU registers"
 msgstr ""
 
-#: config/i386/i386.h:250
+#: config/i386/i386.h:257
 msgid "Do not generate sin, cos, sqrt for FPU"
 msgstr ""
 
-#: config/i386/i386.h:252
+#: config/i386/i386.h:259
 msgid "Generate sin, cos, sqrt for FPU"
 msgstr ""
 
-#: config/i386/i386.h:254
+#: config/i386/i386.h:261
 msgid "Omit the frame pointer in leaf functions"
 msgstr ""
 
@@ -1873,40 +4060,56 @@ msgstr ""
 #. undocumented
 #. undocumented
 #. undocumented
-#: config/i386/i386.h:260
+#: config/i386/i386.h:268
 msgid "Enable stack probing"
 msgstr ""
 
 #. undocumented
 #. undocumented
-#: config/i386/i386.h:265
+#: config/i386/i386.h:273
 msgid "Emit Intel syntax assembler opcodes"
 msgstr ""
 
-#: config/i386/i386.h:268
+#: config/i386/i386.h:276
 msgid "Align destination of the string operations"
 msgstr ""
 
-#: config/i386/i386.h:270
+#: config/i386/i386.h:278
 msgid "Do not align destination of the string operations"
 msgstr ""
 
-#: config/i386/i386.h:272
+#: config/i386/i386.h:280
 msgid "Inline all known string operations"
 msgstr ""
 
-#: config/i386/i386.h:274
+#: config/i386/i386.h:282
 msgid "Do not inline all known string operations"
 msgstr ""
 
-#: config/i386/i386.h:276 config/i386/i386.h:280
+#: config/i386/i386.h:284 config/i386/i386.h:288
 msgid "Use push instructions to save outgoing arguments"
 msgstr ""
 
-#: config/i386/i386.h:278 config/i386/i386.h:282
+#: config/i386/i386.h:286 config/i386/i386.h:290
 msgid "Do not use push instructions to save outgoing arguments"
 msgstr ""
 
+#: config/i386/i386.h:291
+msgid "Support MMX builtins"
+msgstr ""
+
+#: config/i386/i386.h:293
+msgid "Do not support MMX builtins"
+msgstr ""
+
+#: config/i386/i386.h:295
+msgid "Support MMX and SSE builtins"
+msgstr ""
+
+#: config/i386/i386.h:297
+msgid "Do not support MMX and SSE builtins"
+msgstr ""
+
 #. This macro is similar to `TARGET_SWITCHES' but defines names of
 #. command options that have values.  Its definition is an
 #. initializer with a subgrouping for each command option.
@@ -1916,47 +4119,277 @@ msgstr ""
 #. variable, type `char *', is set to the variable part of the given
 #. option if the fixed part matches.  The actual option name is made
 #. by appending `-m' to the specified name.
-#: config/i386/i386.h:315
+#: config/i386/i386.h:330 config/rs6000/rs6000.h:405 config/sparc/sparc.h:711
 msgid "Schedule code for given CPU"
 msgstr ""
 
-#: config/i386/i386.h:317
+#: config/i386/i386.h:332
 msgid "Generate code for given CPU"
 msgstr ""
 
-#: config/i386/i386.h:319
+#: config/i386/i386.h:334
 msgid "Control allocation order of integer registers"
 msgstr ""
 
-#: config/i386/i386.h:321
+#: config/i386/i386.h:336
 msgid "Number of registers used to pass integer arguments"
 msgstr ""
 
-#: config/i386/i386.h:323
+#: config/i386/i386.h:338
 msgid "Loop code aligned to this power of 2"
 msgstr ""
 
-#: config/i386/i386.h:325
+#: config/i386/i386.h:340
 msgid "Jump targets are aligned to this power of 2"
 msgstr ""
 
-#: config/i386/i386.h:327
+#: config/i386/i386.h:342
 msgid "Function starts are aligned to this power of 2"
 msgstr ""
 
-#: config/i386/i386.h:330
+#: config/i386/i386.h:345
 msgid "Attempt to keep stack aligned to this power of 2"
 msgstr ""
 
-#: config/i386/i386.h:332
+#: config/i386/i386.h:347
 msgid "Branches are this expensive (1-5, arbitrary units)"
 msgstr ""
 
+#: config/i386/osf1elf.h:126
+msgid "Profiling uses mcount"
+msgstr ""
+
+#: config/i386/osfrose.h:63
+msgid "Emit half-PIC code"
+msgstr ""
+
+#. intentionally undoc
+#. intentionally undoc
+#: config/i386/osfrose.h:70
+msgid "Emit ELF object code"
+msgstr ""
+
+#: config/i386/osfrose.h:72
+msgid "Emit ROSE object code"
+msgstr ""
+
+#: config/i386/osfrose.h:74
+msgid "Symbols have a leading underscore"
+msgstr ""
+
+#: config/i386/osfrose.h:77
+msgid "Align to >word boundaries"
+msgstr ""
+
+#: config/i386/osfrose.h:80
+msgid "Use mcount for profiling"
+msgstr ""
+
+#: config/i386/osfrose.h:82
+msgid "Use mcount_ptr for profiling"
+msgstr ""
+
+#: config/i386/sco5.h:503 config/rs6000/sysv4.h:962
+#, c-format
+msgid "%s causes a section type conflict"
+msgstr ""
+
+#: config/i386/sco5.h:898
+msgid "Generate COFF output"
+msgstr ""
+
+#: config/i386/sco5.h:899
+msgid "Generate ELF output"
+msgstr ""
+
 #: config/i386/winnt.c:300
 #, c-format
 msgid "`%s' declared as both exported to and imported from a DLL."
 msgstr ""
 
+#: config/i386/winnt.c:328
+#, c-format
+msgid "initialized variable `%s' is marked dllimport"
+msgstr ""
+
+#: config/i386/winnt.c:337
+#, c-format
+msgid "static variable `%s' is marked dllimport"
+msgstr ""
+
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/i860/i860.h:56 config/i860/paragon.h:28
+msgid "Generate code which uses the FPU"
+msgstr ""
+
+#: config/i860/i860.h:57 config/i860/i860.h:58 config/i860/paragon.h:29
+#: config/i860/paragon.h:30 config/i860/paragon.h:31
+msgid "Do not generate code which uses the FPU"
+msgstr ""
+
+#: config/i960/i960.c:1467 config/m68k/m68k.c:406 config/rs6000/rs6000.c:4894
+msgid "stack limit expression is not supported"
+msgstr ""
+
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#. ??? Not all ten of these architecture variations actually exist, but I
+#. am not sure which are real and which aren't.
+#: config/i960/i960.h:238
+msgid "Generate SA code"
+msgstr ""
+
+#: config/i960/i960.h:241
+msgid "Generate SB code"
+msgstr ""
+
+#. {"sc", (TARGET_FLAG_NUMERICS|TARGET_FLAG_PROTECTED|						TARGET_FLAG_MC|TARGET_FLAG_COMPLEX_ADDR),	       N_("Generate SC code")},
+#: config/i960/i960.h:246
+msgid "Generate KA code"
+msgstr ""
+
+#: config/i960/i960.h:249
+msgid "Generate KB code"
+msgstr ""
+
+#. {"kc", (TARGET_FLAG_NUMERICS|TARGET_FLAG_PROTECTED|						TARGET_FLAG_MC|TARGET_FLAG_COMPLEX_ADDR),	       N_("Generate KC code")},
+#: config/i960/i960.h:254
+msgid "Generate JA code"
+msgstr ""
+
+#: config/i960/i960.h:256
+msgid "Generate JD code"
+msgstr ""
+
+#: config/i960/i960.h:259
+msgid "Generate JF code"
+msgstr ""
+
+#: config/i960/i960.h:261
+msgid "generate RP code"
+msgstr ""
+
+#: config/i960/i960.h:264
+msgid "Generate MC code"
+msgstr ""
+
+#: config/i960/i960.h:267
+msgid "Generate CA code"
+msgstr ""
+
+#. {"cb", (TARGET_FLAG_NUMERICS|TARGET_FLAG_C_SERIES|						TARGET_FLAG_BRANCH_PREDICT|TARGET_FLAG_CODE_ALIGN),       N_("Generate CB code")},						    {"cc", (TARGET_FLAG_NUMERICS|TARGET_FLAG_PROTECTED|						TARGET_FLAG_C_SERIES|TARGET_FLAG_BRANCH_PREDICT|			TARGET_FLAG_CODE_ALIGN),			       N_("Generate CC code")},
+#: config/i960/i960.h:277
+msgid "Generate CF code"
+msgstr ""
+
+#: config/i960/i960.h:283
+msgid "Use alternate leaf function entries"
+msgstr ""
+
+#: config/i960/i960.h:285
+msgid "Do not use alternate leaf function entries"
+msgstr ""
+
+#: config/i960/i960.h:287
+msgid "Perform tail call optimization"
+msgstr ""
+
+#: config/i960/i960.h:289
+msgid "Do not perform tail call optimization"
+msgstr ""
+
+#: config/i960/i960.h:291
+msgid "Use complex addressing modes"
+msgstr ""
+
+#: config/i960/i960.h:293
+msgid "Do not use complex addressing modes"
+msgstr ""
+
+#: config/i960/i960.h:295
+msgid "Align code to 8 byte boundary"
+msgstr ""
+
+#: config/i960/i960.h:297
+msgid "Do not align code to 8 byte boundary"
+msgstr ""
+
+#. {"clean-linkage", (TARGET_FLAG_CLEAN_LINKAGE),			       N_("Force use of prototypes")},					    {"no-clean-linkage", -(TARGET_FLAG_CLEAN_LINKAGE),			       N_("Do not force use of prototypes")},
+#: config/i960/i960.h:303 config/i960/i960.h:305
+msgid "Enable compatibility with iC960 v2.0"
+msgstr ""
+
+#: config/i960/i960.h:307
+msgid "Enable compatibility with iC960 v3.0"
+msgstr ""
+
+#: config/i960/i960.h:309 config/i960/i960.h:311
+msgid "Enable compatibility with ic960 assembler"
+msgstr ""
+
+#: config/i960/i960.h:313
+msgid "Do not permit unaligned accesses"
+msgstr ""
+
+#: config/i960/i960.h:315
+msgid "Permit unaligned accesses"
+msgstr ""
+
+#: config/i960/i960.h:317
+msgid "Layout types like Intel's v1.3 gcc"
+msgstr ""
+
+#: config/i960/i960.h:319
+msgid "Do not layout types like Intel's v1.3 gcc"
+msgstr ""
+
+#: config/i960/i960.h:321 config/sparc/linux.h:92 config/sparc/linux64.h:148
+msgid "Use 64 bit long doubles"
+msgstr ""
+
+#: config/i960/i960.h:323
+msgid "Enable linker relaxation"
+msgstr ""
+
+#: config/i960/i960.h:325
+msgid "Do not enable linker relaxation"
+msgstr ""
+
+#. Override conflicting target switch options.
+#. Doesn't actually detect if more than one -mARCH option is given, but
+#. does handle the case of two blatantly conflicting -mARCH options.
+#: config/i960/i960.h:340 config/i960/i960.h:350
+msgid "conflicting architectures defined - using C series"
+msgstr ""
+
+#: config/i960/i960.h:345
+msgid "conflicting architectures defined - using K series"
+msgstr ""
+
+#: config/i960/i960.h:360
+msgid "iC2.0 and iC3.0 are incompatible - using iC3.0"
+msgstr ""
+
+#. ??? See the LONG_DOUBLE_TYPE_SIZE definition below.
+#: config/i960/i960.h:371
+msgid "The -mlong-double-64 option does not work yet."
+msgstr ""
+
+#: config/lynx-ng.h:97 config/lynx.h:120 config/rs6000/lynx.h:88
+msgid "-msystem-v and -p are incompatible"
+msgstr ""
+
+#: config/lynx-ng.h:99 config/lynx.h:122 config/rs6000/lynx.h:90
+msgid "-msystem-v and -mthreads are incompatible"
+msgstr ""
+
 #: config/m32r/m32r.c:84
 #, c-format
 msgid "bad value (%s) for -mmodel switch"
@@ -1967,6 +4400,10 @@ msgstr ""
 msgid "bad value (%s) for -msdata switch"
 msgstr ""
 
+#: config/m32r/m32r.c:381
+msgid "const objects cannot go in .sdata/.sbss"
+msgstr ""
+
 #: config/m32r/m32r.c:2188
 #, c-format
 msgid "invalid operand to %s code"
@@ -1985,6 +4422,31 @@ msgstr ""
 msgid "invalid operand to %N code"
 msgstr ""
 
+#. { "relax",			TARGET_RELAX_MASK, "" },		    { "no-relax",		-TARGET_RELAX_MASK, "" },
+#: config/m32r/m32r.h:185
+msgid "Display compile time statistics"
+msgstr ""
+
+#: config/m32r/m32r.h:187
+msgid "Align all loops to 32 byte boundary"
+msgstr ""
+
+#: config/m32r/m32r.h:190
+msgid "Only issue one instruction per cycle"
+msgstr ""
+
+#: config/m32r/m32r.h:193
+msgid "Prefer branches over conditional execution"
+msgstr ""
+
+#: config/m32r/m32r.h:209
+msgid "Code size: small, medium or large"
+msgstr ""
+
+#: config/m32r/m32r.h:211
+msgid "Small data area: none, sdata, use"
+msgstr ""
+
 #: config/m68k/m68k.c:101
 #, c-format
 msgid "-malign-loops=%d is not between 1 and %d"
@@ -2012,6 +4474,20 @@ msgstr ""
 msgid "-fPIC is not currently supported on the 68000 or 68010\n"
 msgstr ""
 
+#: config/m88k/m88k.c:861
+#, c-format
+msgid "Internal gcc monitor: short-branch(%x)"
+msgstr ""
+
+#: config/m88k/m88k.c:2268
+msgid "Internal gcc error: Can't express symbolic location"
+msgstr ""
+
+#: config/m88k/m88k.c:2549
+#, c-format
+msgid "argument #%d is a structure"
+msgstr ""
+
 #: config/m88k/m88k.c:2864
 msgid "%R not followed by %B/C/D/E"
 msgstr ""
@@ -2157,11 +4633,27 @@ msgstr ""
 msgid "-mips%d does not support 64 bit gp registers"
 msgstr ""
 
+#: config/mips/mips.c:4905
+msgid "-G is incompatible with PIC code which is the default"
+msgstr ""
+
+#: config/mips/mips.c:4921
+msgid "-membedded-pic and -mabicalls are incompatible"
+msgstr ""
+
+#: config/mips/mips.c:4924
+msgid "-G and -membedded-pic are incompatible"
+msgstr ""
+
 #: config/mips/mips.c:4976
 #, c-format
 msgid "Invalid option `entry%s'"
 msgstr ""
 
+#: config/mips/mips.c:4979
+msgid "-mentry is only meaningful with -mips-16"
+msgstr ""
+
 #: config/mips/mips.c:5312
 #, ycp-format
 msgid "internal error: %%) found without a %%( in assembler pattern"
@@ -2200,6 +4692,12 @@ msgstr ""
 msgid "PRINT_OPERAND_ADDRESS, null pointer"
 msgstr ""
 
+#: config/mips/mips.c:5802
+msgid ""
+"MIPS ECOFF format does not allow changing filenames within functions with "
+"#line"
+msgstr ""
+
 #: config/mips/mips.c:6365
 #, c-format
 msgid "gp_offset (%ld) or end_offset (%ld) is less than zero."
@@ -2215,17 +4713,452 @@ msgstr ""
 msgid "can not handle inconsistent calls to `%s'"
 msgstr ""
 
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/mips/mips.h:333
+msgid "No default crt0.o"
+msgstr ""
+
+#: config/mips/mips.h:335
+msgid "Use 64-bit int type"
+msgstr ""
+
+#: config/mips/mips.h:337
+msgid "Use 64-bit long type"
+msgstr ""
+
+#: config/mips/mips.h:339
+msgid "Use 32-bit long type"
+msgstr ""
+
+#: config/mips/mips.h:341
+msgid "Optimize lui/addiu address loads"
+msgstr ""
+
+#: config/mips/mips.h:343
+msgid "Don't optimize lui/addiu address loads"
+msgstr ""
+
+#: config/mips/mips.h:345
+msgid "Use MIPS as"
+msgstr ""
+
+#: config/mips/mips.h:347
+msgid "Use GNU as"
+msgstr ""
+
+#: config/mips/mips.h:349
+msgid "Use symbolic register names"
+msgstr ""
+
+#: config/mips/mips.h:351
+msgid "Don't use symbolic register names"
+msgstr ""
+
+#: config/mips/mips.h:353 config/mips/mips.h:355
+msgid "Use GP relative sdata/sbss sections"
+msgstr ""
+
+#: config/mips/mips.h:357 config/mips/mips.h:359
+msgid "Don't use GP relative sdata/sbss sections"
+msgstr ""
+
+#: config/mips/mips.h:361
+msgid "Output compiler statistics"
+msgstr ""
+
+#: config/mips/mips.h:363
+msgid "Don't output compiler statistics"
+msgstr ""
+
+#: config/mips/mips.h:365
+msgid "Don't optimize block moves"
+msgstr ""
+
+#: config/mips/mips.h:367
+msgid "Optimize block moves"
+msgstr ""
+
+#: config/mips/mips.h:369
+msgid "Use mips-tfile asm postpass"
+msgstr ""
+
+#: config/mips/mips.h:371
+msgid "Don't use mips-tfile asm postpass"
+msgstr ""
+
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of triplets in braces,
+#. each triplet being { "NAME", VALUE, DOC }
+#. where VALUE is the bits to set or minus the bits to clear and DOC
+#. is the documentation for --help (NULL if intentionally undocumented).
+#. An empty string NAME is used to identify the default VALUE.
+#: config/mips/mips.h:375 config/pdp11/pdp11.h:54
+msgid "Use hardware floating point"
+msgstr ""
+
+#: config/mips/mips.h:377
+msgid "Use 64-bit FP registers"
+msgstr ""
+
+#: config/mips/mips.h:379
+msgid "Use 32-bit FP registers"
+msgstr ""
+
+#: config/mips/mips.h:381
+msgid "Use 64-bit general registers"
+msgstr ""
+
+#: config/mips/mips.h:383
+msgid "Use 32-bit general registers"
+msgstr ""
+
+#: config/mips/mips.h:385
+msgid "Use Irix PIC"
+msgstr ""
+
+#: config/mips/mips.h:387
+msgid "Don't use Irix PIC"
+msgstr ""
+
+#: config/mips/mips.h:389
+msgid "Use OSF PIC"
+msgstr ""
+
+#: config/mips/mips.h:391
+msgid "Don't use OSF PIC"
+msgstr ""
+
+#: config/mips/mips.h:393
+msgid "Use indirect calls"
+msgstr ""
+
+#: config/mips/mips.h:395
+msgid "Don't use indirect calls"
+msgstr ""
+
+#: config/mips/mips.h:397
+msgid "Use embedded PIC"
+msgstr ""
+
+#: config/mips/mips.h:399
+msgid "Don't use embedded PIC"
+msgstr ""
+
+#: config/mips/mips.h:401
+msgid "Use ROM instead of RAM"
+msgstr ""
+
+#: config/mips/mips.h:403
+msgid "Don't use ROM instead of RAM"
+msgstr ""
+
+#: config/mips/mips.h:405
+msgid "Put uninitialized constants in ROM (needs -membedded-data)"
+msgstr ""
+
+#: config/mips/mips.h:407
+msgid "Don't put uninitialized constants in ROM"
+msgstr ""
+
+#: config/mips/mips.h:409
+msgid "Use big-endian byte order"
+msgstr ""
+
+#: config/mips/mips.h:411
+msgid "Use little-endian byte order"
+msgstr ""
+
+#: config/mips/mips.h:413
+msgid "Use single (32-bit) FP only"
+msgstr ""
+
+#: config/mips/mips.h:415
+msgid "Don't use single (32-bit) FP only"
+msgstr ""
+
+#: config/mips/mips.h:417
+msgid "Use multiply accumulate"
+msgstr ""
+
+#: config/mips/mips.h:419
+msgid "Don't use multiply accumulate"
+msgstr ""
+
+#: config/mips/mips.h:421
+msgid "Work around early 4300 hardware bug"
+msgstr ""
+
+#: config/mips/mips.h:423
+msgid "Don't work around early 4300 hardware bug"
+msgstr ""
+
+#: config/mips/mips.h:425
+msgid "Optimize for 4650"
+msgstr ""
+
+#: config/mips/mips.h:427
+msgid "Optimize for 3900"
+msgstr ""
+
+#: config/mips/mips.h:429
+msgid "Trap on integer divide by zero"
+msgstr ""
+
+#: config/mips/mips.h:431
+msgid "Don't trap on integer divide by zero"
+msgstr ""
+
+#: config/mips/mips.h:433
+msgid "Trap on integer divide overflow"
+msgstr ""
+
+#: config/mips/mips.h:435
+msgid "Don't trap on integer divide overflow"
+msgstr ""
+
+#. This macro is similar to `TARGET_SWITCHES' but defines names of
+#. command options that have values.  Its definition is an
+#. initializer with a subgrouping for each command option.
+#.
+#. Each subgrouping contains a string constant, that defines the
+#. fixed part of the option name, and the address of a variable.
+#. The variable, type `char *', is set to the variable part of the
+#. given option if the fixed part matches.  The actual option name
+#. is made by appending `-m' to the specified name.
+#.
+#. Here is an example which defines `-mshort-data-NUMBER'.  If the
+#. given option is `-mshort-data-512', the variable `m88k_short_data'
+#. will be set to the string `"512"'.
+#.
+#. extern char *m88k_short_data;
+#. #define TARGET_OPTIONS { { "short-data-", &m88k_short_data } }
+#: config/mips/mips.h:554
+msgid "Specify CPU for scheduling purposes"
+msgstr ""
+
+#: config/mips/mips.h:556
+msgid "Specify MIPS ISA"
+msgstr ""
+
+#: config/mips/mips.h:558
+msgid "Use mips16 entry/exit psuedo ops"
+msgstr ""
+
+#: config/mips/mips.h:560
+msgid "Don't use MIPS16 instructions"
+msgstr ""
+
+#. Output assembler code to FILE to increment profiler label # LABELNO
+#. for profiling a function entry.
+#: config/mips/mips.h:2577
+msgid "mips16 function profiling"
+msgstr ""
+
+#: config/mn10300/mn10300.h:56
+msgid "Work around hardware multiply bug"
+msgstr ""
+
+#: config/mn10300/mn10300.h:57
+msgid "Do not work around hardware multiply bug"
+msgstr ""
+
+#: config/nextstep.c:65
+msgid "optimization turned on"
+msgstr ""
+
+#: config/nextstep.c:71
+msgid "optimization turned off"
+msgstr ""
+
+#: config/nextstep.c:80
+msgid "optimization level restored"
+msgstr ""
+
+#: config/ns32k/ns32k.h:104
+msgid "Don't use hardware fp"
+msgstr ""
+
+#: config/ns32k/ns32k.h:105
+msgid "Alternative calling convention"
+msgstr ""
+
+#: config/ns32k/ns32k.h:107
+msgid "Pass some arguments in registers"
+msgstr ""
+
+#: config/ns32k/ns32k.h:108
+msgid "Pass all arguments on stack"
+msgstr ""
+
+#: config/ns32k/ns32k.h:109
+msgid "Optimize for 32532 cpu"
+msgstr ""
+
+#: config/ns32k/ns32k.h:110
+msgid "Optimize for 32332 cpu"
+msgstr ""
+
+#: config/ns32k/ns32k.h:112
+msgid "Optimize for 32032"
+msgstr ""
+
+#: config/ns32k/ns32k.h:114
+msgid "Register sb is zero. Use for absolute addressing"
+msgstr ""
+
+#: config/ns32k/ns32k.h:115
+msgid "Do not use register sb"
+msgstr ""
+
+#: config/ns32k/ns32k.h:116
+msgid "Do not use bitfield instructions"
+msgstr ""
+
+#: config/ns32k/ns32k.h:118
+msgid "Generate code for high memory"
+msgstr ""
+
+#: config/ns32k/ns32k.h:119
+msgid "Generate code for low memory"
+msgstr ""
+
+#: config/ns32k/ns32k.h:120
+msgid "32381 fpu"
+msgstr ""
+
+#: config/ns32k/ns32k.h:121
+msgid "Use multiply-accumulate fp instructions"
+msgstr ""
+
+#: config/ns32k/ns32k.h:123
+msgid "Do not use multiply-accumulate fp instructions"
+msgstr ""
+
+#: config/ns32k/ns32k.h:124
+msgid "\"Small register classes\" kludge"
+msgstr ""
+
+#: config/ns32k/ns32k.h:125
+msgid "No \"Small register classes\" kludge"
+msgstr ""
+
+#: config/pa/pa.c:142
+#, c-format
+msgid ""
+"Unknown -mschedule= option (%s).\n"
+"Valid options are 700, 7100, 7100LC, 7200, and 8000\n"
+msgstr ""
+
+#: config/pa/pa.c:167
+#, c-format
+msgid ""
+"Unknown -march= option (%s).\n"
+"Valid options are 1.0, 1.1, and 2.0\n"
+msgstr ""
+
+#: config/pa/pa.c:172
+msgid "PIC code generation is not supported in the portable runtime model\n"
+msgstr ""
+
+#: config/pa/pa.c:177
+msgid "PIC code generation is not compatible with fast indirect calls\n"
+msgstr ""
+
+#: config/pa/pa.c:182
+msgid "PIC code generation is not compatible with profiling\n"
+msgstr ""
+
+#: config/pa/pa.c:187
+msgid "-g is only supported when using GAS on this processor,"
+msgstr ""
+
+#: config/pa/pa.c:188
+msgid "-g option disabled."
+msgstr ""
+
+#: config/pdp11/pdp11.h:55
+msgid "Do not use hardware floating point"
+msgstr ""
+
+#. return float result in ac0
+#: config/pdp11/pdp11.h:57
+msgid "Return floating point results in ac0"
+msgstr ""
+
+#: config/pdp11/pdp11.h:58
+msgid "Return floating point results in memory"
+msgstr ""
+
+#. is 11/40
+#: config/pdp11/pdp11.h:60
+msgid "Generate code for an 11/40"
+msgstr ""
+
+#. is 11/45
+#: config/pdp11/pdp11.h:63
+msgid "Generate code for an 11/45"
+msgstr ""
+
+#. is 11/10
+#: config/pdp11/pdp11.h:66
+msgid "Generate code for an 11/10"
+msgstr ""
+
+#. use movstrhi for bcopy
+#. use 32 bit for int
+#: config/pdp11/pdp11.h:71 config/pdp11/pdp11.h:72
+msgid "Use 32 bit int"
+msgstr ""
+
+#: config/pdp11/pdp11.h:73 config/pdp11/pdp11.h:74
+msgid "Use 16 bit int"
+msgstr ""
+
+#. use 32 bit for float
+#: config/pdp11/pdp11.h:76 config/pdp11/pdp11.h:77
+msgid "Use 32 bit float"
+msgstr ""
+
+#: config/pdp11/pdp11.h:78 config/pdp11/pdp11.h:79
+msgid "Use 64 bit float"
+msgstr ""
+
+#. allow abshi pattern? - can trigger "optimizations" which make code SLOW!
+#. is branching expensive - on a PDP, it's actually really cheap
+#. this is just to play around and check what code gcc generates
+#. split instruction and data memory?
+#: config/pdp11/pdp11.h:88
+msgid "Target has split I&D"
+msgstr ""
+
+#: config/pdp11/pdp11.h:89
+msgid "Target does not have split I&D"
+msgstr ""
+
+#. UNIX assembler syntax?
+#: config/pdp11/pdp11.h:91
+msgid "Use UNIX assembler syntax"
+msgstr ""
+
+#: config/pdp11/pdp11.h:92
+msgid "Use DEC assembler syntax"
+msgstr ""
+
 #: config/romp/romp.c:675
 #, ycp-format
 msgid "invalid %%B value"
 msgstr ""
 
-#: config/romp/romp.c:702 config/rs6000/rs6000.c:3695
+#: config/romp/romp.c:702 config/rs6000/rs6000.c:3710
 #, ycp-format
 msgid "invalid %%S value"
 msgstr ""
 
-#: config/romp/romp.c:711 config/romp/romp.c:718 config/rs6000/rs6000.c:3323
+#: config/romp/romp.c:711 config/romp/romp.c:718 config/rs6000/rs6000.c:3339
 #, ycp-format
 msgid "invalid %%b value"
 msgstr ""
@@ -2246,7 +5179,7 @@ msgid "invalid %%Z value"
 msgstr ""
 
 #: config/romp/romp.c:792 config/romp/romp.c:801 config/romp/romp.c:808
-#: config/rs6000/rs6000.c:3478
+#: config/rs6000/rs6000.c:3494
 #, ycp-format
 msgid "invalid %%k value"
 msgstr ""
@@ -2273,77 +5206,265 @@ msgstr ""
 msgid "can't have varargs with -mfp-arg-in-fp-regs"
 msgstr ""
 
-#: config/rs6000/aix43.h:63
+#: config/rs6000/aix.h:254 config/rs6000/beos.h:33
+msgid "Always pass floating-point arguments in memory"
+msgstr ""
+
+#: config/rs6000/aix.h:256 config/rs6000/beos.h:35
+msgid "Don't always pass floating-point arguments in memory"
+msgstr ""
+
+#: config/rs6000/aix41.h:31 config/rs6000/aix43.h:35
+msgid "Support message passing with the Parallel Environment"
+msgstr ""
+
+#: config/rs6000/aix43.h:31
+msgid "Compile for 64-bit pointers"
+msgstr ""
+
+#: config/rs6000/aix43.h:33
+msgid "Compile for 32-bit pointers"
+msgstr ""
+
+#: config/rs6000/aix43.h:52
+msgid "-maix64 and POWER architecture are incompatible."
+msgstr ""
+
+#: config/rs6000/aix43.h:57
+msgid "-maix64 requires PowerPC64 architecture remain enabled."
+msgstr ""
+
+#: config/rs6000/aix43.h:61
 msgid ""
 "-maix64 required: 64-bit computation with 32-bit addressing not yet "
 "supported."
 msgstr ""
 
+#: config/rs6000/rs6000.c:345
+msgid "-mmultiple is not supported on little endian systems"
+msgstr ""
+
+#: config/rs6000/rs6000.c:352
+msgid "-mstring is not supported on little endian systems"
+msgstr ""
+
+#: config/rs6000/rs6000.c:358
+#, c-format
+msgid "-f%s ignored for AIX (all code is position independent)"
+msgstr ""
+
 #: config/rs6000/rs6000.c:373
 #, c-format
 msgid "Unknown -mdebug-%s switch"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3405
+#: config/rs6000/rs6000.c:3421
 #, ycp-format
 msgid "invalid %%f value"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3414
+#: config/rs6000/rs6000.c:3430
 #, ycp-format
 msgid "invalid %%F value"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3423
+#: config/rs6000/rs6000.c:3439
 #, ycp-format
 msgid "invalid %%G value"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3458
+#: config/rs6000/rs6000.c:3474
 #, ycp-format
 msgid "invalid %%j code"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3468
+#: config/rs6000/rs6000.c:3484
 #, ycp-format
 msgid "invalid %%J code"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3498
+#: config/rs6000/rs6000.c:3514
 #, ycp-format
 msgid "invalid %%K value"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3622
+#: config/rs6000/rs6000.c:3638
 #, ycp-format
 msgid "invalid %%p value"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3658
+#: config/rs6000/rs6000.c:3673
 #, ycp-format
 msgid "invalid %%q value"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3721
+#: config/rs6000/rs6000.c:3736
 #, ycp-format
 msgid "%%S computed all 1's mask"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3747
+#: config/rs6000/rs6000.c:3762
 #, ycp-format
 msgid "%%S computed all 0's mask"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3755
+#: config/rs6000/rs6000.c:3770
 #, ycp-format
 msgid "invalid %%u value"
 msgstr ""
 
-#: config/rs6000/rs6000.c:3764
+#: config/rs6000/rs6000.c:3779
 #, ycp-format
 msgid "invalid %%v value"
 msgstr ""
 
+#. Run-time compilation parameters selecting different hardware subsets.
+#.
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/rs6000/rs6000.h:256
+msgid "Use POWER instruction set"
+msgstr ""
+
+#: config/rs6000/rs6000.h:259
+msgid "Use POWER2 instruction set"
+msgstr ""
+
+#: config/rs6000/rs6000.h:261
+msgid "Do not use POWER2 instruction set"
+msgstr ""
+
+#: config/rs6000/rs6000.h:264
+msgid "Do not use POWER instruction set"
+msgstr ""
+
+#: config/rs6000/rs6000.h:266
+msgid "Use PowerPC instruction set"
+msgstr ""
+
+#: config/rs6000/rs6000.h:269
+msgid "Do not use PowerPC instruction set"
+msgstr ""
+
+#: config/rs6000/rs6000.h:271
+msgid "Use PowerPC General Purpose group optional instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:273
+msgid "Don't use PowerPC General Purpose group optional instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:275
+msgid "Use PowerPC Graphics group optional instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:277
+msgid "Don't use PowerPC Graphics group optional instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:279
+msgid "Use PowerPC-64 instruction set"
+msgstr ""
+
+#: config/rs6000/rs6000.h:281
+msgid "Don't use PowerPC-64 instruction set"
+msgstr ""
+
+#: config/rs6000/rs6000.h:283
+msgid "Use new mnemonics for PowerPC architecture"
+msgstr ""
+
+#: config/rs6000/rs6000.h:285
+msgid "Use old mnemonics for PowerPC architecture"
+msgstr ""
+
+#: config/rs6000/rs6000.h:288
+msgid "Put everything in the regular TOC"
+msgstr ""
+
+#: config/rs6000/rs6000.h:290
+msgid "Place floating point constants in TOC"
+msgstr ""
+
+#: config/rs6000/rs6000.h:292
+msgid "Don't place floating point constants in TOC"
+msgstr ""
+
+#: config/rs6000/rs6000.h:294
+msgid "Place symbol+offset constants in TOC"
+msgstr ""
+
+#: config/rs6000/rs6000.h:296
+msgid "Don't place symbol+offset constants in TOC"
+msgstr ""
+
+#: config/rs6000/rs6000.h:302
+msgid "Place variable addresses in the regular TOC"
+msgstr ""
+
+#: config/rs6000/rs6000.h:308
+msgid "Generate load/store multiple instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:310
+msgid "Do not generate load/store multiple instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:314
+msgid "Generate string instructions for block moves"
+msgstr ""
+
+#: config/rs6000/rs6000.h:316
+msgid "Do not generate string instructions for block moves"
+msgstr ""
+
+#: config/rs6000/rs6000.h:320
+msgid "Generate load/store with update instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:322
+msgid "Do not generate load/store with update instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:324
+msgid "Generate fused multiply/add instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:326
+msgid "Don't generate fused multiply/add instructions"
+msgstr ""
+
+#: config/rs6000/rs6000.h:330
+msgid "Don't schedule the start and end of the procedure"
+msgstr ""
+
+#. This macro is similar to `TARGET_SWITCHES' but defines names of
+#. command options that have values.  Its definition is an
+#. initializer with a subgrouping for each command option.
+#.
+#. Each subgrouping contains a string constant, that defines the
+#. fixed part of the option name, and the address of a variable.
+#. The variable, type `char *', is set to the variable part of the
+#. given option if the fixed part matches.  The actual option name
+#. is made by appending `-m' to the specified name.
+#.
+#. Here is an example which defines `-mshort-data-NUMBER'.  If the
+#. given option is `-mshort-data-512', the variable `m88k_short_data'
+#. will be set to the string `"512"'.
+#.
+#. extern char *m88k_short_data;
+#. #define TARGET_OPTIONS { { "short-data-", &m88k_short_data } }
+#: config/rs6000/rs6000.h:403 config/sparc/sparc.h:709
+msgid "Use features of and schedule code for given CPU"
+msgstr ""
+
+#: config/rs6000/rs6000.h:406
+msgid "Enable debug output"
+msgstr ""
+
 #. Definitions for __builtin_return_address and __builtin_frame_address.
 #. __builtin_return_address (0) should give link register (65), enable
 #. this.
@@ -2356,10 +5477,95 @@ msgstr ""
 #. Number of bytes into the frame return addresses can be found.  See
 #. rs6000_stack_info in rs6000.c for more information on how the different
 #. abi's store the return address.
-#: config/rs6000/rs6000.h:1620
+#: config/rs6000/rs6000.h:1627
 msgid "RETURN_ADDRESS_OFFSET not supported"
 msgstr ""
 
+#: config/rs6000/sysv4.h:90
+msgid "Select ABI calling convention."
+msgstr ""
+
+#: config/rs6000/sysv4.h:91
+msgid "Select method for sdata handling."
+msgstr ""
+
+#: config/rs6000/sysv4.h:106
+msgid "Align to the base type of the bitfield."
+msgstr ""
+
+#: config/rs6000/sysv4.h:108
+msgid "Don't align to the base type of the bitfield."
+msgstr ""
+
+#: config/rs6000/sysv4.h:110
+msgid "Don't assume that unaligned accesses are handled by the system"
+msgstr ""
+
+#: config/rs6000/sysv4.h:112
+msgid "Assume that unaligned accesses are handled by the system"
+msgstr ""
+
+#: config/rs6000/sysv4.h:114 config/rs6000/sysv4.h:118
+msgid "Produce code relocatable at runtime."
+msgstr ""
+
+#: config/rs6000/sysv4.h:116 config/rs6000/sysv4.h:120
+msgid "Don't produce code relocatable at runtime."
+msgstr ""
+
+#: config/rs6000/sysv4.h:122 config/rs6000/sysv4.h:124
+msgid "Produce little endian code."
+msgstr ""
+
+#: config/rs6000/sysv4.h:126 config/rs6000/sysv4.h:128
+msgid "Produce big endian code."
+msgstr ""
+
+#: config/rs6000/sysv4.h:129 config/rs6000/sysv4.h:130
+#: config/rs6000/sysv4.h:131 config/rs6000/sysv4.h:132
+#: config/rs6000/sysv4.h:133 config/rs6000/sysv4.h:134
+#: config/rs6000/sysv4.h:141 config/rs6000/sysv4.h:142
+#: config/rs6000/sysv4.h:153 config/rs6000/sysv4.h:154
+#: config/rs6000/sysv4.h:155 config/rs6000/sysv4.h:157
+msgid "no description yet"
+msgstr ""
+
+#: config/rs6000/sysv4.h:135
+msgid "Use EABI."
+msgstr ""
+
+#: config/rs6000/sysv4.h:136
+msgid "Don't use EABI."
+msgstr ""
+
+#: config/rs6000/sysv4.h:138
+msgid "Use alternate register names."
+msgstr ""
+
+#: config/rs6000/sysv4.h:140
+msgid "Don't use alternate register names."
+msgstr ""
+
+#: config/rs6000/sysv4.h:144
+msgid "Link with libsim.a, libc.a and sim-crt0.o."
+msgstr ""
+
+#: config/rs6000/sysv4.h:146
+msgid "Link with libads.a, libc.a and crt0.o."
+msgstr ""
+
+#: config/rs6000/sysv4.h:148
+msgid "Link with libyk.a, libc.a and crt0.o."
+msgstr ""
+
+#: config/rs6000/sysv4.h:150
+msgid "Link with libmvme.a, libc.a and crt0.o."
+msgstr ""
+
+#: config/rs6000/sysv4.h:152
+msgid "Set the PPC_EMB bit in the ELF flags header"
+msgstr ""
+
 #. Sometimes certain combinations of command options do not make sense
 #. on a particular target machine.  You can define a macro
 #. `OVERRIDE_OPTIONS' to take account of this.  This macro, if
@@ -2368,49 +5574,61 @@ msgstr ""
 #.
 #. The macro SUBTARGET_OVERRIDE_OPTIONS is provided for subtargets, to
 #. get control.
-#: config/rs6000/sysv4.h:184
+#: config/rs6000/sysv4.h:203
 #, c-format
 msgid "Bad value for -mcall-%s"
 msgstr ""
 
-#: config/rs6000/sysv4.h:200
+#: config/rs6000/sysv4.h:219
 #, c-format
 msgid "Bad value for -msdata=%s"
 msgstr ""
 
-#: config/rs6000/sysv4.h:217
+#: config/rs6000/sysv4.h:236
 #, c-format
 msgid "-mrelocatable and -msdata=%s are incompatible."
 msgstr ""
 
-#: config/rs6000/sysv4.h:225
+#: config/rs6000/sysv4.h:244
 #, c-format
 msgid "-f%s and -msdata=%s are incompatible."
 msgstr ""
 
-#: config/rs6000/sysv4.h:234
+#: config/rs6000/sysv4.h:253
 #, c-format
 msgid "-msdata=%s and -mcall-%s are incompatible."
 msgstr ""
 
-#: config/rs6000/sysv4.h:241
+#: config/rs6000/sysv4.h:260
 msgid "-mrelocatable and -mno-minimal-toc are incompatible."
 msgstr ""
 
-#: config/rs6000/sysv4.h:247
+#: config/rs6000/sysv4.h:266
 #, c-format
 msgid "-mrelocatable and -mcall-%s are incompatible."
 msgstr ""
 
-#: config/rs6000/sysv4.h:254
+#: config/rs6000/sysv4.h:273
 #, c-format
 msgid "-fPIC and -mcall-%s are incompatible."
 msgstr ""
 
-#: config/rs6000/sysv4.h:261
+#: config/rs6000/sysv4.h:280
 msgid "-mcall-aixdesc must be big endian"
 msgstr ""
 
+#: config/sparc/linux.h:93 config/sparc/linux64.h:149
+msgid "Use 128 bit long doubles"
+msgstr ""
+
+#: config/sparc/sp64-elf.h:84 config/sparc/splet.h:29
+msgid "Generate code for big endian"
+msgstr ""
+
+#: config/sparc/sp64-elf.h:85 config/sparc/splet.h:30
+msgid "Generate code for little endian"
+msgstr ""
+
 #: config/sparc/sparc.c:256
 #, c-format
 msgid "%s is not supported by this configuration"
@@ -2438,54 +5656,196 @@ msgstr ""
 msgid "profiling does not support code models other than medlow"
 msgstr ""
 
-#: config/sparc/sparc.c:5673 config/sparc/sparc.c:5679
+#: config/sparc/sparc.c:5683 config/sparc/sparc.c:5689
 #, ycp-format
 msgid "Invalid %%Y operand"
 msgstr ""
 
-#: config/sparc/sparc.c:5749
+#: config/sparc/sparc.c:5759
 #, ycp-format
 msgid "Invalid %%A operand"
 msgstr ""
 
-#: config/sparc/sparc.c:5759
+#: config/sparc/sparc.c:5769
 #, ycp-format
 msgid "Invalid %%B operand"
 msgstr ""
 
-#: config/sparc/sparc.c:5798
+#: config/sparc/sparc.c:5808
 #, ycp-format
 msgid "Invalid %%c operand"
 msgstr ""
 
-#: config/sparc/sparc.c:5799
+#: config/sparc/sparc.c:5809
 #, ycp-format
 msgid "Invalid %%C operand"
 msgstr ""
 
-#: config/sparc/sparc.c:5820
+#: config/sparc/sparc.c:5830
 #, ycp-format
 msgid "Invalid %%d operand"
 msgstr ""
 
-#: config/sparc/sparc.c:5821
+#: config/sparc/sparc.c:5831
 #, ycp-format
 msgid "Invalid %%D operand"
 msgstr ""
 
-#: config/sparc/sparc.c:5839
+#: config/sparc/sparc.c:5849
 #, ycp-format
 msgid "Invalid %%f operand"
 msgstr ""
 
-#: config/sparc/sparc.c:5889
+#: config/sparc/sparc.c:5899
 msgid "long long constant not a valid immediate operand"
 msgstr ""
 
-#: config/sparc/sparc.c:5892
+#: config/sparc/sparc.c:5902
 msgid "floating point constant not a valid immediate operand"
 msgstr ""
 
+#. To make profiling work with -f{pic,PIC}, we need to emit the profiling
+#. code into the rtl.  Also, if we are profiling, we cannot eliminate
+#. the frame pointer (because the return address will get smashed).
+#: config/sparc/sparc.h:403
+#, c-format
+msgid "%s and profiling conflict: disabling %s"
+msgstr ""
+
+#: config/sparc/sparc.h:588
+msgid "Use FUNCTION_EPILOGUE"
+msgstr ""
+
+#: config/sparc/sparc.h:590
+msgid "Do not use FUNCTION_EPILOGUE"
+msgstr ""
+
+#: config/sparc/sparc.h:592
+msgid "Assume possible double misalignment"
+msgstr ""
+
+#: config/sparc/sparc.h:594
+msgid "Assume all doubles are aligned"
+msgstr ""
+
+#: config/sparc/sparc.h:596
+msgid "Pass -assert pure-text to linker"
+msgstr ""
+
+#: config/sparc/sparc.h:598
+msgid "Do not pass -assert pure-text to linker"
+msgstr ""
+
+#: config/sparc/sparc.h:600
+msgid "Use flat register window model"
+msgstr ""
+
+#: config/sparc/sparc.h:602
+msgid "Do not use flat register window model"
+msgstr ""
+
+#: config/sparc/sparc.h:604
+msgid "Use ABI reserved registers"
+msgstr ""
+
+#: config/sparc/sparc.h:606
+msgid "Do not use ABI reserved registers"
+msgstr ""
+
+#: config/sparc/sparc.h:608
+msgid "Use hardware quad fp instructions"
+msgstr ""
+
+#: config/sparc/sparc.h:610
+msgid "Do not use hardware quad fp instructions"
+msgstr ""
+
+#: config/sparc/sparc.h:612
+msgid "Compile for v8plus ABI"
+msgstr ""
+
+#: config/sparc/sparc.h:614
+msgid "Do not compile for v8plus ABI"
+msgstr ""
+
+#: config/sparc/sparc.h:616
+msgid "Utilize Visual Instruction Set"
+msgstr ""
+
+#: config/sparc/sparc.h:618
+msgid "Do not utilize Visual Instruction Set"
+msgstr ""
+
+#. ??? These are deprecated, coerced to -mcpu=.  Delete in 2.9.
+#: config/sparc/sparc.h:621
+msgid "Optimize for Cypress processors"
+msgstr ""
+
+#: config/sparc/sparc.h:623
+msgid "Optimize for SparcLite processors"
+msgstr ""
+
+#: config/sparc/sparc.h:625
+msgid "Optimize for F930 processors"
+msgstr ""
+
+#: config/sparc/sparc.h:627
+msgid "Optimize for F934 processors"
+msgstr ""
+
+#: config/sparc/sparc.h:629
+msgid "Use V8 Sparc ISA"
+msgstr ""
+
+#: config/sparc/sparc.h:631
+msgid "Optimize for SuperSparc processors"
+msgstr ""
+
+#. End of deprecated options.
+#: config/sparc/sparc.h:634
+msgid "Pointers are 64-bit"
+msgstr ""
+
+#: config/sparc/sparc.h:636
+msgid "Pointers are 32-bit"
+msgstr ""
+
+#: config/sparc/sparc.h:638
+msgid "Use 32-bit ABI"
+msgstr ""
+
+#: config/sparc/sparc.h:640
+msgid "Use 64-bit ABI"
+msgstr ""
+
+#: config/sparc/sparc.h:642
+msgid "Use stack bias"
+msgstr ""
+
+#: config/sparc/sparc.h:644
+msgid "Do not use stack bias"
+msgstr ""
+
+#: config/sparc/sparc.h:646
+msgid "Use structs on stronger alignment for double-word copies"
+msgstr ""
+
+#: config/sparc/sparc.h:648
+msgid "Do not use structs on stronger alignment for double-word copies"
+msgstr ""
+
+#: config/sparc/sparc.h:650
+msgid "Optimize tail call instructions in assembler and linker"
+msgstr ""
+
+#: config/sparc/sparc.h:652
+msgid "Do not optimize tail call instructions in assembler or linker"
+msgstr ""
+
+#: config/sparc/sparc.h:713
+msgid "Use given Sparc code model"
+msgstr ""
+
 #: config/v850/v850.c:99
 #, c-format
 msgid "%s=%s is not numeric."
@@ -2496,6 +5856,15 @@ msgstr ""
 msgid "%s=%s is too large."
 msgstr ""
 
+#: config/v850/v850.c:2031
+msgid "a data area attribute cannot be specified for local variables"
+msgstr ""
+
+#: config/v850/v850.c:2039
+#, c-format
+msgid "data area of '%s' conflicts with previous declaration"
+msgstr ""
+
 #: config/v850/v850.c:2243
 #, c-format
 msgid "Bogus JR construction: %d\n"
@@ -2511,6 +5880,123 @@ msgstr ""
 msgid "Bogus JARL construction: %d\n"
 msgstr ""
 
+#: config/v850/v850.c:2687
+msgid "#pragma GHS endXXXX found without previous startXXX"
+msgstr ""
+
+#: config/v850/v850.c:2689
+msgid "#pragma GHS endXXX does not match previous startXXX"
+msgstr ""
+
+#: config/v850/v850.c:2713
+msgid "Cannot set interrupt attribute: no current function"
+msgstr ""
+
+#: config/v850/v850.c:2721
+msgid "Cannot set interrupt attribute: no such identifier"
+msgstr ""
+
+#: config/v850/v850.c:2754
+msgid "Incomplete #pragma ghs"
+msgstr ""
+
+#: config/v850/v850.c:2761
+msgid "Nothing follows #pragma ghs"
+msgstr ""
+
+#: config/v850/v850.c:2853
+#, c-format
+msgid "Unrecognised GHS pragma: '%s'\n"
+msgstr ""
+
+#: config/v850/v850.c:2859
+#, c-format
+msgid "Extra text after valid #pragma: '%s'"
+msgstr ""
+
+#: config/v850/v850.c:2884
+#, c-format
+msgid "Unrecognised section name '%s' in GHS section pragma"
+msgstr ""
+
+#: config/v850/v850.c:2895
+msgid "Missing '=' in GHS section pragma"
+msgstr ""
+
+#: config/v850/v850.c:2916
+#, c-format
+msgid "Malformed GHS section pragma: found '%s' instead of a comma"
+msgstr ""
+
+#: config/v850/v850.c:2992
+msgid "Missing trailing \" in #pragma ghs"
+msgstr ""
+
+#. Macro to define tables used to set the flags.
+#. This is a list in braces of pairs in braces,
+#. each pair being { "NAME", VALUE }
+#. where VALUE is the bits to set or minus the bits to clear.
+#. An empty string NAME is used to identify the default VALUE.
+#: config/v850/v850.h:118
+msgid "Support Green Hills ABI"
+msgstr ""
+
+#: config/v850/v850.h:121
+msgid "Prohibit PC relative function calls"
+msgstr ""
+
+#: config/v850/v850.h:124
+msgid "Reuse r30 on a per function basis"
+msgstr ""
+
+#: config/v850/v850.h:127
+msgid "Use stubs for function prologues"
+msgstr ""
+
+#: config/v850/v850.h:130
+msgid "Same as: -mep -mprolog-function"
+msgstr ""
+
+#: config/v850/v850.h:131
+msgid "Enable backend debugging"
+msgstr ""
+
+#: config/v850/v850.h:133
+msgid "Compile for the v850 processor"
+msgstr ""
+
+#: config/v850/v850.h:136
+msgid "Use 4 byte entries in switch tables"
+msgstr ""
+
+#. This macro is similar to `TARGET_SWITCHES' but defines names of
+#. command options that have values.  Its definition is an
+#. initializer with a subgrouping for each command option.
+#.
+#. Each subgrouping contains a string constant, that defines the
+#. fixed part of the option name, and the address of a variable.  The
+#. variable, type `char *', is set to the variable part of the given
+#. option if the fixed part matches.  The actual option name is made
+#. by appending `-m' to the specified name.
+#.
+#. Here is an example which defines `-mshort-data-NUMBER'.  If the
+#. given option is `-mshort-data-512', the variable `m88k_short_data'
+#. will be set to the string `"512"'.
+#.
+#. extern char *m88k_short_data;
+#. #define TARGET_OPTIONS            { { "short-data-", &m88k_short_data } }
+#: config/v850/v850.h:180
+msgid "Set the max size of data eligible for the TDA area"
+msgstr ""
+
+#: config/v850/v850.h:183
+msgid "Set the max size of data eligible for the SDA area"
+msgstr ""
+
+#: config/v850/v850.h:186
+msgid "Set the max size of data eligible for the ZDA area"
+msgstr ""
+
 #: convert.c:67
 msgid "cannot convert to a pointer type"
 msgstr ""
@@ -2527,370 +6013,529 @@ msgstr ""
 msgid "conversion to incomplete type"
 msgstr ""
 
-#: convert.c:387
+#: convert.c:390 convert.c:472
+msgid "can't convert between vector values of different size"
+msgstr ""
+
+#: convert.c:396
 msgid "aggregate value used where an integer was expected"
 msgstr ""
 
-#: convert.c:439
+#: convert.c:448
 msgid "pointer value used where a complex was expected"
 msgstr ""
 
-#: convert.c:443
+#: convert.c:452
 msgid "aggregate value used where a complex was expected"
 msgstr ""
 
+#: convert.c:478
+msgid "can't convert value to a vector"
+msgstr ""
+
+#: cp/call.c:378
+msgid "unable to call pointer to member function here"
+msgstr ""
+
 #: cp/call.c:505
 msgid "destructors take no parameters"
 msgstr ""
 
-#: cp/class.c:1464
+#: cp/call.c:2827
+msgid "ISO C++ forbids omitting the middle term of a ?: expression"
+msgstr ""
+
+#: cp/class.c:886
+msgid "internal inconsistency: binfo offset error for rtti"
+msgstr ""
+
+#: cp/class.c:1466
 #, c-format
 msgid "conflicting access specifications for field `%s', ignored"
 msgstr ""
 
-#: cp/class.c:5217
+#: cp/class.c:5268
 msgid "trying to finish struct, but kicked out due to previous parse errors."
 msgstr ""
 
-#: cp/class.c:5666
+#: cp/class.c:5717
 #, c-format
 msgid "language string `\"%s\"' not recognized"
 msgstr ""
 
-#: cp/class.c:5964 cp/class.c:6159 cp/class.c:6166
+#: cp/class.c:6015 cp/class.c:6210 cp/class.c:6217
 msgid "not enough type information"
 msgstr ""
 
-#: cp/class.c:6143
+#: cp/class.c:6194
 msgid "invalid operation on uninstantiated type"
 msgstr ""
 
-#: cp/decl.c:3874
+#: cp/class.c:7489
+msgid ""
+"object size exceeds built-in limit for virtual function table implementation"
+msgstr ""
+
+#: cp/class.c:7491
+msgid ""
+"object size exceeds normal limit for virtual function table implementation, "
+"recompile all source and use -fhuge-objects"
+msgstr ""
+
+#: cp/decl.c:1413
+msgid "internal compiler error: debugging info corrupted"
+msgstr ""
+
+#: cp/decl.c:3898
 msgid "parse errors have confused me too much"
 msgstr ""
 
-#: cp/decl.c:4829
+#: cp/decl.c:4199
+#, c-format
+msgid "declaration of `%s' shadows a member of `this'"
+msgstr ""
+
+#: cp/decl.c:4841
 #, c-format
 msgid "label `%s' referenced outside of any function"
 msgstr ""
 
-#: cp/decl.c:4967 cp/decl.c:5063
+#: cp/decl.c:4946 cp/decl.c:4973
+msgid "jump to case label"
+msgstr ""
+
+#: cp/decl.c:4979 cp/decl.c:5080
 msgid "  enters try block"
 msgstr ""
 
-#: ../libiberty/cplus-dem.c:4795 ../libiberty/cplus-dem.c:4806 cp/decl.c:5504
+#: cp/decl.c:5061
+msgid "  from here"
+msgstr ""
+
+#: cp/decl.c:5174
+msgid "where case label appears here"
+msgstr ""
+
+#: cp/decl.c:5177
+msgid "(enclose actions of previous case statements requiring"
+msgstr ""
+
+#: cp/decl.c:5178
+msgid "destructors in their own binding contours.)"
+msgstr ""
+
+#: ../libiberty/cplus-dem.c:4795 ../libiberty/cplus-dem.c:4806 cp/decl.c:5521
 msgid "virtual memory exhausted"
 msgstr ""
 
-#: cp/decl.c:6274
+#: cp/decl.c:6292
 msgid "the new ABI requires vtable thunks"
 msgstr ""
 
-#: cp/decl.c:6959
+#: cp/decl.c:6977
 msgid "an anonymous union cannot have function members"
 msgstr ""
 
-#: cp/decl.c:7015
+#: cp/decl.c:7033
 msgid "multiple types in one declaration"
 msgstr ""
 
-#: cp/decl.c:8092
+#: cp/decl.c:7036
+msgid "declaration does not declare anything"
+msgstr ""
+
+#: cp/decl.c:7049
+msgid "ISO C++ prohibits anonymous structs"
+msgstr ""
+
+#: cp/decl.c:8114
 msgid "assignment (not initialization) in declaration"
 msgstr ""
 
-#: cp/decl.c:8649
+#: cp/decl.c:8671
 msgid "invalid catch parameter"
 msgstr ""
 
-#: cp/decl.c:8757
+#: cp/decl.c:8779
 #, c-format
 msgid "destructor for alien class `%s' cannot be a member"
 msgstr ""
 
-#: cp/decl.c:8760
+#: cp/decl.c:8782
 #, c-format
 msgid "constructor for alien class `%s' cannot be a member"
 msgstr ""
 
-#: cp/decl.c:8871
+#: cp/decl.c:8893
 msgid "cannot declare `::main' to be a template"
 msgstr ""
 
-#: cp/decl.c:8873
+#: cp/decl.c:8895
 msgid "cannot declare `::main' to be inline"
 msgstr ""
 
-#: cp/decl.c:8875
+#: cp/decl.c:8897
 msgid "cannot declare `::main' to be static"
 msgstr ""
 
-#: cp/decl.c:9428
+#: cp/decl.c:9450
 msgid "overflow in array dimension"
 msgstr ""
 
-#: cp/decl.c:9717
+#: cp/decl.c:9739
 msgid "destructors must be member functions"
 msgstr ""
 
-#: cp/decl.c:10046
+#: cp/decl.c:10068
 msgid "`bool' is now a keyword"
 msgstr ""
 
-#: cp/decl.c:10200
+#: cp/decl.c:10099
+msgid "ISO C++ does not support `long long'"
+msgstr ""
+
+#: cp/decl.c:10222
 #, c-format
 msgid "short, signed or unsigned invalid for `%s'"
 msgstr ""
 
-#: cp/decl.c:10205
+#: cp/decl.c:10227
 #, c-format
 msgid "long and short specified together for `%s'"
 msgstr ""
 
-#: cp/decl.c:10216
+#: cp/decl.c:10238
 #, c-format
 msgid "signed and unsigned given together for `%s'"
 msgstr ""
 
-#: cp/decl.c:10363
+#: cp/decl.c:10385
 msgid "storage class specifiers invalid in parameter declarations"
 msgstr ""
 
-#: cp/decl.c:10367
+#: cp/decl.c:10389
 msgid "typedef declaration invalid in parameter declaration"
 msgstr ""
 
-#: cp/decl.c:10378
+#: cp/decl.c:10400
 msgid "virtual outside class declaration"
 msgstr ""
 
-#: cp/decl.c:10432
+#: cp/decl.c:10454
 #, c-format
 msgid "storage class specified for %s `%s'"
 msgstr ""
 
-#: cp/decl.c:10470
+#: cp/decl.c:10492
 msgid "storage class specifiers invalid in friend function declarations"
 msgstr ""
 
-#: cp/decl.c:10652
+#: cp/decl.c:10674
 msgid "destructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.c:10676
+#: cp/decl.c:10698
 msgid "constructor cannot be static member function"
 msgstr ""
 
-#: cp/decl.c:10694
+#: cp/decl.c:10701
+msgid "constructors cannot be declared virtual"
+msgstr ""
+
+#: cp/decl.c:10716
 msgid "return value type specifier for constructor ignored"
 msgstr ""
 
-#: cp/decl.c:10713
+#: cp/decl.c:10735
 #, c-format
 msgid "can't initialize friend function `%s'"
 msgstr ""
 
 #. Cannot be both friend and virtual.
-#: cp/decl.c:10717
+#: cp/decl.c:10739
 msgid "virtual functions cannot be friends"
 msgstr ""
 
-#: cp/decl.c:10722
+#: cp/decl.c:10744
 msgid "friend declaration not in class definition"
 msgstr ""
 
-#: cp/decl.c:10781
+#: cp/decl.c:10803
 #, c-format
 msgid "cannot declare %s to references"
 msgstr ""
 
-#: cp/decl.c:10807
+#: cp/decl.c:10829
 msgid "invalid type: `void &'"
 msgstr ""
 
+#: cp/decl.c:10880
+msgid "discarding `const' applied to a reference"
+msgstr ""
+
+#: cp/decl.c:10882
+msgid "discarding `volatile' applied to a reference"
+msgstr ""
+
 #. [dcl.fct.spec] The explicit specifier shall only be used in
 #. declarations of constructors within a class definition.
-#: cp/decl.c:11077
+#: cp/decl.c:11099
 msgid "only declarations of constructors can be `explicit'"
 msgstr ""
 
-#: cp/decl.c:11085
+#: cp/decl.c:11107
 #, c-format
 msgid "non-member `%s' cannot be declared `mutable'"
 msgstr ""
 
-#: cp/decl.c:11090
+#: cp/decl.c:11112
 #, c-format
 msgid "non-object member `%s' cannot be declared `mutable'"
 msgstr ""
 
-#: cp/decl.c:11096
+#: cp/decl.c:11118
 #, c-format
 msgid "function `%s' cannot be declared `mutable'"
 msgstr ""
 
-#: cp/decl.c:11101
+#: cp/decl.c:11123
 #, c-format
 msgid "static `%s' cannot be declared `mutable'"
 msgstr ""
 
-#: cp/decl.c:11106
+#: cp/decl.c:11128
 #, c-format
 msgid "const `%s' cannot be declared `mutable'"
 msgstr ""
 
-#: cp/decl.c:11226
+#: cp/decl.c:11248
 msgid "typedef declaration includes an initializer"
 msgstr ""
 
-#: cp/decl.c:11274
+#: cp/decl.c:11296
 #, c-format
 msgid "trying to make class `%s' a friend of global scope"
 msgstr ""
 
-#: cp/decl.c:11315
+#: cp/decl.c:11337
 msgid "unnamed variable or field declared void"
 msgstr ""
 
-#: cp/decl.c:11324
+#: cp/decl.c:11346
 msgid "variable or field declared void"
 msgstr ""
 
-#: cp/decl.c:11334
+#: cp/decl.c:11356
 msgid "cannot use `::' in parameter declaration"
 msgstr ""
 
-#: cp/decl.c:11352
+#: cp/decl.c:11374
 #, c-format
 msgid "declaration of `%s' as void"
 msgstr ""
 
-#: cp/decl.c:11531
+#: cp/decl.c:11553
 #, c-format
 msgid "`%s' is neither function nor member function; cannot be declared friend"
 msgstr ""
 
-#: cp/decl.c:11656
+#: cp/decl.c:11564
+msgid "member functions are implicitly friends of their class"
+msgstr ""
+
+#: cp/decl.c:11678
 #, c-format
 msgid "storage class `auto' invalid for function `%s'"
 msgstr ""
 
-#: cp/decl.c:11658
+#: cp/decl.c:11680
 #, c-format
 msgid "storage class `register' invalid for function `%s'"
 msgstr ""
 
-#: cp/decl.c:11678
+#: cp/decl.c:11691
+#, c-format
+msgid ""
+"storage class `static' invalid for function `%s' declared out of global scope"
+msgstr ""
+
+#: cp/decl.c:11693
+#, c-format
+msgid ""
+"storage class `inline' invalid for function `%s' declared out of global scope"
+msgstr ""
+
+#: cp/decl.c:11700
 #, c-format
 msgid "virtual non-class function `%s'"
 msgstr ""
 
 #. FIXME need arm citation
-#: cp/decl.c:11713
+#: cp/decl.c:11735
 msgid "cannot declare static function inside another function"
 msgstr ""
 
-#: cp/decl.c:11834
-msgid "parameter has incomplete type"
-msgstr ""
-
-#: cp/decl.c:12046
+#: cp/decl.c:12068
 msgid ""
 "invalid integer constant in parameter list, did you forget to give parameter "
 "name?"
 msgstr ""
 
-#: cp/decl.c:12073
+#: cp/decl.c:12095
 msgid "parameter invalidly declared method type"
 msgstr ""
 
-#: cp/decl.c:12083
+#: cp/decl.c:12105
 msgid "parameter invalidly declared offset type"
 msgstr ""
 
-#: cp/decl.c:12117
+#: cp/decl.c:12139
 msgid "`void' in parameter list must be entire list"
 msgstr ""
 
-#: cp/decl2.c:684
+#: cp/decl.c:12525
+#, c-format
+msgid "conversion to %s%s will never use a type conversion operator"
+msgstr ""
+
+#: cp/decl.c:13607
+msgid "return type for `main' changed to `int'"
+msgstr ""
+
+#: cp/decl2.c:640
+#, c-format
+msgid "-f%s is no longer supported"
+msgstr ""
+
+#: cp/decl2.c:646
+msgid ""
+"-fhandle-exceptions has been renamed to -fexceptions (and is now on by "
+"default)"
+msgstr ""
+
+#: cp/decl2.c:688
 msgid "no file specified with -fdump-translation-unit"
 msgstr ""
 
-#: cp/decl2.c:1063
+#: cp/decl2.c:1067
 msgid "name missing for member function"
 msgstr ""
 
-#: cp/decl2.c:1129
+#: cp/decl2.c:1133
 msgid "`__alignof__' applied to a bit-field"
 msgstr ""
 
 #. Something has gone very wrong.  Assume we are mistakenly reducing
 #. an expression instead of a declaration.
-#: cp/decl2.c:1171
+#: cp/decl2.c:1175
 msgid "parser may be lost: is there a '{' missing somewhere?"
 msgstr ""
 
-#: cp/decl2.c:1202 cp/decl2.c:1216
+#: cp/decl2.c:1206 cp/decl2.c:1220
 msgid "ambiguous conversion for array subscript"
 msgstr ""
 
-#: cp/decl2.c:1276
+#: cp/decl2.c:1270
+msgid "anachronistic use of array size in vector delete"
+msgstr ""
+
+#: cp/decl2.c:1280
 msgid ""
 "cannot delete a function.  Only pointer-to-objects are valid arguments to "
 "`delete'"
 msgstr ""
 
-#: cp/decl2.c:1597
+#: cp/decl2.c:1604
 msgid "initializer invalid for static member with constructor"
 msgstr ""
 
-#: cp/decl2.c:1599
+#: cp/decl2.c:1606
 msgid "(you really want to initialize it separately)"
 msgstr ""
 
-#: cp/decl2.c:1781
+#: cp/decl2.c:1788
 msgid "field initializer is not constant"
 msgstr ""
 
-#: cp/decl2.c:2153
+#: cp/decl2.c:2160
 msgid "anonymous struct not inside named type"
 msgstr ""
 
-#: cp/decl2.c:2244
+#: cp/decl2.c:2251
 msgid "namespace-scope anonymous aggregates must be static"
 msgstr ""
 
-#: cp/decl2.c:2319
+#: cp/decl2.c:2261
+msgid "anonymous aggregate with no members"
+msgstr ""
+
+#: cp/decl2.c:2327
 msgid "`operator new' must return type `void *'"
 msgstr ""
 
-#: cp/decl2.c:2324
+#: cp/decl2.c:2332
 msgid "`operator new' takes type `size_t' parameter"
 msgstr ""
 
-#: cp/decl2.c:2326
+#: cp/decl2.c:2334
 msgid "`operator new' takes type `size_t' as first parameter"
 msgstr ""
 
-#: cp/decl2.c:2351
+#: cp/decl2.c:2359
 msgid "`operator delete' must return type `void'"
 msgstr ""
 
-#: cp/decl2.c:2355
+#: cp/decl2.c:2363
 msgid "`operator delete' takes type `void *' as first parameter"
 msgstr ""
 
-#: cp/decl2.c:2366
+#: cp/decl2.c:2374
 msgid "second argument to `operator delete' must be of type `size_t'"
 msgstr ""
 
-#: cp/decl2.c:2371
+#: cp/decl2.c:2379
 msgid "too many arguments in declaration of `operator delete'"
 msgstr ""
 
-#: cp/decl2.c:2373
+#: cp/decl2.c:2381
 msgid "`...' invalid in specification of `operator delete'"
 msgstr ""
 
+#. Overflow occurred.  That means there are at least 4 billion
+#. initialization functions.
+#: cp/decl2.c:3071
+msgid "too many initialization functions required"
+msgstr ""
+
+#: cp/decl2.c:3865
+msgid "use of old-style cast"
+msgstr ""
+
+#: cp/error.c:464
+#, c-format
+msgid "`%s' not supported by dump_type"
+msgstr ""
+
+#: cp/error.c:665
+#, c-format
+msgid "`%s' not supported by dump_type_prefix"
+msgstr ""
+
+#: cp/error.c:756
+#, c-format
+msgid "`%s' not supported by dump_type_suffix"
+msgstr ""
+
+#: cp/error.c:1022
+#, c-format
+msgid "`%s' not supported by dump_decl"
+msgstr ""
+
+#: cp/error.c:2029
+#, c-format
+msgid "`%s' not supported by dump_expr"
+msgstr ""
+
 #: cp/except.c:503
 msgid "call to Java `catch' or `throw', while `jthrowable' undefined"
 msgstr ""
@@ -2907,28 +6552,64 @@ msgstr ""
 msgid "pointers are not permitted as case values"
 msgstr ""
 
+#: cp/expr.c:219
+msgid "ISO C++ forbids range expressions in switch statement"
+msgstr ""
+
 #: cp/expr.c:255
 msgid "duplicate (or overlapping) case value"
 msgstr ""
 
+#: cp/expr.c:273
+msgid "empty range specified"
+msgstr ""
+
 #: cp/expr.c:279
 msgid "`default' label within scope of cleanup or variable array"
 msgstr ""
 
+#: cp/friend.c:220
+#, c-format
+msgid "class `%s' is implicitly friends with itself"
+msgstr ""
+
+#: cp/friend.c:403
+msgid "  declares a non-template function"
+msgstr ""
+
+#: cp/friend.c:406
+msgid ""
+"  (if this is not what you intended, make sure the function template has "
+"already been declared and add <> after the function name here) "
+"-Wno-non-template-friend disables this warning."
+msgstr ""
+
 #: cp/g++spec.c:195
 #, c-format
 msgid "argument to `%s' missing\n"
 msgstr ""
 
-#: cp/init.c:1034
+#: cp/init.c:286
+msgid "initializer list treated as compound expression"
+msgstr ""
+
+#: cp/init.c:401
+msgid "  will be re-ordered to match declaration order"
+msgstr ""
+
+#: cp/init.c:635
+msgid "  will be re-ordered to match inheritance order"
+msgstr ""
+
+#: cp/init.c:1064
 msgid "base class initializer specified, but no base class to initialize"
 msgstr ""
 
-#: cp/init.c:1040
+#: cp/init.c:1070
 msgid "initializer for unnamed base class ambiguous"
 msgstr ""
 
-#: cp/init.c:1067
+#: cp/init.c:1095
 msgid "no base class to initialize"
 msgstr ""
 
@@ -2944,52 +6625,76 @@ msgstr ""
 #. COMPLEX zees(1.0, 0.0)[10];
 #. }
 #.
-#: cp/init.c:1204
+#: cp/init.c:1212
 msgid "bad array initializer"
 msgstr ""
 
-#: cp/init.c:1786
+#: cp/init.c:1802
 msgid "object missing in use of pointer-to-member construct"
 msgstr ""
 
-#: cp/init.c:1829 cp/typeck.c:3125 cp/typeck.c:3227
+#: cp/init.c:1845 cp/typeck.c:3126 cp/typeck.c:3228
 msgid "at this point in file"
 msgstr ""
 
-#: cp/init.c:2013
+#: cp/init.c:2029
 msgid "new of array type fails to specify size"
 msgstr ""
 
-#: cp/init.c:2095
+#: cp/init.c:2040
+msgid "size in array new must have integral type"
+msgstr ""
+
+#: cp/init.c:2046
+msgid "zero size array reserves no space"
+msgstr ""
+
+#: cp/init.c:2111
 msgid "new cannot be applied to a reference type"
 msgstr ""
 
-#: cp/init.c:2101
+#: cp/init.c:2117
 msgid "new cannot be applied to a function type"
 msgstr ""
 
-#: cp/init.c:2148
+#: cp/init.c:2164
 msgid "call to Java constructor, while `jclass' undefined"
 msgstr ""
 
-#: cp/init.c:2260
+#: cp/init.c:2276
 msgid "invalid type `void' for new"
 msgstr ""
 
-#: cp/init.c:2316
+#: cp/init.c:2332
 #, c-format
 msgid "call to Java constructor, while `%s' undefined"
 msgstr ""
 
-#: cp/init.c:2910
+#: cp/init.c:2465 cp/typeck2.c:449 cp/typeck2.c:1256
+msgid "initializer list being treated as compound expression"
+msgstr ""
+
+#: cp/init.c:2468
+msgid "initializer list appears where operand should be used"
+msgstr ""
+
+#: cp/init.c:2912
+msgid "initialization of array from dissimilar array type"
+msgstr ""
+
+#: cp/init.c:2926
 msgid "initializer ends prematurely"
 msgstr ""
 
-#: cp/init.c:3173
+#: cp/init.c:2995
+msgid "cannot initialize multi-dimensional array with initializer"
+msgstr ""
+
+#: cp/init.c:3189
 msgid "unknown array size in delete"
 msgstr ""
 
-#: cp/init.c:3393
+#: cp/init.c:3409
 msgid "type to vector delete is neither pointer or array type"
 msgstr ""
 
@@ -3009,194 +6714,327 @@ msgstr ""
 msgid "type name expected before `&'"
 msgstr ""
 
-#: cp/lex.c:1140 cp/lex.c:1698
+#: cp/lex.c:1134 cp/lex.c:1692
 msgid "parse error at end of saved function text"
 msgstr ""
 
-#: cp/lex.c:1192
+#: cp/lex.c:1186
 msgid "end of file encountered inside string constant"
 msgstr ""
 
-#: cp/lex.c:1194
+#: cp/lex.c:1188
 msgid "end of file encountered inside character constant"
 msgstr ""
 
-#: cp/lex.c:1400
+#: cp/lex.c:1205 cp/lex.c:4413
+msgid "ISO C++ forbids newline in string constant"
+msgstr ""
+
+#: cp/lex.c:1394
 msgid "parse error in method specification"
 msgstr ""
 
-#: cp/lex.c:1493
+#: cp/lex.c:1487
 msgid "function body for constructor missing"
 msgstr ""
 
-#: cp/lex.c:1784
+#: cp/lex.c:1778
 #, c-format
 msgid "semicolon missing after %s declaration"
 msgstr ""
 
-#: cp/lex.c:2363
+#: cp/lex.c:1827
+msgid ""
+"carriage return in source file (we only warn about the first carriage return)"
+msgstr ""
+
+#: cp/lex.c:2267
+msgid "badly nested C headers from preprocessor"
+msgstr ""
+
+#: cp/lex.c:2357
 msgid "invalid #pragma vtable"
 msgstr ""
 
-#: cp/lex.c:2382
+#: cp/lex.c:2367 cp/lex.c:2381
+msgid "trailing characters ignored"
+msgstr ""
+
+#: cp/lex.c:2376
 msgid "invalid #pragma unit"
 msgstr ""
 
-#: cp/lex.c:2403
+#: cp/lex.c:2397
 msgid "invalid `#pragma interface'"
 msgstr ""
 
-#: cp/lex.c:2430
+#: cp/lex.c:2405
+msgid "garbage after `#pragma interface' ignored"
+msgstr ""
+
+#: cp/lex.c:2424
 msgid "invalid `#pragma implementation'"
 msgstr ""
 
-#: cp/lex.c:2483
+#: cp/lex.c:2432
+msgid "garbage after `#pragma implementation' ignored"
+msgstr ""
+
+#: cp/lex.c:2477
 #, c-format
 msgid "non hex digit '%c' in universal-character-name"
 msgstr ""
 
-#: cp/lex.c:2509
+#: cp/lex.c:2491
+msgid "universal-character-name on EBCDIC target"
+msgstr ""
+
+#: cp/lex.c:2503
 #, c-format
 msgid ""
 "universal-character-name designates `%c', part of the basic source character "
 "set"
 msgstr ""
 
-#: cp/lex.c:2512
+#: cp/lex.c:2506
 msgid "invalid universal-character-name"
 msgstr ""
 
-#: cp/lex.c:2542
+#: cp/lex.c:2536
 #, c-format
 msgid "universal-character-name `\\U%08x' not valid in identifier"
 msgstr ""
 
-#: cp/lex.c:2788
+#: cp/lex.c:2782
 #, c-format
 msgid "universal-character-name `\\u%04x' not valid in identifier"
 msgstr ""
 
-#: cp/lex.c:2872 cppexp.c:685
-msgid "\\x used with no following hex digits"
+#: cp/lex.c:2928
+#, c-format
+msgid "non-ISO-standard escape sequence, `\\%c'"
 msgstr ""
 
-#: cp/lex.c:2968
+#: cp/lex.c:2962
 #, c-format
 msgid "%s at end of saved text"
 msgstr ""
 
-#: cp/lex.c:3155
+#: cp/lex.c:3149
 msgid ""
 "(Each undeclared identifier is reported only once for each function it "
 "appears in.)"
 msgstr ""
 
-#: cp/lex.c:3192
+#: cp/lex.c:3172
+#, c-format
+msgid "name lookup of `%s' changed"
+msgstr ""
+
+#: cp/lex.c:3186 cp/lex.c:3193
 #, c-format
 msgid "name lookup of `%s' changed for new ISO `for' scoping"
 msgstr ""
 
-#: cp/lex.c:4188
+#: cp/lex.c:3387 cp/lex.c:4100
+msgid "ISO C++ forbids imaginary numeric constants"
+msgstr ""
+
+#: cp/lex.c:3614
+msgid "universal characters in identifiers"
+msgstr ""
+
+#: cp/lex.c:3746
+#, c-format
+msgid "identifier name `%s' conflicts with GNU C++ internal naming strategy"
+msgstr ""
+
+#: cp/lex.c:4090
+msgid "ISO C++ forbids long long integer constants"
+msgstr ""
+
+#: cp/lex.c:4182
 msgid "complex integer constant is too wide for `__complex int'"
 msgstr ""
 
-#: cp/lex.c:4345 cppexp.c:312
+#: cp/lex.c:4251
+msgid "ISO C++ forbids newline in character constant"
+msgstr ""
+
+#: cp/lex.c:4339 cppexp.c:312
 msgid "malformatted character constant"
 msgstr ""
 
-#: cp/method.c:1941
+#: cp/lex.c:4627
+#, c-format
+msgid "use of `operator %s' is not standard C++"
+msgstr ""
+
+#: cp/method.c:906
+#, c-format
+msgid "conversion of %s as template parameter"
+msgstr ""
+
+#: cp/method.c:1935
+msgid "methods cannot be converted to function pointers"
+msgstr ""
+
+#: cp/method.c:1940
 #, c-format
 msgid "ambiguous request for method pointer `%s'"
 msgstr ""
 
-#: cp/method.c:2049
+#: cp/method.c:2048
 #, c-format
 msgid "request for member `%s' is ambiguous in multiple inheritance lattice"
 msgstr ""
 
-#: parse.y:652
+#: parse.y:654
 msgid "invalid default template argument"
 msgstr ""
 
-#: parse.y:857
-msgid "no base initializers given following ':'"
+#: parse.y:859
+msgid "no base or member initializers given following ':'"
 msgstr ""
 
-#: parse.y:872
+#: parse.y:875
 msgid "base initializers not allowed for non-member functions"
 msgstr ""
 
-#: parse.y:874
+#: parse.y:877
 msgid "only constructors take base initializers"
 msgstr ""
 
-#: parse.y:1062 parse.y:1071
+#: parse.y:910 parse.y:916
+msgid "anachronistic old style base class initializer"
+msgstr ""
+
+#. Handle `Class<Class<Type>>' without space in the `>>'
+#: parse.y:1041
+msgid "`>>' should be `> >' in template class name"
+msgstr ""
+
+#: parse.y:1092 parse.y:1101
 #, c-format
 msgid "ISO C++ forbids an empty condition for `%s'"
 msgstr ""
 
-#: parse.y:1885
+#: parse.y:1195
+msgid "ISO C++ forbids `&&'"
+msgstr ""
+
+#: parse.y:1280
+msgid "ISO C++ forbids initialization of new expression with `='"
+msgstr ""
+
+#: parse.y:1310
+msgid "ISO C++ forbids constructor-expressions"
+msgstr ""
+
+#: parse.y:1505
+msgid "ISO C++ forbids braced-groups within expressions"
+msgstr ""
+
+#: parse.y:1910 parse.y:1925
+msgid "sigof type specifier"
+msgstr ""
+
+#: parse.y:1915
 msgid "`sigof' applied to non-aggregate expression"
 msgstr ""
 
-#: parse.y:1900
+#: parse.y:1930
 msgid "`sigof' applied to non-aggregate type"
 msgstr ""
 
-#: parse.y:2233
+#: parse.y:2262
 #, c-format
 msgid "storage class specifier `%s' not allowed after struct or class"
 msgstr ""
 
-#: parse.y:2235
+#: parse.y:2264
 #, c-format
 msgid "type specifier `%s' not allowed after struct or class"
 msgstr ""
 
-#: parse.y:2237
+#: parse.y:2266
 #, c-format
 msgid "type qualifier `%s' not allowed after struct or class"
 msgstr ""
 
-#: parse.y:2239
+#: parse.y:2268
 msgid "no body nor ';' separates two class, struct or union declarations"
 msgstr ""
 
-#: parse.y:2402
+#: parse.y:2431
 msgid "multiple access specifiers"
 msgstr ""
 
-#: parse.y:2420
+#: parse.y:2449
 msgid "multiple `virtual' specifiers"
 msgstr ""
 
-#: parse.y:2453
+#: parse.y:2482
 msgid "missing ';' before right brace"
 msgstr ""
 
-#: parse.y:3333
+#: parse.y:2703
+msgid "ISO C++ forbids array dimensions with parenthesized type in new"
+msgstr ""
+
+#: parse.y:3208
+msgid "ISO C++ forbids label declarations"
+msgstr ""
+
+#: parse.y:3361
+msgid "ISO C++ forbids computed gotos"
+msgstr ""
+
+#: parse.y:3368
 msgid "label must be followed by statement"
 msgstr ""
 
+#: parse.y:3461
+msgid "ISO C++ forbids compound statements inside for initializations"
+msgstr ""
+
 #. This helps us recover from really nasty
 #. parse errors, for example, a missing right
 #. parenthesis.
-#: parse.y:3509 parse.y:3519
+#: parse.y:3544 parse.y:3554
 msgid "possibly missing ')'"
 msgstr ""
 
-#: parse.y:3616 parse.y:3621
+#: parse.y:3651 parse.y:3656
 msgid "type specifier omitted for parameter"
 msgstr ""
 
-#: cp/pt.c:1828
+#: cp/pt.c:1831
 msgid "  a template type parameter must begin with `class' or `typename'"
 msgstr ""
 
-#: cp/pt.c:7936
+#: cp/pt.c:6250
+msgid "creating array with size zero"
+msgstr ""
+
+#: cp/pt.c:6750
+#, c-format
+msgid "use of `%s' in template"
+msgstr ""
+
+#: cp/pt.c:7886
 msgid "incomplete type unification"
 msgstr ""
 
+#: cp/pt.c:8726
+#, c-format
+msgid "use of `%s' in template type unification"
+msgstr ""
+
+#: cp/repo.c:262
+msgid "-frepo must be used with -c"
+msgstr ""
+
 #: cp/repo.c:355
 #, c-format
 msgid "mysterious repository information in %s"
@@ -3215,107 +7053,276 @@ msgstr ""
 msgid "cannot use typeid with -fno-rtti"
 msgstr ""
 
-#: cp/rtti.c:298 cp/rtti.c:498
+#: cp/rtti.c:298 cp/rtti.c:499
 msgid "must #include <typeinfo> before using typeid"
 msgstr ""
 
-#: cp/tree.c:214
+#: cp/search.c:2027
+msgid "adjusting pointers for covariant returns"
+msgstr ""
+
+#. This shouldn't happen, I don't want errors!
+#: cp/search.c:2545
+msgid "recoverable compiler error, fixups for virtual function"
+msgstr ""
+
+#: cp/spew.c:351
+msgid "keyword 'export' not implemented and will be ignored"
+msgstr ""
+
+#: cp/tree.c:215
 #, c-format
 msgid "non-lvalue in %s"
 msgstr ""
 
-#: cp/tree.c:2158
+#: cp/tree.c:2202
 msgid "`com_interface' only supported with -fvtable-thunks"
 msgstr ""
 
-#: cp/tree.c:2184
+#: cp/tree.c:2211
+msgid "`com_interface' attribute can only be applied to class definitions"
+msgstr ""
+
+#: cp/tree.c:2228
 msgid "requested init_priority is not an integer constant"
 msgstr ""
 
-#: cp/tree.c:2205
+#: cp/tree.c:2249
 msgid ""
 "can only use init_priority attribute on file-scope definitions of objects of "
 "class type"
 msgstr ""
 
-#: cp/tree.c:2211
+#: cp/tree.c:2255
 msgid "requested init_priority is out of range"
 msgstr ""
 
-#: cp/typeck.c:1602
+#: cp/tree.c:2264
+msgid "requested init_priority is reserved for internal use"
+msgstr ""
+
+#: cp/typeck.c:449 cp/typeck.c:455
+#, c-format
+msgid ""
+"ISO C++ forbids %s between pointer of type `void *' and pointer-to-function"
+msgstr ""
+
+#: cp/typeck.c:1553
+msgid "ISO C++ forbids applying `sizeof' to a function type"
+msgstr ""
+
+#: cp/typeck.c:1559
+msgid "ISO C++ forbids applying `sizeof' to a member function"
+msgstr ""
+
+#: cp/typeck.c:1565
+msgid ""
+"ISO C++ forbids applying `sizeof' to type `void' which is an incomplete type"
+msgstr ""
+
+#: cp/typeck.c:1603
 msgid "sizeof applied to a bit-field"
 msgstr ""
 
-#: cp/typeck.c:2200
+#: cp/typeck.c:1606
+msgid "ISO C++ forbids applying `sizeof' to an expression of function type"
+msgstr ""
+
+#: cp/typeck.c:2201
 msgid "invalid reference to NULL ptr, use ptr-to-member instead"
 msgstr ""
 
-#: cp/typeck.c:2364
+#: cp/typeck.c:2365
 #, c-format
 msgid "invalid use of `%s' on pointer to member"
 msgstr ""
 
-#: cp/typeck.c:2370
+#: cp/typeck.c:2371
 msgid "invalid type argument"
 msgstr ""
 
-#: cp/typeck.c:2637 cp/typeck.c:2777
+#: cp/typeck.c:2452
+msgid "ISO C++ forbids subscripting non-lvalue array"
+msgstr ""
+
+#: cp/typeck.c:2463
+msgid "subscripting array declared `register'"
+msgstr ""
+
+#: cp/typeck.c:2638 cp/typeck.c:2778
 msgid "pointer to member function called, but not in class scope"
 msgstr ""
 
-#: cp/typeck.c:2775
+#: cp/typeck.c:2776
 msgid ""
 "invalid call to member function needing `this' in static member function "
 "scope"
 msgstr ""
 
-#: cp/typeck.c:3164
+#: cp/typeck.c:2962
+msgid "ISO C++ forbids calling `::main' from within program"
+msgstr ""
+
+#: cp/typeck.c:3165
 msgid "parameter type of called function is incomplete"
 msgstr ""
 
-#: cp/typeck.c:3613 cp/typeck.c:3618
+#: cp/typeck.c:3555
+#, c-format
+msgid "%s rotate count is negative"
+msgstr ""
+
+#: cp/typeck.c:3558
+#, c-format
+msgid "%s rotate count >= width of type"
+msgstr ""
+
+#: cp/typeck.c:3590 cp/typeck.c:3598
+msgid "ISO C++ forbids comparison of `void *' with function pointer"
+msgstr ""
+
+#: cp/typeck.c:3592
+msgid "ISO C++ forbids conversion of a pointer to member to `void *'"
+msgstr ""
+
+#: cp/typeck.c:3614 cp/typeck.c:3619 cp/typeck.c:3763 cp/typeck.c:3768
 msgid "ISO C++ forbids comparison between pointer and integer"
 msgstr ""
 
-#: cp/typeck.c:4227
+#: cp/typeck.c:3983
+msgid "comparison between a signed and an unsigned integer expressions"
+msgstr ""
+
+#: cp/typeck.c:4122
+msgid "ISO C++ forbids using pointer of type `void *' in pointer arithmetic"
+msgstr ""
+
+#: cp/typeck.c:4128
+msgid "ISO C++ forbids using a pointer-to-function in pointer arithmetic"
+msgstr ""
+
+#: cp/typeck.c:4134
+msgid ""
+"ISO C++ forbids using a pointer to member function in pointer arithmetic"
+msgstr ""
+
+#: cp/typeck.c:4140
+msgid "ISO C++ forbids using pointer to a member in pointer arithmetic"
+msgstr ""
+
+#: cp/typeck.c:4211
+msgid "ISO C++ forbids using pointer of type `void *' in subtraction"
+msgstr ""
+
+#: cp/typeck.c:4213
+msgid "ISO C++ forbids using pointer to a function in subtraction"
+msgstr ""
+
+#: cp/typeck.c:4215
+msgid "ISO C++ forbids using pointer to a method in subtraction"
+msgstr ""
+
+#: cp/typeck.c:4217
+msgid "ISO C++ forbids using pointer to a member in subtraction"
+msgstr ""
+
+#: cp/typeck.c:4228
 msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
 msgstr ""
 
-#: cp/typeck.c:4732
+#: cp/typeck.c:4321
+msgid "taking address of temporary"
+msgstr ""
+
+#: cp/typeck.c:4504
+#, c-format
+msgid "ISO C++ forbids %sing an enum"
+msgstr ""
+
+#: cp/typeck.c:4548
+msgid "cast to non-reference type used as lvalue"
+msgstr ""
+
+#. ARM $3.4
+#: cp/typeck.c:4626
+msgid "ISO C++ forbids taking address of function `::main'"
+msgstr ""
+
+#: cp/typeck.c:4717
+msgid "ISO C++ forbids taking the address of a cast to a non-lvalue expression"
+msgstr ""
+
+#: cp/typeck.c:4733
 msgid "unary `&'"
 msgstr ""
 
-#: cp/typeck.c:4954
+#: cp/typeck.c:4955
 msgid "cannot take the address of `this', which is an ravlue expression"
 msgstr ""
 
-#: cp/typeck.c:5404
+#: cp/typeck.c:5289
+msgid ""
+"ISO C++ forbids casting between pointer-to-function and pointer-to-object"
+msgstr ""
+
+#: cp/typeck.c:5400 cp/typeck.c:5405
 msgid "ISO C++ forbids casting to an array type"
 msgstr ""
 
-#: cp/typeck.c:5996
+#: cp/typeck.c:5732
+msgid "ISO C++ forbids cast to non-reference type used as lvalue"
+msgstr ""
+
+#: cp/typeck.c:5838
+msgid "ISO C++ forbids assignment of arrays"
+msgstr ""
+
+#: cp/typeck.c:5855
+msgid "return value from function receives multiple initializations"
+msgstr ""
+
+#: cp/typeck.c:5997
 msgid "   in pointer to member function conversion"
 msgstr ""
 
-#: cp/typeck.c:6004
+#: cp/typeck.c:6005
 msgid "   in pointer to member conversion"
 msgstr ""
 
-#: cp/typeck.c:6777
+#: cp/typeck.c:6719
+msgid "returning reference to temporary"
+msgstr ""
+
+#: cp/typeck.c:6726
+msgid "reference to non-lvalue returned"
+msgstr ""
+
+#: cp/typeck.c:6778
 msgid "returning a value from a destructor"
 msgstr ""
 
 #. If a return statement appears in a handler of the
 #. function-try-block of a constructor, the program is ill-formed.
-#: cp/typeck.c:6785
+#: cp/typeck.c:6786
 msgid "cannot return from a handler of a function-try-block of a constructor"
 msgstr ""
 
 #. You can't return a value from a constructor.
-#: cp/typeck.c:6790
+#: cp/typeck.c:6791
 msgid "returning a value from a constructor"
 msgstr ""
 
+#: cp/typeck.c:6811
+msgid ""
+"return-statement with no value, in function declared with a non-void return "
+"type"
+msgstr ""
+
+#: cp/typeck.c:6827
+msgid ""
+"return-statement with a value, in function declared with a void return type"
+msgstr ""
+
 #: cp/typeck2.c:172
 msgid "  since the following virtual functions are abstract:"
 msgstr ""
@@ -3346,10 +7353,18 @@ msgstr ""
 msgid "due to the presence of a constructor"
 msgstr ""
 
+#: cp/typeck2.c:431
+msgid "comma expression used to initialize return value"
+msgstr ""
+
 #: cp/typeck2.c:440
 msgid "cannot initialize arrays using this syntax"
 msgstr ""
 
+#: cp/typeck2.c:496
+msgid "ANSI C++ forbids non-constant aggregate initializer expressions"
+msgstr ""
+
 #: cp/typeck2.c:571
 msgid "initializing array with parameter list"
 msgstr ""
@@ -3358,14 +7373,38 @@ msgstr ""
 msgid "initializer for scalar variable requires one element"
 msgstr ""
 
+#: cp/typeck2.c:728
+msgid "aggregate has a partly bracketed initializer"
+msgstr ""
+
+#: cp/typeck2.c:758 cp/typeck2.c:859
+msgid "non-trivial labeled initializers"
+msgstr ""
+
 #: cp/typeck2.c:775
 msgid "non-empty initializer for array of empty elements"
 msgstr ""
 
+#: cp/typeck2.c:825
+msgid "initializer list for object of class with virtual base classes"
+msgstr ""
+
+#: cp/typeck2.c:831
+msgid "initializer list for object of class with base classes"
+msgstr ""
+
+#: cp/typeck2.c:837
+msgid "initializer list for object using virtual functions"
+msgstr ""
+
 #: cp/typeck2.c:947
 msgid "index value instead of field name in union initializer"
 msgstr ""
 
+#: cp/typeck2.c:1003
+msgid "excess elements in aggregate initializer"
+msgstr ""
+
 #: cp/typeck2.c:1106
 msgid "circular pointer delegation detected"
 msgstr ""
@@ -3388,6 +7427,11 @@ msgstr ""
 msgid "duplicate label (%d) in switch statement"
 msgstr ""
 
+#: cp/typeck2.c:1412
+#, c-format
+msgid "case value out of range for enum %s"
+msgstr ""
+
 #: cp/typeck2.c:1420
 #, c-format
 msgid "range values `%s' and `%s' reversed"
@@ -3397,6 +7441,11 @@ msgstr ""
 msgid "range values reversed"
 msgstr ""
 
+#: cp/typeck2.c:1439
+#, c-format
+msgid "ISO C++ forbids defining types within %s"
+msgstr ""
+
 #: cp/xref.c:833
 #, c-format
 msgid "Can't create cross-reference file `%s'"
@@ -3433,7 +7482,7 @@ msgstr ""
 msgid "<command line>: "
 msgstr ""
 
-#: cpperror.c:135
+#: cpperror.c:135 diagnostic.c:662
 msgid "warning: "
 msgstr ""
 
@@ -3479,14 +7528,6 @@ msgstr ""
 msgid "integer constant is so large that it is unsigned"
 msgstr ""
 
-#: cppexp.c:290
-msgid "escape sequence out of range for character"
-msgstr ""
-
-#: cppexp.c:321
-msgid "multi-character character constant"
-msgstr ""
-
 #: cppexp.c:386
 msgid "'defined' without an identifier"
 msgstr ""
@@ -3526,32 +7567,46 @@ msgstr ""
 msgid "comma operator in operand of #if"
 msgstr ""
 
-#: cppfiles.c:299
+#: cppfiles.c:166
 #, c-format
 msgid "included file `%s' exists but is not readable"
 msgstr ""
 
-#: cppfiles.c:562 cppfiles.c:615
+#: cppfiles.c:174
+#, c-format
+msgid "node for '%s' exists, open failed, error '%s', value %lx\n"
+msgstr ""
+
+#: cppfiles.c:321
+#, c-format
+msgid "cpp_make_system_header: bad flag %d\n"
+msgstr ""
+
+#: cppfiles.c:323
+msgid "cpp_make_system_header called on non-file buffer"
+msgstr ""
+
+#: cppfiles.c:353 cppfiles.c:431
 #, c-format
 msgid "No include path in which to find %s"
 msgstr ""
 
-#: cppfiles.c:733
+#: cppfiles.c:499
 #, c-format
 msgid "%s is too large"
 msgstr ""
 
-#: cppfiles.c:741
+#: cppfiles.c:507
 #, c-format
 msgid "%s is shorter than expected\n"
 msgstr ""
 
-#: cppfiles.c:745
+#: cppfiles.c:511
 #, c-format
 msgid "%s is a block device"
 msgstr ""
 
-#: cppfiles.c:750
+#: cppfiles.c:516
 #, c-format
 msgid "%s is a directory"
 msgstr ""
@@ -3696,111 +7751,111 @@ msgstr ""
 msgid "invalid hash type %d in dump_definition"
 msgstr ""
 
-#: cppinit.c:346
+#: cppinit.c:347
 #, c-format
 msgid "ignoring nonexistent directory `%s'\n"
 msgstr ""
 
-#: cppinit.c:352
+#: cppinit.c:353
 #, c-format
 msgid "%s: Not a directory"
 msgstr ""
 
-#: cppinit.c:443 cppinit.c:463 cppinit.c:482 cppinit.c:496
+#: cppinit.c:444 cppinit.c:464 cppinit.c:483 cppinit.c:497
 #, c-format
 msgid "ignoring duplicate directory `%s'\n"
 msgstr ""
 
-#: cppinit.c:875
+#: cppinit.c:876
 msgid "-MG must be specified with one of -M or -MM"
 msgstr ""
 
-#: cppinit.c:882
+#: cppinit.c:883
 msgid "-lang-chill and -trigraphs are mutually exclusive"
 msgstr ""
 
-#: cppinit.c:916
+#: cppinit.c:917
 msgid "#include \"...\" search starts here:\n"
 msgstr ""
 
-#: cppinit.c:920
+#: cppinit.c:921
 msgid "#include <...> search starts here:\n"
 msgstr ""
 
-#: cppinit.c:923
+#: cppinit.c:924
 msgid "End of search list.\n"
 msgstr ""
 
-#: cppinit.c:1016
+#: cppinit.c:1017
 msgid "buffers still stacked in cpp_finish"
 msgstr ""
 
-#: cppinit.c:1042
+#: cppinit.c:1043
 msgid "I/O error on output"
 msgstr ""
 
 #. Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
 #. I.e. a const string initializer with parens around it.  That is
 #. what N_("string") resolves to, so we make no_* be macros instead.
-#: cppinit.c:1077
+#: cppinit.c:1078
 #, c-format
 msgid "Argument missing after %s"
 msgstr ""
 
-#: cppinit.c:1078
+#: cppinit.c:1079
 #, c-format
 msgid "Assertion missing after %s"
 msgstr ""
 
-#: cppinit.c:1079
+#: cppinit.c:1080
 #, c-format
 msgid "Directory name missing after %s"
 msgstr ""
 
-#: cppinit.c:1080
+#: cppinit.c:1081
 #, c-format
 msgid "File name missing after %s"
 msgstr ""
 
-#: cppinit.c:1081
+#: cppinit.c:1082
 #, c-format
 msgid "Macro name missing after %s"
 msgstr ""
 
-#: cppinit.c:1082
+#: cppinit.c:1083
 #, c-format
 msgid "Path name missing after %s"
 msgstr ""
 
-#: cppinit.c:1083
+#: cppinit.c:1084
 #, c-format
 msgid "Number missing after %s"
 msgstr ""
 
-#: cppinit.c:1260
+#: cppinit.c:1261
 #, c-format
 msgid "Too many arguments. Type %s --help for usage info"
 msgstr ""
 
-#: cppinit.c:1342 cppinit.c:1505
+#: cppinit.c:1343 cppinit.c:1506
 #, c-format
 msgid "GNU CPP version %s (cpplib)\n"
 msgstr ""
 
-#: cppinit.c:1497
+#: cppinit.c:1498
 msgid "Output filename specified twice"
 msgstr ""
 
-#: cppinit.c:1633
+#: cppinit.c:1634
 msgid "-I- specified twice"
 msgstr ""
 
-#: cppinit.c:1792
+#: cppinit.c:1793
 #, c-format
 msgid "Usage: %s [switches] input output\n"
 msgstr ""
 
-#: cppinit.c:1793
+#: cppinit.c:1794
 msgid ""
 "Switches:\n"
 "  -include <file>           Include the contents of <file> before other "
@@ -3890,157 +7945,157 @@ msgstr ""
 msgid "mark active in cpp_pop_buffer"
 msgstr ""
 
-#: cpplex.c:439
+#: cpplex.c:446
 msgid "length < 0 in cpp_expand_to_buffer"
 msgstr ""
 
-#: cpplex.c:861 cpplex.c:2440
+#: cpplex.c:868 cpplex.c:2450
 msgid "'/*' within comment"
 msgstr ""
 
-#: cpplex.c:865 cpplex.c:3018
+#: cpplex.c:872 cpplex.c:3028
 msgid "unterminated comment"
 msgstr ""
 
-#: cpplex.c:895
+#: cpplex.c:902
 msgid "backslash-newline within line comment"
 msgstr ""
 
-#: cpplex.c:931
+#: cpplex.c:938
 msgid "C++ style comments are not allowed in traditional C"
 msgstr ""
 
-#: cpplex.c:934 cpplex.c:2974
+#: cpplex.c:941 cpplex.c:2984
 msgid "C++ style comments are not allowed in ISO C89"
 msgstr ""
 
-#: cpplex.c:938 cpplex.c:2976
+#: cpplex.c:945 cpplex.c:2986
 msgid "(this will be reported only once per input file)"
 msgstr ""
 
-#: cpplex.c:986 cpplex.c:2532
+#: cpplex.c:993 cpplex.c:2542
 msgid "embedded null character ignored"
 msgstr ""
 
-#: cpplex.c:988 cpplex.c:2531
+#: cpplex.c:995 cpplex.c:2541
 msgid "embedded null characters ignored"
 msgstr ""
 
-#: cpplex.c:1008 cpplex.c:1076 cpplex.c:2523
+#: cpplex.c:1015 cpplex.c:1083 cpplex.c:2533
 #, c-format
 msgid "%s in preprocessing directive"
 msgstr ""
 
-#: cpplex.c:1132
+#: cpplex.c:1142
 msgid "unterminated string or character constant"
 msgstr ""
 
-#: cpplex.c:1137
+#: cpplex.c:1147
 msgid "possible real start of unterminated constant"
 msgstr ""
 
-#: cpplex.c:1163
+#: cpplex.c:1173
 msgid "unterminated character constant"
 msgstr ""
 
-#: cpplex.c:1169
+#: cpplex.c:1179
 msgid "string constant runs past end of line"
 msgstr ""
 
-#: cpplex.c:1177
+#: cpplex.c:1187
 msgid "\\r escape inside string constant"
 msgstr ""
 
-#: cpplex.c:1199
+#: cpplex.c:1209
 msgid "null character in string or character constant"
 msgstr ""
 
-#: cpplex.c:1201
+#: cpplex.c:1211
 msgid "null characters in string or character constant"
 msgstr ""
 
-#: cpplex.c:1385
+#: cpplex.c:1395
 msgid "missing '>' in `#include <FILENAME>'"
 msgstr ""
 
-#: cpplex.c:1402 cpplex.c:1587
+#: cpplex.c:1412 cpplex.c:1597
 #, c-format
 msgid "unrecognized escape \\r%c"
 msgstr ""
 
-#: cpplex.c:1704
+#: cpplex.c:1714
 #, c-format
 msgid "function macro %s must be used with arguments in traditional C"
 msgstr ""
 
-#: cpplex.c:1730
+#: cpplex.c:1740
 msgid "vertical tab in preprocessing directive"
 msgstr ""
 
-#: cpplex.c:1732
+#: cpplex.c:1742
 msgid "form feed in preprocessing directive"
 msgstr ""
 
-#: cpplex.c:2094 cpplex.c:2321
+#: cpplex.c:2104 cpplex.c:2331
 #, c-format
 msgid "trigraph ??%c converted to %c"
 msgstr ""
 
-#: cpplex.c:2097 cpplex.c:2325
+#: cpplex.c:2107 cpplex.c:2335
 #, c-format
 msgid "trigraph ??%c ignored"
 msgstr ""
 
-#: cpplex.c:2132 cpplex.c:3287
+#: cpplex.c:2142 cpplex.c:3297
 msgid "no newline at end of file"
 msgstr ""
 
-#: cpplex.c:2562
+#: cpplex.c:2572
 msgid "'$' character in identifier"
 msgstr ""
 
-#: cpplex.c:2714
+#: cpplex.c:2724
 msgid "multi-line string constant"
 msgstr ""
 
-#: cpplex.c:2752
+#: cpplex.c:2762
 #, c-format
 msgid "missing terminating %c character"
 msgstr ""
 
-#: cpplex.c:2758
+#: cpplex.c:2768
 msgid "possible start of unterminated string literal"
 msgstr ""
 
-#: cpplex.c:2768
+#: cpplex.c:2778
 msgid "null characters preserved"
 msgstr ""
 
-#: cpplex.c:2769
+#: cpplex.c:2779
 msgid "null character preserved"
 msgstr ""
 
-#: cpplex.c:2983
+#: cpplex.c:2993
 msgid "comment start split across lines"
 msgstr ""
 
-#: cpplex.c:2987
+#: cpplex.c:2997
 msgid "multi-line comment"
 msgstr ""
 
-#: cpplex.c:3015
+#: cpplex.c:3025
 msgid "comment start '/*' split across lines"
 msgstr ""
 
-#: cpplex.c:3021
+#: cpplex.c:3031
 msgid "comment end '*/' split across lines"
 msgstr ""
 
-#: cpplex.c:3071
+#: cpplex.c:3081
 msgid "backslash and newline separated by space"
 msgstr ""
 
-#: cpplex.c:3359
+#: cpplex.c:3369
 msgid "Unspellable token"
 msgstr ""
 
@@ -4054,202 +8109,202 @@ msgstr ""
 
 #: cpplib.c:247
 #, c-format
-msgid "invalid preprocessing directive #%s"
+msgid "invalid preprocessing directive #%.*s"
 msgstr ""
 
-#: cpplib.c:266
+#: cpplib.c:267
 #, c-format
 msgid "ignoring #%s because of its indented #"
 msgstr ""
 
-#: cpplib.c:276
+#: cpplib.c:277
 #, c-format
 msgid "#%s may not be used inside a macro argument"
 msgstr ""
 
-#: cpplib.c:284
+#: cpplib.c:285
 #, c-format
 msgid "ISO C does not allow #%s"
 msgstr ""
 
-#: cpplib.c:291
+#: cpplib.c:292
 #, c-format
 msgid "traditional C ignores #%s with the # indented"
 msgstr ""
 
-#: cpplib.c:295
+#: cpplib.c:296
 #, c-format
 msgid "suggest hiding #%s from traditional C with an indented #"
 msgstr ""
 
-#: cpplib.c:357
+#: cpplib.c:358
 msgid "#define must be followed by an identifier"
 msgstr ""
 
-#: cpplib.c:369
+#: cpplib.c:370
 msgid "\"defined\" is not a legal macro name"
 msgstr ""
 
-#: cpplib.c:378
+#: cpplib.c:379
 #, c-format
 msgid "redefining poisoned `%.*s'"
 msgstr ""
 
-#: cpplib.c:416
+#: cpplib.c:417
 #, c-format
 msgid "#%s expects \"FILENAME\" or <FILENAME>"
 msgstr ""
 
-#: cpplib.c:424
+#: cpplib.c:425
 #, c-format
 msgid "junk at end of #%s"
 msgstr ""
 
-#: cpplib.c:431
+#: cpplib.c:432
 #, c-format
 msgid "empty file name in #%s"
 msgstr ""
 
-#: cpplib.c:469
+#: cpplib.c:470
 msgid "#import is obsolete, use an #ifndef wrapper in the header file"
 msgstr ""
 
-#: cpplib.c:514
+#: cpplib.c:515
 msgid "#include_next in primary source file"
 msgstr ""
 
-#: cpplib.c:545
+#: cpplib.c:546
 msgid "invalid format #line"
 msgstr ""
 
-#: cpplib.c:569 cpplib.c:578
+#: cpplib.c:570 cpplib.c:579
 msgid "token after #line is not an integer"
 msgstr ""
 
-#: cpplib.c:584
+#: cpplib.c:585
 msgid "line number out of range in #line"
 msgstr ""
 
-#: cpplib.c:597
+#: cpplib.c:598
 msgid "garbage at end of #line"
 msgstr ""
 
-#: cpplib.c:638
+#: cpplib.c:639
 msgid "second token after #line is not a string"
 msgstr ""
 
-#: cpplib.c:674
+#: cpplib.c:675
 msgid "token after #undef is not an identifier"
 msgstr ""
 
-#: cpplib.c:683
+#: cpplib.c:684
 msgid "junk on line after #undef"
 msgstr ""
 
-#: cpplib.c:694
+#: cpplib.c:695
 #, c-format
 msgid "cannot undefine poisoned \"%s\""
 msgstr ""
 
-#: cpplib.c:704
+#: cpplib.c:705
 #, c-format
 msgid "undefining `%s'"
 msgstr ""
 
-#: cpplib.c:730
+#: cpplib.c:731
 #, c-format
 msgid "#error %.*s"
 msgstr ""
 
-#: cpplib.c:750
+#: cpplib.c:751
 #, c-format
 msgid "#warning %.*s"
 msgstr ""
 
-#: cpplib.c:845
+#: cpplib.c:876
 msgid "malformed #pragma directive"
 msgstr ""
 
-#: cpplib.c:871
+#: cpplib.c:923
 msgid "#pragma once is obsolete"
 msgstr ""
 
-#: cpplib.c:874
+#: cpplib.c:926
 msgid "#pragma once outside include file"
 msgstr ""
 
-#: cpplib.c:898
+#: cpplib.c:950
 msgid "malformed #pragma implementation"
 msgstr ""
 
-#: cpplib.c:911
+#: cpplib.c:963
 #, c-format
 msgid "#pragma implementation for %s appears after file is included"
 msgstr ""
 
-#: cpplib.c:943
+#: cpplib.c:995
 msgid "invalid #pragma poison directive"
 msgstr ""
 
-#: cpplib.c:956
+#: cpplib.c:1008
 #, c-format
 msgid "poisoning existing macro `%s'"
 msgstr ""
 
-#: cpplib.c:978
+#: cpplib.c:1030
 msgid "#pragma system_header outside include file"
 msgstr ""
 
-#: cpplib.c:1094
+#: cpplib.c:1146
 #, c-format
 msgid "#%s with no argument"
 msgstr ""
 
-#: cpplib.c:1104
+#: cpplib.c:1156
 #, c-format
 msgid "#%s with invalid argument"
 msgstr ""
 
-#: cpplib.c:1112
+#: cpplib.c:1164
 #, c-format
 msgid "garbage at end of #%s"
 msgstr ""
 
-#: cpplib.c:1130 cpplib.c:1151 cpplib.c:1611
+#: cpplib.c:1184 cpplib.c:1208 cpplib.c:1668
 #, c-format
 msgid "attempt to use poisoned `%s'"
 msgstr ""
 
-#: cpplib.c:1193
+#: cpplib.c:1250
 msgid "#else without #if"
 msgstr ""
 
-#: cpplib.c:1198
+#: cpplib.c:1255
 msgid "#else after #else"
 msgstr ""
 
-#: cpplib.c:1199 cpplib.c:1236
+#: cpplib.c:1256 cpplib.c:1293
 msgid "the conditional began here"
 msgstr ""
 
-#: cpplib.c:1230
+#: cpplib.c:1287
 msgid "#elif without #if"
 msgstr ""
 
-#: cpplib.c:1235
+#: cpplib.c:1292
 msgid "#elif after #else"
 msgstr ""
 
-#: cpplib.c:1265
+#: cpplib.c:1322
 msgid "#endif without #if"
 msgstr ""
 
-#: cpplib.c:1315
+#: cpplib.c:1372
 #, c-format
 msgid "ISO C forbids text after #%s"
 msgstr ""
 
-#: cpplib.c:1334
+#: cpplib.c:1391
 #, c-format
 msgid "unterminated #%s"
 msgstr ""
@@ -4273,6 +8328,94 @@ msgstr ""
 msgid ";; Processing block from %d to %d, %d sets.\n"
 msgstr ""
 
+#: diagnostic.c:518
+#, c-format
+msgid "%s:%d: warning: "
+msgstr ""
+
+#: diagnostic.c:520
+#, c-format
+msgid "%s:%d: "
+msgstr ""
+
+#: diagnostic.c:525
+#, c-format
+msgid "%s: warning: "
+msgstr ""
+
+#: diagnostic.c:527 diagnostic.c:1213
+#, c-format
+msgid "%s: "
+msgstr ""
+
+#: diagnostic.c:723
+#, c-format
+msgid "%.*s"
+msgstr ""
+
+#: diagnostic.c:1018
+msgid "sorry, not implemented: "
+msgstr ""
+
+#: diagnostic.c:1041
+#, c-format
+msgid "%s: warnings being treated as errors\n"
+msgstr ""
+
+#: diagnostic.c:1088
+#, c-format
+msgid "%s: %s: I/O error\n"
+msgstr ""
+
+#: diagnostic.c:1190
+#, c-format
+msgid " %s"
+msgstr ""
+
+#: diagnostic.c:1227 diagnostic.c:1229
+msgid "At top level:\n"
+msgstr ""
+
+#: diagnostic.c:1237 diagnostic.c:1240
+#, c-format
+msgid "In method `%s':\n"
+msgstr ""
+
+#: diagnostic.c:1247 diagnostic.c:1250
+#, c-format
+msgid "In function `%s':\n"
+msgstr ""
+
+#: diagnostic.c:1285
+#, c-format
+msgid "In file included from %s:%d"
+msgstr ""
+
+#: diagnostic.c:1287
+#, c-format
+msgid ""
+",\n"
+"                 from %s:%d"
+msgstr ""
+
+#: diagnostic.c:1424
+msgid "Unrecognizable insn:"
+msgstr ""
+
+#: diagnostic.c:1426
+msgid "Insn does not satisfy its constraints:"
+msgstr ""
+
+#: dwarf2out.c:2874
+#, c-format
+msgid "DW_LOC_OP %s not implememnted yet.\n"
+msgstr ""
+
+#: dwarf2out.c:6501 dwarfout.c:1644
+#, c-format
+msgid "internal regno botch: regno = %d\n"
+msgstr ""
+
 #: emit-rtl.c:963
 msgid ""
 "Unable to access real part of complex value in a hard register on this target"
@@ -4284,6 +8427,14 @@ msgid ""
 "target"
 msgstr ""
 
+#: emit-rtl.c:2477
+msgid "ICE: emit_insn used where emit_jump_insn needed:\n"
+msgstr ""
+
+#: except.c:776
+msgid "additional handler after ..."
+msgstr ""
+
 #: except.c:954
 msgid "Cannot duplicate non-existant exception region."
 msgstr ""
@@ -4296,6 +8447,11 @@ msgstr ""
 msgid "Never issued previous false_label"
 msgstr ""
 
+#: except.c:2532
+#, c-format
+msgid "Counted %d copies of EH region %d in list.\n"
+msgstr ""
+
 #: except.c:3074
 msgid "Duplicate call to __builtin_eh_return"
 msgstr ""
@@ -4304,95 +8460,155 @@ msgstr ""
 msgid "function uses __builtin_eh_return"
 msgstr ""
 
-#: explow.c:1451
+#: explow.c:1459
 msgid "stack limits not supported on this target"
 msgstr ""
 
-#: expr.c:2682
+#: expr.c:2699
 msgid "function using short complex types cannot be inline"
 msgstr ""
 
-#: expr.c:5643 expr.c:5652 expr.c:5661 expr.c:5666 expr.c:5845 expr.c:5860
+#: expr.c:5669 expr.c:5678 expr.c:5687 expr.c:5692 expr.c:5871 expr.c:5886
 msgid "unsupported wide integer operation"
 msgstr ""
 
-#: final.c:3367
+#: expr.c:5939
+#, c-format
+msgid "prior parameter's size depends on `%s'"
+msgstr ""
+
+#: expr.c:6337
+msgid "returned value in block_exit_expr"
+msgstr ""
+
+#: final.c:3382
+#, c-format
+msgid "invalid `asm': %s"
+msgstr ""
+
+#: final.c:3385
 #, c-format
 msgid "output_operand: %s"
 msgstr ""
 
-#: final.c:3507
+#: final.c:3525
 #, c-format
 msgid "operand number missing after %-letter"
 msgstr ""
 
-#: final.c:3509 final.c:3542
+#: final.c:3527 final.c:3560
 msgid "operand number out of range"
 msgstr ""
 
-#: final.c:3555
+#: final.c:3573
 #, ycp-format
 msgid "invalid %%-code"
 msgstr ""
 
-#: final.c:3582
+#: final.c:3600
 msgid "`%l' operand isn't a label"
 msgstr ""
 
-#: flow.c:6338
+#: flow.c:3435
+msgid "ICE: would have deleted prologue/epilogue insn"
+msgstr ""
+
+#: flow.c:6365
 #, c-format
 msgid "Head insn %d for block %d not found in the insn stream."
 msgstr ""
 
-#: flow.c:6349
+#: flow.c:6376
 #, c-format
 msgid "Insn %d is in multiple basic blocks (%d and %d)"
 msgstr ""
 
-#: flow.c:6360
+#: flow.c:6387
 #, c-format
 msgid "End insn %d for block %d not found in the insn stream."
 msgstr ""
 
-#: flow.c:6394 flow.c:6421
+#: flow.c:6421 flow.c:6448
 #, c-format
 msgid "Basic block %i edge lists are corrupted"
 msgstr ""
 
-#: flow.c:6406
+#: flow.c:6433
 #, c-format
 msgid "Basic block %d pred edge is corrupted"
 msgstr ""
 
-#: flow.c:6436
+#: flow.c:6463
 #, c-format
 msgid "NOTE_INSN_BASIC_BLOCK is missing for block %d"
 msgstr ""
 
-#: flow.c:6446
+#: flow.c:6473
 #, c-format
 msgid "NOTE_INSN_BASIC_BLOCK is missing for block %d\n"
 msgstr ""
 
-#: flow.c:6463
+#: flow.c:6490
 #, c-format
 msgid "NOTE_INSN_BASIC_BLOCK %d in the middle of basic block %d"
 msgstr ""
 
-#: flow.c:6475
+#: flow.c:6502
 #, c-format
 msgid "In basic block %d:"
 msgstr ""
 
-#: flow.c:6495
+#: flow.c:6522
 msgid "Basic blocks not numbered consecutively"
 msgstr ""
 
-#: flow.c:6535
+#: flow.c:6562
 #, c-format
 msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)"
 msgstr ""
 
+#: fold-const.c:3017 fold-const.c:3030
+#, c-format
+msgid "comparison is always %d due to width of bitfield"
+msgstr ""
+
+#: fold-const.c:4073 fold-const.c:4090
+#, c-format
+msgid "comparison is always %d"
+msgstr ""
+
+#: fold-const.c:4221
+msgid "`or' of unmatched not-equal tests is always 1"
+msgstr ""
+
+#: fold-const.c:4226
+msgid "`and' of mutually exclusive equal-tests is always 0"
+msgstr ""
+
+#: function.c:5167
+#, c-format
+msgid "`%s' might be used uninitialized in this function"
+msgstr ""
+
+#: function.c:5174
+#, c-format
+msgid "variable `%s' might be clobbered by `longjmp' or `vfork'"
+msgstr ""
+
+#: function.c:5192
+#, c-format
+msgid "argument `%s' might be clobbered by `longjmp' or `vfork'"
+msgstr ""
+
+#: function.c:5951
+msgid "function returns an aggregate"
+msgstr ""
+
+#: function.c:6460
+#, c-format
+msgid "unused parameter `%s'"
+msgstr ""
+
 #: gcc.c:978
 #, c-format
 msgid "Ambiguous abbreviation %s"
@@ -4649,11 +8865,11 @@ msgstr ""
 msgid "No executable code associated with file %s.\n"
 msgstr ""
 
-#: gcov.c:747
+#: gcov.c:747 profile.c:982
 msgid ".da file contents exhausted too early\n"
 msgstr ""
 
-#: gcov.c:750
+#: gcov.c:750 profile.c:985
 msgid ".da file contents not exhausted\n"
 msgstr ""
 
@@ -4905,10 +9121,30 @@ msgstr ""
 msgid "Objective-C text in C source file"
 msgstr ""
 
+#: objc/objc-act.c:981
+#, c-format
+msgid "object does not conform to the `%s' protocol"
+msgstr ""
+
+#: objc/objc-act.c:1019
+#, c-format
+msgid "class `%s' does not implement the `%s' protocol"
+msgstr ""
+
+#: objc/objc-act.c:1101
+#, c-format
+msgid "`%s' cannot be statically allocated"
+msgstr ""
+
 #: objc/objc-act.c:1102
 msgid "statically allocated objects not supported"
 msgstr ""
 
+#: objc/objc-act.c:1160
+#, c-format
+msgid "Unexpected type for `id' (%s)"
+msgstr ""
+
 #: objc/objc-act.c:1164
 msgid "Undefined type `id', please import <objc/objc.h>"
 msgstr ""
@@ -4918,15 +9154,20 @@ msgstr ""
 msgid "Cannot find protocol declaration for `%s'"
 msgstr ""
 
-#: objc-parse.y:1497 objc/objc-act.c:1447 objc/objc-act.c:5918
-#: objc/objc-act.c:6268 objc/objc-act.c:6304
+#: objc-parse.y:1342 objc/objc-act.c:1447 objc/objc-act.c:5918
+#: objc/objc-act.c:6219 objc/objc-act.c:6268 objc/objc-act.c:6304
 #, c-format
 msgid "Cannot find interface declaration for `%s'"
 msgstr ""
 
-#: objc/objc-act.c:2507 objc/objc-act.c:6178
+#: objc/objc-act.c:2484
 #, c-format
-msgid "`%s' redeclared as different kind of symbol"
+msgid "Cannot find class `%s'"
+msgstr ""
+
+#: objc/objc-act.c:2486
+#, c-format
+msgid "Class `%s' already exists"
 msgstr ""
 
 #. fatal did not work with 2 args...should fix
@@ -4944,11 +9185,62 @@ msgstr ""
 msgid "inconsistent instance variable specification"
 msgstr ""
 
+#: objc/objc-act.c:4879
+#, c-format
+msgid "multiple declarations for method `%s'"
+msgstr ""
+
+#: objc/objc-act.c:4996
+#, c-format
+msgid "invalid receiver type `%s'"
+msgstr ""
+
+#: objc/objc-act.c:5064 objc/objc-act.c:5090 objc/objc-act.c:5138
+#, c-format
+msgid "`%s' does not respond to `%s'"
+msgstr ""
+
 #: objc/objc-act.c:5070 objc/objc-act.c:7328
 #, c-format
 msgid "no super class declared in interface for `%s'"
 msgstr ""
 
+#: objc/objc-act.c:5168
+msgid "cannot find class (factory) method."
+msgstr ""
+
+#: objc/objc-act.c:5169 objc/objc-act.c:5213
+#, c-format
+msgid "return type for `%s' defaults to id"
+msgstr ""
+
+#: objc/objc-act.c:5186
+#, c-format
+msgid "method `%s' not implemented by protocol."
+msgstr ""
+
+#: objc/objc-act.c:5195
+msgid "return type defaults to id"
+msgstr ""
+
+#: objc/objc-act.c:5212
+msgid "cannot find method."
+msgstr ""
+
+#. Historically, a class method that produced objects (factory
+#. method) would assign `self' to the instance that it
+#. allocated.  This would effectively turn the class method into
+#. an instance method.  Following this assignment, the instance
+#. variables could be accessed.  That practice, while safe,
+#. violates the simple rule that a class method should not refer
+#. to an instance variable.  It's better to catch the cases
+#. where this is done unknowingly than to support the above
+#. paradigm.
+#: objc/objc-act.c:5467
+#, c-format
+msgid "instance variable `%s' accessed in class method"
+msgstr ""
+
 #: objc/objc-act.c:5719
 #, c-format
 msgid "duplicate definition of class method `%s'."
@@ -4969,6 +9261,11 @@ msgstr ""
 msgid "duplicate declaration of instance method `%s'."
 msgstr ""
 
+#: objc/objc-act.c:5807
+#, c-format
+msgid "duplicate interface declaration for category `%s(%s)'"
+msgstr ""
+
 #: objc/objc-act.c:5893
 #, c-format
 msgid "instance variable `%s' is declared private"
@@ -4979,6 +9276,30 @@ msgstr ""
 msgid "instance variable `%s' is declared %s"
 msgstr ""
 
+#: objc/objc-act.c:5950
+msgid "static access to object of type `id'"
+msgstr ""
+
+#: objc/objc-act.c:5987 objc/objc-act.c:6081
+#, c-format
+msgid "incomplete implementation of class `%s'"
+msgstr ""
+
+#: objc/objc-act.c:5991 objc/objc-act.c:6086
+#, c-format
+msgid "incomplete implementation of category `%s'"
+msgstr ""
+
+#: objc/objc-act.c:5996 objc/objc-act.c:6091
+#, c-format
+msgid "method definition for `%c%s' not found"
+msgstr ""
+
+#: objc/objc-act.c:6132
+#, c-format
+msgid "%s `%s' does not fully implement the `%s' protocol"
+msgstr ""
+
 #: objc/objc-act.c:6191
 #, c-format
 msgid "reimplementation of class `%s'"
@@ -4989,24 +9310,42 @@ msgstr ""
 msgid "conflicting super class name `%s'"
 msgstr ""
 
-#: objc/objc-act.c:6235
+#: objc/objc-act.c:6248
 #, c-format
-msgid "previous declaration of `%s'"
+msgid "duplicate interface declaration for class `%s'"
+msgstr ""
+
+#: objc/objc-act.c:6494
+#, c-format
+msgid "duplicate declaration for protocol `%s'"
 msgstr ""
 
 #: objc/objc-act.c:7369
 msgid "[super ...] must appear in a method context"
 msgstr ""
 
-#: objc-parse.y:701
+#: objc/objc-act.c:8321 objc/objc-act.c:8337
 #, c-format
-msgid "Instance variable `%s' implicitly declared as function"
+msgid "potential selector conflict for method `%s'"
 msgstr ""
 
-#: objc-parse.y:2627 objc-parse.y:2652
+#: objc-parse.y:2206
+msgid "`@end' must appear in an implementation context"
+msgstr ""
+
+#: objc-parse.y:2472 objc-parse.y:2497
 msgid "method definition not in class context"
 msgstr ""
 
+#: profile.c:495
+msgid "Arc profiling: some edge counts were bad."
+msgstr ""
+
+#: profile.c:936
+#, c-format
+msgid "file %s not found, execution counts assumed to be zero."
+msgstr ""
+
 #: protoize.c:598
 #, c-format
 msgid "%s: internal abort\n"
@@ -5315,51 +9654,178 @@ msgstr ""
 msgid "%s: input file names must have .c suffixes: %s\n"
 msgstr ""
 
-#: regclass.c:656
+#: real.c:788 real.c:955
+msgid "conversion from NaN to int"
+msgstr ""
+
+#: real.c:811
+msgid "conversion from NaN to unsigned int"
+msgstr ""
+
+#: real.c:2673
+msgid "floating point overflow"
+msgstr ""
+
+#: real.c:4313 real.c:6587 real.c:6668
+msgid "overflow on truncation to integer"
+msgstr ""
+
+#: real.c:4385
+msgid "overflow on truncation to unsigned integer"
+msgstr ""
+
+#: real.c:5731
+#, c-format
+msgid "%s: argument domain error"
+msgstr ""
+
+#: real.c:5732
+#, c-format
+msgid "%s: function singularity"
+msgstr ""
+
+#: real.c:5733
+#, c-format
+msgid "%s: overflow range error"
+msgstr ""
+
+#: real.c:5734
+#, c-format
+msgid "%s: underflow range error"
+msgstr ""
+
+#: real.c:5735
+#, c-format
+msgid "%s: total loss of precision"
+msgstr ""
+
+#: real.c:5736
+#, c-format
+msgid "%s: partial loss of precision"
+msgstr ""
+
+#: real.c:5737
+#, c-format
+msgid "%s: NaN - producing operation"
+msgstr ""
+
+#: reg-stack.c:661
+#, c-format
+msgid "Output constraint %d must specify a single register"
+msgstr ""
+
+#: reg-stack.c:681
+msgid "Output regs must be grouped at top of stack"
+msgstr ""
+
+#: reg-stack.c:718
+msgid "Implicitly popped regs must be grouped at top of stack"
+msgstr ""
+
+#: reg-stack.c:737
+#, c-format
+msgid "Output operand %d must use `&' constraint"
+msgstr ""
+
+#: regclass.c:658
 #, c-format
 msgid "can't use '%s' as a %s register"
 msgstr ""
 
-#: regclass.c:678
+#: regclass.c:669
+#, c-format
+msgid "unknown register name: %s"
+msgstr ""
+
+#: regclass.c:680
 msgid "global register variable follows a function definition"
 msgstr ""
 
+#: regclass.c:684
+msgid "register used for two global register variables"
+msgstr ""
+
+#: regclass.c:689
+msgid "call-clobbered register used for global register variable"
+msgstr ""
+
+#: reload.c:1182
+msgid "cannot reload integer constant operand in `asm'"
+msgstr ""
+
+#: reload.c:1204
+msgid "impossible register constraint in `asm'"
+msgstr ""
+
+#: reload.c:3287
+msgid "`&' constraint used with no register class"
+msgstr ""
+
+#: reload.c:3439 reload.c:3649
+msgid "inconsistent operand constraints in an `asm'"
+msgstr ""
+
+#: reload1.c:1166
+msgid "frame size too large for reliable stack checking"
+msgstr ""
+
+#: reload1.c:1169
+msgid "try reducing the number of local variables"
+msgstr ""
+
+#: reload1.c:1820
+#, c-format
+msgid "Can't find a register in class `%s' while reloading `asm'."
+msgstr ""
+
 #: reload1.c:1824
 #, c-format
 msgid "Unable to find a register to spill in class `%s'."
 msgstr ""
 
-#: rtl.c:1148
+#: reload1.c:3831
+msgid "`asm' operand requires impossible reload"
+msgstr ""
+
+#: reload1.c:4883
+msgid "`asm' operand constraint incompatible with operand size"
+msgstr ""
+
+#: reload1.c:6444
+msgid "output operand is constant in `asm'"
+msgstr ""
+
+#: rtl.c:1123
 #, c-format
 msgid "RTL check: access of elt %d of `%s' with last elt %d"
 msgstr ""
 
-#: rtl.c:1162
+#: rtl.c:1137
 #, c-format
 msgid "RTL check: expected elt %d type '%c', have '%c' (rtx %s)"
 msgstr ""
 
-#: rtl.c:1177
+#: rtl.c:1152
 #, c-format
 msgid "RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s)"
 msgstr ""
 
-#: rtl.c:1191
+#: rtl.c:1166
 #, c-format
 msgid "RTL check: expected code `%s', have `%s'"
 msgstr ""
 
-#: rtl.c:1204
+#: rtl.c:1179
 #, c-format
 msgid "RTL check: expected code `%s' or `%s', have `%s'"
 msgstr ""
 
-#: rtl.c:1219
+#: rtl.c:1194
 #, c-format
 msgid "RTL check: access of elt %d of vector with last elt %d"
 msgstr ""
 
-#: rtl.c:1264
+#: rtl.c:1239
 #, c-format
 msgid ""
 "Internal compiler error in `%s', at %s:%d\n"
@@ -5372,6 +9838,11 @@ msgstr ""
 msgid "jump to `%s' invalidly jumps into binding contour"
 msgstr ""
 
+#: stmt.c:1157 stmt.c:3677
+#, c-format
+msgid "label `%s' used before containing binding contour"
+msgstr ""
+
 #: stmt.c:1283 stmt.c:1354
 msgid "`asm' cannot be used in function where memory usage is checked"
 msgstr ""
@@ -5397,6 +9868,11 @@ msgstr ""
 msgid "output operand constraint lacks `='"
 msgstr ""
 
+#: stmt.c:1452
+#, c-format
+msgid "output constraint `%c' for operand %d is not at the beginning"
+msgstr ""
+
 #: stmt.c:1461
 #, c-format
 msgid "output operand constraint %d contains `+'"
@@ -5439,6 +9915,34 @@ msgstr ""
 msgid "matching constraint references invalid operand number"
 msgstr ""
 
+#. ??? Leave this only until we have experience with what
+#. happens in combine and elsewhere when constraints are
+#. not satisfied.
+#: stmt.c:1701 stmt.c:1726
+#, c-format
+msgid "asm operand %d probably doesn't match constraints"
+msgstr ""
+
+#: stmt.c:3595
+#, c-format
+msgid "unused variable `%s'"
+msgstr ""
+
+#: stmt.c:5179
+#, c-format
+msgid "enumeration value `%s' not handled in switch"
+msgstr ""
+
+#: stmt.c:5205 stmt.c:5225
+#, c-format
+msgid "case value `%ld' not in enumerated type"
+msgstr ""
+
+#: stmt.c:5208 stmt.c:5228
+#, c-format
+msgid "case value `%ld' not in enumerated type `%s'"
+msgstr ""
+
 #: stor-layout.c:126
 msgid "type size can't be explicitly evaluated"
 msgstr ""
@@ -5447,7 +9951,44 @@ msgstr ""
 msgid "variable-size type declared outside of any function"
 msgstr ""
 
-#: toplev.c:1438 toplev.c:4787
+#: stor-layout.c:399
+#, c-format
+msgid "size of `%s' is %d bytes"
+msgstr ""
+
+#: stor-layout.c:401
+#, c-format
+msgid "size of `%s' is larger than %d bytes"
+msgstr ""
+
+#: stor-layout.c:751 stor-layout.c:1002
+#, c-format
+msgid "packed attribute causes inefficient alignment for `%s'"
+msgstr ""
+
+#: stor-layout.c:753 stor-layout.c:1004
+#, c-format
+msgid "packed attribute is unnecessary for `%s'"
+msgstr ""
+
+#: stor-layout.c:768
+#, c-format
+msgid "padding struct to align `%s'"
+msgstr ""
+
+#: stor-layout.c:966
+msgid "padding struct size to alignment boundary"
+msgstr ""
+
+#: stor-layout.c:1009
+msgid "packed attribute causes inefficient alignment"
+msgstr ""
+
+#: stor-layout.c:1011
+msgid "packed attribute is unnecessary"
+msgstr ""
+
+#: toplev.c:1438 toplev.c:4786
 #, c-format
 msgid "Invalid option `%s'"
 msgstr ""
@@ -5456,101 +9997,259 @@ msgstr ""
 msgid "output pipe has been closed"
 msgstr ""
 
+#: toplev.c:1946
+#, c-format
+msgid "`%s' used but never defined"
+msgstr ""
+
+#: toplev.c:1949
+#, c-format
+msgid "`%s' declared `static' but never defined"
+msgstr ""
+
+#: toplev.c:1971
+#, c-format
+msgid "`%s' defined but not used"
+msgstr ""
+
+#: toplev.c:2213
+msgid "-ffunction-sections not supported for this target."
+msgstr ""
+
+#: toplev.c:2218
+msgid "-fdata-sections not supported for this target."
+msgstr ""
+
+#: toplev.c:2226
+msgid "-ffunction-sections disabled; it makes profiling impossible."
+msgstr ""
+
+#: toplev.c:2232
+msgid "-ffunction-sections may affect debugging on some targets."
+msgstr ""
+
 #: toplev.c:2292
 msgid "Errors detected in input file (your bison.simple is out of date)\n"
 msgstr ""
 
-#: toplev.c:2522
+#: toplev.c:2521
 #, c-format
 msgid "invalid register name `%s' for register variable"
 msgstr ""
 
-#: toplev.c:3982
+#: toplev.c:3919
+#, c-format
+msgid "unrecognized gcc debugging option: %c"
+msgstr ""
+
+#: toplev.c:3981
 #, c-format
 msgid "unrecognized register name `%s'"
 msgstr ""
 
-#: toplev.c:4009 toplev.c:4608
+#: toplev.c:4008 toplev.c:4607
 #, c-format
 msgid "Unrecognized option `%s'"
 msgstr ""
 
-#: toplev.c:4136
+#: toplev.c:4135
 #, c-format
 msgid "use -gdwarf -g%d for DWARF v1, level %d"
 msgstr ""
 
-#: toplev.c:4139
+#: toplev.c:4138
 msgid "use -gdwarf-2   for DWARF v2"
 msgstr ""
 
-#: toplev.c:4733
+#: toplev.c:4143
+#, c-format
+msgid "ignoring option `%s' due to invalid debug level specification"
+msgstr ""
+
+#: toplev.c:4166 toplev.c:4199
+#, c-format
+msgid "`%s': unknown or unsupported -g option"
+msgstr ""
+
+#: toplev.c:4173
+#, c-format
+msgid "`%s' ignored, conflicts with `-g%s'"
+msgstr ""
+
+#: toplev.c:4323
+msgid "`-a' option (basic block profile) not supported"
+msgstr ""
+
+#: toplev.c:4331
+msgid "`-ax' option (jump profiling) not supported"
+msgstr ""
+
+#: toplev.c:4600
+#, c-format
+msgid "Ignoring command line option '%s'"
+msgstr ""
+
+#: toplev.c:4602
+#, c-format
+msgid "(It is valid for %s but not the selected language)"
+msgstr ""
+
+#: toplev.c:4631
+msgid "-Wuninitialized is not supported without -O"
+msgstr ""
+
+#: toplev.c:4673
+msgid "`-ax' and `-a' are conflicting options. `-a' ignored."
+msgstr ""
+
+#: toplev.c:4694
+msgid "instruction scheduling not supported on this target machine"
+msgstr ""
+
+#: toplev.c:4698
+msgid "this target machine does not have delayed branches"
+msgstr ""
+
+#: toplev.c:4712
+#, c-format
+msgid "-f%sleading-underscore not supported on this target machine"
+msgstr ""
+
+#: toplev.c:4732
 #, c-format
 msgid "Data size %ld.\n"
 msgstr ""
 
-#: toplev.c:4804
+#: toplev.c:4803
 #, c-format
 msgid ""
 "%s%s%s version %s (%s) compiled by GNU C version %s.\n"
 "%s%s%s version %s (%s) compiled by CC.\n"
 msgstr ""
 
-#: toplev.c:4859
+#: toplev.c:4858
 msgid "options passed: "
 msgstr ""
 
-#: toplev.c:4888
+#: toplev.c:4887
 msgid "options enabled: "
 msgstr ""
 
-#: tree.c:4748
+#: tree.c:1293
+#, c-format
+msgid "`%s' and `%s' identical in first %d characters"
+msgstr ""
+
+#: tree.c:4750
 msgid "arrays of functions are not meaningful"
 msgstr ""
 
-#: tree.c:4805
+#: tree.c:4807
 msgid "function return type cannot be function"
 msgstr ""
 
-#: tree.c:5532
+#: tree.c:5534
 msgid "invalid initializer for bit string"
 msgstr ""
 
-#: tree.c:5590
+#: tree.c:5592
 #, c-format
 msgid "Tree check: expected %s, have %s"
 msgstr ""
 
-#: tree.c:5605
+#: tree.c:5607
 #, c-format
 msgid "Tree check: expected class '%c', have '%c' (%s)"
 msgstr ""
 
+#: varasm.c:702
+#, c-format
+msgid "register name not specified for `%s'"
+msgstr ""
+
+#: varasm.c:706
+#, c-format
+msgid "invalid register name for `%s'"
+msgstr ""
+
+#: varasm.c:711
+#, c-format
+msgid "register name given for non-register variable `%s'"
+msgstr ""
+
+#: varasm.c:716
+#, c-format
+msgid "data type of `%s' isn't suitable for a register"
+msgstr ""
+
+#: varasm.c:721
+#, c-format
+msgid "register number for `%s' isn't suitable for data type"
+msgstr ""
+
 #: varasm.c:730
 msgid "global register variable has initial value"
 msgstr ""
 
+#: varasm.c:733
+msgid "volatile register variables don't work as you might wish"
+msgstr ""
+
+#: varasm.c:1419
+#, c-format
+msgid "size of variable `%s' is too large"
+msgstr ""
+
+#: varasm.c:1459
+#, c-format
+msgid ""
+"alignment of `%s' is greater than maximum object file alignment. Using %d."
+msgstr ""
+
+#: varasm.c:1505
+#, c-format
+msgid "requested alignment for %s is greater than implemented alignment of %d."
+msgstr ""
+
 #: varasm.c:1977
 msgid "floating point trap outputting a constant"
 msgstr ""
 
-#: varasm.c:4278
+#: varasm.c:4287
 msgid "initializer for integer value is too complicated"
 msgstr ""
 
-#: varasm.c:4284
+#: varasm.c:4293
 msgid "initializer for floating value is not a floating constant"
 msgstr ""
 
-#: varasm.c:4341
+#: varasm.c:4350
 msgid "unknown set constructor type"
 msgstr ""
 
-#: varasm.c:4487
+#: varasm.c:4496
 #, c-format
 msgid "invalid initial value for member `%s'"
 msgstr ""
 
+#: varasm.c:4675
+#, c-format
+msgid "weak declaration of `%s' must be public"
+msgstr ""
+
+#: varasm.c:4677
+#, c-format
+msgid "weak declaration of `%s' must precede definition"
+msgstr ""
+
+#: varasm.c:4770
+msgid "only weak aliases are supported in this configuration"
+msgstr ""
+
+#: varasm.c:4775
+msgid "alias definitions not supported in this configuration; ignored"
+msgstr ""
+
 #. Print an error message for unrecognized stab codes.
 #: xcoffout.c:182
 #, c-format
@@ -5573,15 +10272,15 @@ msgstr ""
 msgid "-mbig-endian and -mlittle-endian may not be used together"
 msgstr ""
 
-#: config/arm/riscix.h:72 config/arm/riscix.h:134
+#: config/arm/riscix.h:73 config/arm/riscix.h:135
 msgid "-mbsd and -pedantic incompatible"
 msgstr ""
 
-#: config/arm/riscix.h:73 config/arm/riscix.h:135
+#: config/arm/riscix.h:74 config/arm/riscix.h:136
 msgid "-mbsd and -mxopen incompatible"
 msgstr ""
 
-#: config/arm/riscix.h:74 config/arm/riscix.h:136
+#: config/arm/riscix.h:75 config/arm/riscix.h:137
 msgid "-mxopen and -pedantic incompatible"
 msgstr ""