diff options
Diffstat (limited to 'gcc/po/cat-id-tbl.c')
| -rw-r--r-- | gcc/po/cat-id-tbl.c | 4746 |
1 files changed, 2463 insertions, 2283 deletions
diff --git a/gcc/po/cat-id-tbl.c b/gcc/po/cat-id-tbl.c index 82c4a54f008..ecc4ae2b3f6 100644 --- a/gcc/po/cat-id-tbl.c +++ b/gcc/po/cat-id-tbl.c @@ -8,1805 +8,1772 @@ const struct _msg_ent _msg_tbl[] = { {"", 1}, - {"`%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}, + {"offset outside bounds of constant string", 2}, + {"__builtin_saveregs not supported by this target", 3}, + {"argument of `__builtin_args_info' must be constant", 4}, + {"argument of `__builtin_args_info' out of range", 5}, + {"missing argument in `__builtin_args_info'", 6}, + {"`va_start' used in function with fixed args", 7}, + {"second parameter of `va_start' not last named argument", 8}, + {"`__builtin_next_arg' called without an argument", 9}, + {"too many arguments to function `va_start'", 10}, + {"first argument to `va_arg' not of type `va_list'", 11}, + {"`%s' is promoted to `%s' when passed through `...'", 12}, + {"(so you should pass `%s' not `%s' to `va_arg')", 13}, + {"invalid arg to `__builtin_frame_address'", 14}, + {"invalid arg to `__builtin_return_address'", 15}, + {"unsupported arg to `__builtin_frame_address'", 16}, + {"unsupported arg to `__builtin_return_address'", 17}, + {"second arg to `__builtin_expect' must be a constant", 18}, + {"__builtin_longjmp second argument must be 1", 19}, + {"__builtin_trap not supported by this target", 20}, + {"built-in function `%s' not currently supported", 21}, + {"\ +string length `%d' is greater than the minimum length `%d' ISO C%d is \ +required to support", 22}, + {"`%s' attribute directive ignored", 23}, + {"`%s' attribute does not apply to types", 24}, + {"wrong number of arguments specified for `%s' attribute", 25}, + {"`%s' attribute ignored", 26}, + {"unknown machine mode `%s'", 27}, + {"no data type for mode `%s'", 28}, + {"section attribute cannot be specified for local variables", 29}, + {"section of `%s' conflicts with previous declaration", 30}, + {"section attribute not allowed for `%s'", 31}, + {"section attributes are not supported for this target", 32}, + {"requested alignment is not a constant", 33}, + {"requested alignment is not a power of 2", 34}, + {"requested alignment is too large", 35}, + {"alignment may not be specified for `%s'", 36}, + {"argument format specified for non-function `%s'", 37}, + {"unrecognized format specifier", 38}, + {"`%s' is an unrecognized format function type", 39}, + {"format string has invalid operand number", 40}, + {"format string arg follows the args to be formatted", 41}, + {"format string arg not a string type", 42}, + {"args to be formatted is not '...'", 43}, + {"function does not return string type", 44}, + {"`%s' defined both normally and as an alias", 45}, + {"alias arg not a string", 46}, + {"`%s' attribute applies only to functions", 47}, + {"can't set `%s' attribute after definition", 48}, + {"too few arguments for format", 49}, + {"missing $ operand number in format", 50}, + {"ISO C does not support %%n$ operand number formats", 51}, + {"operand number out of range in format", 52}, + {"format argument %d unused before used argument %d in $-style format", 53}, + {"unused arguments in $-style format", 54}, + {"null format string", 55}, + {"format not a string literal, argument types not checked", 56}, + {"zero-length format string", 57}, + {"unterminated format string", 58}, + {"embedded `\\0' in format", 59}, + {"too many arguments for format", 60}, + {"spurious trailing `%%' in format", 61}, + {"zero width in scanf format", 62}, + {"ISO C does not support the strftime `%c' flag", 63}, + {"repeated `%c' flag in format", 64}, + {"ISO C does not support strftime format width", 65}, + {"multiple E/O modifiers in format", 66}, + {"use of both ` ' and `+' flags in format", 67}, + {"use of both `0' and `-' flags in format", 68}, + {"ISO C does not support the `'' format flag", 69}, + {"ISO C does not support the `I' format flag", 70}, + {"field width is not type int (arg %d)", 71}, + {"field precision is not type int (arg %d)", 72}, + {"ISO C does not support the `%s' %s length modifier", 73}, + {"ISO C89 does not support the `%s' %s length modifier", 74}, + {"use of `*' and `%s' together in format", 75}, + {"conversion lacks type at end of format", 76}, + {"unknown conversion type character `%c' in format", 77}, + {"unknown conversion type character 0x%x in format", 78}, + {"ISO C does not support the `%%%c' %s format", 79}, + {"ISO C89 does not support the `%%%c' %s format", 80}, + {"ISO C does not support `%%O%c'", 81}, + {"ISO C89 does not support `%%O%c'", 82}, + {"ISO C89 does not support `%%E%c'", 83}, + {"width used with `%c' format", 84}, + {"`%%%c' yields only last 2 digits of year in some locales", 85}, + {"`%%%c' yields only last 2 digits of year", 86}, + {"precision used with `%c' format", 87}, + {"`a' flag used with `%c' format", 88}, + {"ISO C does not support the `a' flag", 89}, + {"no closing `]' for `%%[' format", 90}, + {"suppression of `%c' conversion in format", 91}, + {"flag `%c' used with type `%c'", 92}, + {"`0' flag ignored with precision specifier and `%c' format", 93}, + {"use of `%s' length modifier with `%c' type character", 94}, + {"ISO C does not support the `%%%s%c' %s format", 95}, + {"ISO C89 does not support the `%%%s%c' %s format", 96}, + {"writing into constant object (arg %d)", 97}, + {"extra type qualifiers in format argument (arg %d)", 98}, + {"format argument is not a pointer (arg %d)", 99}, + {"format argument is not a pointer to a pointer (arg %d)", 100}, + {"%s format, %s arg (arg %d)", 101}, + {"overflow in constant expression", 102}, + {"integer overflow in expression", 103}, + {"floating point overflow in expression", 104}, + {"large integer implicitly truncated to unsigned type", 105}, + {"negative integer implicitly converted to unsigned type", 106}, + {"overflow in implicit constant conversion", 107}, + {"expression statement has incomplete type", 108}, + {"case label does not reduce to an integer constant", 109}, + {"invalid truth-value expression", 110}, + {"invalid operands to binary %s", 111}, + {"comparison is always false due to limited range of data type", 112}, + {"comparison is always true due to limited range of data type", 113}, + {"comparison of unsigned expression >= 0 is always true", 114}, + {"comparison of unsigned expression < 0 is always false", 115}, + {"struct type value used where scalar is required", 116}, + {"union type value used where scalar is required", 117}, + {"array type value used where scalar is required", 118}, + {"suggest parentheses around assignment used as truth value", 119}, + {"invalid use of `restrict'", 120}, + {"too few arguments to function `%s'", 121}, + {"too many arguments to function `%s'", 122}, + {"void value not ignored as it ought to be", 123}, + {"conversion to non-scalar type requested", 124}, + {"unknown C standard `%s'", 125}, + {"array `%s' assumed to have one element", 126}, + {"`struct %s' incomplete in scope ending here", 127}, + {"`union %s' incomplete in scope ending here", 128}, + {"`enum %s' incomplete in scope ending here", 129}, + {"label `%s' used but not defined", 130}, + {"label `%s' defined but not used", 131}, + {"shadowing built-in function `%s'", 132}, + {"shadowing library function `%s'", 133}, + {"library function `%s' declared as non-function", 134}, + {"built-in function `%s' declared as non-function", 135}, + {"`%s' redeclared as different kind of symbol", 136}, + {"previous declaration of `%s'", 137}, + {"conflicting types for built-in function `%s'", 138}, + {"conflicting types for `%s'", 139}, {"\ A parameter list with an ellipsis can't match an empty parameter name list \ -declaration.", 108}, +declaration.", 140}, {"\ An argument type that has a default promotion can't match an empty parameter \ -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}, +name list declaration.", 141}, + {"redefinition of `%s'", 142}, + {"redeclaration of `%s'", 143}, + {"conflicting declarations of `%s'", 144}, + {"`%s' previously defined here", 145}, + {"`%s' previously declared here", 146}, + {"prototype for `%s' follows", 147}, + {"non-prototype definition here", 148}, + {"prototype for `%s' follows and number of arguments doesn't match", 149}, + {"prototype for `%s' follows and argument %d doesn't match", 150}, + {"`%s' declared inline after being called", 151}, + {"`%s' declared inline after its definition", 152}, + {"static declaration for `%s' follows non-static", 153}, + {"non-static declaration for `%s' follows static", 154}, + {"const declaration for `%s' follows non-const", 155}, + {"type qualifiers for `%s' conflict with previous decl", 156}, + {"redundant redeclaration of `%s' in same scope", 157}, + {"nested extern declaration of `%s'", 158}, + {"`%s' used prior to declaration", 159}, + {"`%s' was declared implicitly `extern' and later `static'", 160}, + {"type mismatch with previous external decl", 161}, + {"previous external decl of `%s'", 162}, + {"type mismatch with previous implicit declaration", 163}, + {"previous implicit declaration of `%s'", 164}, + {"type of external `%s' is not global", 165}, + {"`%s' was previously implicitly declared to return `int'", 166}, + {"`%s' was declared `extern' and later `static'", 167}, + {"extern declaration of `%s' doesn't match global one", 168}, + {"`%s' locally external but globally static", 169}, + {"declaration of `%s' shadows a parameter", 170}, + {"declaration of `%s' shadows a symbol from the parameter list", 171}, + {"declaration of `%s' shadows previous local", 172}, + {"declaration of `%s' shadows global declaration", 173}, + {"function `%s' was previously declared within a block", 174}, + {"implicit declaration of function `%s'", 175}, + {"label %s referenced outside of any function", 176}, + {"duplicate label declaration `%s'", 177}, + {"this is a previous declaration", 178}, + {"unnamed struct/union that defines no instances", 179}, + {"useless keyword or type name in empty declaration", 180}, + {"two types specified in one empty declaration", 181}, + {"empty declaration", 182}, + {"`%s' is usually a function", 183}, + {"typedef `%s' is initialized", 184}, + {"function `%s' is initialized like a variable", 185}, + {"parameter `%s' is initialized", 186}, + {"variable-sized object may not be initialized", 187}, + {"variable `%s' has initializer but incomplete type", 188}, + {"elements of array `%s' have incomplete type", 189}, + {"declaration of `%s' has `extern' and is initialized", 190}, + {"initializer fails to determine size of `%s'", 191}, + {"array size missing in `%s'", 192}, + {"zero or negative size array `%s'", 193}, + {"storage size of `%s' isn't known", 194}, + {"storage size of `%s' isn't constant", 195}, + {"ANSI C forbids parameter `%s' shadowing typedef", 196}, + {"`long long long' is too long for GCC", 197}, + {"ISO C89 does not support `long long'", 198}, + {"duplicate `%s'", 199}, + {"two or more data types in declaration of `%s'", 200}, + {"`%s' fails to be a typedef or built in type", 201}, + {"both long and short specified for `%s'", 202}, + {"long or short specified with char for `%s'", 203}, + {"long or short specified with floating type for `%s'", 204}, + {"the only valid combination is `long double'", 205}, + {"both signed and unsigned specified for `%s'", 206}, + {"long, short, signed or unsigned invalid for `%s'", 207}, + {"long, short, signed or unsigned used invalidly for `%s'", 208}, + {"complex invalid for `%s'", 209}, + {"duplicate `const'", 210}, + {"duplicate `restrict'", 211}, + {"duplicate `volatile'", 212}, + {"multiple storage classes in declaration of `%s'", 213}, + {"function definition declared `auto'", 214}, + {"function definition declared `register'", 215}, + {"function definition declared `typedef'", 216}, + {"storage class specified for structure field `%s'", 217}, + {"storage class specified for parameter `%s'", 218}, + {"storage class specified for typename", 219}, + {"`%s' initialized and declared `extern'", 220}, + {"`%s' has both `extern' and initializer", 221}, + {"nested function `%s' declared `extern'", 222}, + {"top-level declaration of `%s' specifies `auto'", 223}, + {"declaration of `%s' as array of voids", 224}, + {"declaration of `%s' as array of functions", 225}, + {"size of array `%s' has non-integer type", 226}, + {"ISO C forbids zero-size array `%s'", 227}, + {"size of array `%s' is negative", 228}, + {"ISO C89 forbids array `%s' whose size can't be evaluated", 229}, + {"ISO C89 forbids variable-size array `%s'", 230}, + {"size of array `%s' is too large", 231}, + {"array type has incomplete element type", 232}, + {"ANSI C forbids const or volatile function types", 233}, + {"`%s' declared as function returning a function", 234}, + {"`%s' declared as function returning an array", 235}, + {"ISO C forbids qualified function types", 236}, + {"invalid type modifier within pointer declarator", 237}, + {"ISO C forbids const or volatile function types", 238}, + {"variable or field `%s' declared void", 239}, + {"field `%s' declared as a function", 240}, + {"field `%s' has incomplete type", 241}, + {"invalid storage class for function `%s'", 242}, + {"ISO C forbids qualified void function return type", 243}, + {"`noreturn' function returns non-void value", 244}, + {"cannot inline function `main'", 245}, + {"variable `%s' declared `inline'", 246}, + {"function declaration isn't a prototype", 247}, + {"parameter names (without types) in function declaration", 248}, + {"parameter `%s' has incomplete type", 249}, + {"parameter has incomplete type", 250}, + {"parameter `%s' points to incomplete type", 251}, + {"parameter points to incomplete type", 252}, + {"parameter `%s' has just a forward declaration", 253}, + {"`void' in parameter list must be the entire list", 254}, + {"`%s %s' declared inside parameter list", 255}, + {"anonymous struct declared inside parameter list", 256}, + {"anonymous union declared inside parameter list", 257}, + {"anonymous enum declared inside parameter list", 258}, {"\ 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}, +you want.", 259}, + {"ISO C forbids forward references to `enum' types", 260}, + {"redefinition of `%s %s'", 261}, + {"%s defined inside parms", 262}, + {"union", 263}, + {"structure", 264}, + {"%s has no %s", 265}, + {"struct", 266}, + {"named members", 267}, + {"members", 268}, + {"nested redefinition of `%s'", 269}, + {"bit-field `%s' width not an integer constant", 270}, + {"bit-field `%s' has invalid type", 271}, + {"bit-field `%s' type invalid in ISO C", 272}, + {"negative width in bit-field `%s'", 273}, + {"width of `%s' exceeds its type", 274}, + {"zero width for bit-field `%s'", 275}, + {"`%s' is narrower than values of its type", 276}, + {"duplicate member `%s'", 277}, + {"union cannot be made transparent", 278}, + {"redeclaration of `enum %s'", 279}, + {"enum defined inside parms", 280}, + {"enumeration values exceed range of largest integer", 281}, + {"enumerator value for `%s' not integer constant", 282}, + {"overflow in enumeration values", 283}, + {"ISO C restricts enumerator values to range of `int'", 284}, + {"return type is an incomplete type", 285}, + {"no previous prototype for `%s'", 286}, + {"`%s' was used with no prototype before its definition", 287}, + {"no previous declaration for `%s'", 288}, + {"`%s' was used with no declaration before its definition", 289}, + {"return type of `%s' is not `int'", 290}, + {"first argument of `%s' should be `int'", 291}, + {"second argument of `%s' should be `char **'", 292}, + {"third argument of `%s' should probably be `char **'", 293}, + {"`%s' takes only zero or two arguments", 294}, + {"third argument of `%s' is deprecated", 295}, + {"`%s' is normally a non-static function", 296}, + {"parm types given both in parmlist and separately", 297}, + {"parameter name omitted", 298}, + {"parameter `%s' declared void", 299}, + {"parameter name missing from parameter list", 300}, + {"multiple parameters named `%s'", 301}, + {"type of `%s' defaults to `int'", 302}, + {"declaration for parameter `%s' but no such parameter", 303}, + {"number of arguments doesn't match prototype", 304}, + {"promoted argument `%s' doesn't match prototype", 305}, + {"argument `%s' doesn't match prototype", 306}, + {"type of parameter `%s' is not declared", 307}, + {"function might be possible candidate for attribute `noreturn'", 308}, + {"`noreturn' function does return", 309}, + {"control reaches end of non-void function", 310}, + {"this function may return with or without a value", 311}, + {"size of return value of `%s' is %u bytes", 312}, + {"size of return value of `%s' is larger than %d bytes", 313}, + {"ISO C forbids case ranges", 314}, + {"label must have integral type in ISO C", 315}, + {"default label not within a switch statement", 316}, + {"case label not within a switch statement", 317}, + {"multiple default labels in one switch", 318}, + {"this is the first default label", 319}, + {"duplicate case value", 320}, + {"this is the first entry for that value", 321}, + {"case value out of range", 322}, + {"case label within scope of cleanup or variable array", 323}, + {"stray '\\' in program", 324}, + {"invalid #-line", 325}, + {"undefined or invalid # directive `%s'", 326}, + {"invalid #line", 327}, + {"badly nested C headers from preprocessor", 328}, + {"#-lines for entering and leaving files don't match", 329}, + {"ignoring #pragma %s %s", 330}, + {"ignoring #pragma %s", 331}, + {"incomplete universal-character-name", 332}, + {"non hex digit '%c' in universal-character-name", 333}, + {"universal-character-name on EBCDIC target", 334}, + {"universal-character-name used for '%c'", 335}, + {"invalid universal-character-name", 336}, + {"the meaning of `\\x' varies with -traditional", 337}, + {"\\x used with no following hex digits", 338}, + {"hex escape out of range", 339}, + {"the meaning of '\\a' varies with -traditional", 340}, + {"the meaning of '\\%c' varies with -traditional", 341}, + {"non-ISO-standard escape sequence, '\\%c'", 342}, + {"unknown escape sequence '\\%c'", 343}, + {"unknown escape sequence: '\\' followed by char 0x%.2x", 344}, + {"universal-character-name '\\U%08x' not valid in identifier", 345}, + {"universal-character-name '\\u%04x' not valid in identifier", 346}, + {"both 'f' and 'l' suffixes on floating constant", 347}, + {"floating point number exceeds range of '%s'", 348}, + {"stray '%c' in program", 349}, + {"stray '\\%#o' in program", 350}, + {"'$' in identifier", 351}, + {"parse error at '..'", 352}, + {"floating constant may not be in radix 16", 353}, + {"traditional C rejects the 'f' suffix", 354}, + {"traditional C rejects the 'l' suffix", 355}, + {"ISO C forbids imaginary numeric constants", 356}, + {"floating point number exceeds range of 'double'", 357}, + {"two 'u' suffixes on integer constant", 358}, + {"traditional C rejects the 'u' suffix", 359}, + {"three 'l' suffixes on integer constant", 360}, + {"'lul' is not a valid integer suffix", 361}, + {"'Ll' and 'lL' are not valid integer suffixes", 362}, + {"ISO C89 forbids long long integer constants", 363}, + {"more than one 'i' or 'j' suffix on integer constant", 364}, {"\ 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}, +truncated to %d bits", 365}, + {"width of integer constant changes with -traditional", 366}, + {"integer constant is unsigned in ISO C, signed with -traditional", 367}, + {"width of integer constant may change on other systems with -traditional", 368}, + {"integer constant larger than the maximum value of an unsigned long int", 369}, + {"decimal constant is so large that it is unsigned", 370}, + {"integer constant is larger than the maximum value for its type", 371}, + {"missing white space after number '%.*s'", 372}, + {"Ignoring invalid multibyte character", 373}, + {"escape sequence out of range for character", 374}, + {"empty character constant", 375}, + {"character constant too long", 376}, + {"multi-character character constant", 377}, + {"syntax error", 378}, + {"syntax error: cannot back up", 379}, + {"parser stack overflow", 380}, + {"ISO C forbids an empty source file", 381}, + {"argument of `asm' is not a constant string", 382}, + {"ISO C forbids data definition with no type or storage class", 383}, + {"data definition has no type or storage class", 384}, + {"ISO C does not allow extra `;' outside of a function", 385}, + {"traditional C rejects the unary plus operator", 386}, + {"ISO C forbids `&&'", 387}, + {"`sizeof' applied to a bit-field", 388}, + {"ISO C89 forbids constructor expressions", 389}, + {"ISO C forbids omitting the middle term of a ?: expression", 390}, + {"ISO C forbids braced-groups within expressions", 391}, + {"traditional C rejects string concatenation", 392}, + {"ISO C does not permit use of `varargs.h'", 393}, + {"`%s' is not at beginning of declaration", 394}, + {"ISO C forbids empty initializer braces", 395}, + {"ISO C forbids nested functions", 396}, + {"`[*]' in parameter declaration only allowed in ISO C 99", 397}, + {"comma at end of enumerator list", 398}, + {"no semicolon at end of struct or union", 399}, + {"extra semicolon in struct or union specified", 400}, + {"ISO C doesn't support unnamed structs/unions", 401}, + {"ISO C forbids member declarations with no members", 402}, + {"ISO C forbids label at end of compound statement", 403}, + {"ISO C forbids label declarations", 404}, + {"braced-group within expression allowed only inside a function", 405}, + {"empty body in an else-statement", 406}, + {"ISO C forbids `goto *expr;'", 407}, + {"ISO C forbids forward parameter declarations", 408}, + {"ISO C requires a named argument before `...'", 409}, + {"`...' in old-style identifier list", 410}, + {"parse error; also virtual memory exceeded", 411}, + {"parse error", 412}, + {"%s at end of input", 413}, + {"%s before %s'%c'", 414}, + {"%s before %s'\\x%x'", 415}, + {"%s before string constant", 416}, + {"%s before numeric constant", 417}, + {"%s before \"%s\"", 418}, + {"%s before '%s' token", 419}, + {"invalid identifier `%s'", 420}, + {"syntax error before '%s' token", 421}, + {"YYDEBUG not defined.", 422}, + {"\ +#pragma pack (pop) encountered without matching #pragma pack (push, <n>)", 423}, {"\ #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>)", 424}, + {"junk at end of '#pragma pack'", 425}, + {"junk at end of #pragma weak", 426}, + {"malformed #pragma directive", 427}, + {"break statement not within loop or switch", 428}, + {"continue statement not within a loop", 429}, + {"%s qualifier ignored on asm", 430}, + {"`%s' has an incomplete type", 431}, + {"invalid use of void expression", 432}, + {"invalid use of array with unspecified bounds", 433}, + {"invalid use of undefined type `%s %s'", 434}, + {"invalid use of incomplete typedef `%s'", 435}, + {"function types not truly compatible in ISO C", 436}, + {"types are not quite compatible", 437}, + {"sizeof applied to a function type", 438}, + {"sizeof applied to a void type", 439}, + {"sizeof applied to an incomplete type", 440}, + {"arithmetic on pointer to an incomplete type", 441}, + {"__alignof__ applied to an incomplete type", 442}, + {"`__alignof' applied to a bit-field", 443}, + {"invalid use of non-lvalue array", 444}, + {"%s has no member named `%s'", 445}, + {"request for member `%s' in something not a structure or union", 446}, + {"dereferencing pointer to incomplete type", 447}, + {"dereferencing `void *' pointer", 448}, + {"invalid type argument of `%s'", 449}, + {"subscript missing in array reference", 450}, + {"array subscript has type `char'", 451}, + {"array subscript is not an integer", 452}, + {"ISO C forbids subscripting `register' array", 453}, + {"ISO C89 forbids subscripting non-lvalue array", 454}, + {"subscript has type `char'", 455}, + {"subscripted value is neither array nor pointer", 456}, + {"`%s' undeclared here (not in a function)", 457}, + {"`%s' undeclared (first use in this function)", 458}, + {"(Each undeclared identifier is reported only once", 459}, + {"for each function it appears in.)", 460}, + {"local declaration of `%s' hides instance variable", 461}, + {"called object is not a function", 462}, + {"too many arguments to function", 463}, + {"type of formal parameter %d is incomplete", 464}, + {"%s as integer rather than floating due to prototype", 465}, + {"%s as complex rather than floating due to prototype", 466}, + {"%s as floating rather than integer due to prototype", 467}, + {"%s as floating rather than complex due to prototype", 468}, + {"%s as `float' rather than `double' due to prototype", 469}, + {"%s with different width due to prototype", 470}, + {"%s as unsigned due to prototype", 471}, + {"%s as signed due to prototype", 472}, + {"too few arguments to function", 473}, + {"suggest parentheses around + or - inside shift", 474}, + {"suggest parentheses around && within ||", 475}, + {"suggest parentheses around arithmetic in operand of |", 476}, + {"suggest parentheses around comparison in operand of |", 477}, + {"suggest parentheses around arithmetic in operand of ^", 478}, + {"suggest parentheses around comparison in operand of ^", 479}, + {"suggest parentheses around + or - in operand of &", 480}, + {"suggest parentheses around comparison in operand of &", 481}, + {"comparisons like X<=Y<=Z do not have their mathematical meaning", 482}, + {"right shift count is negative", 483}, + {"right shift count >= width of type", 484}, + {"left shift count is negative", 485}, + {"left shift count >= width of type", 486}, + {"shift count is negative", 487}, + {"shift count >= width of type", 488}, + {"comparing floating point with == or != is unsafe", 489}, + {"ISO C forbids comparison of `void *' with function pointer", 490}, + {"comparison of distinct pointer types lacks a cast", 491}, + {"comparison between pointer and integer", 492}, + {"ISO C forbids ordered comparisons of pointers to functions", 493}, + {"comparison of complete and incomplete pointers", 494}, + {"ordered comparison of pointer with integer zero", 495}, + {"unordered comparison on non-floating point argument", 496}, + {"comparison between signed and unsigned", 497}, + {"comparison of promoted ~unsigned with constant", 498}, + {"comparison of promoted ~unsigned with unsigned", 499}, + {"pointer of type `void *' used in arithmetic", 500}, + {"pointer to a function used in arithmetic", 501}, + {"pointer of type `void *' used in subtraction", 502}, + {"pointer to a function used in subtraction", 503}, + {"wrong type argument to unary plus", 504}, + {"wrong type argument to unary minus", 505}, + {"wrong type argument to bit-complement", 506}, + {"wrong type argument to abs", 507}, + {"wrong type argument to conjugation", 508}, + {"wrong type argument to unary exclamation mark", 509}, + {"wrong type argument to %s", 510}, + {"%s of pointer to unknown structure", 511}, + {"invalid lvalue in increment", 512}, + {"invalid lvalue in decrement", 513}, + {"increment", 514}, + {"decrement", 515}, + {"ISO C forbids the address of a cast expression", 516}, + {"invalid lvalue in unary `&'", 517}, + {"attempt to take address of bit-field structure member `%s'", 518}, + {"%s", 519}, + {"ISO C forbids use of conditional expressions as lvalues", 520}, + {"ISO C forbids use of compound expressions as lvalues", 521}, + {"ISO C forbids use of cast expressions as lvalues", 522}, + {"%s of read-only member `%s'", 523}, + {"%s of read-only variable `%s'", 524}, + {"%s of read-only location", 525}, + {"cannot take address of bitfield `%s'", 526}, + {"global register variable `%s' used in nested function", 527}, + {"register variable `%s' used in nested function", 528}, + {"address of global register variable `%s' requested", 529}, + {"cannot put object with volatile field into register", 530}, + {"address of register variable `%s' requested", 531}, + {"signed and unsigned type in conditional expression", 532}, + {"ISO C forbids conditional expr with only one void side", 533}, + {"ISO C forbids conditional expr between `void *' and function pointer", 534}, + {"pointer type mismatch in conditional expression", 535}, + {"pointer/integer type mismatch in conditional expression", 536}, + {"ANSI C forbids conditional expr between 0 and function pointer", 537}, + {"type mismatch in conditional expression", 538}, + {"left-hand operand of comma expression has no effect", 539}, + {"cast specifies array type", 540}, + {"cast specifies function type", 541}, + {"ISO C forbids casting nonscalar to the same type", 542}, + {"ISO C forbids casts to union type", 543}, + {"cast to union type from type not present in union", 544}, + {"cast discards qualifiers from pointer target type", 545}, + {"cast increases required alignment of target type", 546}, + {"cast from pointer to integer of different size", 547}, + {"cast does not match function type", 548}, + {"cast to pointer from integer of different size", 549}, + {"invalid lvalue in assignment", 550}, + {"assignment", 551}, + {"%s makes qualified function pointer from unqualified", 552}, + {"%s discards qualifiers from pointer target type", 553}, + {"ISO C prohibits argument conversion to union type", 554}, + {"ISO C forbids %s between function pointer and `void *'", 555}, + {"pointer targets in %s differ in signedness", 556}, + {"%s from incompatible pointer type", 557}, + {"%s makes pointer from integer without a cast", 558}, + {"%s makes integer from pointer without a cast", 559}, + {"incompatible type for argument %d of `%s'", 560}, + {"incompatible type for argument %d of indirect function call", 561}, + {"incompatible types in %s", 562}, + {"passing arg %d of `%s'", 563}, + {"passing arg %d of pointer to function", 564}, + {"initializer for static variable is not constant", 565}, + {"initializer for static variable uses complicated arithmetic", 566}, + {"aggregate initializer is not constant", 567}, + {"aggregate initializer uses complicated arithmetic", 568}, + {"traditional C rejects automatic aggregate initialization", 569}, + {"(near initialization for `%s')", 570}, + {"char-array initialized from wide string", 571}, + {"int-array initialized from non-wide string", 572}, + {"initializer-string for array of chars is too long", 573}, + {"array initialized from non-constant array expression", 574}, + {"initializer element is not constant", 575}, + {"initializer element is not computable at load time", 576}, + {"initialization", 577}, + {"invalid initializer", 578}, + {"extra brace group at end of initializer", 579}, + {"missing braces around initializer", 580}, + {"braces around scalar initializer", 581}, + {"missing initializer", 582}, + {"empty braces in initializer", 583}, + {"empty scalar initializer", 584}, + {"extra elements in scalar initializer", 585}, + {"zero or negative array size `%s'", 586}, + {"nonconstant array index in initializer", 587}, + {"array index in non-array initializer", 588}, + {"duplicate array index in initializer", 589}, + {"empty index range in initializer", 590}, + {"ISO C89 forbids specifying element to initialize", 591}, + {"unknown field `%s' specified in initializer", 592}, + {"field `%s' already initialized", 593}, + {"ISO C89 forbids specifying structure member to initialize", 594}, + {"duplicate initializer", 595}, + {"excess elements in char array initializer", 596}, + {"excess elements in struct initializer", 597}, + {"excess elements in union initializer", 598}, + {"traditional C rejects initialization of unions", 599}, + {"excess elements in array initializer", 600}, + {"excess elements in scalar initializer", 601}, + {"asm template is not a string constant", 602}, + {"invalid lvalue in asm statement", 603}, + {"modification by `asm'", 604}, + {"function declared `noreturn' has a `return' statement", 605}, + {"`return' with a value, in function returning void", 606}, + {"return", 607}, + {"function returns address of local variable", 608}, + {"switch quantity not an integer", 609}, + {"`long' switch expression not converted to `int' in ISO C", 610}, + {"inlining failed in call to `%s'", 611}, + {"called from here", 612}, + {"can't inline call to `%s'", 613}, + {"function call has aggregate value", 614}, + {"internal error", 615}, + {"no arguments", 616}, + {"fopen %s", 617}, + {"fclose %s", 618}, + {"collect2 version %s", 619}, + {"%d constructor(s) found\n", 620}, + {"%d destructor(s) found\n", 621}, + {"%d frame table(s) found\n", 622}, + {"%s terminated with signal %d [%s]%s", 623}, + {"%s returned %d exit status", 624}, + {"[cannot find %s]", 625}, + {"cannot find `%s'", 626}, + {"redirecting stdout: %s", 627}, + {"[Leaving %s]\n", 628}, {"\ \n\ -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}, +write_c_file - output name is %s, prefix is %s\n", 629}, + {"cannot find `nm'", 630}, + {"pipe", 631}, + {"fdopen", 632}, + {"dup2 %d 1", 633}, + {"close %d", 634}, + {"execvp %s", 635}, + {"init function found in object %s", 636}, + {"fini function found in object %s", 637}, + {"fclose", 638}, + {"unable to open file '%s'", 639}, + {"unable to stat file '%s'", 640}, + {"unable to mmap file '%s'", 641}, + {"not found\n", 642}, + {"dynamic dependency %s not found", 643}, + {"bad magic number in file '%s'", 644}, + {"dynamic dependencies.\n", 645}, + {"cannot find `ldd'", 646}, + {"execv %s", 647}, {"\ \n\ -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}, +ldd output with constructors/destructors.\n", 648}, + {"unable to open dynamic dependency '%s'", 649}, + {"%s: not a COFF file", 650}, + {"%s: cannot open as COFF file", 651}, + {"Library lib%s not found", 652}, + {"open %s", 653}, + {"incompatibilities between object file & expected values", 654}, {"\ \n\ -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}, +Processing symbol table #%d, offset = 0x%.8lx, kind = %s\n", 655}, + {"string section missing", 656}, + {"section pointer missing", 657}, + {"no symbol table found", 658}, + {"no cmd_strings found", 659}, {"\ \n\ Updating header and load commands.\n\ -\n", 639}, - {"load command map, %d cmds, new size %ld.\n", 640}, +\n", 660}, + {"load command map, %d cmds, new size %ld.\n", 661}, {"\ writing load commands.\n\ -\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}, +\n", 662}, + {"close %s", 663}, + {"could not convert 0x%l.8x into a region", 664}, + {"%s function, region %d, offset = %ld (0x%.8lx)\n", 665}, + {"bad magic number", 666}, + {"bad header version", 667}, + {"bad raw header version", 668}, + {"raw header buffer too small", 669}, + {"old raw header file", 670}, + {"unsupported version", 671}, + {"unknown {de,en}code_mach_o_hdr return value %d", 672}, + {"fstat %s", 673}, + {"lseek %s 0", 674}, + {"read %s", 675}, + {"read %ld bytes, expected %ld, from %s", 676}, + {"msync %s", 677}, + {"munmap %s", 678}, + {"write %s", 679}, + {"wrote %ld bytes, expected %ld, to %s", 680}, {"\ ;; Combiner statistics: %d attempts, %d substitutions (%d requiring new \ space),\n\ ;; %d successes.\n\ -\n", 660}, +\n", 681}, {"\ \n\ ;; Combiner totals: %d attempts, %d substitutions (%d requiring new space),\n\ -;; %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}, +;; %d successes.\n", 682}, + {"invalid %%Q value", 683}, + {"invalid %%C value", 684}, + {"invalid %%N value", 685}, + {"invalid %%M value", 686}, + {"invalid %%m value", 687}, + {"invalid %%L value", 688}, + {"invalid %%O value", 689}, + {"invalid %%P value", 690}, + {"invalid %%V value", 691}, + {"Generate code assuming DW bit is set", 692}, + {"Generate code assuming DW bit is not set", 693}, + {"Generate code using byte writes", 694}, + {"Do not generate byte writes", 695}, + {"Use small memory model", 696}, + {"Use normal memory model", 697}, + {"Use large memory model", 698}, + {"Generate 29050 code", 699}, + {"Generate 29000 code", 700}, + {"Use kernel global registers", 701}, + {"Use user global registers", 702}, + {"Emit stack checking code", 703}, + {"Do not emit stack checking code", 704}, + {"Work around storem hardware bug", 705}, + {"Do not work around storem hardware bug", 706}, + {"Store locals in argument registers", 707}, + {"Do not store locals in arg registers", 708}, + {"Use software floating point", 709}, + {"Do not generate multm instructions", 710}, + {"bad value `%s' for -mtrap-precision switch", 711}, + {"bad value `%s' for -mfp-rounding-mode switch", 712}, + {"bad value `%s' for -mfp-trap-mode switch", 713}, + {"bad value `%s' for -mcpu switch", 714}, + {"fp software completion requires -mtrap-precision=i", 715}, + {"rounding mode not supported for VAX floats", 716}, + {"trap mode not supported for VAX floats", 717}, + {"L%d cache latency unknown for %s", 718}, + {"bad value `%s' for -mmemory-latency", 719}, + {"invalid %%r value", 720}, + {"invalid %%R value", 721}, + {"invalid %%h value", 722}, + {"invalid %%U value", 723}, + {"invalid %%s value", 724}, + {"invalid %%E value", 725}, + {"invalid %%xn code", 726}, + {"Use hardware fp", 727}, + {"Do not use hardware fp", 728}, + {"Use fp registers", 729}, + {"Do not use fp registers", 730}, + {"Do not assume GAS", 731}, + {"Assume GAS", 732}, + {"Request IEEE-conformant math library routines (OSF/1)", 733}, + {"Emit IEEE-conformant code, without inexact exceptions", 734}, + {"Emit IEEE-conformant code, with inexact exceptions", 735}, + {"Do not emit complex integer constants to read-only memory", 736}, + {"Use VAX fp", 737}, + {"Do not use VAX fp", 738}, + {"Emit code for the byte/word ISA extension", 739}, + {"Emit code for the motion video ISA extension", 740}, + {"Emit code for the fp move and sqrt ISA extension", 741}, + {"Emit code for the counting ISA extension", 742}, + {"Generate code for a given CPU", 743}, + {"Control the generated fp rounding mode", 744}, + {"Control the IEEE trap mode", 745}, + {"Control the precision given to fp exceptions", 746}, + {"Tune expected memory latency", 747}, + {"bad value (%s) for -mcpu switch", 748}, + {"invalid operand to %R code", 749}, + {"invalid operand to %H/%L code", 750}, + {"invalid operand to %U code", 751}, + {"invalid operand to %V code", 752}, + {"invalid operand output code", 753}, + {"switch -mcpu=%s conflicts with -march= switch", 754}, + {"bad value (%s) for %s switch", 755}, + {"target CPU does not support APCS-32", 756}, + {"target CPU does not support APCS-26", 757}, + {"target CPU does not support interworking", 758}, + {"target CPU does not supoport THUMB instructions.", 759}, + {"\ +enabling backtrace support is only meaningful when compiling for the Thumb.", 760}, {"\ enabling callee interworking support is only meaningful when compiling for \ -the Thumb.", 740}, +the Thumb.", 761}, {"\ 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}, +the Thumb.", 762}, + {"interworking forces APCS-32 to be used", 763}, + {"-mapcs-stack-check incompatible with -mno-apcs-frame", 764}, + {"-fpic and -mapcs-reent are incompatible", 765}, + {"APCS reentrant code not supported. Ignored", 766}, + {"-g with -mno-apcs-frame may not give sensible debugging", 767}, + {"Passing floating point arguments in fp regs not yet supported", 768}, + {"Invalid floating point emulation option: -mfpe-%s", 769}, + {"Structure size boundary can only be set to 8 or 32", 770}, + {"-mpic-register= is useless without -fpic", 771}, + {"Unable to use '%s' for PIC register", 772}, + {"Unable to compute real location of stacked parameter", 773}, + {"No low registers available for popping high registers", 774}, + {"thumb_load_double_from_address: destination is not a register", 775}, + {"thumb_load_double_from_address: source is not a computed memory address", 776}, + {"thumb_load_double_from_address: base is not a register", 777}, + {"thumb_load_double_from_address: Unhandled address calculation", 778}, + {"Generate APCS conformant stack frames", 779}, + {"Store function names in object code", 780}, + {"Use the 32bit version of the APCS", 781}, + {"Use the 26bit version of the APCS", 782}, + {"Pass FP arguments in FP registers", 783}, + {"Generate re-entrant, PIC code", 784}, + {"The MMU will trap on unaligned accesses", 785}, + {"Use library calls to perform FP operations", 786}, + {"Use hardware floating point instructions", 787}, + {"Assume target CPU is configured as big endian", 788}, + {"Assume target CPU is configured as little endian", 789}, + {"Assume big endian bytes, little endian words", 790}, + {"Support calls between THUMB and ARM instructions sets", 791}, + {"Generate a call to abort if a noreturn function returns", 792}, + {"Do not move instructions into a function's prologue", 793}, + {"Do not load the PIC register in function prologues", 794}, + {"Generate call insns as indirect calls, if necessary", 795}, + {"Compile for the Thumb not the ARM", 796}, + {"Thumb: Generate (non-leaf) stack frames even if not needed", 797}, + {"Thumb: Generate (leaf) stack frames even if not needed", 798}, + {"Thumb: Assume non-static functions may be called from ARM code", 799}, + {"Thumb: Assume function pointers may go to non-Thumb aware code", 800}, + {"Specify the name of the target CPU", 801}, + {"Specify the name of the target architecture", 802}, + {"Specify the version of the floating point emulator", 803}, + {"Specify the minimum bit alignment of structures", 804}, + {"Specify the register to be used for PIC addressing", 805}, + {"Do symbol renaming for BSD", 806}, + {"Do symbol renaming for X/OPEN", 807}, + {"Don't do symbol renaming", 808}, + {"Generate code for the C400", 809}, + {"Generate code for the C300", 810}, + {"Generate code for c1", 811}, + {"Generate code for c2", 812}, + {"Generate code for c32", 813}, + {"Generate code for c34", 814}, + {"Use standard calling sequence, with arg count word", 815}, + {"Place arg count in a nop instruction (faster than push)", 816}, + {"Don't push arg count, depend on symbol table", 817}, + {"Use data cache for volatile mem refs (default)", 818}, + {"Don't use data cache for volatile mem refs", 819}, + {"Bypass data cache for volatile mem refs", 820}, + {"Use 64-bit longs", 821}, + {"Use cc- and libc-compatible 32-bit longs", 822}, + {"Invalid register class letter %c", 823}, + {"ACCUM_HIGH_REGS class in limit_reload_class", 824}, + {"YH_OR_ACCUM_HIGH_REGS found in limit_reload_class", 825}, + {"YL found in limit_reload_class", 826}, + {"Stack size > 32k", 827}, + {"Invalid addressing mode", 828}, + {"Bad register extension code", 829}, + {"Invalid offset in ybase addressing", 830}, + {"Invalid register in ybase addressing", 831}, + {"inline float constants not supported on this host", 832}, + {"Invalid shift operator in emit_1600_core_shift", 833}, + {"Invalid mode for gen_tst_reg", 834}, + {"Invalid mode for integer comparison in gen_compare_reg", 835}, + {"Invalid register for compare", 836}, + {"Profiling not implemented yet.", 837}, + {"Trampolines not yet implemented", 838}, + {"Generate code the unix assembler can handle", 839}, + {"Generate code an embedded assembler can handle", 840}, + {"Generate code for a mc68020", 841}, + {"Use bitfield instructions", 842}, + {"Generate code for a mc68000", 843}, + {"Generate software FP code", 844}, + {"Do not generate bitfield insns", 845}, + {"Use 16bit integers", 846}, + {"Use 32bit integers", 847}, + {"Compile for Gmicro/300", 848}, + {"Compile for Gmicro/200", 849}, + {"Compile for Gmicro/100", 850}, + {"Use floating point co-processor", 851}, + {"Do not use floating point co-processor", 852}, + {"Alternate calling convention", 853}, + {"Use normal calling convention", 854}, + {"Do not use bitfield instructions", 855}, + {"Use alternative return sequence", 856}, + {"Use normal return sequence", 857}, + {"Always use string instruction", 858}, + {"Use string instruction when appropriate", 859}, + {"Only initialized variables can be placed into the 8-bit area.", 860}, + {"Generate H8/S code", 861}, + {"Do not generate H8/S code", 862}, + {"Make integers 32 bits wide", 863}, + {"Use registers for argument passing", 864}, + {"Do not use registers for argument passing", 865}, + {"Consider access to byte sized memory slow", 866}, + {"Enable linker relaxing", 867}, + {"Generate H8/300H code", 868}, + {"Do not generate H8/300H code", 869}, + {"Use H8/300 alignment rules", 870}, + {"real name is too long - alias ignored", 871}, + {"alias name is too long - alias ignored", 872}, + {"junk at end of #pragma map", 873}, + {"malformed #pragma map, ignored", 874}, + {"Generate char instructions", 875}, + {"Do not generate char instructions", 876}, + {"Use the Cygwin interface", 877}, + {"Use the Mingw32 interface", 878}, + {"Create GUI application", 879}, + {"Create console application", 880}, + {"Generate code for a DLL", 881}, + {"Ignore dllimport for functions", 882}, + {"Use Mingw-specific thread support", 883}, + {"-f%s ignored for target (all code is position independent)", 884}, + {"Internal gcc abort from %s:%d", 885}, + {"The local variable `insn' has the value:", 886}, + {"Retain standard MXDB information", 887}, + {"Retain legend information", 888}, + {"Generate external legend information", 889}, + {"Emit identifying info in .s file", 890}, + {"Warn when a function arg is a structure", 891}, + {"argument is a structure", 892}, + {"bad value (%s) for -march= switch", 893}, + {"bad value (%s) for -mcpu= switch", 894}, + {"Register '%c' is unknown", 895}, + {"Register '%c' already specified in allocation order", 896}, + {"-mregparm=%d is not between 0 and %d", 897}, + {"-malign-loops=%d is not between 0 and %d", 898}, + {"-malign-jumps=%d is not between 0 and %d", 899}, + {"-malign-functions=%d is not between 0 and %d", 900}, + {"-mpreferred-stack-boundary=%d is not between 2 and 31", 901}, + {"-mbranch-cost=%d is not between 0 and 5", 902}, + {"floating constant misused", 903}, + {"invalid UNSPEC as operand", 904}, + {"invalid expression as operand", 905}, + {"half-pic init called on systems that don't support it.", 906}, + {"Same as -mcpu=i386", 907}, + {"Same as -mcpu=i486", 908}, + {"Same as -mcpu=pentium", 909}, + {"Same as -mcpu=pentiumpro", 910}, + {"Align some doubles on dword boundary", 911}, + {"Align doubles on word boundary", 912}, + {"Uninitialized locals in .bss", 913}, + {"Uninitialized locals in .data", 914}, + {"Use IEEE math for fp comparisons", 915}, + {"Do not use IEEE math for fp comparisons", 916}, + {"Return values of functions in FPU registers", 917}, + {"Do not return values of functions in FPU registers", 918}, + {"Do not generate sin, cos, sqrt for FPU", 919}, + {"Generate sin, cos, sqrt for FPU", 920}, + {"Omit the frame pointer in leaf functions", 921}, + {"Enable stack probing", 922}, + {"Emit Intel syntax assembler opcodes", 923}, + {"Align destination of the string operations", 924}, + {"Do not align destination of the string operations", 925}, + {"Inline all known string operations", 926}, + {"Do not inline all known string operations", 927}, + {"Use push instructions to save outgoing arguments", 928}, + {"Do not use push instructions to save outgoing arguments", 929}, + {"Support MMX builtins", 930}, + {"Do not support MMX builtins", 931}, + {"Support MMX and SSE builtins", 932}, + {"Do not support MMX and SSE builtins", 933}, + {"Schedule code for given CPU", 934}, + {"Generate code for given CPU", 935}, + {"Control allocation order of integer registers", 936}, + {"Number of registers used to pass integer arguments", 937}, + {"Loop code aligned to this power of 2", 938}, + {"Jump targets are aligned to this power of 2", 939}, + {"Function starts are aligned to this power of 2", 940}, + {"Attempt to keep stack aligned to this power of 2", 941}, + {"Branches are this expensive (1-5, arbitrary units)", 942}, + {"Profiling uses mcount", 943}, + {"Emit half-PIC code", 944}, + {"Emit ELF object code", 945}, + {"Emit ROSE object code", 946}, + {"Symbols have a leading underscore", 947}, + {"Align to >word boundaries", 948}, + {"Use mcount for profiling", 949}, + {"Use mcount_ptr for profiling", 950}, + {"%s causes a section type conflict", 951}, + {"Generate COFF output", 952}, + {"Generate ELF output", 953}, + {"`%s' declared as both exported to and imported from a DLL.", 954}, + {"initialized variable `%s' is marked dllimport", 955}, + {"static variable `%s' is marked dllimport", 956}, + {"Environment variable DJGPP not defined.", 957}, + {"Environment variable DJGPP points to missing file '%s'.", 958}, + {"Environment variable DJGPP points to corrupt file '%s'.", 959}, + {"Generate code which uses the FPU", 960}, + {"Do not generate code which uses the FPU", 961}, + {"sorry, not implemented: #pragma align NAME=SIZE", 962}, + {"malformed #pragma align - ignored", 963}, + {"sorry, not implemented: #pragma noalign NAME", 964}, + {"stack limit expression is not supported", 965}, + {"Generate SA code", 966}, + {"Generate SB code", 967}, + {"Generate KA code", 968}, + {"Generate KB code", 969}, + {"Generate JA code", 970}, + {"Generate JD code", 971}, + {"Generate JF code", 972}, + {"generate RP code", 973}, + {"Generate MC code", 974}, + {"Generate CA code", 975}, + {"Generate CF code", 976}, + {"Use alternate leaf function entries", 977}, + {"Do not use alternate leaf function entries", 978}, + {"Perform tail call optimization", 979}, + {"Do not perform tail call optimization", 980}, + {"Use complex addressing modes", 981}, + {"Do not use complex addressing modes", 982}, + {"Align code to 8 byte boundary", 983}, + {"Do not align code to 8 byte boundary", 984}, + {"Enable compatibility with iC960 v2.0", 985}, + {"Enable compatibility with iC960 v3.0", 986}, + {"Enable compatibility with ic960 assembler", 987}, + {"Do not permit unaligned accesses", 988}, + {"Permit unaligned accesses", 989}, + {"Layout types like Intel's v1.3 gcc", 990}, + {"Do not layout types like Intel's v1.3 gcc", 991}, + {"Use 64 bit long doubles", 992}, + {"Enable linker relaxation", 993}, + {"Do not enable linker relaxation", 994}, + {"conflicting architectures defined - using C series", 995}, + {"conflicting architectures defined - using K series", 996}, + {"iC2.0 and iC3.0 are incompatible - using iC3.0", 997}, + {"The -mlong-double-64 option does not work yet.", 998}, + {"-msystem-v and -p are incompatible", 999}, + {"-msystem-v and -mthreads are incompatible", 1000}, + {"bad value (%s) for -mmodel switch", 1001}, + {"bad value (%s) for -msdata switch", 1002}, + {"const objects cannot go in .sdata/.sbss", 1003}, + {"invalid operand to %s code", 1004}, + {"invalid operand to %p code", 1005}, + {"invalid operand to %T/%B code", 1006}, + {"invalid operand to %N code", 1007}, + {"Display compile time statistics", 1008}, + {"Align all loops to 32 byte boundary", 1009}, + {"Only issue one instruction per cycle", 1010}, + {"Prefer branches over conditional execution", 1011}, + {"Code size: small, medium or large", 1012}, + {"Small data area: none, sdata, use", 1013}, + {"-malign-loops=%d is not between 1 and %d", 1014}, + {"-malign-jumps=%d is not between 1 and %d", 1015}, + {"-malign-functions=%d is not between 1 and %d", 1016}, + {"-fPIC is not currently supported on the 68000 or 68010\n", 1017}, + {"Internal gcc monitor: short-branch(%x)", 1018}, + {"Internal gcc error: Can't express symbolic location", 1019}, + {"argument #%d is a structure", 1020}, + {"%R not followed by %B/C/D/E", 1021}, + {"invalid %x/X value", 1022}, + {"invalid %H value", 1023}, + {"invalid %h value", 1024}, + {"invalid %Q value", 1025}, + {"invalid %q value", 1026}, + {"invalid %o value", 1027}, + {"invalid %p value", 1028}, + {"invalid %s/S value", 1029}, + {"invalid %P operand", 1030}, + {"invalid %B value", 1031}, + {"invalid %C value", 1032}, + {"invalid %D value", 1033}, + {"invalid %E value", 1034}, + {"`%d' operand isn't a register", 1035}, + {"invalid %r value", 1036}, + {"operand is r0", 1037}, + {"operand is const_double", 1038}, + {"invalid code", 1039}, + {"-mtrap-large-shift and -mhandle-large-shift are incompatible", 1040}, + {"Invalid option `-mshort-data-%s'", 1041}, + {"-mshort-data-%s is too large ", 1042}, + {"-mshort-data-%s and PIC are incompatible", 1043}, + {"-mips%d not supported", 1044}, + {"bad value (%s) for -mips switch", 1045}, + {"bad value (%s) for -mabi= switch", 1046}, + {"-mabi=%s does not support -mips%d", 1047}, + {"The -mabi=32 support does not work yet.", 1048}, + {"This target does not support the -mabi switch.", 1049}, + {"-mcpu=%s does not support -mips%d", 1050}, + {"-mips%d does not support 64 bit fp registers", 1051}, + {"-mips%d does not support 64 bit gp registers", 1052}, + {"-G is incompatible with PIC code which is the default", 1053}, + {"-membedded-pic and -mabicalls are incompatible", 1054}, + {"-G and -membedded-pic are incompatible", 1055}, + {"Invalid option `entry%s'", 1056}, + {"-mentry is only meaningful with -mips-16", 1057}, + {"internal error: %%) found without a %%( in assembler pattern", 1058}, + {"internal error: %%] found without a %%[ in assembler pattern", 1059}, + {"internal error: %%> found without a %%< in assembler pattern", 1060}, + {"internal error: %%} found without a %%{ in assembler pattern", 1061}, + {"PRINT_OPERAND: Unknown punctuation '%c'", 1062}, + {"PRINT_OPERAND null pointer", 1063}, + {"PRINT_OPERAND: letter %c was found & insn was not CONST_INT", 1064}, + {"PRINT_OPERAND_ADDRESS, null pointer", 1065}, {"\ 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}, +#line", 1066}, + {"gp_offset (%ld) or end_offset (%ld) is less than zero.", 1067}, + {"fp_offset (%ld) or end_offset (%ld) is less than zero.", 1068}, + {"can not handle inconsistent calls to `%s'", 1069}, + {"No default crt0.o", 1070}, + {"Use 64-bit int type", 1071}, + {"Use 64-bit long type", 1072}, + {"Use 32-bit long type", 1073}, + {"Optimize lui/addiu address loads", 1074}, + {"Don't optimize lui/addiu address loads", 1075}, + {"Use MIPS as", 1076}, + {"Use GNU as", 1077}, + {"Use symbolic register names", 1078}, + {"Don't use symbolic register names", 1079}, + {"Use GP relative sdata/sbss sections", 1080}, + {"Don't use GP relative sdata/sbss sections", 1081}, + {"Output compiler statistics", 1082}, + {"Don't output compiler statistics", 1083}, + {"Don't optimize block moves", 1084}, + {"Optimize block moves", 1085}, + {"Use mips-tfile asm postpass", 1086}, + {"Don't use mips-tfile asm postpass", 1087}, + {"Use hardware floating point", 1088}, + {"Use 64-bit FP registers", 1089}, + {"Use 32-bit FP registers", 1090}, + {"Use 64-bit general registers", 1091}, + {"Use 32-bit general registers", 1092}, + {"Use Irix PIC", 1093}, + {"Don't use Irix PIC", 1094}, + {"Use OSF PIC", 1095}, + {"Don't use OSF PIC", 1096}, + {"Use indirect calls", 1097}, + {"Don't use indirect calls", 1098}, + {"Use embedded PIC", 1099}, + {"Don't use embedded PIC", 1100}, + {"Use ROM instead of RAM", 1101}, + {"Don't use ROM instead of RAM", 1102}, + {"Put uninitialized constants in ROM (needs -membedded-data)", 1103}, + {"Don't put uninitialized constants in ROM", 1104}, + {"Use big-endian byte order", 1105}, + {"Use little-endian byte order", 1106}, + {"Use single (32-bit) FP only", 1107}, + {"Don't use single (32-bit) FP only", 1108}, + {"Use multiply accumulate", 1109}, + {"Don't use multiply accumulate", 1110}, + {"Work around early 4300 hardware bug", 1111}, + {"Don't work around early 4300 hardware bug", 1112}, + {"Optimize for 4650", 1113}, + {"Optimize for 3900", 1114}, + {"Trap on integer divide by zero", 1115}, + {"Don't trap on integer divide by zero", 1116}, + {"Trap on integer divide overflow", 1117}, + {"Don't trap on integer divide overflow", 1118}, + {"Specify CPU for scheduling purposes", 1119}, + {"Specify MIPS ISA", 1120}, + {"Use mips16 entry/exit psuedo ops", 1121}, + {"Don't use MIPS16 instructions", 1122}, + {"mips16 function profiling", 1123}, + {"Work around hardware multiply bug", 1124}, + {"Do not work around hardware multiply bug", 1125}, + {"Target the AM33 processor", 1126}, + {"optimization turned on", 1127}, + {"optimization turned off", 1128}, + {"optimization level restored", 1129}, + {"Don't use hardware fp", 1130}, + {"Alternative calling convention", 1131}, + {"Pass some arguments in registers", 1132}, + {"Pass all arguments on stack", 1133}, + {"Optimize for 32532 cpu", 1134}, + {"Optimize for 32332 cpu", 1135}, + {"Optimize for 32032", 1136}, + {"Register sb is zero. Use for absolute addressing", 1137}, + {"Do not use register sb", 1138}, + {"Generate code for high memory", 1139}, + {"Generate code for low memory", 1140}, + {"32381 fpu", 1141}, + {"Use multiply-accumulate fp instructions", 1142}, + {"Do not use multiply-accumulate fp instructions", 1143}, + {"\"Small register classes\" kludge", 1144}, + {"No \"Small register classes\" kludge", 1145}, {"\ Unknown -mschedule= option (%s).\n\ -Valid options are 700, 7100, 7100LC, 7200, and 8000\n", 1110}, +Valid options are 700, 7100, 7100LC, 7200, and 8000\n", 1146}, {"\ 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}, +Valid options are 1.0, 1.1, and 2.0\n", 1147}, + {"PIC code generation is not supported in the portable runtime model\n", 1148}, + {"PIC code generation is not compatible with fast indirect calls\n", 1149}, + {"PIC code generation is not compatible with profiling\n", 1150}, + {"-g is only supported when using GAS on this processor,", 1151}, + {"-g option disabled.", 1152}, + {"Do not use hardware floating point", 1153}, + {"Return floating point results in ac0", 1154}, + {"Return floating point results in memory", 1155}, + {"Generate code for an 11/40", 1156}, + {"Generate code for an 11/45", 1157}, + {"Generate code for an 11/10", 1158}, + {"Use 32 bit int", 1159}, + {"Use 16 bit int", 1160}, + {"Use 32 bit float", 1161}, + {"Use 64 bit float", 1162}, + {"Target has split I&D", 1163}, + {"Target does not have split I&D", 1164}, + {"Use UNIX assembler syntax", 1165}, + {"Use DEC assembler syntax", 1166}, + {"invalid %%B value", 1167}, + {"invalid %%S value", 1168}, + {"invalid %%b value", 1169}, + {"invalid %%H value", 1170}, + {"invalid %%z value", 1171}, + {"invalid %%Z value", 1172}, + {"invalid %%k value", 1173}, + {"invalid %%j value", 1174}, + {"can't have varargs with -mfp-arg-in-fp-regs", 1175}, + {"Always pass floating-point arguments in memory", 1176}, + {"Don't always pass floating-point arguments in memory", 1177}, + {"Support message passing with the Parallel Environment", 1178}, + {"Compile for 64-bit pointers", 1179}, + {"Compile for 32-bit pointers", 1180}, + {"-maix64 and POWER architecture are incompatible.", 1181}, + {"-maix64 requires PowerPC64 architecture remain enabled.", 1182}, {"\ -maix64 required: 64-bit computation with 32-bit addressing not yet \ -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}, +supported.", 1183}, + {"-mmultiple is not supported on little endian systems", 1184}, + {"-mstring is not supported on little endian systems", 1185}, + {"-f%s ignored for AIX (all code is position independent)", 1186}, + {"-ffunction-sections disabled on AIX when debugging", 1187}, + {"-fdata-sections not supported on AIX", 1188}, + {"Unknown -mdebug-%s switch", 1189}, + {"invalid %%f value", 1190}, + {"invalid %%F value", 1191}, + {"invalid %%G value", 1192}, + {"invalid %%j code", 1193}, + {"invalid %%J code", 1194}, + {"invalid %%K value", 1195}, + {"invalid %%p value", 1196}, + {"invalid %%q value", 1197}, + {"%%S computed all 1's mask", 1198}, + {"%%S computed all 0's mask", 1199}, + {"invalid %%T value", 1200}, + {"invalid %%u value", 1201}, + {"invalid %%v value", 1202}, + {"invalid %%W value", 1203}, + {"Use POWER instruction set", 1204}, + {"Use POWER2 instruction set", 1205}, + {"Do not use POWER2 instruction set", 1206}, + {"Do not use POWER instruction set", 1207}, + {"Use PowerPC instruction set", 1208}, + {"Do not use PowerPC instruction set", 1209}, + {"Use PowerPC General Purpose group optional instructions", 1210}, + {"Don't use PowerPC General Purpose group optional instructions", 1211}, + {"Use PowerPC Graphics group optional instructions", 1212}, + {"Don't use PowerPC Graphics group optional instructions", 1213}, + {"Use PowerPC-64 instruction set", 1214}, + {"Don't use PowerPC-64 instruction set", 1215}, + {"Use new mnemonics for PowerPC architecture", 1216}, + {"Use old mnemonics for PowerPC architecture", 1217}, + {"Put everything in the regular TOC", 1218}, + {"Place floating point constants in TOC", 1219}, + {"Don't place floating point constants in TOC", 1220}, + {"Place symbol+offset constants in TOC", 1221}, + {"Don't place symbol+offset constants in TOC", 1222}, + {"Place variable addresses in the regular TOC", 1223}, + {"Generate load/store multiple instructions", 1224}, + {"Do not generate load/store multiple instructions", 1225}, + {"Generate string instructions for block moves", 1226}, + {"Do not generate string instructions for block moves", 1227}, + {"Generate load/store with update instructions", 1228}, + {"Do not generate load/store with update instructions", 1229}, + {"Generate fused multiply/add instructions", 1230}, + {"Don't generate fused multiply/add instructions", 1231}, + {"Don't schedule the start and end of the procedure", 1232}, + {"Use features of and schedule code for given CPU", 1233}, + {"Enable debug output", 1234}, + {"RETURN_ADDRESS_OFFSET not supported", 1235}, + {"Select ABI calling convention.", 1236}, + {"Select method for sdata handling.", 1237}, + {"Align to the base type of the bitfield.", 1238}, + {"Don't align to the base type of the bitfield.", 1239}, + {"Don't assume that unaligned accesses are handled by the system", 1240}, + {"Assume that unaligned accesses are handled by the system", 1241}, + {"Produce code relocatable at runtime.", 1242}, + {"Don't produce code relocatable at runtime.", 1243}, + {"Produce little endian code.", 1244}, + {"Produce big endian code.", 1245}, + {"Use 128 bit long doubles", 1246}, + {"no description yet", 1247}, + {"Use EABI.", 1248}, + {"Don't use EABI.", 1249}, + {"Use alternate register names.", 1250}, + {"Don't use alternate register names.", 1251}, + {"Link with libsim.a, libc.a and sim-crt0.o.", 1252}, + {"Link with libads.a, libc.a and crt0.o.", 1253}, + {"Link with libyk.a, libc.a and crt0.o.", 1254}, + {"Link with libmvme.a, libc.a and crt0.o.", 1255}, + {"Set the PPC_EMB bit in the ELF flags header", 1256}, + {"Bad value for -mcall-%s", 1257}, + {"Bad value for -msdata=%s", 1258}, + {"-mrelocatable and -msdata=%s are incompatible.", 1259}, + {"-f%s and -msdata=%s are incompatible.", 1260}, + {"-msdata=%s and -mcall-%s are incompatible.", 1261}, + {"-mrelocatable and -mno-minimal-toc are incompatible.", 1262}, + {"-mrelocatable and -mcall-%s are incompatible.", 1263}, + {"-fPIC and -mcall-%s are incompatible.", 1264}, + {"-mcall-aixdesc must be big endian", 1265}, + {"Generate code for big endian", 1266}, + {"Generate code for little endian", 1267}, + {"%s is not supported by this configuration", 1268}, + {"-mptr%d not allowed on -m%d", 1269}, + {"-mlong-double-64 not allowed with -m64", 1270}, + {"bad value (%s) for -mcmodel= switch", 1271}, + {"-mcmodel= is not supported on 32 bit systems", 1272}, + {"profiling does not support code models other than medlow", 1273}, + {"Invalid %%Y operand", 1274}, + {"Invalid %%A operand", 1275}, + {"Invalid %%B operand", 1276}, + {"Invalid %%c operand", 1277}, + {"Invalid %%C operand", 1278}, + {"Invalid %%d operand", 1279}, + {"Invalid %%D operand", 1280}, + {"Invalid %%f operand", 1281}, + {"long long constant not a valid immediate operand", 1282}, + {"floating point constant not a valid immediate operand", 1283}, + {"%s and profiling conflict: disabling %s", 1284}, + {"Use FUNCTION_EPILOGUE", 1285}, + {"Do not use FUNCTION_EPILOGUE", 1286}, + {"Assume possible double misalignment", 1287}, + {"Assume all doubles are aligned", 1288}, + {"Pass -assert pure-text to linker", 1289}, + {"Do not pass -assert pure-text to linker", 1290}, + {"Use flat register window model", 1291}, + {"Do not use flat register window model", 1292}, + {"Use ABI reserved registers", 1293}, + {"Do not use ABI reserved registers", 1294}, + {"Use hardware quad fp instructions", 1295}, + {"Do not use hardware quad fp instructions", 1296}, + {"Compile for v8plus ABI", 1297}, + {"Do not compile for v8plus ABI", 1298}, + {"Utilize Visual Instruction Set", 1299}, + {"Do not utilize Visual Instruction Set", 1300}, + {"Optimize for Cypress processors", 1301}, + {"Optimize for SparcLite processors", 1302}, + {"Optimize for F930 processors", 1303}, + {"Optimize for F934 processors", 1304}, + {"Use V8 Sparc ISA", 1305}, + {"Optimize for SuperSparc processors", 1306}, + {"Pointers are 64-bit", 1307}, + {"Pointers are 32-bit", 1308}, + {"Use 32-bit ABI", 1309}, + {"Use 64-bit ABI", 1310}, + {"Use stack bias", 1311}, + {"Do not use stack bias", 1312}, + {"Use structs on stronger alignment for double-word copies", 1313}, + {"Do not use structs on stronger alignment for double-word copies", 1314}, + {"Optimize tail call instructions in assembler and linker", 1315}, + {"Do not optimize tail call instructions in assembler or linker", 1316}, + {"Use given Sparc code model", 1317}, + {"%s=%s is not numeric.", 1318}, + {"%s=%s is too large.", 1319}, + {"a data area attribute cannot be specified for local variables", 1320}, + {"data area of '%s' conflicts with previous declaration", 1321}, + {"Bogus JR construction: %d\n", 1322}, + {"Bad amount of stack space removal: %d", 1323}, + {"Bogus JARL construction: %d\n", 1324}, + {"#pragma GHS endXXXX found without previous startXXX", 1325}, + {"#pragma GHS endXXX does not match previous startXXX", 1326}, + {"Cannot set interrupt attribute: no current function", 1327}, + {"Cannot set interrupt attribute: no such identifier", 1328}, + {"junk at end of #pragma ghs section", 1329}, + {"unrecognised section name \"%s\"", 1330}, + {"malformed #pragma ghs section", 1331}, + {"junk at end of #pragma ghs interrupt", 1332}, + {"junk at end of #pragma ghs starttda", 1333}, + {"junk at end of #pragma ghs startsda", 1334}, + {"junk at end of #pragma ghs startzda", 1335}, + {"junk at end of #pragma ghs endtda", 1336}, + {"junk at end of #pragma ghs endsda", 1337}, + {"junk at end of #pragma ghs endzda", 1338}, + {"Support Green Hills ABI", 1339}, + {"Prohibit PC relative function calls", 1340}, + {"Reuse r30 on a per function basis", 1341}, + {"Use stubs for function prologues", 1342}, + {"Same as: -mep -mprolog-function", 1343}, + {"Enable backend debugging", 1344}, + {"Compile for the v850 processor", 1345}, + {"Use 4 byte entries in switch tables", 1346}, + {"Set the max size of data eligible for the TDA area", 1347}, + {"Set the max size of data eligible for the SDA area", 1348}, + {"Set the max size of data eligible for the ZDA area", 1349}, + {"cannot convert to a pointer type", 1350}, + {"pointer value used where a floating point value was expected", 1351}, + {"aggregate value used where a float was expected", 1352}, + {"conversion to incomplete type", 1353}, + {"can't convert between vector values of different size", 1354}, + {"aggregate value used where an integer was expected", 1355}, + {"pointer value used where a complex was expected", 1356}, + {"aggregate value used where a complex was expected", 1357}, + {"can't convert value to a vector", 1358}, + {"unable to call pointer to member function here", 1359}, + {"destructors take no parameters", 1360}, + {"ISO C++ forbids omitting the middle term of a ?: expression", 1361}, + {"internal inconsistency: binfo offset error for rtti", 1362}, + {"conflicting access specifications for field `%s', ignored", 1363}, + {"trying to finish struct, but kicked out due to previous parse errors.", 1364}, + {"language string `\"%s\"' not recognized", 1365}, + {"not enough type information", 1366}, + {"invalid operation on uninstantiated type", 1367}, + {"\ +object size exceeds built-in limit for virtual function table implementation", 1368}, {"\ 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}, +recompile all source and use -fhuge-objects", 1369}, + {"internal compiler error: debugging info corrupted", 1370}, + {"parse errors have confused me too much", 1371}, + {"declaration of `%s' shadows a member of `this'", 1372}, + {"label `%s' referenced outside of any function", 1373}, + {"jump to case label", 1374}, + {" enters try block", 1375}, + {" from here", 1376}, + {"`default' label not within a switch statement", 1377}, + {"pointers are not permitted as case values", 1378}, + {"ISO C++ forbids range expressions in switch statement", 1379}, + {"empty range specified", 1380}, + {"duplicate (or overlapping) case value", 1381}, + {"where case label appears here", 1382}, + {"\ +(enclose actions of previous case statements requiring destructors in their \ +own scope.)", 1383}, + {"virtual memory exhausted", 1384}, + {"the new ABI requires vtable thunks", 1385}, + {"an anonymous union cannot have function members", 1386}, + {"multiple types in one declaration", 1387}, + {"declaration does not declare anything", 1388}, + {"ISO C++ prohibits anonymous structs", 1389}, + {"assignment (not initialization) in declaration", 1390}, + {"invalid catch parameter", 1391}, + {"cannot declare `::main' to be a template", 1392}, + {"cannot declare `::main' to be inline", 1393}, + {"cannot declare `::main' to be static", 1394}, + {"`main' must return `int'", 1395}, + {"overflow in array dimension", 1396}, + {"destructors must be member functions", 1397}, + {"`bool' is now a keyword", 1398}, + {"ISO C++ does not support `long long'", 1399}, + {"short, signed or unsigned invalid for `%s'", 1400}, + {"long and short specified together for `%s'", 1401}, + {"signed and unsigned given together for `%s'", 1402}, + {"storage class specifiers invalid in parameter declarations", 1403}, + {"typedef declaration invalid in parameter declaration", 1404}, + {"virtual outside class declaration", 1405}, + {"storage class specified for %s `%s'", 1406}, + {"storage class specifiers invalid in friend function declarations", 1407}, + {"destructor cannot be static member function", 1408}, + {"constructor cannot be static member function", 1409}, + {"constructors cannot be declared virtual", 1410}, + {"return value type specifier for constructor ignored", 1411}, + {"can't initialize friend function `%s'", 1412}, + {"virtual functions cannot be friends", 1413}, + {"friend declaration not in class definition", 1414}, + {"cannot declare %s to references", 1415}, + {"invalid type: `void &'", 1416}, + {"discarding `const' applied to a reference", 1417}, + {"discarding `volatile' applied to a reference", 1418}, + {"only declarations of constructors can be `explicit'", 1419}, + {"non-member `%s' cannot be declared `mutable'", 1420}, + {"non-object member `%s' cannot be declared `mutable'", 1421}, + {"function `%s' cannot be declared `mutable'", 1422}, + {"static `%s' cannot be declared `mutable'", 1423}, + {"const `%s' cannot be declared `mutable'", 1424}, + {"typedef declaration includes an initializer", 1425}, + {"unnamed variable or field declared void", 1426}, + {"variable or field declared void", 1427}, + {"cannot use `::' in parameter declaration", 1428}, + {"declaration of `%s' as void", 1429}, + {"`%s' is neither function nor member function; cannot be declared friend", 1430}, + {"member functions are implicitly friends of their class", 1431}, + {"storage class `auto' invalid for function `%s'", 1432}, + {"storage class `register' invalid for function `%s'", 1433}, + {"\ +storage class `static' invalid for function `%s' declared out of global scope", 1434}, + {"\ +storage class `inline' invalid for function `%s' declared out of global scope", 1435}, + {"virtual non-class function `%s'", 1436}, + {"cannot declare static function inside another function", 1437}, {"\ invalid integer constant in parameter list, did you forget to give parameter \ -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}, +name?", 1438}, + {"parameter invalidly declared method type", 1439}, + {"parameter invalidly declared offset type", 1440}, + {"`void' in parameter list must be entire list", 1441}, + {"conversion to %s%s will never use a type conversion operator", 1442}, + {"return type for `main' changed to `int'", 1443}, + {"no return statement in function returning non-void", 1444}, + {"-f%s is no longer supported", 1445}, {"\ -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}, +default)", 1446}, + {"no file specified with -fdump-translation-unit", 1447}, + {"-Wno-strict-prototypes is not supported in C++", 1448}, + {"name missing for member function", 1449}, + {"`__alignof__' applied to a bit-field", 1450}, + {"parser may be lost: is there a '{' missing somewhere?", 1451}, + {"ambiguous conversion for array subscript", 1452}, + {"anachronistic use of array size in vector delete", 1453}, {"\ cannot delete a function. Only pointer-to-objects are valid arguments to \ -`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 \ +`delete'", 1454}, + {"initializer invalid for static member with constructor", 1455}, + {"(an out of class initialization is required)", 1456}, + {"field initializer is not constant", 1457}, + {"anonymous struct not inside named type", 1458}, + {"namespace-scope anonymous aggregates must be static", 1459}, + {"anonymous aggregate with no members", 1460}, + {"`operator new' must return type `void *'", 1461}, + {"`operator new' takes type `size_t' parameter", 1462}, + {"`operator new' takes type `size_t' as first parameter", 1463}, + {"`operator delete' must return type `void'", 1464}, + {"`operator delete' takes type `void *' as first parameter", 1465}, + {"second argument to `operator delete' must be of type `size_t'", 1466}, + {"too many arguments in declaration of `operator delete'", 1467}, + {"`...' invalid in specification of `operator delete'", 1468}, + {"too many initialization functions required", 1469}, + {"use of old-style cast", 1470}, + {"`%s' not supported by dump_type", 1471}, + {"`%s' not supported by dump_type_prefix", 1472}, + {"`%s' not supported by dump_type_suffix", 1473}, + {"`%s' not supported by dump_decl", 1474}, + {"`%s' not supported by dump_expr", 1475}, + {"In %s `%s':", 1476}, + {"call to Java `catch' or `throw', while `jthrowable' undefined", 1477}, + {"mixing C++ and Java `catch'es in single translation unit", 1478}, + {" in thrown expression", 1479}, + {"\ +(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", 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}, +-Wno-non-template-friend disables this warning.", 1480}, + {"argument to `%s' missing\n", 1481}, + {"initializer list treated as compound expression", 1482}, + {" will be re-ordered to match declaration order", 1483}, + {" will be re-ordered to match inheritance order", 1484}, + {"base class initializer specified, but no base class to initialize", 1485}, + {"initializer for unnamed base class ambiguous", 1486}, + {"no base class to initialize", 1487}, + {"object missing in use of pointer-to-member construct", 1488}, + {"at this point in file", 1489}, + {"new of array type fails to specify size", 1490}, + {"size in array new must have integral type", 1491}, + {"zero size array reserves no space", 1492}, + {"new cannot be applied to a reference type", 1493}, + {"new cannot be applied to a function type", 1494}, + {"call to Java constructor, while `jclass' undefined", 1495}, + {"invalid type `void' for new", 1496}, + {"call to Java constructor, while `%s' undefined", 1497}, + {"initializer list being treated as compound expression", 1498}, + {"initializer list appears where operand should be used", 1499}, + {"initialization of array from dissimilar array type", 1500}, + {"initializer ends prematurely", 1501}, + {"cannot initialize multi-dimensional array with initializer", 1502}, + {"unknown array size in delete", 1503}, + {"type to vector delete is neither pointer or array type", 1504}, + {"type name expected before `*'", 1505}, + {"cannot declare references to references", 1506}, + {"cannot declare pointers to references", 1507}, + {"type name expected before `&'", 1508}, + {"semicolon missing after %s declaration", 1509}, + {"junk at end of #pragma %s", 1510}, + {"invalid #pragma %s", 1511}, + {"#pragma implementation for %s appears after file is included", 1512}, {"\ (Each undeclared identifier is reported only once for each function it \ -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}, +appears in.)", 1513}, + {"name lookup of `%s' changed", 1514}, + {"name lookup of `%s' changed for new ISO `for' scoping", 1515}, + {"conversion of %s as template parameter", 1516}, + {"methods cannot be converted to function pointers", 1517}, + {"ambiguous request for method pointer `%s'", 1518}, + {"request for member `%s' is ambiguous in multiple inheritance lattice", 1519}, + {"invalid default template argument", 1520}, + {"no base or member initializers given following ':'", 1521}, + {"base initializers not allowed for non-member functions", 1522}, + {"only constructors take base initializers", 1523}, + {"anachronistic old style base class initializer", 1524}, + {"`>>' should be `> >' in template class name", 1525}, + {"ISO C++ forbids an empty condition for `%s'", 1526}, + {"ISO C++ forbids `&&'", 1527}, + {"ISO C++ forbids initialization of new expression with `='", 1528}, + {"ISO C++ forbids constructor-expressions", 1529}, + {"ISO C++ forbids braced-groups within expressions", 1530}, + {"sigof type specifier", 1531}, + {"`sigof' applied to non-aggregate expression", 1532}, + {"`sigof' applied to non-aggregate type", 1533}, + {"storage class specifier `%s' not allowed after struct or class", 1534}, + {"type specifier `%s' not allowed after struct or class", 1535}, + {"type qualifier `%s' not allowed after struct or class", 1536}, + {"no body nor ';' separates two class, struct or union declarations", 1537}, + {"multiple access specifiers", 1538}, + {"multiple `virtual' specifiers", 1539}, + {"missing ';' before right brace", 1540}, + {"ISO C++ forbids array dimensions with parenthesized type in new", 1541}, + {"ISO C++ forbids label declarations", 1542}, + {"ISO C++ forbids computed gotos", 1543}, + {"label must be followed by statement", 1544}, + {"ISO C++ forbids compound statements inside for initializations", 1545}, + {"possibly missing ')'", 1546}, + {"type specifier omitted for parameter", 1547}, + {" a template type parameter must begin with `class' or `typename'", 1548}, + {"creating array with size zero", 1549}, + {"use of `%s' in template", 1550}, + {"incomplete type unification", 1551}, + {"use of `%s' in template type unification", 1552}, + {"-frepo must be used with -c", 1553}, + {"mysterious repository information in %s", 1554}, + {"can't create repository information file `%s'", 1555}, + {"taking dynamic typeid of object with -fno-rtti", 1556}, + {"cannot use typeid with -fno-rtti", 1557}, + {"must #include <typeinfo> before using typeid", 1558}, + {"adjusting pointers for covariant returns", 1559}, + {"recoverable compiler error, fixups for virtual function", 1560}, + {"identifier name `%s' conflicts with GNU C++ internal naming strategy", 1561}, + {"syntax error before '#' token", 1562}, + {"syntax error before '\\' token", 1563}, + {"keyword 'export' not implemented and will be ignored", 1564}, + {"parse error at end of saved function text", 1565}, + {"parse error in method specification", 1566}, + {"function body for constructor missing", 1567}, + {"non-lvalue in %s", 1568}, + {"`com_interface' only supported with -fvtable-thunks", 1569}, + {"`com_interface' attribute can only be applied to class definitions", 1570}, + {"requested init_priority is not an integer constant", 1571}, {"\ can only use init_priority attribute on file-scope definitions of objects of \ -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}, +class type", 1572}, + {"requested init_priority is out of range", 1573}, + {"requested init_priority is reserved for internal use", 1574}, + {"\ +ISO C++ forbids %s between pointer of type `void *' and pointer-to-function", 1575}, + {"ISO C++ forbids applying `sizeof' to a function type", 1576}, + {"ISO C++ forbids applying `sizeof' to a member function", 1577}, + {"\ +ISO C++ forbids applying `sizeof' to type `void' which is an incomplete type", 1578}, + {"sizeof applied to a bit-field", 1579}, + {"ISO C++ forbids applying `sizeof' to an expression of function type", 1580}, + {"invalid reference to NULL ptr, use ptr-to-member instead", 1581}, + {"invalid use of `%s' on pointer to member", 1582}, + {"invalid type argument", 1583}, + {"ISO C++ forbids subscripting non-lvalue array", 1584}, + {"subscripting array declared `register'", 1585}, + {"pointer to member function called, but not in class scope", 1586}, {"\ invalid call to member function needing `this' in static member function \ -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}, +scope", 1587}, + {"ISO C++ forbids calling `::main' from within program", 1588}, + {"parameter type of called function is incomplete", 1589}, + {"%s rotate count is negative", 1590}, + {"%s rotate count >= width of type", 1591}, + {"ISO C++ forbids comparison between pointer and integer", 1592}, + {"comparison between signed and unsigned integer expressions", 1593}, + {"ISO C++ forbids using pointer of type `void *' in pointer arithmetic", 1594}, + {"ISO C++ forbids using a pointer-to-function in pointer arithmetic", 1595}, + {"\ +ISO C++ forbids using a pointer to member function in pointer arithmetic", 1596}, + {"ISO C++ forbids using pointer to a member in pointer arithmetic", 1597}, + {"ISO C++ forbids using pointer of type `void *' in subtraction", 1598}, + {"ISO C++ forbids using pointer to a function in subtraction", 1599}, + {"ISO C++ forbids using pointer to a method in subtraction", 1600}, + {"ISO C++ forbids using pointer to a member in subtraction", 1601}, + {"invalid use of a pointer to an incomplete type in pointer arithmetic", 1602}, + {"taking address of temporary", 1603}, + {"ISO C++ forbids %sing an enum", 1604}, + {"cast to non-reference type used as lvalue", 1605}, + {"ISO C++ forbids taking address of function `::main'", 1606}, + {"ISO C++ forbids taking the address of a cast to a non-lvalue expression", 1607}, + {"unary `&'", 1608}, + {"cannot take the address of `this', which is an ravlue expression", 1609}, + {"\ +ISO C++ forbids casting between pointer-to-function and pointer-to-object", 1610}, + {"ISO C++ forbids casting to an array type", 1611}, + {"ISO C++ forbids cast to non-reference type used as lvalue", 1612}, + {"ISO C++ forbids assignment of arrays", 1613}, + {"return value from function receives multiple initializations", 1614}, + {" in pointer to member function conversion", 1615}, + {" in pointer to member conversion", 1616}, + {"returning reference to temporary", 1617}, + {"reference to non-lvalue returned", 1618}, + {"returning a value from a destructor", 1619}, + {"cannot return from a handler of a function-try-block of a constructor", 1620}, + {"returning a value from a constructor", 1621}, {"\ 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}, +type", 1622}, + {"\ +return-statement with a value, in function declared with a void return type", 1623}, + {" since the following virtual functions are abstract:", 1624}, + {"Internal error #%d.", 1625}, + {"due to the presence of a constructor", 1626}, + {"comma expression used to initialize return value", 1627}, + {"cannot initialize arrays using this syntax", 1628}, + {"ANSI C++ forbids non-constant aggregate initializer expressions", 1629}, + {"initializing array with parameter list", 1630}, + {"initializer for scalar variable requires one element", 1631}, + {"aggregate has a partly bracketed initializer", 1632}, + {"non-trivial labeled initializers", 1633}, + {"non-empty initializer for array of empty elements", 1634}, + {"initializer list for object of class with virtual base classes", 1635}, + {"initializer list for object of class with base classes", 1636}, + {"initializer list for object using virtual functions", 1637}, + {"index value instead of field name in union initializer", 1638}, + {"excess elements in aggregate initializer", 1639}, + {"circular pointer delegation detected", 1640}, + {"result of `operator->()' yields non-pointer result", 1641}, + {"base operand of `->' is not a pointer", 1642}, + {"ISO C++ forbids defining types within %s", 1643}, + {"Can't create cross-reference file `%s'", 1644}, + {"Internal gcc abort.", 1645}, + {"In file included from %s:%u", 1646}, {"\ ,\n\ - 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}, + from %s:%u", 1647}, + {"internal error: ", 1648}, + {"warning: ", 1649}, + {"%s: %s", 1650}, + {"traditional C rejects the `U' suffix", 1651}, + {"integer constant contains digits beyond the radix", 1652}, + {"integer constant out of range", 1653}, + {"integer constant is so large that it is unsigned", 1654}, + {"invalid suffix '%.*s' on integer constant", 1655}, + {"\"%s\" is not defined", 1656}, + {"octal escape sequence out of range", 1657}, + {"hex escape sequence out of range", 1658}, + {"integer overflow in preprocessor expression", 1659}, + {"impossible operator type %s", 1660}, + {"comma operator in operand of #if", 1661}, + {"included file \"%s\" exists but is not readable", 1662}, + {"node for '%s' exists, open failed, error '%s', value %lx\n", 1663}, + {"cpp_make_system_header: bad flag %d\n", 1664}, + {"cpp_make_system_header called on non-file buffer", 1665}, + {"Multiple include guards may be useful for:\n", 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}, + {"ignoring nonexistent directory \"%s\"\n", 1672}, + {"%s: Not a directory", 1673}, + {"ignoring duplicate directory \"%s\"\n", 1674}, + {"-MG must be specified with one of -M or -MM", 1675}, + {"#include \"...\" search starts here:\n", 1676}, + {"#include <...> search starts here:\n", 1677}, + {"End of search list.\n", 1678}, + {"buffers still stacked in cpp_finish", 1679}, + {"I/O error on output", 1680}, + {"Argument missing after %s", 1681}, + {"Assertion missing after %s", 1682}, + {"Directory name missing after %s", 1683}, + {"File name missing after %s", 1684}, + {"Macro name missing after %s", 1685}, + {"Path name missing after %s", 1686}, + {"Number missing after %s", 1687}, + {"Too many arguments. Type %s --help for usage info", 1688}, + {"GNU CPP version %s (cpplib)\n", 1689}, + {"Output filename specified twice", 1690}, + {"-I- specified twice", 1691}, + {"Usage: %s [switches] input output\n", 1692}, {"\ Switches:\n\ -include <file> Include the contents of <file> before other \ @@ -1816,7 +1783,8 @@ files\n\ -iwithprefix <dir> Add <dir> to the end of the system include path\n\ -iwithprefixbefore <dir> Add <dir> to the end of the main include path\n\ -isystem <dir> Add <dir> to the start of the system include \ -path\n\ +path\n", 1693}, + {"\ -idirafter <dir> Add <dir> to the end of the system include path\n\ -I <dir> Add <dir> to the end of the main include path\n\ -I- Fine-grained include path control; see info \ @@ -1826,20 +1794,20 @@ docs\n\ used)\n\ -nostdinc++ Do not search system include directories for \ C++\n\ - -o <file> Put output into <file>\n\ - -pedantic Issue all warnings demanded by strict ANSI C\n\ + -o <file> Put output into <file>\n", 1694}, + {"\ + -pedantic Issue all warnings demanded by strict ISO C\n\ -pedantic-errors Issue -pedantic warnings as errors instead\n\ - -traditional Follow K&R pre-processor behaviour\n\ - -trigraphs Support ANSI C trigraphs\n\ + -trigraphs Support ISO C trigraphs\n\ -lang-c Assume that the input sources are in C\n\ - -lang-c89 Assume that the input sources are in C89\n\ + -lang-c89 Assume that the input sources are in C89\n", 1695}, + {"\ -lang-c++ Assume that the input sources are in C++\n\ -lang-objc Assume that the input sources are in ObjectiveC\n\ -lang-objc++ Assume that the input sources are in \ ObjectiveC++\n\ - -lang-asm Assume that the input sources are in assembler\n\ - -lang-fortran\t\t Assume that the input sources are in Fortran\n\ - -lang-chill Assume that the input sources are in Chill\n\ + -lang-asm Assume that the input sources are in assembler\n", 1696}, + {"\ -std=<std name> Specify the conformance standard; one of:\n\ gnu89, gnu99, c89, c99, iso9899:1990,\n\ iso9899:199409, iso9899:1999\n\ @@ -1847,34 +1815,38 @@ ObjectiveC++\n\ -w Inhibit warning messages\n\ -Wtrigraphs Warn if trigraphs are encountered\n\ -Wno-trigraphs Do not warn about trigraphs\n\ - -Wcomment{s} Warn if one comment starts inside another\n\ + -Wcomment{s} Warn if one comment starts inside another\n", 1697}, + {"\ -Wno-comment{s} Do not warn about comments\n\ - -Wtraditional Warn if a macro argument is/would be turned \ -into\n\ - a string if -traditional is specified\n\ - -Wno-traditional Do not warn about stringification\n\ + -Wtraditional Warn about features not present in traditional \ +C\n\ + -Wno-traditional Do not warn about traditional C\n\ -Wundef Warn if an undefined macro is used by #if\n\ -Wno-undef Do not warn about testing undefined macros\n\ - -Wimport Warn about the use of the #import directive\n\ + -Wimport Warn about the use of the #import directive\n", 1698}, + {"\ -Wno-import Do not warn about the use of #import\n\ -Werror Treat all warnings as errors\n\ -Wno-error Do not treat warnings as errors\n\ -Wall Enable all preprocessor warnings\n\ -M Generate make dependencies\n\ - -MM As -M, but ignore system header files\n\ + -MM As -M, but ignore system header files\n", 1699}, + {"\ -MD As -M, but put output in a .d file\n\ -MMD As -MD, but ignore system header files\n\ -MG Treat missing header file as generated files\n\ -g3 Include #define and #undef directives in the \ output\n\ -D<macro> Define a <macro> with string '1' as its value\n\ - -D<macro>=<val> Define a <macro> with <val> as its value\n\ + -D<macro>=<val> Define a <macro> with <val> as its value\n", 1700}, + {"\ -A<question> (<answer>) Assert the <answer> to <question>\n\ -A-<question> (<answer>) Disable the <answer> to <question>\n\ -U<macro> Undefine <macro> \n\ -v Display the version number\n\ -H Print the name of header files as they are used\n\ - -C Do not discard comments\n\ + -C Do not discard comments\n", 1701}, + {"\ -dM Display a list of macro definitions active at \ end\n\ -dD Preserve macro definitions in output\n\ @@ -1882,558 +1854,766 @@ end\n\ -dI Include #include directives in the output\n\ -ftabstop=<number> Distance between tab stops for column reporting\n\ -P Do not generate #line directives\n\ - -$ Do not allow '$' in identifiers\n\ + -$ Do not allow '$' in identifiers\n", 1702}, + {"\ -remap Remap file names when including files.\n\ --version Display version information\n\ - -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}, + -h or --help Display this information\n", 1703}, + {"missing terminating > character", 1704}, + {"trigraph ??%c converted to %c", 1705}, + {"trigraph ??%c ignored", 1706}, + {"'/*' within comment", 1707}, + {"embedded null character ignored", 1708}, + {"%s in preprocessing directive", 1709}, + {"'$' character in identifier", 1710}, + {"multi-line string constant", 1711}, + {"missing terminating %c character", 1712}, + {"possible start of unterminated string literal", 1713}, + {"null characters preserved", 1714}, + {"null character preserved", 1715}, + {"C++ style comments are not allowed in ISO C89", 1716}, + {"(this will be reported only once per input file)", 1717}, + {"comment start split across lines", 1718}, + {"multi-line comment", 1719}, + {"comment start '/*' split across lines", 1720}, + {"unterminated comment", 1721}, + {"comment end '*/' split across lines", 1722}, + {"backslash-newline at end of file", 1723}, + {"backslash and newline separated by space", 1724}, + {"K+R C ignores #\\n with the # indented", 1725}, + {"no newline at end of file", 1726}, + {"invalid preprocessing directive #%s", 1727}, + {"invalid preprocessing directive", 1728}, + {"Unspellable token %s", 1729}, + {"function macro %s must be used with arguments in traditional C", 1730}, + {"unterminated argument list for macro \"%s\"", 1731}, + {"ISO C99 requires rest arguments to be used", 1732}, + {"not enough arguments for macro \"%s\"", 1733}, + {"too many arguments for macro \"%s\"", 1734}, + {"pasting would not give a valid preprocessing token", 1735}, + {"invalid string literal, ignoring final '\\'", 1736}, + {"two tokens pushed in a row", 1737}, + {"directive begins with %s?!", 1738}, + {"macros nested too deep invoking '%s'", 1739}, + {"#%s may not be used inside a macro argument", 1740}, + {"attempt to use poisoned \"%s\"", 1741}, + {"invalid special hash type", 1742}, + {"<command line>", 1743}, + {"traditional C ignores #%s with the # indented", 1744}, + {"suggest hiding #%s from traditional C with an indented #", 1745}, + {"ISO C does not allow #%s", 1746}, + {"# followed by integer", 1747}, + {"\"defined\" cannot be used as a macro name", 1748}, + {"\"%s\" cannot be used as a macro name in C++", 1749}, + {"macro names must be identifiers", 1750}, + {"\"%s\" cannot be used as a macro name", 1751}, + {"junk on line after #undef", 1752}, + {"undefining \"%s\"", 1753}, + {"#%s expects \"FILENAME\" or <FILENAME>", 1754}, + {"empty file name in #%s", 1755}, + {"junk at end of #%s", 1756}, + {"#import is obsolete, use an #ifndef wrapper in the header file", 1757}, + {"#include_next in primary source file", 1758}, + {"invalid format #line", 1759}, + {"token after #line is not a positive integer", 1760}, + {"line number out of range", 1761}, + {"second token after #line is not a string", 1762}, + {"garbage at end of #line", 1763}, + {"invalid #ident", 1764}, + {"unknown #pragma namespace %s", 1765}, + {"#pragma once is obsolete", 1766}, + {"#pragma once outside include file", 1767}, + {"invalid #pragma poison directive", 1768}, + {"poisoning existing macro \"%s\"", 1769}, + {"#pragma system_header outside include file", 1770}, + {"cannot find source %c%s%c", 1771}, + {"current file is older than %c%.*s%c", 1772}, + {"#%s with no argument", 1773}, + {"#%s with invalid argument", 1774}, + {"garbage at end of #%s", 1775}, + {"attempt to use poisoned identifier \"%s\"", 1776}, + {"#else without #if", 1777}, + {"#else after #else", 1778}, + {"the conditional began here", 1779}, + {"#elif without #if", 1780}, + {"#elif after #else", 1781}, + {"#endif without #if", 1782}, + {"ISO C forbids text after #%s", 1783}, + {"unterminated #%s", 1784}, + {"assertion without predicate", 1785}, + {"predicate must be an identifier", 1786}, + {"missing '(' after predicate", 1787}, + {"missing ')' to complete answer", 1788}, + {"predicate's answer is empty", 1789}, + {"junk at end of assertion", 1790}, + {"\"%s\" re-asserted", 1791}, + {"<builtin>", 1792}, + {"#include nested too deep", 1793}, + {"buffer pushed with contexts stacked", 1794}, + {"Invalid option %s", 1795}, + {"malformed #pragma implementation", 1796}, + {"\"%s\" is not a valid option to the preprocessor", 1797}, + {"too many input files", 1798}, + {";; Processing block from %d to %d, %d sets.\n", 1799}, + {"%s:%d: warning: ", 1800}, + {"%s:%d: ", 1801}, + {"%s: warning: ", 1802}, + {"%s: ", 1803}, + {"((anonymous))", 1804}, + {"sorry, not implemented: ", 1805}, + {"In method `%s':", 1806}, + {"In function `%s':", 1807}, + {"Unrecognizable insn:", 1808}, + {"Insn does not satisfy its constraints:", 1809}, {"\ -,\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}, +Internal compiler error in %s, at %s:%d\n\ +Please submit a full bug report.\n\ +See %s for instructions.", 1810}, + {"DW_LOC_OP %s not implememnted yet.\n", 1811}, + {"internal regno botch: regno = %d\n", 1812}, + {"getpwd", 1813}, {"\ -Unable to access real part of complex value in a hard register on this target", 1834}, +Unable to access real part of complex value in a hard register on this target", 1814}, {"\ Unable to access imaginary part of complex value in a hard register on this \ -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}, +target", 1815}, + {"ICE: emit_insn used where emit_jump_insn needed:\n", 1816}, + {"additional handler after ...", 1817}, + {"Cannot duplicate non-existant exception region.", 1818}, + {"exception handling disabled, use -fexceptions to enable", 1819}, + {"Never issued previous false_label", 1820}, + {"Counted %d copies of EH region %d in list.\n", 1821}, + {"Duplicate call to __builtin_eh_return", 1822}, + {"function uses __builtin_eh_return", 1823}, + {"stack limits not supported on this target", 1824}, + {"function using short complex types cannot be inline", 1825}, + {"unsupported wide integer operation", 1826}, + {"prior parameter's size depends on `%s'", 1827}, + {"returned value in block_exit_expr", 1828}, + {"invalid `asm': %s", 1829}, + {"output_operand: %s", 1830}, + {"operand number missing after %-letter", 1831}, + {"operand number out of range", 1832}, + {"invalid %%-code", 1833}, + {"`%l' operand isn't a label", 1834}, + {"ICE: would have deleted prologue/epilogue insn", 1835}, + {"End insn %d for block %d not found in the insn stream.", 1836}, + {"Insn %d is in multiple basic blocks (%d and %d)", 1837}, + {"Head insn %d for block %d not found in the insn stream.", 1838}, + {"Basic block %i edge lists are corrupted", 1839}, + {"Basic block %d pred edge is corrupted", 1840}, + {"NOTE_INSN_BASIC_BLOCK is missing for block %d", 1841}, + {"NOTE_INSN_BASIC_BLOCK is missing for block %d\n", 1842}, + {"NOTE_INSN_BASIC_BLOCK %d in the middle of basic block %d", 1843}, + {"In basic block %d:", 1844}, + {"Basic blocks not numbered consecutively", 1845}, + {"number of bb notes in insn chain (%d) != n_basic_blocks (%d)", 1846}, + {"comparison is always %d due to width of bitfield", 1847}, + {"comparison is always %d", 1848}, + {"`or' of unmatched not-equal tests is always 1", 1849}, + {"`and' of mutually exclusive equal-tests is always 0", 1850}, + {"`%s' might be used uninitialized in this function", 1851}, + {"variable `%s' might be clobbered by `longjmp' or `vfork'", 1852}, + {"argument `%s' might be clobbered by `longjmp' or `vfork'", 1853}, + {"function returns an aggregate", 1854}, + {"unused parameter `%s'", 1855}, + {"Ambiguous abbreviation %s", 1856}, + {"Incomplete `%s' option", 1857}, + {"Missing argument to `%s' option", 1858}, + {"Extraneous argument to `%s' option", 1859}, + {"Using builtin specs.\n", 1860}, {"\ Setting spec %s to '%s'\n\ -\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}, +\n", 1861}, + {"Reading specs from %s\n", 1862}, + {"specs %%include syntax malformed after %ld characters", 1863}, + {"Could not find specs file %s\n", 1864}, + {"specs %%rename syntax malformed after %ld characters", 1865}, + {"specs %s spec was not found to be renamed", 1866}, + {"rename spec %s to %s\n", 1867}, {"\ spec is '%s'\n\ -\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", 1868}, + {"specs unknown %% command after %ld characters", 1869}, + {"specs file malformed after %ld characters", 1870}, + {"spec file has no spec for linking", 1871}, + {"-pipe not supported", 1872}, {"\ \n\ -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}, +Go ahead? (y or n) ", 1873}, + {"\ +Internal error: %s (program %s)\n\ +Please submit a full bug report.\n\ +See %s for instructions.", 1874}, + {"# %s %.2f %.2f\n", 1875}, + {"Usage: %s [options] file...\n", 1876}, + {"Options:\n", 1877}, + {" -pass-exit-codes Exit with highest error code from a phase\n", 1878}, + {" --help Display this information\n", 1879}, + {" (Use '-v --help' to display command line options of sub-processes)\n", 1880}, + {" -dumpspecs Display all of the built in spec strings\n", 1881}, + {" -dumpversion Display the version of the compiler\n", 1882}, + {" -dumpmachine Display the compiler's target processor\n", 1883}, + {"\ + -print-search-dirs Display the directories in the compiler's search \ +path\n", 1884}, + {"\ + -print-libgcc-file-name Display the name of the compiler's companion \ +library\n", 1885}, + {" -print-file-name=<lib> Display the full path to library <lib>\n", 1886}, + {"\ + -print-prog-name=<prog> Display the full path to compiler component \ +<prog>\n", 1887}, + {"\ + -print-multi-directory Display the root directory for versions of \ +libgcc\n", 1888}, + {"\ + -print-multi-lib Display the mapping between command line options \ +and\n\ + multiple library search directories\n", 1889}, + {"\ + -Wa,<options> Pass comma-separated <options> on to the \ +assembler\n", 1890}, + {"\ + -Wp,<options> Pass comma-separated <options> on to the \ +preprocessor\n", 1891}, + {"\ + -Wl,<options> Pass comma-separated <options> on to the linker\n", 1892}, + {" -Xlinker <arg> Pass <arg> on to the linker\n", 1893}, + {" -save-temps Do not delete intermediate files\n", 1894}, + {" -pipe Use pipes rather than intermediate files\n", 1895}, + {" -time Time the execution of each subprocess\n", 1896}, + {"\ + -specs=<file> Override builtin specs with the contents of \ +<file>\n", 1897}, + {"\ + -std=<standard> Assume that the input sources are for <standard>\n", 1898}, + {"\ + -B <directory> Add <directory> to the compiler's search paths\n", 1899}, + {" -b <machine> Run gcc for target <machine>, if installed\n", 1900}, + {"\ + -V <version> Run gcc version number <version>, if installed\n", 1901}, + {"\ + -v Display the programs invoked by the compiler\n", 1902}, + {"\ + -E Preprocess only; do not compile, assemble or \ +link\n", 1903}, + {" -S Compile only; do not assemble or link\n", 1904}, + {" -c Compile and assemble, but do not link\n", 1905}, + {" -o <file> Place the output into <file>\n", 1906}, + {"\ + -x <language> Specify the language of the following input \ +files\n\ + Permissable languages include: c c++ assembler \ +none\n\ + 'none' means revert to the default behaviour of\n\ + guessing the language based on the file's \ +extension\n", 1907}, + {"\ +\n\ +Options starting with -g, -f, -m, -O or -W are automatically passed on to\n\ +the various sub-processes invoked by %s. In order to pass other options\n\ +on to these processes the -W<letter> options must be used.\n", 1908}, + {"argument to `-Xlinker' is missing", 1909}, + {"argument to `-specs' is missing", 1910}, + {"argument to `-specs=' is missing", 1911}, + {"argument to `-b' is missing", 1912}, + {"argument to `-B' is missing", 1913}, + {"argument to `-V' is missing", 1914}, + {"invalid version number format", 1915}, + {"cannot specify -o with -c or -S and multiple compilations", 1916}, + {"Warning: -pipe ignored since -save-temps specified", 1917}, + {"Warning: -pipe ignored since -time specified", 1918}, + {"argument to `-x' is missing", 1919}, + {"argument to `-%s' is missing", 1920}, + {"Warning: `-x %s' after last input file has no effect", 1921}, + {"Invalid specification! Bug in cc.", 1922}, + {"Spec failure: '%%*' has not been initialised by pattern match", 1923}, + {"Warning: use of obsolete %%[ operator in specs", 1924}, + {"Processing spec %c%s%c, which is '%s'\n", 1925}, + {"Spec failure: Unrecognised spec option '%c'", 1926}, + {"unrecognized option `-%s'", 1927}, + {"install: %s%s\n", 1928}, + {"programs: %s\n", 1929}, + {"libraries: %s\n", 1930}, + {"\ +\n\ +For bug reporting instructions, please see:\n", 1931}, + {"gcc version %s\n", 1932}, + {"gcc driver version %s executing gcc version %s\n", 1933}, + {"No input files", 1934}, + {"%s: %s compiler not installed on this system", 1935}, + {"%s: linker input file unused since linking not done", 1936}, + {"language %s not recognized", 1937}, + {"Internal gcov abort.\n", 1938}, + {"gcov [-b] [-v] [-n] [-l] [-f] [-o OBJDIR] file\n", 1939}, + {"Could not open basic block file %s.\n", 1940}, + {"Could not open data file %s.\n", 1941}, + {"Assuming that all execution counts are zero.\n", 1942}, + {"Could not open program flow graph file %s.\n", 1943}, + {"No executable code associated with file %s.\n", 1944}, + {".da file contents exhausted too early\n", 1945}, + {".da file contents not exhausted\n", 1946}, + {"%6.2f%% of %d source lines executed in function %s\n", 1947}, + {"No executable source lines in function %s\n", 1948}, + {"%6.2f%% of %d branches executed in function %s\n", 1949}, + {"%6.2f%% of %d branches taken at least once in function %s\n", 1950}, + {"No branches in function %s\n", 1951}, + {"%6.2f%% of %d calls executed in function %s\n", 1952}, + {"No calls in function %s\n", 1953}, + {"didn't use all bb entries of graph, function %s\n", 1954}, + {"block_num = %ld, num_blocks = %d\n", 1955}, + {"ERROR: too many basic blocks in .bb file %s\n", 1956}, + {"%6.2f%% of %d source lines executed in file %s\n", 1957}, + {"No executable source lines in file %s\n", 1958}, + {"%6.2f%% of %d branches executed in file %s\n", 1959}, + {"%6.2f%% of %d branches taken at least once in file %s\n", 1960}, + {"No branches in file %s\n", 1961}, + {"%6.2f%% of %d calls executed in file %s\n", 1962}, + {"No calls in file %s\n", 1963}, + {"Could not open source file %s.\n", 1964}, + {"Could not open output file %s.\n", 1965}, + {"Creating %s.\n", 1966}, + {"call %d never executed\n", 1967}, + {"call %d returns = %d\n", 1968}, + {"call %d returns = %d%%\n", 1969}, + {"branch %d never executed\n", 1970}, + {"branch %d taken = %d\n", 1971}, + {"branch %d taken = %d%%\n", 1972}, + {"Unexpected EOF while reading source file %s.\n", 1973}, + {"%s: option `%s' is ambiguous\n", 1974}, + {"%s: option `--%s' doesn't allow an argument\n", 1975}, + {"%s: option `%c%s' doesn't allow an argument\n", 1976}, + {"%s: option `%s' requires an argument\n", 1977}, + {"%s: unrecognized option `--%s'\n", 1978}, + {"%s: unrecognized option `%c%s'\n", 1979}, + {"%s: illegal option -- %c\n", 1980}, + {"%s: invalid option -- %c\n", 1981}, + {"%s: option requires an argument -- %c\n", 1982}, + {"%s: option `-W %s' is ambiguous\n", 1983}, + {"%s: option `-W %s' doesn't allow an argument\n", 1984}, + {"fix_sched_param: unknown param: %s", 1985}, + {"no memory", 1986}, + {"varargs function cannot be inline", 1987}, + {"function using alloca cannot be inline", 1988}, + {"function using setjmp cannot be inline", 1989}, + {"function with nested functions cannot be inline", 1990}, + {"function with label addresses used in initializers cannot inline", 1991}, + {"function too large to be inline", 1992}, + {"no prototype, and parameter address used; cannot be inline", 1993}, + {"inline functions not supported for this return value type", 1994}, + {"function with varying-size return value cannot be inline", 1995}, + {"function with varying-size parameter cannot be inline", 1996}, + {"function with transparent unit parameter cannot be inline", 1997}, + {"function with computed jump cannot inline", 1998}, + {"function with nonlocal goto cannot be inline", 1999}, + {"function with complex parameters cannot be inline", 2000}, + {"function with target specific attribute(s) cannot be inlined", 2001}, + {"Objective-C text in C source file", 2002}, + {"no class name specified as argument to -fconstant-string-class", 2003}, + {"object does not conform to the `%s' protocol", 2004}, + {"class `%s' does not implement the `%s' protocol", 2005}, + {"`%s' cannot be statically allocated", 2006}, + {"statically allocated objects not supported", 2007}, + {"Unexpected type for `id' (%s)", 2008}, + {"Undefined type `id', please import <objc/objc.h>", 2009}, + {"Cannot find protocol declaration for `%s'", 2010}, + {"Cannot find interface declaration for `%s'", 2011}, + {"Cannot find class `%s'", 2012}, + {"Class `%s' already exists", 2013}, + {"Cannot find interface declaration for `%s', superclass of `%s'", 2014}, + {"Circular inheritance in interface declaration for `%s'", 2015}, + {"inconsistent instance variable specification", 2016}, + {"multiple declarations for method `%s'", 2017}, + {"invalid receiver type `%s'", 2018}, + {"`%s' does not respond to `%s'", 2019}, + {"no super class declared in interface for `%s'", 2020}, + {"cannot find class (factory) method.", 2021}, + {"return type for `%s' defaults to id", 2022}, + {"method `%s' not implemented by protocol.", 2023}, + {"return type defaults to id", 2024}, + {"cannot find method.", 2025}, + {"instance variable `%s' accessed in class method", 2026}, + {"duplicate definition of class method `%s'.", 2027}, + {"duplicate declaration of class method `%s'.", 2028}, + {"duplicate definition of instance method `%s'.", 2029}, + {"duplicate declaration of instance method `%s'.", 2030}, + {"duplicate interface declaration for category `%s(%s)'", 2031}, + {"instance variable `%s' is declared private", 2032}, + {"instance variable `%s' is declared %s", 2033}, + {"static access to object of type `id'", 2034}, + {"incomplete implementation of class `%s'", 2035}, + {"incomplete implementation of category `%s'", 2036}, + {"method definition for `%c%s' not found", 2037}, + {"%s `%s' does not fully implement the `%s' protocol", 2038}, + {"reimplementation of class `%s'", 2039}, + {"conflicting super class name `%s'", 2040}, + {"duplicate interface declaration for class `%s'", 2041}, + {"duplicate declaration for protocol `%s'", 2042}, + {"[super ...] must appear in a method context", 2043}, + {"potential selector conflict for method `%s'", 2044}, + {"`@end' must appear in an implementation context", 2045}, + {"method definition not in class context", 2046}, + {"Arc profiling: some edge counts were bad.", 2047}, + {"file %s not found, execution counts assumed to be zero.", 2048}, + {"%s: internal abort\n", 2049}, + {"%s: error writing file `%s': %s\n", 2050}, + {"%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ filename ... ]'\n", 2051}, + {"%s: usage '%s [ -VqfnkNlgC ] [ -B <dirname> ] [ filename ... ]'\n", 2052}, + {"%s: warning: no read access for file `%s'\n", 2053}, + {"%s: warning: no write access for file `%s'\n", 2054}, + {"%s: warning: no write access for dir containing `%s'\n", 2055}, + {"%s: invalid file name: %s\n", 2056}, + {"%s: %s: can't get status: %s\n", 2057}, + {"\ +\n\ +%s: fatal error: aux info file corrupted at line %d\n", 2058}, + {"%s:%d: declaration of function `%s' takes different forms\n", 2059}, + {"%s: compiling `%s'\n", 2060}, + {"%s: wait: %s\n", 2061}, + {"%s: subprocess got fatal signal %d\n", 2062}, + {"%s: %s exited with status %d\n", 2063}, + {"%s: warning: missing SYSCALLS file `%s'\n", 2064}, + {"%s: can't read aux info file `%s': %s\n", 2065}, + {"%s: can't get status of aux info file `%s': %s\n", 2066}, + {"%s: can't open aux info file `%s' for reading: %s\n", 2067}, + {"%s: error reading aux info file `%s': %s\n", 2068}, + {"%s: error closing aux info file `%s': %s\n", 2069}, + {"%s: can't delete aux info file `%s': %s\n", 2070}, + {"%s: can't delete file `%s': %s\n", 2071}, + {"%s: warning: can't rename file `%s' to `%s': %s\n", 2072}, + {"%s: conflicting extern definitions of '%s'\n", 2073}, + {"%s: declarations of '%s' will not be converted\n", 2074}, + {"%s: conflict list for '%s' follows:\n", 2075}, + {"%s: warning: using formals list from %s(%d) for function `%s'\n", 2076}, + {"%s: %d: `%s' used but missing from SYSCALLS\n", 2077}, + {"%s: %d: warning: no extern definition for `%s'\n", 2078}, + {"%s: warning: no static definition for `%s' in file `%s'\n", 2079}, + {"%s: multiple static defs of `%s' in file `%s'\n", 2080}, + {"%s: %d: warning: source too confusing\n", 2081}, + {"%s: %d: warning: varargs function declaration not converted\n", 2082}, + {"%s: declaration of function `%s' not converted\n", 2083}, + {"%s: warning: too many parameter lists in declaration of `%s'\n", 2084}, {"\ \n\ -%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}, +%s: warning: too few parameter lists in declaration of `%s'\n", 2085}, + {"%s: %d: warning: found `%s' but expected `%s'\n", 2086}, + {"%s: local declaration for function `%s' not inserted\n", 2087}, {"\ \n\ -%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}, +%s: %d: warning: can't add declaration of `%s' into macro call\n", 2088}, + {"%s: global declarations for file `%s' not inserted\n", 2089}, + {"%s: definition of function `%s' not converted\n", 2090}, + {"%s: %d: warning: definition of %s not converted\n", 2091}, + {"%s: found definition of `%s' at %s(%d)\n", 2092}, + {"%s: %d: warning: `%s' excluded by preprocessing\n", 2093}, + {"%s: function definition not converted\n", 2094}, + {"%s: `%s' not converted\n", 2095}, + {"%s: would convert file `%s'\n", 2096}, + {"%s: converting file `%s'\n", 2097}, + {"%s: can't get status for file `%s': %s\n", 2098}, + {"%s: can't open file `%s' for reading: %s\n", 2099}, {"\ \n\ -%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}, +%s: error reading input file `%s': %s\n", 2100}, + {"%s: can't create/open clean file `%s': %s\n", 2101}, + {"%s: warning: file `%s' already saved in `%s'\n", 2102}, + {"%s: can't link file `%s' to `%s': %s\n", 2103}, + {"%s: can't create/open output file `%s': %s\n", 2104}, + {"%s: can't change mode of file `%s': %s\n", 2105}, + {"%s: cannot get working directory: %s\n", 2106}, + {"%s: input file names must have .c suffixes: %s\n", 2107}, + {"conversion from NaN to int", 2108}, + {"conversion from NaN to unsigned int", 2109}, + {"floating point overflow", 2110}, + {"overflow on truncation to integer", 2111}, + {"overflow on truncation to unsigned integer", 2112}, + {"%s: argument domain error", 2113}, + {"%s: function singularity", 2114}, + {"%s: overflow range error", 2115}, + {"%s: underflow range error", 2116}, + {"%s: total loss of precision", 2117}, + {"%s: partial loss of precision", 2118}, + {"%s: NaN - producing operation", 2119}, + {"Output constraint %d must specify a single register", 2120}, + {"Output regs must be grouped at top of stack", 2121}, + {"Implicitly popped regs must be grouped at top of stack", 2122}, + {"Output operand %d must use `&' constraint", 2123}, + {"can't use '%s' as a %s register", 2124}, + {"unknown register name: %s", 2125}, + {"global register variable follows a function definition", 2126}, + {"register used for two global register variables", 2127}, + {"call-clobbered register used for global register variable", 2128}, + {"cannot reload integer constant operand in `asm'", 2129}, + {"impossible register constraint in `asm'", 2130}, + {"`&' constraint used with no register class", 2131}, + {"inconsistent operand constraints in an `asm'", 2132}, + {"frame size too large for reliable stack checking", 2133}, + {"try reducing the number of local variables", 2134}, + {"Can't find a register in class `%s' while reloading `asm'.", 2135}, + {"Unable to find a register to spill in class `%s'.", 2136}, + {"`asm' operand requires impossible reload", 2137}, + {"`asm' operand constraint incompatible with operand size", 2138}, + {"output operand is constant in `asm'", 2139}, + {"RTL check: access of elt %d of `%s' with last elt %d", 2140}, + {"RTL check: expected elt %d type '%c', have '%c' (rtx %s)", 2141}, + {"RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s)", 2142}, + {"RTL check: expected code `%s', have `%s'", 2143}, + {"RTL check: expected code `%s' or `%s', have `%s'", 2144}, + {"RTL check: access of elt %d of vector with last elt %d", 2145}, + {"jump to `%s' invalidly jumps into binding contour", 2146}, + {"label `%s' used before containing binding contour", 2147}, + {"`asm' cannot be used in function where memory usage is checked", 2148}, + {"`asm' cannot be used with `-fcheck-memory-usage'", 2149}, + {"unknown register name `%s' in `asm'", 2150}, + {"too many alternatives in `asm'", 2151}, + {"operand constraints for `asm' differ in number of alternatives", 2152}, + {"output operand constraint lacks `='", 2153}, + {"output constraint `%c' for operand %d is not at the beginning", 2154}, + {"output operand constraint %d contains `+'", 2155}, + {"operand constraint contains '+' or '=' at illegal position.", 2156}, + {"`%%' constraint used with last operand", 2157}, + {"matching constraint not valid in output operand", 2158}, + {"invalid punctuation `%c' in constraint", 2159}, + {"output number %d not directly addressable", 2160}, + {"more than %d operands in `asm'", 2161}, + {"hard register `%s' listed as input operand to `asm'", 2162}, + {"input operand constraint contains `%c'", 2163}, + {"matching constraint references invalid operand number", 2164}, + {"asm operand %d probably doesn't match constraints", 2165}, + {"unused variable `%s'", 2166}, + {"enumeration value `%s' not handled in switch", 2167}, + {"case value `%ld' not in enumerated type", 2168}, + {"case value `%ld' not in enumerated type `%s'", 2169}, + {"type size can't be explicitly evaluated", 2170}, + {"variable-size type declared outside of any function", 2171}, + {"size of `%s' is %d bytes", 2172}, + {"size of `%s' is larger than %d bytes", 2173}, + {"packed attribute causes inefficient alignment for `%s'", 2174}, + {"packed attribute is unnecessary for `%s'", 2175}, + {"padding struct to align `%s'", 2176}, + {"padding struct size to alignment boundary", 2177}, + {"packed attribute causes inefficient alignment", 2178}, + {"packed attribute is unnecessary", 2179}, {"\ \n\ -%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\ +Execution times (seconds)\n", 2180}, + {" TOTAL :", 2181}, + {"time in %s: %ld.%06ld (%ld%%)\n", 2182}, + {"collect: reading %s\n", 2183}, + {"collect: recompiling %s\n", 2184}, + {"collect: tweaking %s in %s\n", 2185}, + {"collect: relinking\n", 2186}, + {"ld returned %d exit status", 2187}, + {"Invalid option `%s'", 2188}, + {"\ +Internal error: %s.\n\ Please submit a full bug report.\n\ -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}, +See %s for instructions.", 2189}, + {"`%s' used but never defined", 2190}, + {"`%s' declared `static' but never defined", 2191}, + {"`%s' defined but not used", 2192}, + {"-ffunction-sections not supported for this target.", 2193}, + {"-fdata-sections not supported for this target.", 2194}, + {"-ffunction-sections disabled; it makes profiling impossible.", 2195}, + {"-ffunction-sections may affect debugging on some targets.", 2196}, + {"Errors detected in input file (your bison.simple is out of date)\n", 2197}, + {"invalid register name `%s' for register variable", 2198}, + {"Usage: %s input [switches]\n", 2199}, + {"Switches:\n", 2200}, + {"\ + -ffixed-<register> Mark <register> as being unavailable to the \ +compiler\n", 2201}, + {"\ + -fcall-used-<register> Mark <register> as being corrupted by function \ +calls\n", 2202}, + {"\ + -fcall-saved-<register> Mark <register> as being preserved across \ +functions\n", 2203}, + {"\ + -finline-limit=<number> Limits the size of inlined functions to <number>\n", 2204}, + {"\ + -fmessage-length=<number> Limits diagnostics messages lengths to <number> \ +characters per line. 0 suppresses line-wrapping\n", 2205}, + {"\ + -fdiagnostics-show-location=[once | every-line] Indicates how often source \ +location information should be emitted, as prefix, at the beginning of \ +diagnostics when line-wrapping\n", 2206}, + {" -O[number] Set optimisation level to [number]\n", 2207}, + {" -Os Optimise for space rather than speed\n", 2208}, + {"\ + -pedantic Issue warnings needed by strict compliance to ISO \ +C\n", 2209}, + {"\ + -pedantic-errors Like -pedantic except that errors are produced\n", 2210}, + {" -w Suppress warnings\n", 2211}, + {" -W Enable extra warnings\n", 2212}, + {" -Wunused Enable unused warnings\n", 2213}, + {"\ + -Wid-clash-<num> Warn if 2 identifiers have the same first <num> \ +chars\n", 2214}, + {"\ + -Wlarger-than-<number> Warn if an object is larger than <number> bytes\n", 2215}, + {" -p Enable function profiling\n", 2216}, + {" -a Enable block profiling \n", 2217}, + {" -ax Enable jump profiling \n", 2218}, + {" -o <file> Place output into <file> \n", 2219}, + {"\ + -G <number> Put global and static data smaller than <number>\n\ + bytes into a special section (on some targets)\n", 2220}, + {" -aux-info <file> Emit declaration info into <file>.X\n", 2221}, + {"\ + -quiet Do not display functions compiled or elapsed time\n", 2222}, + {" -version Display the compiler's version\n", 2223}, + {"\ + -d[letters] Enable dumps from specific passes of the compiler\n", 2224}, + {"\ + -dumpbase <file> Base name to be used for dumps from specific \ +passes\n", 2225}, + {" -fsched-verbose=<number> Set the verbosity level of the scheduler\n", 2226}, + {" --help Display this information\n", 2227}, + {"\ +\n\ +Language specific options:\n", 2228}, + {" %-23.23s [undocumented]\n", 2229}, + {"\ +\n\ +There are undocumented %s specific options as well.\n", 2230}, + {"\ +\n\ + Options for %s:\n", 2231}, + {"\ +\n\ +Target specific options:\n", 2232}, + {" -m%-21.21s [undocumented]\n", 2233}, + {"\ +\n\ +There are undocumented target specific options as well.\n", 2234}, + {" They exist, but they are not documented.\n", 2235}, + {"unrecognized gcc debugging option: %c", 2236}, + {"unrecognized register name `%s'", 2237}, + {"Unrecognized option `%s'", 2238}, + {"use -gdwarf -g%d for DWARF v1, level %d", 2239}, + {"use -gdwarf-2 for DWARF v2", 2240}, + {"ignoring option `%s' due to invalid debug level specification", 2241}, + {"`%s': unknown or unsupported -g option", 2242}, + {"`%s' ignored, conflicts with `-g%s'", 2243}, + {"`-a' option (basic block profile) not supported", 2244}, + {"`-ax' option (jump profiling) not supported", 2245}, + {"Ignoring command line option '%s'", 2246}, + {"(It is valid for %s but not the selected language)", 2247}, + {"-Wuninitialized is not supported without -O", 2248}, + {"`-ax' and `-a' are conflicting options. `-a' ignored.", 2249}, + {"instruction scheduling not supported on this target machine", 2250}, + {"this target machine does not have delayed branches", 2251}, + {"-f%sleading-underscore not supported on this target machine", 2252}, + {"Data size %ld.\n", 2253}, {"\ %s%s%s version %s (%s) compiled by GNU C version %s.\n\ -%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}, +%s%s%s version %s (%s) compiled by CC.\n", 2254}, + {"options passed: ", 2255}, + {"options enabled: ", 2256}, + {"macro or #include recursion too deep", 2257}, + {"Usage: %s [switches] input output", 2258}, + {"-traditional is not supported in C++", 2259}, + {"-traditional and -ansi are mutually exclusive", 2260}, + {"Filename missing after -i option", 2261}, + {"Filename missing after -o option", 2262}, + {"Macro name missing after -D option", 2263}, + {"Macro name missing after -U option", 2264}, + {"-pedantic and -traditional are mutually exclusive", 2265}, + {"-trigraphs and -traditional are mutually exclusive", 2266}, + {"Directory name missing after -I option", 2267}, + {"`/*' within comment", 2268}, + {"unterminated #%s conditional", 2269}, + {"not in any file?!", 2270}, + {"`defined' must be followed by ident or (ident)", 2271}, + {"cccp error: invalid special hash type", 2272}, + {"#include expects \"fname\" or <fname>", 2273}, + {"nonexistent file <%.*s> omitted from dependency output", 2274}, + {"invalid macro name", 2275}, + {"invalid macro name `%s'", 2276}, + {"defining `defined' as a macro", 2277}, + {"parameter name starts with a digit in #define", 2278}, + {"badly punctuated parameter list in #define", 2279}, + {"unterminated parameter list in #define", 2280}, + {"\"%.*s\" redefined", 2281}, + {"# operator should be followed by a macro argument name", 2282}, + {"invalid format #line command", 2283}, + {"undefining `defined'", 2284}, + {"undefining `%s'", 2285}, + {"#elif not within a conditional", 2286}, + {"#%s not within a conditional", 2287}, + {"#else or #elif after #else", 2288}, + {"#else not within a conditional", 2289}, + {"unbalanced #endif", 2290}, + {"unterminated string or character constant", 2291}, + {"arguments given to macro `%s'", 2292}, + {"no args to macro `%s'", 2293}, + {"only 1 arg to macro `%s'", 2294}, + {"only %d args to macro `%s'", 2295}, + {"too many (%d) args to macro `%s'", 2296}, + {"\ +Internal error in %s, at tradcpp.c:%d\n\ +Please submit a full bug report.\n\ +See %s for instructions.", 2297}, + {"`%s' and `%s' identical in first %d characters", 2298}, + {"arrays of functions are not meaningful", 2299}, + {"function return type cannot be function", 2300}, + {"invalid initializer for bit string", 2301}, + {"Tree check: expected %s, have %s", 2302}, + {"Tree check: expected class '%c', have '%c' (%s)", 2303}, + {"register name not specified for `%s'", 2304}, + {"invalid register name for `%s'", 2305}, + {"data type of `%s' isn't suitable for a register", 2306}, + {"register specified for `%s' isn't suitable for data type", 2307}, + {"global register variable has initial value", 2308}, + {"volatile register variables don't work as you might wish", 2309}, + {"register name given for non-register variable `%s'", 2310}, + {"size of variable `%s' is too large", 2311}, + {"\ +alignment of `%s' is greater than maximum object file alignment. Using %d.", 2312}, + {"requested alignment for %s is greater than implemented alignment of %d.", 2313}, + {"floating point trap outputting a constant", 2314}, + {"initializer for integer value is too complicated", 2315}, + {"initializer for floating value is not a floating constant", 2316}, + {"unknown set constructor type", 2317}, + {"invalid initial value for member `%s'", 2318}, + {"weak declaration of `%s' must be public", 2319}, + {"weak declaration of `%s' must precede definition", 2320}, + {"only weak aliases are supported in this configuration", 2321}, + {"alias definitions not supported in this configuration; ignored", 2322}, + {"Virtual array %s[%lu]: element %lu out of bounds", 2323}, + {"Unknown stab %s: : 0x%x\n", 2324}, + {"may not use both -EB and -EL", 2325}, + {"-mapcs-26 and -mapcs-32 may not be used together", 2326}, + {"-msoft-float and -mhard_float may not be used together", 2327}, + {"-mbig-endian and -mlittle-endian may not be used together", 2328}, + {"Incompatible interworking options", 2329}, + {"-mbsd and -pedantic incompatible", 2330}, + {"-mbsd and -mxopen incompatible", 2331}, + {"-mxopen and -pedantic incompatible", 2332}, + {"A -ifile option requires a -map option", 2333}, + {"`-p' not supported; use `-pg' and gprof(1)", 2334}, + {"-static not valid with -mcoff", 2335}, + {"-shared not valid with -mcoff", 2336}, + {"-symbolic not valid with -mcoff", 2337}, + {"-fpic is not valid with -mcoff", 2338}, + {"-fPIC is not valid with -mcoff", 2339}, + {"-fpic not valid with -mcoff", 2340}, + {"-fPIC not valid with -mcoff", 2341}, + {"-p option not supported: use -pg instead", 2342}, + {"-pipe is not supported.", 2343}, + {"may not use both -mfp64 and -msingle-float", 2344}, + {"may not use both -mfp64 and -m4650", 2345}, + {"-mhard-float not supported.", 2346}, + {"-msingle-float and -msoft-float can not both be specified.", 2347}, + {"-p profiling is no longer supported. Use -pg instead.", 2348}, + {"profiling not supported with -mg\n", 2349}, + {"GNU C does not support -C without using -E", 2350}, + {"-pg and -fomit-frame-pointer are incompatible", 2351}, + {"-E required when input is from standard input", 2352}, + {"Compilation of header file requested", 2353}, }; -int _msg_tbl_length = 2248; +int _msg_tbl_length = 2353; |