39a40
> #include "intl.h"
58c59
< static tree convert_for_assignment PROTO((tree, tree, char *, tree,
---
> static tree convert_for_assignment PROTO((tree, tree, const char *, tree,
60c61,62
< static void warn_for_assignment PROTO((char *, char *, tree, int));
---
> static void warn_for_assignment PROTO((const char *, const char *,
> tree, int));
62c64
< static void push_string PROTO((char *));
---
> static void push_string PROTO((const char *));
67,69c69
< static char *get_spelling PROTO((char *));
< static void warning_init PROTO((char *, char *,
< char *));
---
> static void warning_init PROTO((const char *));
85a86,88
> if (TREE_CODE (value) == ERROR_MARK)
> return error_mark_node;
>
104c107
< char *errmsg;
---
> const char *type_code_string;
122c125
< errmsg = "invalid use of undefined type `struct %s'";
---
> type_code_string = "struct";
126c129
< errmsg = "invalid use of undefined type `union %s'";
---
> type_code_string = "union";
130c133
< errmsg = "invalid use of undefined type `enum %s'";
---
> type_code_string = "enum";
151c154,155
< error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
---
> error ("invalid use of undefined type `%s %s'",
> type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
166,168c170
< int constflag = TYPE_READONLY (type) || TYPE_READONLY (like);
< int volflag = TYPE_VOLATILE (type) || TYPE_VOLATILE (like);
< return c_build_type_variant (type, constflag, volflag);
---
> return c_build_qualified_type (type, TYPE_QUALS (like));
286,293c288,295
< tree target = common_type (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
< TYPE_MAIN_VARIANT (TREE_TYPE (t2)));
< int constp
< = TYPE_READONLY (TREE_TYPE (t1)) || TYPE_READONLY (TREE_TYPE (t2));
< int volatilep
< = TYPE_VOLATILE (TREE_TYPE (t1)) || TYPE_VOLATILE (TREE_TYPE (t2));
< t1 = build_pointer_type (c_build_type_variant (target, constp,
< volatilep));
---
> tree pointed_to_1 = TREE_TYPE (t1);
> tree pointed_to_2 = TREE_TYPE (t2);
> tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
> TYPE_MAIN_VARIANT (pointed_to_2));
> t1 = build_pointer_type (c_build_qualified_type
> (target,
> TYPE_QUALS (pointed_to_1) |
> TYPE_QUALS (pointed_to_2)));
450c452
< if (TYPE_READONLY (t1) != TYPE_READONLY (t2))
---
> if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
452,453d453
< if (TYPE_VOLATILE (t1) != TYPE_VOLATILE (t2))
< return 0;
1087,1091c1087,1092
< if (TYPE_READONLY (type) || TYPE_VOLATILE (type)
< || constp || volatilep)
< restype = c_build_type_variant (restype,
< TYPE_READONLY (type) || constp,
< TYPE_VOLATILE (type) || volatilep);
---
> if (TYPE_QUALS (type) || constp || volatilep)
> restype
> = c_build_qualified_type (restype,
> TYPE_QUALS (type)
> | (constp * TYPE_QUAL_CONST)
> | (volatilep * TYPE_QUAL_VOLATILE));
1327c1328
< char *errorstring;
---
> const char *errorstring;
2796d2796
< char *errstring = NULL;
2812c2812,2815
< errstring = "wrong type argument to unary plus";
---
> {
> error ("wrong type argument to unary plus");
> return error_mark_node;
> }
2820c2823,2826
< errstring = "wrong type argument to unary minus";
---
> {
> error ("wrong type argument to unary minus");
> return error_mark_node;
> }
2833c2839,2842
< errstring = "wrong type argument to bit-complement";
---
> {
> error ("wrong type argument to bit-complement");
> return error_mark_node;
> }
2841c2850,2853
< errstring = "wrong type argument to abs";
---
> {
> error ("wrong type argument to abs");
> return error_mark_node;
> }
2850c2862,2865
< errstring = "wrong type argument to conjugation";
---
> {
> error ("wrong type argument to conjugation");
> return error_mark_node;
> }
2862,2863c2877,2878
< errstring = "wrong type argument to unary exclamation mark";
< break;
---
> error ("wrong type argument to unary exclamation mark");
> return error_mark_node;
2916,2920c2931,2934
< if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
< errstring ="wrong type argument to increment";
< else
< errstring ="wrong type argument to decrement";
< break;
---
> error (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
> ? "wrong type argument to increment"
> : "wrong type argument to decrement");
> return error_mark_node;
2937,2940c2951,2953
< error ("%s of pointer to unknown structure",
< ((code == PREINCREMENT_EXPR
< || code == POSTINCREMENT_EXPR)
< ? "increment" : "decrement"));
---
> error (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
> ? "increment of pointer to unknown structure"
> : "decrement of pointer to unknown structure");
2944,2947c2957,2959
< pedwarn ("wrong type argument to %s",
< ((code == PREINCREMENT_EXPR
< || code == POSTINCREMENT_EXPR)
< ? "increment" : "decrement"));
---
> pedwarn (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
> ? "wrong type argument to increment"
> : "wrong type argument to decrement");
3004c3016,3017
< ? "increment" : "decrement")))
---
> ? "invalid lvalue in increment"
> : "invalid lvalue in decrement")))
3078c3091,3092
< else if (typecode != FUNCTION_TYPE && !lvalue_or_else (arg, "unary `&'"))
---
> else if (typecode != FUNCTION_TYPE
> && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3083,3084c3097,3100
< /* If the lvalue is const or volatile,
< merge that into the type that the address will point to. */
---
> /* If the lvalue is const or volatile, merge that into the type
> to which the address will point. Note that you can't get a
> restricted pointer by taking the address of something, so we
> only have to deal with `const' and `volatile' here. */
3144,3152c3160,3162
< if (!errstring)
< {
< if (argtype == 0)
< argtype = TREE_TYPE (arg);
< return fold (build1 (code, argtype, arg));
< }
<
< error (errstring);
< return error_mark_node;
---
> if (argtype == 0)
> argtype = TREE_TYPE (arg);
> return fold (build1 (code, argtype, arg));
3226c3236
< lvalue_or_else (ref, string)
---
> lvalue_or_else (ref, msgid)
3228c3238
< char *string;
---
> const char *msgid;
3232c3242
< error ("invalid lvalue in %s", string);
---
> error (msgid);
3285,3287c3295,3299
< pedwarn ("ANSI C forbids use of %s expressions as lvalues",
< code == COND_EXPR ? "conditional"
< : code == COMPOUND_EXPR ? "compound" : "cast");
---
> pedwarn (code == COND_EXPR
> ? "ANSI C forbids use of conditional expressions as lvalues"
> : code == COMPOUND_EXPR
> ? "ANSI C forbids use of compound expressions as lvalues"
> : "ANSI C forbids use of cast expressions as lvalues");
3293c3305
< readonly_warning (arg, string)
---
> readonly_warning (arg, msgid)
3295c3307
< char *string;
---
> const char *msgid;
3297,3299d3308
< char buf[80];
< strcpy (buf, string);
<
3302,3305c3311,3312
< {
< strcat (buf, " of iterator `%s'");
< pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
< }
---
> pedwarn ("%s of iterator `%s'", _(msgid),
> IDENTIFIER_POINTER (DECL_NAME (arg)));
3310c3317
< readonly_warning (TREE_OPERAND (arg, 0), string);
---
> readonly_warning (TREE_OPERAND (arg, 0), msgid);
3312,3315c3319,3320
< {
< strcat (buf, " of read-only member `%s'");
< pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
< }
---
> pedwarn ("%s of read-only member `%s'", _(msgid),
> IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3318,3321c3323,3324
< {
< strcat (buf, " of read-only variable `%s'");
< pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
< }
---
> pedwarn ("%s of read-only variable `%s'", _(msgid),
> IDENTIFIER_POINTER (DECL_NAME (arg)));
3323,3325c3326
< {
< pedwarn ("%s of read-only location", buf);
< }
---
> pedwarn ("%s of read-only location", _(msgid));
3729c3730
< char *name;
---
> const char *name;
3782,3786c3783,3787
<
< if (TYPE_VOLATILE (in_otype) && ! TYPE_VOLATILE (in_type))
< pedwarn ("cast discards `volatile' from pointer target type");
< if (TYPE_READONLY (in_otype) && ! TYPE_READONLY (in_type))
< pedwarn ("cast discards `const' from pointer target type");
---
>
> if (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type))
> /* There are qualifiers present in IN_OTYPE that are not
> present in IN_TYPE. */
> pedwarn ("cast discards qualifiers from pointer target type");
3967c3968
< if (!lvalue_or_else (lhs, "assignment"))
---
> if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
4000c4001
< newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
---
> newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
4015c4016
< return convert_for_assignment (olhstype, result, "assignment",
---
> return convert_for_assignment (olhstype, result, _("assignment"),
4026,4028c4027
< for a function call (and different error messages are output). Otherwise,
< it may be a name stored in the spelling stack and interpreted by
< get_spelling.
---
> for a function call (and different error messages are output).
4037c4036
< char *errtype;
---
> const char *errtype;
4117,4122c4116,4122
< if ((TREE_CODE (ttr) == FUNCTION_TYPE
< && TREE_CODE (ttl) == FUNCTION_TYPE)
< ? ((! TYPE_READONLY (ttl) | TYPE_READONLY (ttr))
< & (! TYPE_VOLATILE (ttl) | TYPE_VOLATILE (ttr)))
< : ((TYPE_READONLY (ttl) | ! TYPE_READONLY (ttr))
< & (TYPE_VOLATILE (ttl) | ! TYPE_VOLATILE (ttr))))
---
> if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
> || ((TREE_CODE (ttr) == FUNCTION_TYPE
> && TREE_CODE (ttl) == FUNCTION_TYPE)
> ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
> == TYPE_QUALS (ttr))
> : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
> == TYPE_QUALS (ttl))))
4160,4167c4160,4162
< if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
< warn_for_assignment ("%s makes `const *' function pointer from non-const",
< get_spelling (errtype), funname,
< parmnum);
< if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
< warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
< get_spelling (errtype), funname,
< parmnum);
---
> if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
> warn_for_assignment ("%s makes qualified function pointer from unqualified",
> errtype, funname, parmnum);
4169,4179c4164,4167
< else
< {
< if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
< warn_for_assignment ("%s discards `const' from pointer target type",
< get_spelling (errtype), funname,
< parmnum);
< if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
< warn_for_assignment ("%s discards `volatile' from pointer target type",
< get_spelling (errtype), funname,
< parmnum);
< }
---
> else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
> warn_for_assignment ("%s discards qualifiers from pointer target type",
> errtype, funname,
> parmnum);
4214c4202
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4220,4225c4208,4210
< if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
< warn_for_assignment ("%s discards `const' from pointer target type",
< get_spelling (errtype), funname, parmnum);
< else if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
< warn_for_assignment ("%s discards `volatile' from pointer target type",
< get_spelling (errtype), funname, parmnum);
---
> if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
> warn_for_assignment ("%s discards qualifiers from pointer target type",
> errtype, funname, parmnum);
4235c4220
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4244,4249c4229,4231
< if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
< warn_for_assignment ("%s makes `const *' function pointer from non-const",
< get_spelling (errtype), funname, parmnum);
< if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
< warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
< get_spelling (errtype), funname, parmnum);
---
> if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
> warn_for_assignment ("%s makes qualified function pointer from unqualified",
> errtype, funname, parmnum);
4254c4236
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4270c4252
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4278c4260
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4300c4282
< error ("incompatible types in %s", get_spelling (errtype));
---
> error ("incompatible types in %s", errtype);
4305c4287
< /* Print a warning using MSG.
---
> /* Print a warning using MSGID.
4312,4314c4294,4296
< warn_for_assignment (msg, opname, function, argnum)
< char *msg;
< char *opname;
---
> warn_for_assignment (msgid, opname, function, argnum)
> const char *msgid;
> const char *opname;
4318,4320d4299
< static char argstring[] = "passing arg %d of `%s'";
< static char argnofun[] = "passing arg %d";
<
4323a4303
> char * new_opname;
4333,4335c4313,4318
< opname = (char *) alloca (IDENTIFIER_LENGTH (function)
< + sizeof (argstring) + 25 /*%d*/ + 1);
< sprintf (opname, argstring, argnum, IDENTIFIER_POINTER (function));
---
> const char *argstring = _("passing arg %d of `%s'");
> new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
> + strlen (argstring) + 1 + 25
> /*%d*/ + 1);
> sprintf (new_opname, argstring, argnum,
> IDENTIFIER_POINTER (function));
4339,4341c4322,4325
< /* Function name unknown (call through ptr); just give arg number. */
< opname = (char *) alloca (sizeof (argnofun) + 25 /*%d*/ + 1);
< sprintf (opname, argnofun, argnum);
---
> /* Function name unknown (call through ptr); just give arg number.*/
> const char *argnofun = _("passing arg %d of pointer to function");
> new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
> sprintf (new_opname, argnofun, argnum);
4342a4327
> opname = new_opname;
4344c4329
< pedwarn (msg, opname);
---
> pedwarn (msgid, opname);
4426c4411,4412
< /* Likewise conversions from int to pointers. */
---
> /* Likewise conversions from int to pointers, but also allow
> conversions from 0. */
4428,4432c4414,4422
< && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
< && (TYPE_PRECISION (TREE_TYPE (value))
< <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
< return initializer_constant_valid_p (TREE_OPERAND (value, 0),
< endtype);
---
> && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
> {
> if (integer_zerop (TREE_OPERAND (value, 0)))
> return null_pointer_node;
> else if (TYPE_PRECISION (TREE_TYPE (value))
> <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
> return initializer_constant_valid_p (TREE_OPERAND (value, 0),
> endtype);
> }
4578c4568
< char *s;
---
> const char *s;
4634c4624
< char *string;
---
> const char *string;
4646c4636
< char *string
---
> const char *string
4686d4675
< register char *s;
4696a4686
> register const char *s;
4706,4738d4695
< /* Provide a means to pass component names derived from the spelling stack. */
<
< char initialization_message;
<
< /* Interpret the spelling of the given ERRTYPE message. */
<
< static char *
< get_spelling (errtype)
< char *errtype;
< {
< static char *buffer;
< static int size = -1;
<
< if (errtype == &initialization_message)
< {
< /* Avoid counting chars */
< static char message[] = "initialization of `%s'";
< register int needed = sizeof (message) + spelling_length () + 1;
< char *temp;
<
< if (size < 0)
< buffer = (char *) xmalloc (size = needed);
< if (needed > size)
< buffer = (char *) xrealloc (buffer, size = needed);
<
< temp = (char *) alloca (needed);
< sprintf (buffer, message, print_spelling (temp));
< return buffer;
< }
<
< return errtype;
< }
<
4740,4742c4697,4698
< FORMAT describes the message. OFWHAT is the name for the component.
< LOCAL is a format string for formatting the insertion of the name
< into the message.
---
> MSGID identifies the message.
> The component name is taken from the spelling stack. */
4744,4746d4699
< If OFWHAT is null, the component name is stored on the spelling stack.
< If the component name is a null string, then LOCAL is omitted entirely. */
<
4748,4749c4701,4702
< error_init (format, local, ofwhat)
< char *format, *local, *ofwhat;
---
> error_init (msgid)
> const char *msgid;
4751c4704
< char *buffer;
---
> char *ofwhat;
4753,4756c4706,4707
< if (ofwhat == 0)
< ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
< buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
<
---
> error (msgid);
> ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4758,4762c4709
< sprintf (buffer, local, ofwhat);
< else
< buffer[0] = 0;
<
< error (format, buffer);
---
> error ("(near initialization for `%s')", ofwhat);
4766,4768c4713,4714
< FORMAT describes the message. OFWHAT is the name for the component.
< LOCAL is a format string for formatting the insertion of the name
< into the message.
---
> MSGID identifies the message.
> The component name is taken from the spelling stack. */
4770,4772d4715
< If OFWHAT is null, the component name is stored on the spelling stack.
< If the component name is a null string, then LOCAL is omitted entirely. */
<
4774,4775c4717,4718
< pedwarn_init (format, local, ofwhat)
< char *format, *local, *ofwhat;
---
> pedwarn_init (msgid)
> const char *msgid;
4777c4720
< char *buffer;
---
> char *ofwhat;
4779,4782c4722,4723
< if (ofwhat == 0)
< ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
< buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
<
---
> pedwarn (msgid);
> ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4784,4788c4725
< sprintf (buffer, local, ofwhat);
< else
< buffer[0] = 0;
<
< pedwarn (format, buffer);
---
> pedwarn ("(near initialization for `%s')", ofwhat);
4792,4794c4729,4730
< FORMAT describes the message. OFWHAT is the name for the component.
< LOCAL is a format string for formatting the insertion of the name
< into the message.
---
> MSGID identifies the message.
> The component name is taken from the spelling stack. */
4796,4798d4731
< If OFWHAT is null, the component name is stored on the spelling stack.
< If the component name is a null string, then LOCAL is omitted entirely. */
<
4800,4801c4733,4734
< warning_init (format, local, ofwhat)
< char *format, *local, *ofwhat;
---
> warning_init (msgid)
> const char *msgid;
4803c4736
< char *buffer;
---
> char *ofwhat;
4805,4808c4738,4739
< if (ofwhat == 0)
< ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
< buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
<
---
> warning (msgid);
> ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4810,4814c4741
< sprintf (buffer, local, ofwhat);
< else
< buffer[0] = 0;
<
< warning (format, buffer);
---
> warning ("(near initialization for `%s')", ofwhat);
4862,4863c4789
< error_init ("char-array%s initialized from wide string",
< " `%s'", NULL);
---
> error_init ("char-array initialized from wide string");
4870,4871c4796
< error_init ("int-array%s initialized from non-wide string",
< " `%s'", NULL);
---
> error_init ("int-array initialized from non-wide string");
4888,4890c4813
< pedwarn_init (
< "initializer-string for array of chars%s is too long",
< " `%s'", NULL);
---
> pedwarn_init ("initializer-string for array of chars is too long");
4917,4918c4840
< error_init ("array%s initialized from non-constant array expression",
< " `%s'", NULL);
---
> error_init ("array initialized from non-constant array expression");
4935,4936c4857
< error_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> error_init ("initializer element is not constant");
4938,4939c4859
< pedwarn_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> pedwarn_init ("initializer element is not constant");
4945,4946c4865
< error_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> error_init ("initializer element is not constant");
4952,4953c4871
< error_init ("initializer element%s is not computable at load time",
< " for `%s'", NULL);
---
> error_init ("initializer element is not computable at load time");
4969c4887
< = convert_for_assignment (type, init, "initialization",
---
> = convert_for_assignment (type, init, _("initialization"),
4974,4975c4892
< error_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> error_init ("initializer element is not constant");
4981,4982c4898
< error_init ("initializer element%s is not computable at load time",
< " for `%s'", NULL);
---
> error_init ("initializer element is not computable at load time");
4993,4994c4909
< error_init ("variable-sized object%s may not be initialized",
< " `%s'", NULL);
---
> error_init ("variable-sized object may not be initialized");
5020c4935
< error_init ("invalid initializer%s", " for `%s'", NULL);
---
> error_init ("invalid initializer");
5036c4951
< error_init ("invalid initializer%s", " for `%s'", NULL);
---
> error_init ("invalid initializer");
5199c5114
< char *locus;
---
> const char *locus;
5513,5514c5428
< error_init ("extra brace group at end of initializer%s",
< " for `%s'", NULL);
---
> error_init ("extra brace group at end of initializer");
5526c5440
< warning_init ("missing braces around initializer%s", " for `%s'", NULL);
---
> warning_init ("missing braces around initializer");
5557c5471
< warning_init ("braces around scalar initializer%s", " for `%s'", NULL);
---
> warning_init ("braces around scalar initializer");
5577,5579c5491
< if (DECL_C_BIT_FIELD (tail)
< /* This catches cases like `int foo : 8;'. */
< || DECL_MODE (tail) != TYPE_MODE (TREE_TYPE (tail)))
---
> if (DECL_C_BIT_FIELD (tail))
5588a5501,5511
> else if (TREE_CODE (type) == UNION_TYPE)
> {
> tree tail = TYPE_FIELDS (type);
> if (tail && DECL_C_BIT_FIELD (tail))
> /* We also use the nonincremental algorithm for initiliazation
> of unions whose first member is a bitfield, becuase the
> incremental algorithm has no code for dealing with
> bitfields. */
> constructor_incremental = 0;
> }
>
5629c5552
< warning_init ("missing initializer%s", " for `%s'", NULL);
---
> warning_init ("missing initializer");
5642c5565
< pedwarn_init ("empty braces in initializer%s", " for `%s'", NULL);
---
> pedwarn_init ("empty braces in initializer");
5706,5707c5629
< error_init ("empty scalar initializer%s",
< " for `%s'", NULL);
---
> error_init ("empty scalar initializer");
5712,5713c5634
< error_init ("extra elements in scalar initializer%s",
< " for `%s'", NULL);
---
> error_init ("extra elements in scalar initializer");
5847c5768
< error_init ("nonconstant array index in initializer%s", " for `%s'", NULL);
---
> error_init ("nonconstant array index in initializer");
5849c5770
< error_init ("nonconstant array index in initializer%s", " for `%s'", NULL);
---
> error_init ("nonconstant array index in initializer");
5851c5772
< error_init ("array index in non-array initializer%s", " for `%s'", NULL);
---
> error_init ("array index in non-array initializer");
5853c5774
< error_init ("duplicate array index in initializer%s", " for `%s'", NULL);
---
> error_init ("duplicate array index in initializer");
5860c5781
< error_init ("empty index range in initializer%s", " for `%s'", NULL);
---
> error_init ("empty index range in initializer");
6191,6192c6112
< error_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> error_init ("initializer element is not constant");
6198,6199c6118
< error_init ("initializer element%s is not computable at load time",
< " for `%s'", NULL);
---
> error_init ("initializer element is not computable at load time");
6215c6134
< error_init ("duplicate initializer%s", " for `%s'", NULL);
---
> error_init ("duplicate initializer");
6568,6569c6487
< error_init ("excess elements in struct initializer%s",
< " after `%s'", NULL_PTR);
---
> error_init ("excess elements in struct initializer");
6604,6605c6522
< pedwarn_init ("excess elements in struct initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in struct initializer");
6669,6670c6586
< pedwarn_init ("excess elements in union initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in union initializer");
6744,6745c6660
< pedwarn_init ("excess elements in array initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in array initializer");
6756,6757c6671
< pedwarn_init ("excess elements in array initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in array initializer");
6808,6809c6722
< pedwarn_init ("excess elements in scalar initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in scalar initializer");
6926c6839
< tree t = convert_for_assignment (valtype, retval, "return",
---
> tree t = convert_for_assignment (valtype, retval, _("return"),
> #include "intl.h"
58c59
< static tree convert_for_assignment PROTO((tree, tree, char *, tree,
---
> static tree convert_for_assignment PROTO((tree, tree, const char *, tree,
60c61,62
< static void warn_for_assignment PROTO((char *, char *, tree, int));
---
> static void warn_for_assignment PROTO((const char *, const char *,
> tree, int));
62c64
< static void push_string PROTO((char *));
---
> static void push_string PROTO((const char *));
67,69c69
< static char *get_spelling PROTO((char *));
< static void warning_init PROTO((char *, char *,
< char *));
---
> static void warning_init PROTO((const char *));
85a86,88
> if (TREE_CODE (value) == ERROR_MARK)
> return error_mark_node;
>
104c107
< char *errmsg;
---
> const char *type_code_string;
122c125
< errmsg = "invalid use of undefined type `struct %s'";
---
> type_code_string = "struct";
126c129
< errmsg = "invalid use of undefined type `union %s'";
---
> type_code_string = "union";
130c133
< errmsg = "invalid use of undefined type `enum %s'";
---
> type_code_string = "enum";
151c154,155
< error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
---
> error ("invalid use of undefined type `%s %s'",
> type_code_string, IDENTIFIER_POINTER (TYPE_NAME (type)));
166,168c170
< int constflag = TYPE_READONLY (type) || TYPE_READONLY (like);
< int volflag = TYPE_VOLATILE (type) || TYPE_VOLATILE (like);
< return c_build_type_variant (type, constflag, volflag);
---
> return c_build_qualified_type (type, TYPE_QUALS (like));
286,293c288,295
< tree target = common_type (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
< TYPE_MAIN_VARIANT (TREE_TYPE (t2)));
< int constp
< = TYPE_READONLY (TREE_TYPE (t1)) || TYPE_READONLY (TREE_TYPE (t2));
< int volatilep
< = TYPE_VOLATILE (TREE_TYPE (t1)) || TYPE_VOLATILE (TREE_TYPE (t2));
< t1 = build_pointer_type (c_build_type_variant (target, constp,
< volatilep));
---
> tree pointed_to_1 = TREE_TYPE (t1);
> tree pointed_to_2 = TREE_TYPE (t2);
> tree target = common_type (TYPE_MAIN_VARIANT (pointed_to_1),
> TYPE_MAIN_VARIANT (pointed_to_2));
> t1 = build_pointer_type (c_build_qualified_type
> (target,
> TYPE_QUALS (pointed_to_1) |
> TYPE_QUALS (pointed_to_2)));
450c452
< if (TYPE_READONLY (t1) != TYPE_READONLY (t2))
---
> if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
452,453d453
< if (TYPE_VOLATILE (t1) != TYPE_VOLATILE (t2))
< return 0;
1087,1091c1087,1092
< if (TYPE_READONLY (type) || TYPE_VOLATILE (type)
< || constp || volatilep)
< restype = c_build_type_variant (restype,
< TYPE_READONLY (type) || constp,
< TYPE_VOLATILE (type) || volatilep);
---
> if (TYPE_QUALS (type) || constp || volatilep)
> restype
> = c_build_qualified_type (restype,
> TYPE_QUALS (type)
> | (constp * TYPE_QUAL_CONST)
> | (volatilep * TYPE_QUAL_VOLATILE));
1327c1328
< char *errorstring;
---
> const char *errorstring;
2796d2796
< char *errstring = NULL;
2812c2812,2815
< errstring = "wrong type argument to unary plus";
---
> {
> error ("wrong type argument to unary plus");
> return error_mark_node;
> }
2820c2823,2826
< errstring = "wrong type argument to unary minus";
---
> {
> error ("wrong type argument to unary minus");
> return error_mark_node;
> }
2833c2839,2842
< errstring = "wrong type argument to bit-complement";
---
> {
> error ("wrong type argument to bit-complement");
> return error_mark_node;
> }
2841c2850,2853
< errstring = "wrong type argument to abs";
---
> {
> error ("wrong type argument to abs");
> return error_mark_node;
> }
2850c2862,2865
< errstring = "wrong type argument to conjugation";
---
> {
> error ("wrong type argument to conjugation");
> return error_mark_node;
> }
2862,2863c2877,2878
< errstring = "wrong type argument to unary exclamation mark";
< break;
---
> error ("wrong type argument to unary exclamation mark");
> return error_mark_node;
2916,2920c2931,2934
< if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
< errstring ="wrong type argument to increment";
< else
< errstring ="wrong type argument to decrement";
< break;
---
> error (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
> ? "wrong type argument to increment"
> : "wrong type argument to decrement");
> return error_mark_node;
2937,2940c2951,2953
< error ("%s of pointer to unknown structure",
< ((code == PREINCREMENT_EXPR
< || code == POSTINCREMENT_EXPR)
< ? "increment" : "decrement"));
---
> error (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
> ? "increment of pointer to unknown structure"
> : "decrement of pointer to unknown structure");
2944,2947c2957,2959
< pedwarn ("wrong type argument to %s",
< ((code == PREINCREMENT_EXPR
< || code == POSTINCREMENT_EXPR)
< ? "increment" : "decrement"));
---
> pedwarn (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR
> ? "wrong type argument to increment"
> : "wrong type argument to decrement");
3004c3016,3017
< ? "increment" : "decrement")))
---
> ? "invalid lvalue in increment"
> : "invalid lvalue in decrement")))
3078c3091,3092
< else if (typecode != FUNCTION_TYPE && !lvalue_or_else (arg, "unary `&'"))
---
> else if (typecode != FUNCTION_TYPE
> && !lvalue_or_else (arg, "invalid lvalue in unary `&'"))
3083,3084c3097,3100
< /* If the lvalue is const or volatile,
< merge that into the type that the address will point to. */
---
> /* If the lvalue is const or volatile, merge that into the type
> to which the address will point. Note that you can't get a
> restricted pointer by taking the address of something, so we
> only have to deal with `const' and `volatile' here. */
3144,3152c3160,3162
< if (!errstring)
< {
< if (argtype == 0)
< argtype = TREE_TYPE (arg);
< return fold (build1 (code, argtype, arg));
< }
<
< error (errstring);
< return error_mark_node;
---
> if (argtype == 0)
> argtype = TREE_TYPE (arg);
> return fold (build1 (code, argtype, arg));
3226c3236
< lvalue_or_else (ref, string)
---
> lvalue_or_else (ref, msgid)
3228c3238
< char *string;
---
> const char *msgid;
3232c3242
< error ("invalid lvalue in %s", string);
---
> error (msgid);
3285,3287c3295,3299
< pedwarn ("ANSI C forbids use of %s expressions as lvalues",
< code == COND_EXPR ? "conditional"
< : code == COMPOUND_EXPR ? "compound" : "cast");
---
> pedwarn (code == COND_EXPR
> ? "ANSI C forbids use of conditional expressions as lvalues"
> : code == COMPOUND_EXPR
> ? "ANSI C forbids use of compound expressions as lvalues"
> : "ANSI C forbids use of cast expressions as lvalues");
3293c3305
< readonly_warning (arg, string)
---
> readonly_warning (arg, msgid)
3295c3307
< char *string;
---
> const char *msgid;
3297,3299d3308
< char buf[80];
< strcpy (buf, string);
<
3302,3305c3311,3312
< {
< strcat (buf, " of iterator `%s'");
< pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
< }
---
> pedwarn ("%s of iterator `%s'", _(msgid),
> IDENTIFIER_POINTER (DECL_NAME (arg)));
3310c3317
< readonly_warning (TREE_OPERAND (arg, 0), string);
---
> readonly_warning (TREE_OPERAND (arg, 0), msgid);
3312,3315c3319,3320
< {
< strcat (buf, " of read-only member `%s'");
< pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
< }
---
> pedwarn ("%s of read-only member `%s'", _(msgid),
> IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1))));
3318,3321c3323,3324
< {
< strcat (buf, " of read-only variable `%s'");
< pedwarn (buf, IDENTIFIER_POINTER (DECL_NAME (arg)));
< }
---
> pedwarn ("%s of read-only variable `%s'", _(msgid),
> IDENTIFIER_POINTER (DECL_NAME (arg)));
3323,3325c3326
< {
< pedwarn ("%s of read-only location", buf);
< }
---
> pedwarn ("%s of read-only location", _(msgid));
3729c3730
< char *name;
---
> const char *name;
3782,3786c3783,3787
<
< if (TYPE_VOLATILE (in_otype) && ! TYPE_VOLATILE (in_type))
< pedwarn ("cast discards `volatile' from pointer target type");
< if (TYPE_READONLY (in_otype) && ! TYPE_READONLY (in_type))
< pedwarn ("cast discards `const' from pointer target type");
---
>
> if (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type))
> /* There are qualifiers present in IN_OTYPE that are not
> present in IN_TYPE. */
> pedwarn ("cast discards qualifiers from pointer target type");
3967c3968
< if (!lvalue_or_else (lhs, "assignment"))
---
> if (!lvalue_or_else (lhs, "invalid lvalue in assignment"))
4000c4001
< newrhs = convert_for_assignment (lhstype, newrhs, "assignment",
---
> newrhs = convert_for_assignment (lhstype, newrhs, _("assignment"),
4015c4016
< return convert_for_assignment (olhstype, result, "assignment",
---
> return convert_for_assignment (olhstype, result, _("assignment"),
4026,4028c4027
< for a function call (and different error messages are output). Otherwise,
< it may be a name stored in the spelling stack and interpreted by
< get_spelling.
---
> for a function call (and different error messages are output).
4037c4036
< char *errtype;
---
> const char *errtype;
4117,4122c4116,4122
< if ((TREE_CODE (ttr) == FUNCTION_TYPE
< && TREE_CODE (ttl) == FUNCTION_TYPE)
< ? ((! TYPE_READONLY (ttl) | TYPE_READONLY (ttr))
< & (! TYPE_VOLATILE (ttl) | TYPE_VOLATILE (ttr)))
< : ((TYPE_READONLY (ttl) | ! TYPE_READONLY (ttr))
< & (TYPE_VOLATILE (ttl) | ! TYPE_VOLATILE (ttr))))
---
> if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
> || ((TREE_CODE (ttr) == FUNCTION_TYPE
> && TREE_CODE (ttl) == FUNCTION_TYPE)
> ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
> == TYPE_QUALS (ttr))
> : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
> == TYPE_QUALS (ttl))))
4160,4167c4160,4162
< if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
< warn_for_assignment ("%s makes `const *' function pointer from non-const",
< get_spelling (errtype), funname,
< parmnum);
< if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
< warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
< get_spelling (errtype), funname,
< parmnum);
---
> if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
> warn_for_assignment ("%s makes qualified function pointer from unqualified",
> errtype, funname, parmnum);
4169,4179c4164,4167
< else
< {
< if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
< warn_for_assignment ("%s discards `const' from pointer target type",
< get_spelling (errtype), funname,
< parmnum);
< if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
< warn_for_assignment ("%s discards `volatile' from pointer target type",
< get_spelling (errtype), funname,
< parmnum);
< }
---
> else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
> warn_for_assignment ("%s discards qualifiers from pointer target type",
> errtype, funname,
> parmnum);
4214c4202
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4220,4225c4208,4210
< if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr))
< warn_for_assignment ("%s discards `const' from pointer target type",
< get_spelling (errtype), funname, parmnum);
< else if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr))
< warn_for_assignment ("%s discards `volatile' from pointer target type",
< get_spelling (errtype), funname, parmnum);
---
> if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
> warn_for_assignment ("%s discards qualifiers from pointer target type",
> errtype, funname, parmnum);
4235c4220
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4244,4249c4229,4231
< if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr))
< warn_for_assignment ("%s makes `const *' function pointer from non-const",
< get_spelling (errtype), funname, parmnum);
< if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr))
< warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile",
< get_spelling (errtype), funname, parmnum);
---
> if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
> warn_for_assignment ("%s makes qualified function pointer from unqualified",
> errtype, funname, parmnum);
4254c4236
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4270c4252
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4278c4260
< get_spelling (errtype), funname, parmnum);
---
> errtype, funname, parmnum);
4300c4282
< error ("incompatible types in %s", get_spelling (errtype));
---
> error ("incompatible types in %s", errtype);
4305c4287
< /* Print a warning using MSG.
---
> /* Print a warning using MSGID.
4312,4314c4294,4296
< warn_for_assignment (msg, opname, function, argnum)
< char *msg;
< char *opname;
---
> warn_for_assignment (msgid, opname, function, argnum)
> const char *msgid;
> const char *opname;
4318,4320d4299
< static char argstring[] = "passing arg %d of `%s'";
< static char argnofun[] = "passing arg %d";
<
4323a4303
> char * new_opname;
4333,4335c4313,4318
< opname = (char *) alloca (IDENTIFIER_LENGTH (function)
< + sizeof (argstring) + 25 /*%d*/ + 1);
< sprintf (opname, argstring, argnum, IDENTIFIER_POINTER (function));
---
> const char *argstring = _("passing arg %d of `%s'");
> new_opname = (char *) alloca (IDENTIFIER_LENGTH (function)
> + strlen (argstring) + 1 + 25
> /*%d*/ + 1);
> sprintf (new_opname, argstring, argnum,
> IDENTIFIER_POINTER (function));
4339,4341c4322,4325
< /* Function name unknown (call through ptr); just give arg number. */
< opname = (char *) alloca (sizeof (argnofun) + 25 /*%d*/ + 1);
< sprintf (opname, argnofun, argnum);
---
> /* Function name unknown (call through ptr); just give arg number.*/
> const char *argnofun = _("passing arg %d of pointer to function");
> new_opname = (char *) alloca (strlen (argnofun) + 1 + 25 /*%d*/ + 1);
> sprintf (new_opname, argnofun, argnum);
4342a4327
> opname = new_opname;
4344c4329
< pedwarn (msg, opname);
---
> pedwarn (msgid, opname);
4426c4411,4412
< /* Likewise conversions from int to pointers. */
---
> /* Likewise conversions from int to pointers, but also allow
> conversions from 0. */
4428,4432c4414,4422
< && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE
< && (TYPE_PRECISION (TREE_TYPE (value))
< <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
< return initializer_constant_valid_p (TREE_OPERAND (value, 0),
< endtype);
---
> && TREE_CODE (TREE_TYPE (TREE_OPERAND (value, 0))) == INTEGER_TYPE)
> {
> if (integer_zerop (TREE_OPERAND (value, 0)))
> return null_pointer_node;
> else if (TYPE_PRECISION (TREE_TYPE (value))
> <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
> return initializer_constant_valid_p (TREE_OPERAND (value, 0),
> endtype);
> }
4578c4568
< char *s;
---
> const char *s;
4634c4624
< char *string;
---
> const char *string;
4646c4636
< char *string
---
> const char *string
4686d4675
< register char *s;
4696a4686
> register const char *s;
4706,4738d4695
< /* Provide a means to pass component names derived from the spelling stack. */
<
< char initialization_message;
<
< /* Interpret the spelling of the given ERRTYPE message. */
<
< static char *
< get_spelling (errtype)
< char *errtype;
< {
< static char *buffer;
< static int size = -1;
<
< if (errtype == &initialization_message)
< {
< /* Avoid counting chars */
< static char message[] = "initialization of `%s'";
< register int needed = sizeof (message) + spelling_length () + 1;
< char *temp;
<
< if (size < 0)
< buffer = (char *) xmalloc (size = needed);
< if (needed > size)
< buffer = (char *) xrealloc (buffer, size = needed);
<
< temp = (char *) alloca (needed);
< sprintf (buffer, message, print_spelling (temp));
< return buffer;
< }
<
< return errtype;
< }
<
4740,4742c4697,4698
< FORMAT describes the message. OFWHAT is the name for the component.
< LOCAL is a format string for formatting the insertion of the name
< into the message.
---
> MSGID identifies the message.
> The component name is taken from the spelling stack. */
4744,4746d4699
< If OFWHAT is null, the component name is stored on the spelling stack.
< If the component name is a null string, then LOCAL is omitted entirely. */
<
4748,4749c4701,4702
< error_init (format, local, ofwhat)
< char *format, *local, *ofwhat;
---
> error_init (msgid)
> const char *msgid;
4751c4704
< char *buffer;
---
> char *ofwhat;
4753,4756c4706,4707
< if (ofwhat == 0)
< ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
< buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
<
---
> error (msgid);
> ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4758,4762c4709
< sprintf (buffer, local, ofwhat);
< else
< buffer[0] = 0;
<
< error (format, buffer);
---
> error ("(near initialization for `%s')", ofwhat);
4766,4768c4713,4714
< FORMAT describes the message. OFWHAT is the name for the component.
< LOCAL is a format string for formatting the insertion of the name
< into the message.
---
> MSGID identifies the message.
> The component name is taken from the spelling stack. */
4770,4772d4715
< If OFWHAT is null, the component name is stored on the spelling stack.
< If the component name is a null string, then LOCAL is omitted entirely. */
<
4774,4775c4717,4718
< pedwarn_init (format, local, ofwhat)
< char *format, *local, *ofwhat;
---
> pedwarn_init (msgid)
> const char *msgid;
4777c4720
< char *buffer;
---
> char *ofwhat;
4779,4782c4722,4723
< if (ofwhat == 0)
< ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
< buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
<
---
> pedwarn (msgid);
> ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4784,4788c4725
< sprintf (buffer, local, ofwhat);
< else
< buffer[0] = 0;
<
< pedwarn (format, buffer);
---
> pedwarn ("(near initialization for `%s')", ofwhat);
4792,4794c4729,4730
< FORMAT describes the message. OFWHAT is the name for the component.
< LOCAL is a format string for formatting the insertion of the name
< into the message.
---
> MSGID identifies the message.
> The component name is taken from the spelling stack. */
4796,4798d4731
< If OFWHAT is null, the component name is stored on the spelling stack.
< If the component name is a null string, then LOCAL is omitted entirely. */
<
4800,4801c4733,4734
< warning_init (format, local, ofwhat)
< char *format, *local, *ofwhat;
---
> warning_init (msgid)
> const char *msgid;
4803c4736
< char *buffer;
---
> char *ofwhat;
4805,4808c4738,4739
< if (ofwhat == 0)
< ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
< buffer = (char *) alloca (strlen (local) + strlen (ofwhat) + 2);
<
---
> warning (msgid);
> ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4810,4814c4741
< sprintf (buffer, local, ofwhat);
< else
< buffer[0] = 0;
<
< warning (format, buffer);
---
> warning ("(near initialization for `%s')", ofwhat);
4862,4863c4789
< error_init ("char-array%s initialized from wide string",
< " `%s'", NULL);
---
> error_init ("char-array initialized from wide string");
4870,4871c4796
< error_init ("int-array%s initialized from non-wide string",
< " `%s'", NULL);
---
> error_init ("int-array initialized from non-wide string");
4888,4890c4813
< pedwarn_init (
< "initializer-string for array of chars%s is too long",
< " `%s'", NULL);
---
> pedwarn_init ("initializer-string for array of chars is too long");
4917,4918c4840
< error_init ("array%s initialized from non-constant array expression",
< " `%s'", NULL);
---
> error_init ("array initialized from non-constant array expression");
4935,4936c4857
< error_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> error_init ("initializer element is not constant");
4938,4939c4859
< pedwarn_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> pedwarn_init ("initializer element is not constant");
4945,4946c4865
< error_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> error_init ("initializer element is not constant");
4952,4953c4871
< error_init ("initializer element%s is not computable at load time",
< " for `%s'", NULL);
---
> error_init ("initializer element is not computable at load time");
4969c4887
< = convert_for_assignment (type, init, "initialization",
---
> = convert_for_assignment (type, init, _("initialization"),
4974,4975c4892
< error_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> error_init ("initializer element is not constant");
4981,4982c4898
< error_init ("initializer element%s is not computable at load time",
< " for `%s'", NULL);
---
> error_init ("initializer element is not computable at load time");
4993,4994c4909
< error_init ("variable-sized object%s may not be initialized",
< " `%s'", NULL);
---
> error_init ("variable-sized object may not be initialized");
5020c4935
< error_init ("invalid initializer%s", " for `%s'", NULL);
---
> error_init ("invalid initializer");
5036c4951
< error_init ("invalid initializer%s", " for `%s'", NULL);
---
> error_init ("invalid initializer");
5199c5114
< char *locus;
---
> const char *locus;
5513,5514c5428
< error_init ("extra brace group at end of initializer%s",
< " for `%s'", NULL);
---
> error_init ("extra brace group at end of initializer");
5526c5440
< warning_init ("missing braces around initializer%s", " for `%s'", NULL);
---
> warning_init ("missing braces around initializer");
5557c5471
< warning_init ("braces around scalar initializer%s", " for `%s'", NULL);
---
> warning_init ("braces around scalar initializer");
5577,5579c5491
< if (DECL_C_BIT_FIELD (tail)
< /* This catches cases like `int foo : 8;'. */
< || DECL_MODE (tail) != TYPE_MODE (TREE_TYPE (tail)))
---
> if (DECL_C_BIT_FIELD (tail))
5588a5501,5511
> else if (TREE_CODE (type) == UNION_TYPE)
> {
> tree tail = TYPE_FIELDS (type);
> if (tail && DECL_C_BIT_FIELD (tail))
> /* We also use the nonincremental algorithm for initiliazation
> of unions whose first member is a bitfield, becuase the
> incremental algorithm has no code for dealing with
> bitfields. */
> constructor_incremental = 0;
> }
>
5629c5552
< warning_init ("missing initializer%s", " for `%s'", NULL);
---
> warning_init ("missing initializer");
5642c5565
< pedwarn_init ("empty braces in initializer%s", " for `%s'", NULL);
---
> pedwarn_init ("empty braces in initializer");
5706,5707c5629
< error_init ("empty scalar initializer%s",
< " for `%s'", NULL);
---
> error_init ("empty scalar initializer");
5712,5713c5634
< error_init ("extra elements in scalar initializer%s",
< " for `%s'", NULL);
---
> error_init ("extra elements in scalar initializer");
5847c5768
< error_init ("nonconstant array index in initializer%s", " for `%s'", NULL);
---
> error_init ("nonconstant array index in initializer");
5849c5770
< error_init ("nonconstant array index in initializer%s", " for `%s'", NULL);
---
> error_init ("nonconstant array index in initializer");
5851c5772
< error_init ("array index in non-array initializer%s", " for `%s'", NULL);
---
> error_init ("array index in non-array initializer");
5853c5774
< error_init ("duplicate array index in initializer%s", " for `%s'", NULL);
---
> error_init ("duplicate array index in initializer");
5860c5781
< error_init ("empty index range in initializer%s", " for `%s'", NULL);
---
> error_init ("empty index range in initializer");
6191,6192c6112
< error_init ("initializer element%s is not constant",
< " for `%s'", NULL);
---
> error_init ("initializer element is not constant");
6198,6199c6118
< error_init ("initializer element%s is not computable at load time",
< " for `%s'", NULL);
---
> error_init ("initializer element is not computable at load time");
6215c6134
< error_init ("duplicate initializer%s", " for `%s'", NULL);
---
> error_init ("duplicate initializer");
6568,6569c6487
< error_init ("excess elements in struct initializer%s",
< " after `%s'", NULL_PTR);
---
> error_init ("excess elements in struct initializer");
6604,6605c6522
< pedwarn_init ("excess elements in struct initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in struct initializer");
6669,6670c6586
< pedwarn_init ("excess elements in union initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in union initializer");
6744,6745c6660
< pedwarn_init ("excess elements in array initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in array initializer");
6756,6757c6671
< pedwarn_init ("excess elements in array initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in array initializer");
6808,6809c6722
< pedwarn_init ("excess elements in scalar initializer%s",
< " after `%s'", NULL_PTR);
---
> pedwarn_init ("excess elements in scalar initializer");
6926c6839
< tree t = convert_for_assignment (valtype, retval, "return",
---
> tree t = convert_for_assignment (valtype, retval, _("return"),