]>
Commit | Line | Data |
---|---|---|
8d08fdba MS |
1 | /* Report error messages, build initializers, and perform |
2 | some front-end optimizations for C++ compiler. | |
d6a8bdff | 3 | Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
3c2426b9 KH |
4 | 1999, 2000, 2001, 2002, 2004 |
5 | Free Software Foundation, Inc. | |
8d08fdba MS |
6 | Hacked by Michael Tiemann (tiemann@cygnus.com) |
7 | ||
f5adbb8d | 8 | This file is part of GCC. |
8d08fdba | 9 | |
f5adbb8d | 10 | GCC is free software; you can redistribute it and/or modify |
8d08fdba MS |
11 | it under the terms of the GNU General Public License as published by |
12 | the Free Software Foundation; either version 2, or (at your option) | |
13 | any later version. | |
14 | ||
f5adbb8d | 15 | GCC is distributed in the hope that it will be useful, |
8d08fdba MS |
16 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | GNU General Public License for more details. | |
19 | ||
20 | You should have received a copy of the GNU General Public License | |
f5adbb8d | 21 | along with GCC; see the file COPYING. If not, write to |
6bc06b8f RK |
22 | the Free Software Foundation, 59 Temple Place - Suite 330, |
23 | Boston, MA 02111-1307, USA. */ | |
8d08fdba MS |
24 | |
25 | ||
26 | /* This file is part of the C++ front end. | |
27 | It contains routines to build C++ expressions given their operands, | |
28 | including computing the types of the result, C and C++ specific error | |
29 | checks, and some optimization. | |
30 | ||
31 | There are also routines to build RETURN_STMT nodes and CASE_STMT nodes, | |
32 | and to process initializations in declarations (since they work | |
33 | like a strange sort of assignment). */ | |
34 | ||
35 | #include "config.h" | |
8d052bc7 | 36 | #include "system.h" |
4977bab6 ZW |
37 | #include "coretypes.h" |
38 | #include "tm.h" | |
8d08fdba MS |
39 | #include "tree.h" |
40 | #include "cp-tree.h" | |
41 | #include "flags.h" | |
12027a89 | 42 | #include "toplev.h" |
71144a65 | 43 | #include "output.h" |
2a2b2d43 | 44 | #include "diagnostic.h" |
8d08fdba | 45 | |
0a8cb79e | 46 | static tree process_init_constructor (tree, tree, tree *); |
8d08fdba | 47 | |
8d08fdba MS |
48 | /* Print an error message stemming from an attempt to use |
49 | BASETYPE as a base class for TYPE. */ | |
e92cc029 | 50 | |
8d08fdba | 51 | tree |
0a8cb79e | 52 | error_not_base_type (tree basetype, tree type) |
8d08fdba MS |
53 | { |
54 | if (TREE_CODE (basetype) == FUNCTION_DECL) | |
4f1c5b7d | 55 | basetype = DECL_CONTEXT (basetype); |
33bd39a2 | 56 | error ("type `%T' is not a base type for type `%T'", basetype, type); |
8d08fdba MS |
57 | return error_mark_node; |
58 | } | |
59 | ||
60 | tree | |
0a8cb79e | 61 | binfo_or_else (tree base, tree type) |
8d08fdba | 62 | { |
2db1ab2d NS |
63 | tree binfo = lookup_base (type, base, ba_ignore, NULL); |
64 | ||
65 | if (binfo == error_mark_node) | |
66 | return NULL_TREE; | |
67 | else if (!binfo) | |
68 | error_not_base_type (base, type); | |
69 | return binfo; | |
8d08fdba MS |
70 | } |
71 | ||
8d08fdba MS |
72 | /* According to ARM $7.1.6, "A `const' object may be initialized, but its |
73 | value may not be changed thereafter. Thus, we emit hard errors for these, | |
74 | rather than just pedwarns. If `SOFT' is 1, then we just pedwarn. (For | |
75 | example, conversions to references.) */ | |
e92cc029 | 76 | |
8d08fdba | 77 | void |
0a8cb79e | 78 | readonly_error (tree arg, const char* string, int soft) |
8d08fdba | 79 | { |
d8e178a0 | 80 | const char *fmt; |
0a8cb79e | 81 | void (*fn) (const char *, ...); |
8d08fdba MS |
82 | |
83 | if (soft) | |
33bd39a2 | 84 | fn = pedwarn; |
8d08fdba | 85 | else |
33bd39a2 | 86 | fn = error; |
8d08fdba MS |
87 | |
88 | if (TREE_CODE (arg) == COMPONENT_REF) | |
89 | { | |
90 | if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) | |
7e4d7898 | 91 | fmt = "%s of data-member `%D' in read-only structure"; |
8d08fdba | 92 | else |
7e4d7898 | 93 | fmt = "%s of read-only data-member `%D'"; |
8251199e | 94 | (*fn) (fmt, string, TREE_OPERAND (arg, 1)); |
8d08fdba MS |
95 | } |
96 | else if (TREE_CODE (arg) == VAR_DECL) | |
97 | { | |
98 | if (DECL_LANG_SPECIFIC (arg) | |
99 | && DECL_IN_AGGR_P (arg) | |
100 | && !TREE_STATIC (arg)) | |
8251199e | 101 | fmt = "%s of constant field `%D'"; |
8d08fdba | 102 | else |
8251199e JM |
103 | fmt = "%s of read-only variable `%D'"; |
104 | (*fn) (fmt, string, arg); | |
8d08fdba MS |
105 | } |
106 | else if (TREE_CODE (arg) == PARM_DECL) | |
8251199e | 107 | (*fn) ("%s of read-only parameter `%D'", string, arg); |
8d08fdba MS |
108 | else if (TREE_CODE (arg) == INDIRECT_REF |
109 | && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 0))) == REFERENCE_TYPE | |
110 | && (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL | |
111 | || TREE_CODE (TREE_OPERAND (arg, 0)) == PARM_DECL)) | |
8251199e | 112 | (*fn) ("%s of read-only reference `%D'", string, TREE_OPERAND (arg, 0)); |
8d08fdba | 113 | else if (TREE_CODE (arg) == RESULT_DECL) |
8251199e | 114 | (*fn) ("%s of read-only named return value `%D'", string, arg); |
69851283 MM |
115 | else if (TREE_CODE (arg) == FUNCTION_DECL) |
116 | (*fn) ("%s of function `%D'", string, arg); | |
117 | else | |
8251199e | 118 | (*fn) ("%s of read-only location", string); |
8d08fdba MS |
119 | } |
120 | ||
a7a64a77 MM |
121 | /* If TYPE has abstract virtual functions, issue an error about trying |
122 | to create an object of that type. DECL is the object declared, or | |
123 | NULL_TREE if the declaration is unavailable. Returns 1 if an error | |
124 | occurred; zero if all was well. */ | |
e92cc029 | 125 | |
a7a64a77 | 126 | int |
0a8cb79e | 127 | abstract_virtuals_error (tree decl, tree type) |
8d08fdba | 128 | { |
a7a64a77 | 129 | tree u; |
4a67c9e9 MH |
130 | tree tu; |
131 | ||
fee7654e | 132 | if (!CLASS_TYPE_P (type) || !CLASSTYPE_PURE_VIRTUALS (type)) |
a7a64a77 MM |
133 | return 0; |
134 | ||
e60505a5 NS |
135 | if (!TYPE_SIZE (type)) |
136 | /* TYPE is being defined, and during that time | |
137 | CLASSTYPE_PURE_VIRTUALS holds the inline friends. */ | |
138 | return 0; | |
139 | ||
9e236a9d KL |
140 | if (dependent_type_p (type)) |
141 | /* For a dependent type, we do not yet know which functions are pure | |
142 | virtuals. */ | |
143 | return 0; | |
144 | ||
fee7654e | 145 | u = CLASSTYPE_PURE_VIRTUALS (type); |
8d08fdba MS |
146 | if (decl) |
147 | { | |
148 | if (TREE_CODE (decl) == RESULT_DECL) | |
a7a64a77 | 149 | return 0; |
8d08fdba MS |
150 | |
151 | if (TREE_CODE (decl) == VAR_DECL) | |
33bd39a2 | 152 | error ("cannot declare variable `%D' to be of type `%T'", |
8d08fdba MS |
153 | decl, type); |
154 | else if (TREE_CODE (decl) == PARM_DECL) | |
33bd39a2 | 155 | error ("cannot declare parameter `%D' to be of type `%T'", |
8d08fdba MS |
156 | decl, type); |
157 | else if (TREE_CODE (decl) == FIELD_DECL) | |
33bd39a2 | 158 | error ("cannot declare field `%D' to be of type `%T'", |
8d08fdba MS |
159 | decl, type); |
160 | else if (TREE_CODE (decl) == FUNCTION_DECL | |
161 | && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE) | |
33bd39a2 | 162 | error ("invalid return type for member function `%#D'", decl); |
8d08fdba | 163 | else if (TREE_CODE (decl) == FUNCTION_DECL) |
33bd39a2 | 164 | error ("invalid return type for function `%#D'", decl); |
8d08fdba | 165 | } |
4a67c9e9 | 166 | else |
33bd39a2 | 167 | error ("cannot allocate an object of type `%T'", type); |
4a67c9e9 | 168 | |
8d08fdba MS |
169 | /* Only go through this once. */ |
170 | if (TREE_PURPOSE (u) == NULL_TREE) | |
171 | { | |
8d08fdba | 172 | TREE_PURPOSE (u) = error_mark_node; |
4a67c9e9 | 173 | |
2e44948d | 174 | error (" because the following virtual functions are abstract:"); |
8ebeee52 | 175 | for (tu = u; tu; tu = TREE_CHAIN (tu)) |
83f660b7 | 176 | cp_error_at ("\t%#D", TREE_VALUE (tu)); |
8d08fdba | 177 | } |
4a67c9e9 | 178 | else |
33bd39a2 | 179 | error (" since type `%T' has abstract virtual functions", type); |
a7a64a77 MM |
180 | |
181 | return 1; | |
8d08fdba MS |
182 | } |
183 | ||
8d08fdba MS |
184 | /* Print an error message for invalid use of an incomplete type. |
185 | VALUE is the expression that was used (or 0 if that isn't known) | |
5aa3396c JM |
186 | and TYPE is the type that was invalid. DIAG_TYPE indicates the |
187 | type of diagnostic: 0 for an error, 1 for a warning, 2 for a | |
188 | pedwarn. */ | |
8d08fdba MS |
189 | |
190 | void | |
0a8cb79e | 191 | cxx_incomplete_type_diagnostic (tree value, tree type, int diag_type) |
8d08fdba | 192 | { |
146c8d60 | 193 | int decl = 0; |
0a8cb79e NN |
194 | void (*p_msg) (const char *, ...); |
195 | void (*p_msg_at) (const char *, ...); | |
23b4deba | 196 | |
5aa3396c | 197 | if (diag_type == 1) |
23b4deba AO |
198 | { |
199 | p_msg = warning; | |
200 | p_msg_at = cp_warning_at; | |
201 | } | |
5aa3396c JM |
202 | else if (diag_type == 2) |
203 | { | |
204 | p_msg = pedwarn; | |
205 | p_msg_at = cp_pedwarn_at; | |
206 | } | |
23b4deba AO |
207 | else |
208 | { | |
209 | p_msg = error; | |
210 | p_msg_at = cp_error_at; | |
211 | } | |
146c8d60 | 212 | |
8d08fdba MS |
213 | /* Avoid duplicate error message. */ |
214 | if (TREE_CODE (type) == ERROR_MARK) | |
215 | return; | |
216 | ||
146c8d60 | 217 | if (value != 0 && (TREE_CODE (value) == VAR_DECL |
17f29637 KL |
218 | || TREE_CODE (value) == PARM_DECL |
219 | || TREE_CODE (value) == FIELD_DECL)) | |
146c8d60 | 220 | { |
23b4deba | 221 | (*p_msg_at) ("`%D' has incomplete type", value); |
146c8d60 NS |
222 | decl = 1; |
223 | } | |
66543169 NS |
224 | retry: |
225 | /* We must print an error message. Be clever about what it says. */ | |
226 | ||
227 | switch (TREE_CODE (type)) | |
8d08fdba | 228 | { |
66543169 NS |
229 | case RECORD_TYPE: |
230 | case UNION_TYPE: | |
231 | case ENUMERAL_TYPE: | |
146c8d60 | 232 | if (!decl) |
23b4deba | 233 | (*p_msg) ("invalid use of undefined type `%#T'", type); |
17f29637 KL |
234 | if (!TYPE_TEMPLATE_INFO (type)) |
235 | (*p_msg_at) ("forward declaration of `%#T'", type); | |
236 | else | |
04c4491d | 237 | (*p_msg_at) ("declaration of `%#T'", type); |
66543169 NS |
238 | break; |
239 | ||
240 | case VOID_TYPE: | |
23b4deba | 241 | (*p_msg) ("invalid use of `%T'", type); |
66543169 NS |
242 | break; |
243 | ||
244 | case ARRAY_TYPE: | |
245 | if (TYPE_DOMAIN (type)) | |
246 | { | |
247 | type = TREE_TYPE (type); | |
248 | goto retry; | |
249 | } | |
23b4deba | 250 | (*p_msg) ("invalid use of array with unspecified bounds"); |
66543169 NS |
251 | break; |
252 | ||
253 | case OFFSET_TYPE: | |
254 | bad_member: | |
23b4deba | 255 | (*p_msg) ("invalid use of member (did you forget the `&' ?)"); |
66543169 NS |
256 | break; |
257 | ||
258 | case TEMPLATE_TYPE_PARM: | |
23b4deba | 259 | (*p_msg) ("invalid use of template type parameter"); |
66543169 NS |
260 | break; |
261 | ||
262 | case UNKNOWN_TYPE: | |
263 | if (value && TREE_CODE (value) == COMPONENT_REF) | |
264 | goto bad_member; | |
265 | else if (value && TREE_CODE (value) == ADDR_EXPR) | |
23b4deba | 266 | (*p_msg) ("address of overloaded function with no contextual type information"); |
66543169 | 267 | else if (value && TREE_CODE (value) == OVERLOAD) |
23b4deba | 268 | (*p_msg) ("overloaded function with no contextual type information"); |
66543169 | 269 | else |
23b4deba | 270 | (*p_msg) ("insufficient contextual information to determine type"); |
66543169 NS |
271 | break; |
272 | ||
273 | default: | |
a98facb0 | 274 | abort (); |
8d08fdba MS |
275 | } |
276 | } | |
277 | ||
23b4deba AO |
278 | /* Backward-compatibility interface to incomplete_type_diagnostic; |
279 | required by ../tree.c. */ | |
280 | #undef cxx_incomplete_type_error | |
281 | void | |
0a8cb79e | 282 | cxx_incomplete_type_error (tree value, tree type) |
23b4deba AO |
283 | { |
284 | cxx_incomplete_type_diagnostic (value, type, 0); | |
285 | } | |
286 | ||
8d08fdba | 287 | \f |
25ebb82a RH |
288 | /* The recursive part of split_nonconstant_init. DEST is an lvalue |
289 | expression to which INIT should be assigned. INIT is a CONSTRUCTOR. | |
290 | PCODE is a pointer to the tail of a chain of statements being emitted. | |
291 | The return value is the new tail of that chain after new statements | |
292 | are generated. */ | |
293 | ||
294 | static tree * | |
295 | split_nonconstant_init_1 (tree dest, tree init, tree *pcode) | |
296 | { | |
297 | tree *pelt, elt, type = TREE_TYPE (dest); | |
298 | tree sub, code, inner_type = NULL; | |
299 | bool array_type_p = false; | |
300 | ||
301 | pelt = &CONSTRUCTOR_ELTS (init); | |
302 | switch (TREE_CODE (type)) | |
303 | { | |
304 | case ARRAY_TYPE: | |
305 | inner_type = TREE_TYPE (type); | |
306 | array_type_p = true; | |
307 | /* FALLTHRU */ | |
308 | ||
309 | case RECORD_TYPE: | |
310 | case UNION_TYPE: | |
311 | case QUAL_UNION_TYPE: | |
312 | while ((elt = *pelt)) | |
313 | { | |
314 | tree field_index = TREE_PURPOSE (elt); | |
315 | tree value = TREE_VALUE (elt); | |
316 | ||
317 | if (!array_type_p) | |
318 | inner_type = TREE_TYPE (field_index); | |
319 | ||
320 | if (TREE_CODE (value) == CONSTRUCTOR) | |
321 | { | |
322 | if (array_type_p) | |
323 | sub = build (ARRAY_REF, inner_type, dest, field_index); | |
324 | else | |
325 | sub = build (COMPONENT_REF, inner_type, dest, field_index); | |
326 | ||
327 | pcode = split_nonconstant_init_1 (sub, value, pcode); | |
328 | } | |
329 | else if (!initializer_constant_valid_p (value, inner_type)) | |
330 | { | |
331 | *pelt = TREE_CHAIN (elt); | |
332 | ||
333 | if (array_type_p) | |
334 | sub = build (ARRAY_REF, inner_type, dest, field_index); | |
335 | else | |
336 | sub = build (COMPONENT_REF, inner_type, dest, field_index); | |
337 | ||
338 | code = build (MODIFY_EXPR, inner_type, sub, value); | |
339 | code = build_stmt (EXPR_STMT, code); | |
340 | ||
341 | *pcode = code; | |
342 | pcode = &TREE_CHAIN (code); | |
343 | continue; | |
344 | } | |
345 | pelt = &TREE_CHAIN (elt); | |
346 | } | |
347 | break; | |
348 | ||
349 | case VECTOR_TYPE: | |
350 | if (!initializer_constant_valid_p (init, type)) | |
351 | { | |
352 | CONSTRUCTOR_ELTS (init) = NULL; | |
353 | code = build (MODIFY_EXPR, type, dest, init); | |
354 | code = build_stmt (EXPR_STMT, code); | |
355 | pcode = &TREE_CHAIN (code); | |
356 | } | |
357 | break; | |
358 | ||
359 | default: | |
360 | abort (); | |
361 | } | |
362 | ||
363 | return pcode; | |
364 | } | |
365 | ||
366 | /* A subroutine of store_init_value. Splits non-constant static | |
367 | initializer INIT into a constant part and generates code to | |
368 | perform the non-constant part of the initialization to DEST. | |
369 | Returns the code for the runtime init. */ | |
370 | ||
371 | static tree | |
372 | split_nonconstant_init (tree dest, tree init) | |
373 | { | |
374 | tree code; | |
375 | ||
376 | if (TREE_CODE (init) == CONSTRUCTOR) | |
377 | { | |
378 | code = build_stmt (COMPOUND_STMT, NULL_TREE); | |
379 | split_nonconstant_init_1 (dest, init, &COMPOUND_BODY (code)); | |
380 | code = build1 (STMT_EXPR, void_type_node, code); | |
381 | TREE_SIDE_EFFECTS (code) = 1; | |
382 | DECL_INITIAL (dest) = init; | |
383 | } | |
384 | else | |
385 | code = build (INIT_EXPR, TREE_TYPE (dest), dest, init); | |
386 | ||
387 | return code; | |
388 | } | |
389 | ||
8d08fdba MS |
390 | /* Perform appropriate conversions on the initial value of a variable, |
391 | store it in the declaration DECL, | |
392 | and print any error messages that are appropriate. | |
393 | If the init is invalid, store an ERROR_MARK. | |
394 | ||
395 | C++: Note that INIT might be a TREE_LIST, which would mean that it is | |
396 | a base class initializer for some aggregate type, hopefully compatible | |
397 | with DECL. If INIT is a single element, and DECL is an aggregate | |
398 | type, we silently convert INIT into a TREE_LIST, allowing a constructor | |
399 | to be called. | |
400 | ||
401 | If INIT is a TREE_LIST and there is no constructor, turn INIT | |
402 | into a CONSTRUCTOR and use standard initialization techniques. | |
403 | Perhaps a warning should be generated? | |
404 | ||
25ebb82a RH |
405 | Returns code to be executed if initialization could not be performed |
406 | for static variable. In that case, caller must emit the code. */ | |
8d08fdba MS |
407 | |
408 | tree | |
0a8cb79e | 409 | store_init_value (tree decl, tree init) |
8d08fdba | 410 | { |
926ce8bd | 411 | tree value, type; |
8d08fdba MS |
412 | |
413 | /* If variable's type was invalidly declared, just ignore it. */ | |
414 | ||
415 | type = TREE_TYPE (decl); | |
416 | if (TREE_CODE (type) == ERROR_MARK) | |
417 | return NULL_TREE; | |
418 | ||
e8abc66f | 419 | if (IS_AGGR_TYPE (type)) |
8d08fdba | 420 | { |
e8abc66f MS |
421 | if (! TYPE_HAS_TRIVIAL_INIT_REF (type) |
422 | && TREE_CODE (init) != CONSTRUCTOR) | |
a98facb0 | 423 | abort (); |
e8abc66f | 424 | |
6eabb241 | 425 | if (TREE_CODE (init) == TREE_LIST) |
8d08fdba | 426 | { |
33bd39a2 | 427 | error ("constructor syntax used, but no constructor declared for type `%T'", type); |
dcf92453 | 428 | init = build_constructor (NULL_TREE, nreverse (init)); |
8d08fdba | 429 | } |
8d08fdba MS |
430 | } |
431 | else if (TREE_CODE (init) == TREE_LIST | |
432 | && TREE_TYPE (init) != unknown_type_node) | |
433 | { | |
434 | if (TREE_CODE (decl) == RESULT_DECL) | |
c7b62f14 NS |
435 | init = build_x_compound_expr_from_list (init, |
436 | "return value initializer"); | |
8d08fdba MS |
437 | else if (TREE_CODE (init) == TREE_LIST |
438 | && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) | |
439 | { | |
8251199e | 440 | error ("cannot initialize arrays using this syntax"); |
8d08fdba MS |
441 | return NULL_TREE; |
442 | } | |
443 | else | |
c7b62f14 NS |
444 | /* We get here with code like `int a (2);' */ |
445 | init = build_x_compound_expr_from_list (init, "initializer"); | |
8d08fdba MS |
446 | } |
447 | ||
448 | /* End of special C++ code. */ | |
449 | ||
8e3df2de MM |
450 | /* Digest the specified initializer into an expression. */ |
451 | value = digest_init (type, init, (tree *) 0); | |
8d08fdba MS |
452 | |
453 | /* Store the expression if valid; else report error. */ | |
454 | ||
455 | if (TREE_CODE (value) == ERROR_MARK) | |
456 | ; | |
7834ab39 MS |
457 | /* Other code expects that initializers for objects of types that need |
458 | constructing never make it into DECL_INITIAL, and passes 'init' to | |
f1dedc31 | 459 | build_aggr_init without checking DECL_INITIAL. So just return. */ |
7834ab39 | 460 | else if (TYPE_NEEDS_CONSTRUCTING (type)) |
25ebb82a | 461 | return build (INIT_EXPR, type, decl, value); |
8d08fdba MS |
462 | else if (TREE_STATIC (decl) |
463 | && (! TREE_CONSTANT (value) | |
7993382e | 464 | || ! initializer_constant_valid_p (value, TREE_TYPE (value)))) |
25ebb82a | 465 | return split_nonconstant_init (decl, value); |
4d6abc1c MM |
466 | |
467 | /* Store the VALUE in DECL_INITIAL. If we're building a | |
468 | statement-tree we will actually expand the initialization later | |
469 | when we output this function. */ | |
8d08fdba MS |
470 | DECL_INITIAL (decl) = value; |
471 | return NULL_TREE; | |
472 | } | |
94e6e4c4 | 473 | |
8d08fdba MS |
474 | \f |
475 | /* Digest the parser output INIT as an initializer for type TYPE. | |
476 | Return a C expression of type TYPE to represent the initial value. | |
477 | ||
478 | If TAIL is nonzero, it points to a variable holding a list of elements | |
479 | of which INIT is the first. We update the list stored there by | |
480 | removing from the head all the elements that we use. | |
481 | Normally this is only one; we use more than one element only if | |
482 | TYPE is an aggregate and INIT is not a constructor. */ | |
483 | ||
484 | tree | |
0a8cb79e | 485 | digest_init (tree type, tree init, tree* tail) |
8d08fdba MS |
486 | { |
487 | enum tree_code code = TREE_CODE (type); | |
00595019 | 488 | tree element = NULL_TREE; |
a703fb38 | 489 | tree old_tail_contents = NULL_TREE; |
8e3df2de | 490 | /* Nonzero if INIT is a braced grouping. */ |
8d08fdba MS |
491 | int raw_constructor; |
492 | ||
493 | /* By default, assume we use one element from a list. | |
494 | We correct this later in the sole case where it is not true. */ | |
495 | ||
496 | if (tail) | |
497 | { | |
498 | old_tail_contents = *tail; | |
499 | *tail = TREE_CHAIN (*tail); | |
500 | } | |
501 | ||
502 | if (init == error_mark_node || (TREE_CODE (init) == TREE_LIST | |
503 | && TREE_VALUE (init) == error_mark_node)) | |
504 | return error_mark_node; | |
505 | ||
0ba8a114 NS |
506 | if (TREE_CODE (init) == ERROR_MARK) |
507 | /* __PRETTY_FUNCTION__'s initializer is a bogus expression inside | |
c6002625 | 508 | a template function. This gets substituted during instantiation. */ |
0ba8a114 | 509 | return init; |
b8b98c66 NS |
510 | |
511 | /* We must strip the outermost array type when completing the type, | |
512 | because the its bounds might be incomplete at the moment. */ | |
513 | if (!complete_type_or_else (TREE_CODE (type) == ARRAY_TYPE | |
514 | ? TREE_TYPE (type) : type, NULL_TREE)) | |
515 | return error_mark_node; | |
0ba8a114 | 516 | |
8d08fdba MS |
517 | /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ |
518 | if (TREE_CODE (init) == NON_LVALUE_EXPR) | |
519 | init = TREE_OPERAND (init, 0); | |
520 | ||
8e3df2de MM |
521 | raw_constructor = (TREE_CODE (init) == CONSTRUCTOR |
522 | && TREE_HAS_CONSTRUCTOR (init)); | |
8d08fdba | 523 | |
dc26f471 | 524 | if (raw_constructor |
8d08fdba MS |
525 | && CONSTRUCTOR_ELTS (init) != 0 |
526 | && TREE_CHAIN (CONSTRUCTOR_ELTS (init)) == 0) | |
527 | { | |
528 | element = TREE_VALUE (CONSTRUCTOR_ELTS (init)); | |
529 | /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ | |
530 | if (element && TREE_CODE (element) == NON_LVALUE_EXPR) | |
531 | element = TREE_OPERAND (element, 0); | |
532 | if (element == error_mark_node) | |
533 | return element; | |
534 | } | |
535 | ||
8d08fdba MS |
536 | /* Initialization of an array of chars from a string constant |
537 | optionally enclosed in braces. */ | |
538 | ||
539 | if (code == ARRAY_TYPE) | |
540 | { | |
8c90d611 JM |
541 | tree typ1; |
542 | ||
543 | if (TREE_CODE (init) == TREE_LIST) | |
544 | { | |
8251199e | 545 | error ("initializing array with parameter list"); |
8c90d611 JM |
546 | return error_mark_node; |
547 | } | |
548 | ||
549 | typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); | |
7b019c19 | 550 | if (char_type_p (typ1) |
8d08fdba MS |
551 | && ((init && TREE_CODE (init) == STRING_CST) |
552 | || (element && TREE_CODE (element) == STRING_CST))) | |
553 | { | |
554 | tree string = element ? element : init; | |
555 | ||
556 | if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string))) | |
557 | != char_type_node) | |
558 | && TYPE_PRECISION (typ1) == BITS_PER_UNIT) | |
559 | { | |
8251199e | 560 | error ("char-array initialized from wide string"); |
8d08fdba MS |
561 | return error_mark_node; |
562 | } | |
563 | if ((TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string))) | |
564 | == char_type_node) | |
565 | && TYPE_PRECISION (typ1) != BITS_PER_UNIT) | |
566 | { | |
8251199e | 567 | error ("int-array initialized from non-wide string"); |
8d08fdba MS |
568 | return error_mark_node; |
569 | } | |
570 | ||
8d08fdba MS |
571 | TREE_TYPE (string) = type; |
572 | if (TYPE_DOMAIN (type) != 0 | |
573 | && TREE_CONSTANT (TYPE_SIZE (type))) | |
574 | { | |
926ce8bd | 575 | int size = TREE_INT_CST_LOW (TYPE_SIZE (type)); |
8d08fdba MS |
576 | size = (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT; |
577 | /* In C it is ok to subtract 1 from the length of the string | |
578 | because it's ok to ignore the terminating null char that is | |
579 | counted in the length of the constant, but in C++ this would | |
580 | be invalid. */ | |
581 | if (size < TREE_STRING_LENGTH (string)) | |
8251199e | 582 | pedwarn ("initializer-string for array of chars is too long"); |
8d08fdba MS |
583 | } |
584 | return string; | |
585 | } | |
586 | } | |
587 | ||
588 | /* Handle scalar types, including conversions, | |
589 | and signature pointers and references. */ | |
590 | ||
591 | if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE | |
592 | || code == ENUMERAL_TYPE || code == REFERENCE_TYPE | |
ca4feb54 | 593 | || code == BOOLEAN_TYPE || code == COMPLEX_TYPE |
a5ac359a | 594 | || TYPE_PTR_TO_MEMBER_P (type)) |
8d08fdba MS |
595 | { |
596 | if (raw_constructor) | |
597 | { | |
598 | if (element == 0) | |
599 | { | |
8251199e | 600 | error ("initializer for scalar variable requires one element"); |
8d08fdba MS |
601 | return error_mark_node; |
602 | } | |
603 | init = element; | |
604 | } | |
dc26f471 | 605 | while (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init)) |
b7484fbe | 606 | { |
33bd39a2 | 607 | pedwarn ("braces around scalar initializer for `%T'", type); |
b7484fbe MS |
608 | init = CONSTRUCTOR_ELTS (init); |
609 | if (TREE_CHAIN (init)) | |
33bd39a2 | 610 | pedwarn ("ignoring extra initializers for `%T'", type); |
b7484fbe MS |
611 | init = TREE_VALUE (init); |
612 | } | |
8d08fdba MS |
613 | |
614 | return convert_for_initialization (0, type, init, LOOKUP_NORMAL, | |
615 | "initialization", NULL_TREE, 0); | |
616 | } | |
617 | ||
618 | /* Come here only for records and arrays (and unions with constructors). */ | |
619 | ||
d0f062fb | 620 | if (COMPLETE_TYPE_P (type) && ! TREE_CONSTANT (TYPE_SIZE (type))) |
8d08fdba | 621 | { |
33bd39a2 | 622 | error ("variable-sized object of type `%T' may not be initialized", |
7177d104 | 623 | type); |
8d08fdba MS |
624 | return error_mark_node; |
625 | } | |
626 | ||
ca4feb54 | 627 | if (code == ARRAY_TYPE || code == VECTOR_TYPE || IS_AGGR_TYPE_CODE (code)) |
8d08fdba | 628 | { |
f30efcb7 JM |
629 | if (raw_constructor && TYPE_NON_AGGREGATE_CLASS (type) |
630 | && TREE_HAS_CONSTRUCTOR (init)) | |
f30432d7 | 631 | { |
33bd39a2 | 632 | error ("subobject of type `%T' must be initialized by constructor, not by `%E'", |
f30432d7 MS |
633 | type, init); |
634 | return error_mark_node; | |
635 | } | |
636 | else if (raw_constructor) | |
8d08fdba | 637 | return process_init_constructor (type, init, (tree *)0); |
dc26f471 JM |
638 | else if (can_convert_arg (type, TREE_TYPE (init), init) |
639 | || TYPE_NON_AGGREGATE_CLASS (type)) | |
640 | /* These are never initialized from multiple constructor elements. */; | |
8d08fdba MS |
641 | else if (tail != 0) |
642 | { | |
643 | *tail = old_tail_contents; | |
644 | return process_init_constructor (type, 0, tail); | |
645 | } | |
d22c8596 | 646 | |
bb26522d | 647 | if (code != ARRAY_TYPE) |
dc26f471 JM |
648 | { |
649 | int flags = LOOKUP_NORMAL; | |
650 | /* Initialization from { } is copy-initialization. */ | |
651 | if (tail) | |
652 | flags |= LOOKUP_ONLYCONVERTING; | |
653 | ||
654 | return convert_for_initialization (NULL_TREE, type, init, flags, | |
655 | "initialization", NULL_TREE, 0); | |
656 | } | |
8d08fdba MS |
657 | } |
658 | ||
8251199e | 659 | error ("invalid initializer"); |
8d08fdba MS |
660 | return error_mark_node; |
661 | } | |
662 | \f | |
663 | /* Process a constructor for a variable of type TYPE. | |
664 | The constructor elements may be specified either with INIT or with ELTS, | |
665 | only one of which should be non-null. | |
666 | ||
667 | If INIT is specified, it is a CONSTRUCTOR node which is specifically | |
668 | and solely for initializing this datum. | |
669 | ||
670 | If ELTS is specified, it is the address of a variable containing | |
671 | a list of expressions. We take as many elements as we need | |
672 | from the head of the list and update the list. | |
673 | ||
674 | In the resulting constructor, TREE_CONSTANT is set if all elts are | |
675 | constant, and TREE_STATIC is set if, in addition, all elts are simple enough | |
676 | constants that the assembler and linker can compute them. */ | |
677 | ||
678 | static tree | |
0a8cb79e | 679 | process_init_constructor (tree type, tree init, tree* elts) |
8d08fdba | 680 | { |
926ce8bd | 681 | tree tail; |
8d08fdba MS |
682 | /* List of the elements of the result constructor, |
683 | in reverse order. */ | |
926ce8bd KH |
684 | tree members = NULL; |
685 | tree next1; | |
8d08fdba MS |
686 | tree result; |
687 | int allconstant = 1; | |
688 | int allsimple = 1; | |
689 | int erroneous = 0; | |
690 | ||
691 | /* Make TAIL be the list of elements to use for the initialization, | |
692 | no matter how the data was given to us. */ | |
693 | ||
694 | if (elts) | |
695 | { | |
696 | if (warn_missing_braces) | |
8251199e | 697 | warning ("aggregate has a partly bracketed initializer"); |
8d08fdba MS |
698 | tail = *elts; |
699 | } | |
700 | else | |
701 | tail = CONSTRUCTOR_ELTS (init); | |
702 | ||
703 | /* Gobble as many elements as needed, and make a constructor or initial value | |
704 | for each element of this aggregate. Chain them together in result. | |
705 | If there are too few, use 0 for each scalar ultimate component. */ | |
706 | ||
ca4feb54 | 707 | if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == VECTOR_TYPE) |
8d08fdba | 708 | { |
926ce8bd KH |
709 | long len; |
710 | int i; | |
8d08fdba | 711 | |
ca4feb54 JM |
712 | if (TREE_CODE (type) == ARRAY_TYPE) |
713 | { | |
714 | tree domain = TYPE_DOMAIN (type); | |
715 | if (domain) | |
716 | len = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (domain)) | |
717 | - TREE_INT_CST_LOW (TYPE_MIN_VALUE (domain)) | |
718 | + 1); | |
719 | else | |
f4f206f4 | 720 | len = -1; /* Take as many as there are. */ |
ca4feb54 | 721 | } |
8d08fdba | 722 | else |
ca4feb54 JM |
723 | { |
724 | /* Vectors are like simple fixed-size arrays. */ | |
725 | len = TYPE_VECTOR_SUBPARTS (type); | |
726 | } | |
8d08fdba | 727 | |
e6267549 | 728 | for (i = 0; len < 0 || i < len; i++) |
8d08fdba | 729 | { |
e6267549 | 730 | if (tail) |
8d08fdba | 731 | { |
e6267549 JM |
732 | if (TREE_PURPOSE (tail) |
733 | && (TREE_CODE (TREE_PURPOSE (tail)) != INTEGER_CST | |
05bccae2 | 734 | || compare_tree_int (TREE_PURPOSE (tail), i) != 0)) |
e6267549 JM |
735 | sorry ("non-trivial labeled initializers"); |
736 | ||
737 | if (TREE_VALUE (tail) != 0) | |
a5894242 | 738 | { |
e6267549 JM |
739 | tree tail1 = tail; |
740 | next1 = digest_init (TREE_TYPE (type), | |
741 | TREE_VALUE (tail), &tail1); | |
0db982be ML |
742 | if (next1 == error_mark_node) |
743 | return next1; | |
7e2067ca | 744 | my_friendly_assert |
9edc3913 MM |
745 | (same_type_ignoring_top_level_qualifiers_p |
746 | (TREE_TYPE (type), TREE_TYPE (next1)), | |
7e2067ca | 747 | 981123); |
e6267549 JM |
748 | my_friendly_assert (tail1 == 0 |
749 | || TREE_CODE (tail1) == TREE_LIST, 319); | |
750 | if (tail == tail1 && len < 0) | |
751 | { | |
752 | error ("non-empty initializer for array of empty elements"); | |
753 | /* Just ignore what we were supposed to use. */ | |
754 | tail1 = NULL_TREE; | |
755 | } | |
756 | tail = tail1; | |
a5894242 | 757 | } |
e6267549 | 758 | else |
8d08fdba | 759 | { |
e6267549 JM |
760 | next1 = error_mark_node; |
761 | tail = TREE_CHAIN (tail); | |
8d08fdba | 762 | } |
8d08fdba | 763 | } |
e6267549 JM |
764 | else if (len < 0) |
765 | /* We're done. */ | |
766 | break; | |
767 | else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type))) | |
8d08fdba | 768 | { |
e6267549 JM |
769 | /* If this type needs constructors run for |
770 | default-initialization, we can't rely on the backend to do it | |
771 | for us, so build up TARGET_EXPRs. If the type in question is | |
772 | a class, just build one up; if it's an array, recurse. */ | |
773 | ||
774 | if (IS_AGGR_TYPE (TREE_TYPE (type))) | |
775 | next1 = build_functional_cast (TREE_TYPE (type), NULL_TREE); | |
776 | else | |
dcf92453 | 777 | next1 = build_constructor (NULL_TREE, NULL_TREE); |
e6267549 | 778 | next1 = digest_init (TREE_TYPE (type), next1, 0); |
8d08fdba | 779 | } |
94e6e4c4 | 780 | else if (! zero_init_p (TREE_TYPE (type))) |
17bbb839 | 781 | next1 = build_zero_init (TREE_TYPE (type), |
1cb8292f | 782 | /*nelts=*/NULL_TREE, |
17bbb839 | 783 | /*static_storage_p=*/false); |
e6267549 JM |
784 | else |
785 | /* The default zero-initialization is fine for us; don't | |
786 | add anything to the CONSTRUCTOR. */ | |
787 | break; | |
8d08fdba MS |
788 | |
789 | if (next1 == error_mark_node) | |
790 | erroneous = 1; | |
791 | else if (!TREE_CONSTANT (next1)) | |
792 | allconstant = 0; | |
8ccc31eb | 793 | else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1))) |
8d08fdba | 794 | allsimple = 0; |
96756199 | 795 | members = tree_cons (size_int (i), next1, members); |
8d08fdba MS |
796 | } |
797 | } | |
8a72a046 | 798 | else if (TREE_CODE (type) == RECORD_TYPE) |
8d08fdba | 799 | { |
926ce8bd | 800 | tree field; |
8d08fdba MS |
801 | |
802 | if (tail) | |
803 | { | |
804 | if (TYPE_USES_VIRTUAL_BASECLASSES (type)) | |
805 | { | |
7e4d7898 | 806 | sorry ("initializer list for object of class with virtual base classes"); |
8d08fdba MS |
807 | return error_mark_node; |
808 | } | |
809 | ||
810 | if (TYPE_BINFO_BASETYPES (type)) | |
811 | { | |
7e4d7898 | 812 | sorry ("initializer list for object of class with base classes"); |
8d08fdba MS |
813 | return error_mark_node; |
814 | } | |
815 | ||
4c6b7393 | 816 | if (TYPE_POLYMORPHIC_P (type)) |
8d08fdba MS |
817 | { |
818 | sorry ("initializer list for object using virtual functions"); | |
819 | return error_mark_node; | |
820 | } | |
821 | } | |
822 | ||
e6267549 | 823 | for (field = TYPE_FIELDS (type); field; |
8d08fdba MS |
824 | field = TREE_CHAIN (field)) |
825 | { | |
c8c133cd | 826 | if (! DECL_NAME (field) && DECL_C_BIT_FIELD (field)) |
8d08fdba | 827 | { |
96756199 | 828 | members = tree_cons (field, integer_zero_node, members); |
8d08fdba MS |
829 | continue; |
830 | } | |
831 | ||
17bbb839 | 832 | if (TREE_CODE (field) != FIELD_DECL || DECL_ARTIFICIAL (field)) |
8d08fdba MS |
833 | continue; |
834 | ||
e6267549 JM |
835 | if (tail) |
836 | { | |
837 | if (TREE_PURPOSE (tail) | |
838 | && TREE_PURPOSE (tail) != field | |
839 | && TREE_PURPOSE (tail) != DECL_NAME (field)) | |
840 | sorry ("non-trivial labeled initializers"); | |
841 | ||
842 | if (TREE_VALUE (tail) != 0) | |
843 | { | |
844 | tree tail1 = tail; | |
c8fcb331 | 845 | |
e6267549 JM |
846 | next1 = digest_init (TREE_TYPE (field), |
847 | TREE_VALUE (tail), &tail1); | |
848 | my_friendly_assert (tail1 == 0 | |
849 | || TREE_CODE (tail1) == TREE_LIST, 320); | |
850 | tail = tail1; | |
851 | } | |
852 | else | |
853 | { | |
854 | next1 = error_mark_node; | |
855 | tail = TREE_CHAIN (tail); | |
856 | } | |
857 | } | |
858 | else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field))) | |
8d08fdba | 859 | { |
e6267549 JM |
860 | /* If this type needs constructors run for |
861 | default-initialization, we can't rely on the backend to do it | |
862 | for us, so build up TARGET_EXPRs. If the type in question is | |
863 | a class, just build one up; if it's an array, recurse. */ | |
864 | ||
865 | if (IS_AGGR_TYPE (TREE_TYPE (field))) | |
866 | next1 = build_functional_cast (TREE_TYPE (field), | |
867 | NULL_TREE); | |
868 | else | |
45abaea8 | 869 | { |
dcf92453 | 870 | next1 = build_constructor (NULL_TREE, NULL_TREE); |
45abaea8 NS |
871 | if (init) |
872 | TREE_HAS_CONSTRUCTOR (next1) | |
873 | = TREE_HAS_CONSTRUCTOR (init); | |
874 | } | |
e6267549 | 875 | next1 = digest_init (TREE_TYPE (field), next1, 0); |
8d08fdba | 876 | |
e6267549 | 877 | /* Warn when some struct elements are implicitly initialized. */ |
45abaea8 NS |
878 | if (extra_warnings |
879 | && (!init || TREE_HAS_CONSTRUCTOR (init))) | |
33bd39a2 | 880 | warning ("missing initializer for member `%D'", field); |
8d08fdba MS |
881 | } |
882 | else | |
883 | { | |
e6267549 | 884 | if (TREE_READONLY (field)) |
33bd39a2 | 885 | error ("uninitialized const member `%D'", field); |
6eb35968 | 886 | else if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (TREE_TYPE (field))) |
33bd39a2 | 887 | error ("member `%D' with uninitialized const fields", |
e6267549 JM |
888 | field); |
889 | else if (TREE_CODE (TREE_TYPE (field)) == REFERENCE_TYPE) | |
33bd39a2 | 890 | error ("member `%D' is uninitialized reference", field); |
e6267549 JM |
891 | |
892 | /* Warn when some struct elements are implicitly initialized | |
893 | to zero. */ | |
45abaea8 NS |
894 | if (extra_warnings |
895 | && (!init || TREE_HAS_CONSTRUCTOR (init))) | |
33bd39a2 | 896 | warning ("missing initializer for member `%D'", field); |
e6267549 | 897 | |
94e6e4c4 | 898 | if (! zero_init_p (TREE_TYPE (field))) |
17bbb839 | 899 | next1 = build_zero_init (TREE_TYPE (field), |
1cb8292f | 900 | /*nelts=*/NULL_TREE, |
17bbb839 | 901 | /*static_storage_p=*/false); |
94e6e4c4 AO |
902 | else |
903 | /* The default zero-initialization is fine for us; don't | |
904 | add anything to the CONSTRUCTOR. */ | |
905 | continue; | |
8d08fdba MS |
906 | } |
907 | ||
908 | if (next1 == error_mark_node) | |
909 | erroneous = 1; | |
910 | else if (!TREE_CONSTANT (next1)) | |
911 | allconstant = 0; | |
8ccc31eb | 912 | else if (! initializer_constant_valid_p (next1, TREE_TYPE (next1))) |
8d08fdba | 913 | allsimple = 0; |
96756199 | 914 | members = tree_cons (field, next1, members); |
8d08fdba | 915 | } |
8d08fdba | 916 | } |
a59f8640 R |
917 | else if (TREE_CODE (type) == UNION_TYPE |
918 | /* If the initializer was empty, use default zero initialization. */ | |
919 | && tail) | |
8d08fdba | 920 | { |
926ce8bd | 921 | tree field = TYPE_FIELDS (type); |
8d08fdba MS |
922 | |
923 | /* Find the first named field. ANSI decided in September 1990 | |
924 | that only named fields count here. */ | |
17bbb839 | 925 | while (field && (!DECL_NAME (field) || TREE_CODE (field) != FIELD_DECL)) |
8d08fdba MS |
926 | field = TREE_CHAIN (field); |
927 | ||
928 | /* If this element specifies a field, initialize via that field. */ | |
929 | if (TREE_PURPOSE (tail) != NULL_TREE) | |
930 | { | |
931 | int win = 0; | |
932 | ||
933 | if (TREE_CODE (TREE_PURPOSE (tail)) == FIELD_DECL) | |
934 | /* Handle the case of a call by build_c_cast. */ | |
935 | field = TREE_PURPOSE (tail), win = 1; | |
936 | else if (TREE_CODE (TREE_PURPOSE (tail)) != IDENTIFIER_NODE) | |
8251199e | 937 | error ("index value instead of field name in union initializer"); |
8d08fdba MS |
938 | else |
939 | { | |
940 | tree temp; | |
941 | for (temp = TYPE_FIELDS (type); | |
942 | temp; | |
943 | temp = TREE_CHAIN (temp)) | |
944 | if (DECL_NAME (temp) == TREE_PURPOSE (tail)) | |
945 | break; | |
946 | if (temp) | |
947 | field = temp, win = 1; | |
948 | else | |
33bd39a2 | 949 | error ("no field `%D' in union being initialized", |
e6267549 | 950 | TREE_PURPOSE (tail)); |
8d08fdba MS |
951 | } |
952 | if (!win) | |
953 | TREE_VALUE (tail) = error_mark_node; | |
954 | } | |
7177d104 MS |
955 | else if (field == 0) |
956 | { | |
33bd39a2 | 957 | error ("union `%T' with no named members cannot be initialized", |
7177d104 MS |
958 | type); |
959 | TREE_VALUE (tail) = error_mark_node; | |
960 | } | |
8d08fdba MS |
961 | |
962 | if (TREE_VALUE (tail) != 0) | |
963 | { | |
964 | tree tail1 = tail; | |
965 | ||
966 | next1 = digest_init (TREE_TYPE (field), | |
967 | TREE_VALUE (tail), &tail1); | |
968 | if (tail1 != 0 && TREE_CODE (tail1) != TREE_LIST) | |
a98facb0 | 969 | abort (); |
8d08fdba MS |
970 | tail = tail1; |
971 | } | |
972 | else | |
973 | { | |
974 | next1 = error_mark_node; | |
975 | tail = TREE_CHAIN (tail); | |
976 | } | |
977 | ||
978 | if (next1 == error_mark_node) | |
979 | erroneous = 1; | |
980 | else if (!TREE_CONSTANT (next1)) | |
981 | allconstant = 0; | |
8ccc31eb | 982 | else if (initializer_constant_valid_p (next1, TREE_TYPE (next1)) == 0) |
8d08fdba | 983 | allsimple = 0; |
96756199 | 984 | members = tree_cons (field, next1, members); |
8d08fdba MS |
985 | } |
986 | ||
987 | /* If arguments were specified as a list, just remove the ones we used. */ | |
988 | if (elts) | |
989 | *elts = tail; | |
990 | /* If arguments were specified as a constructor, | |
991 | complain unless we used all the elements of the constructor. */ | |
992 | else if (tail) | |
8251199e | 993 | pedwarn ("excess elements in aggregate initializer"); |
8d08fdba MS |
994 | |
995 | if (erroneous) | |
996 | return error_mark_node; | |
997 | ||
dcf92453 | 998 | result = build_constructor (type, nreverse (members)); |
8c081e84 MM |
999 | if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type) == NULL_TREE) |
1000 | complete_array_type (type, result, /*do_default=*/0); | |
8d08fdba MS |
1001 | if (init) |
1002 | TREE_HAS_CONSTRUCTOR (result) = TREE_HAS_CONSTRUCTOR (init); | |
1003 | if (allconstant) TREE_CONSTANT (result) = 1; | |
1004 | if (allconstant && allsimple) TREE_STATIC (result) = 1; | |
1005 | return result; | |
1006 | } | |
1007 | \f | |
1008 | /* Given a structure or union value DATUM, construct and return | |
1009 | the structure or union component which results from narrowing | |
a29e1034 | 1010 | that value to the base specified in BASETYPE. For example, given the |
8d08fdba MS |
1011 | hierarchy |
1012 | ||
1013 | class L { int ii; }; | |
1014 | class A : L { ... }; | |
1015 | class B : L { ... }; | |
1016 | class C : A, B { ... }; | |
1017 | ||
1018 | and the declaration | |
1019 | ||
1020 | C x; | |
1021 | ||
1022 | then the expression | |
1023 | ||
be99da77 | 1024 | x.A::ii refers to the ii member of the L part of |
38e01259 | 1025 | the A part of the C object named by X. In this case, |
aa52c1ff JM |
1026 | DATUM would be x, and BASETYPE would be A. |
1027 | ||
477f6664 JM |
1028 | I used to think that this was nonconformant, that the standard specified |
1029 | that first we look up ii in A, then convert x to an L& and pull out the | |
1030 | ii part. But in fact, it does say that we convert x to an A&; A here | |
a29e1034 JM |
1031 | is known as the "naming class". (jason 2000-12-19) |
1032 | ||
1033 | BINFO_P points to a variable initialized either to NULL_TREE or to the | |
1034 | binfo for the specific base subobject we want to convert to. */ | |
8d08fdba MS |
1035 | |
1036 | tree | |
0a8cb79e | 1037 | build_scoped_ref (tree datum, tree basetype, tree* binfo_p) |
8d08fdba | 1038 | { |
338d90b8 | 1039 | tree binfo; |
8d08fdba MS |
1040 | |
1041 | if (datum == error_mark_node) | |
1042 | return error_mark_node; | |
a29e1034 JM |
1043 | if (*binfo_p) |
1044 | binfo = *binfo_p; | |
1045 | else | |
1046 | binfo = lookup_base (TREE_TYPE (datum), basetype, ba_check, NULL); | |
8d08fdba | 1047 | |
a29e1034 JM |
1048 | if (!binfo || binfo == error_mark_node) |
1049 | { | |
1050 | *binfo_p = NULL_TREE; | |
1051 | if (!binfo) | |
1052 | error_not_base_type (basetype, TREE_TYPE (datum)); | |
1053 | return error_mark_node; | |
1054 | } | |
8d08fdba | 1055 | |
a29e1034 JM |
1056 | *binfo_p = binfo; |
1057 | return build_base_path (PLUS_EXPR, datum, binfo, 1); | |
8d08fdba MS |
1058 | } |
1059 | ||
1060 | /* Build a reference to an object specified by the C++ `->' operator. | |
1061 | Usually this just involves dereferencing the object, but if the | |
1062 | `->' operator is overloaded, then such overloads must be | |
1063 | performed until an object which does not have the `->' operator | |
1064 | overloaded is found. An error is reported when circular pointer | |
1065 | delegation is detected. */ | |
e92cc029 | 1066 | |
8d08fdba | 1067 | tree |
d17811fd | 1068 | build_x_arrow (tree expr) |
8d08fdba | 1069 | { |
d17811fd | 1070 | tree orig_expr = expr; |
8d08fdba | 1071 | tree types_memoized = NULL_TREE; |
d17811fd | 1072 | tree type = TREE_TYPE (expr); |
a703fb38 | 1073 | tree last_rval = NULL_TREE; |
8d08fdba MS |
1074 | |
1075 | if (type == error_mark_node) | |
1076 | return error_mark_node; | |
1077 | ||
5156628f | 1078 | if (processing_template_decl) |
d17811fd MM |
1079 | { |
1080 | if (type_dependent_expression_p (expr)) | |
1081 | return build_min_nt (ARROW_EXPR, expr); | |
1082 | expr = build_non_dependent_expr (expr); | |
1083 | } | |
5566b478 | 1084 | |
8d08fdba MS |
1085 | if (TREE_CODE (type) == REFERENCE_TYPE) |
1086 | { | |
d17811fd MM |
1087 | expr = convert_from_reference (expr); |
1088 | type = TREE_TYPE (expr); | |
8d08fdba MS |
1089 | } |
1090 | ||
3c215895 | 1091 | if (IS_AGGR_TYPE (type)) |
8d08fdba | 1092 | { |
d17811fd | 1093 | while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr, |
ec835fb2 MM |
1094 | NULL_TREE, NULL_TREE, |
1095 | /*overloaded_p=*/NULL))) | |
8d08fdba | 1096 | { |
d17811fd | 1097 | if (expr == error_mark_node) |
8d08fdba MS |
1098 | return error_mark_node; |
1099 | ||
d17811fd | 1100 | if (value_member (TREE_TYPE (expr), types_memoized)) |
8d08fdba | 1101 | { |
8251199e | 1102 | error ("circular pointer delegation detected"); |
8d08fdba MS |
1103 | return error_mark_node; |
1104 | } | |
1105 | else | |
1106 | { | |
d17811fd | 1107 | types_memoized = tree_cons (NULL_TREE, TREE_TYPE (expr), |
8d08fdba MS |
1108 | types_memoized); |
1109 | } | |
d17811fd | 1110 | last_rval = expr; |
8d08fdba | 1111 | } |
297dcfb3 MM |
1112 | |
1113 | if (last_rval == NULL_TREE) | |
1114 | { | |
33bd39a2 | 1115 | error ("base operand of `->' has non-pointer type `%T'", type); |
297dcfb3 MM |
1116 | return error_mark_node; |
1117 | } | |
1118 | ||
8d08fdba MS |
1119 | if (TREE_CODE (TREE_TYPE (last_rval)) == REFERENCE_TYPE) |
1120 | last_rval = convert_from_reference (last_rval); | |
1121 | } | |
1122 | else | |
d17811fd | 1123 | last_rval = decay_conversion (expr); |
8d08fdba | 1124 | |
8d08fdba | 1125 | if (TREE_CODE (TREE_TYPE (last_rval)) == POINTER_TYPE) |
d17811fd MM |
1126 | { |
1127 | if (processing_template_decl) | |
8e1daa34 NS |
1128 | { |
1129 | expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr); | |
04c06002 | 1130 | /* It will be dereferenced. */ |
8e1daa34 NS |
1131 | TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval)); |
1132 | return expr; | |
1133 | } | |
d17811fd MM |
1134 | |
1135 | return build_indirect_ref (last_rval, NULL); | |
1136 | } | |
8d08fdba | 1137 | |
8d08fdba | 1138 | if (types_memoized) |
8251199e | 1139 | error ("result of `operator->()' yields non-pointer result"); |
8d08fdba | 1140 | else |
8251199e | 1141 | error ("base operand of `->' is not a pointer"); |
8d08fdba MS |
1142 | return error_mark_node; |
1143 | } | |
1144 | ||
d6b4ea85 MM |
1145 | /* Return an expression for "DATUM .* COMPONENT". DATUM has not |
1146 | already been checked out to be of aggregate type. */ | |
e92cc029 | 1147 | |
8d08fdba | 1148 | tree |
0a8cb79e | 1149 | build_m_component_ref (tree datum, tree component) |
8d08fdba | 1150 | { |
d6b4ea85 | 1151 | tree ptrmem_type; |
c3e899c1 | 1152 | tree objtype; |
d6b4ea85 | 1153 | tree type; |
71851aaa | 1154 | tree binfo; |
8d08fdba | 1155 | |
c3e899c1 | 1156 | datum = decay_conversion (datum); |
f1a3f197 MM |
1157 | |
1158 | if (datum == error_mark_node || component == error_mark_node) | |
1159 | return error_mark_node; | |
1160 | ||
d6b4ea85 | 1161 | ptrmem_type = TREE_TYPE (component); |
a5ac359a | 1162 | if (!TYPE_PTR_TO_MEMBER_P (ptrmem_type)) |
8d08fdba | 1163 | { |
33bd39a2 | 1164 | error ("`%E' cannot be used as a member pointer, since it is of type `%T'", |
d6b4ea85 | 1165 | component, ptrmem_type); |
8d08fdba MS |
1166 | return error_mark_node; |
1167 | } | |
d6b4ea85 MM |
1168 | |
1169 | objtype = TYPE_MAIN_VARIANT (TREE_TYPE (datum)); | |
51c184be MS |
1170 | if (! IS_AGGR_TYPE (objtype)) |
1171 | { | |
3ad97789 NS |
1172 | error ("cannot apply member pointer `%E' to `%E', which is of non-aggregate type `%T'", |
1173 | component, datum, objtype); | |
51c184be MS |
1174 | return error_mark_node; |
1175 | } | |
71851aaa | 1176 | |
d6b4ea85 MM |
1177 | type = TYPE_PTRMEM_POINTED_TO_TYPE (ptrmem_type); |
1178 | binfo = lookup_base (objtype, TYPE_PTRMEM_CLASS_TYPE (ptrmem_type), | |
2db1ab2d NS |
1179 | ba_check, NULL); |
1180 | if (!binfo) | |
8d08fdba | 1181 | { |
33bd39a2 | 1182 | error ("member type `%T::' incompatible with object type `%T'", |
d6b4ea85 | 1183 | type, objtype); |
8d08fdba MS |
1184 | return error_mark_node; |
1185 | } | |
71851aaa MS |
1186 | else if (binfo == error_mark_node) |
1187 | return error_mark_node; | |
8d08fdba | 1188 | |
d6b4ea85 MM |
1189 | if (TYPE_PTRMEM_P (ptrmem_type)) |
1190 | { | |
1191 | /* Compute the type of the field, as described in [expr.ref]. | |
1192 | There's no such thing as a mutable pointer-to-member, so | |
1193 | things are not as complex as they are for references to | |
1194 | non-static data members. */ | |
1195 | type = cp_build_qualified_type (type, | |
1196 | (cp_type_quals (type) | |
1197 | | cp_type_quals (TREE_TYPE (datum)))); | |
a5ac359a MM |
1198 | /* Build an expression for "object + offset" where offset is the |
1199 | value stored in the pointer-to-data-member. */ | |
1200 | datum = build (PLUS_EXPR, build_pointer_type (type), | |
1201 | build_base_path (PLUS_EXPR, build_address (datum), | |
1202 | binfo, 1), | |
1203 | build_nop (ptrdiff_type_node, component)); | |
d6b4ea85 MM |
1204 | return build_indirect_ref (datum, 0); |
1205 | } | |
1206 | else | |
1207 | return build (OFFSET_REF, type, datum, component); | |
8d08fdba MS |
1208 | } |
1209 | ||
fc378698 | 1210 | /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */ |
e92cc029 | 1211 | |
8d08fdba | 1212 | tree |
0a8cb79e | 1213 | build_functional_cast (tree exp, tree parms) |
8d08fdba MS |
1214 | { |
1215 | /* This is either a call to a constructor, | |
1216 | or a C cast in C++'s `functional' notation. */ | |
fc378698 | 1217 | tree type; |
8d08fdba MS |
1218 | |
1219 | if (exp == error_mark_node || parms == error_mark_node) | |
1220 | return error_mark_node; | |
1221 | ||
4b0d3cbe | 1222 | if (TREE_CODE (exp) == TYPE_DECL) |
45537677 | 1223 | type = TREE_TYPE (exp); |
8d08fdba MS |
1224 | else |
1225 | type = exp; | |
1226 | ||
5156628f | 1227 | if (processing_template_decl) |
8e1daa34 NS |
1228 | { |
1229 | tree t = build_min (CAST_EXPR, type, parms); | |
1230 | /* We don't know if it will or will not have side effects. */ | |
1231 | TREE_SIDE_EFFECTS (t) = 1; | |
1232 | return t; | |
1233 | } | |
5566b478 | 1234 | |
8d08fdba MS |
1235 | if (! IS_AGGR_TYPE (type)) |
1236 | { | |
f4f206f4 | 1237 | /* This must build a C cast. */ |
8d08fdba | 1238 | if (parms == NULL_TREE) |
d18c083e | 1239 | parms = integer_zero_node; |
8ccc31eb | 1240 | else |
c7b62f14 | 1241 | parms = build_x_compound_expr_from_list (parms, "functional cast"); |
8ccc31eb | 1242 | |
faf5394a | 1243 | return build_c_cast (type, parms); |
8d08fdba MS |
1244 | } |
1245 | ||
45537677 MS |
1246 | /* Prepare to evaluate as a call to a constructor. If this expression |
1247 | is actually used, for example, | |
1248 | ||
1249 | return X (arg1, arg2, ...); | |
1250 | ||
1251 | then the slot being initialized will be filled in. */ | |
1252 | ||
d0f062fb NS |
1253 | if (!complete_type_or_else (type, NULL_TREE)) |
1254 | return error_mark_node; | |
a7a64a77 MM |
1255 | if (abstract_virtuals_error (NULL_TREE, type)) |
1256 | return error_mark_node; | |
8d08fdba MS |
1257 | |
1258 | if (parms && TREE_CHAIN (parms) == NULL_TREE) | |
faf5394a | 1259 | return build_c_cast (type, TREE_VALUE (parms)); |
8d08fdba | 1260 | |
3551c177 JM |
1261 | /* We need to zero-initialize POD types. Let's do that for everything |
1262 | that doesn't need a constructor. */ | |
1263 | if (parms == NULL_TREE && !TYPE_NEEDS_CONSTRUCTING (type) | |
1264 | && TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) | |
1265 | { | |
dcf92453 | 1266 | exp = build_constructor (type, NULL_TREE); |
3551c177 JM |
1267 | return get_target_expr (exp); |
1268 | } | |
1269 | ||
4ba126e4 MM |
1270 | exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms, |
1271 | TYPE_BINFO (type), LOOKUP_NORMAL); | |
8d08fdba | 1272 | |
fc378698 | 1273 | if (exp == error_mark_node) |
a0a33927 | 1274 | return error_mark_node; |
8d08fdba | 1275 | |
fc378698 | 1276 | return build_cplus_new (type, exp); |
8d08fdba MS |
1277 | } |
1278 | \f | |
46b02c6d | 1279 | |
4cc1d462 NS |
1280 | /* Add new exception specifier SPEC, to the LIST we currently have. |
1281 | If it's already in LIST then do nothing. | |
1282 | Moan if it's bad and we're allowed to. COMPLAIN < 0 means we | |
1283 | know what we're doing. */ | |
1284 | ||
1285 | tree | |
0a8cb79e | 1286 | add_exception_specifier (tree list, tree spec, int complain) |
4cc1d462 | 1287 | { |
ef09717a | 1288 | bool ok; |
4cc1d462 | 1289 | tree core = spec; |
ef09717a | 1290 | bool is_ptr; |
5aa3396c | 1291 | int diag_type = -1; /* none */ |
4cc1d462 NS |
1292 | |
1293 | if (spec == error_mark_node) | |
1294 | return list; | |
1295 | ||
1296 | my_friendly_assert (spec && (!list || TREE_VALUE (list)), 19990317); | |
1297 | ||
1298 | /* [except.spec] 1, type in an exception specifier shall not be | |
1299 | incomplete, or pointer or ref to incomplete other than pointer | |
1300 | to cv void. */ | |
1301 | is_ptr = TREE_CODE (core) == POINTER_TYPE; | |
1302 | if (is_ptr || TREE_CODE (core) == REFERENCE_TYPE) | |
1303 | core = TREE_TYPE (core); | |
1304 | if (complain < 0) | |
ef09717a | 1305 | ok = true; |
b72801e2 | 1306 | else if (VOID_TYPE_P (core)) |
4cc1d462 NS |
1307 | ok = is_ptr; |
1308 | else if (TREE_CODE (core) == TEMPLATE_TYPE_PARM) | |
ef09717a | 1309 | ok = true; |
baeb4732 | 1310 | else if (processing_template_decl) |
ef09717a | 1311 | ok = true; |
4cc1d462 | 1312 | else |
5aa3396c | 1313 | { |
ef09717a | 1314 | ok = true; |
5aa3396c JM |
1315 | /* 15.4/1 says that types in an exception specifier must be complete, |
1316 | but it seems more reasonable to only require this on definitions | |
1317 | and calls. So just give a pedwarn at this point; we will give an | |
1318 | error later if we hit one of those two cases. */ | |
1319 | if (!COMPLETE_TYPE_P (complete_type (core))) | |
1320 | diag_type = 2; /* pedwarn */ | |
1321 | } | |
baeb4732 | 1322 | |
4cc1d462 NS |
1323 | if (ok) |
1324 | { | |
1325 | tree probe; | |
1326 | ||
1327 | for (probe = list; probe; probe = TREE_CHAIN (probe)) | |
1328 | if (same_type_p (TREE_VALUE (probe), spec)) | |
1329 | break; | |
1330 | if (!probe) | |
80b1331c | 1331 | list = tree_cons (NULL_TREE, spec, list); |
4cc1d462 | 1332 | } |
5aa3396c JM |
1333 | else |
1334 | diag_type = 0; /* error */ | |
1335 | ||
1336 | if (diag_type >= 0 && complain) | |
1337 | cxx_incomplete_type_diagnostic (NULL_TREE, core, diag_type); | |
1338 | ||
4cc1d462 NS |
1339 | return list; |
1340 | } | |
03378143 NS |
1341 | |
1342 | /* Combine the two exceptions specifier lists LIST and ADD, and return | |
c6002625 | 1343 | their union. */ |
03378143 NS |
1344 | |
1345 | tree | |
0a8cb79e | 1346 | merge_exception_specifiers (tree list, tree add) |
03378143 NS |
1347 | { |
1348 | if (!list || !add) | |
1349 | return NULL_TREE; | |
1350 | else if (!TREE_VALUE (list)) | |
1351 | return add; | |
1352 | else if (!TREE_VALUE (add)) | |
1353 | return list; | |
1354 | else | |
1355 | { | |
1356 | tree orig_list = list; | |
1357 | ||
1358 | for (; add; add = TREE_CHAIN (add)) | |
1359 | { | |
1360 | tree spec = TREE_VALUE (add); | |
1361 | tree probe; | |
1362 | ||
1363 | for (probe = orig_list; probe; probe = TREE_CHAIN (probe)) | |
1364 | if (same_type_p (TREE_VALUE (probe), spec)) | |
1365 | break; | |
1366 | if (!probe) | |
1367 | { | |
1368 | spec = build_tree_list (NULL_TREE, spec); | |
1369 | TREE_CHAIN (spec) = list; | |
1370 | list = spec; | |
1371 | } | |
1372 | } | |
1373 | } | |
1374 | return list; | |
1375 | } | |
5aa3396c JM |
1376 | |
1377 | /* Subroutine of build_call. Ensure that each of the types in the | |
1378 | exception specification is complete. Technically, 15.4/1 says that | |
1379 | they need to be complete when we see a declaration of the function, | |
1380 | but we should be able to get away with only requiring this when the | |
1381 | function is defined or called. See also add_exception_specifier. */ | |
1382 | ||
1383 | void | |
0a8cb79e | 1384 | require_complete_eh_spec_types (tree fntype, tree decl) |
5aa3396c JM |
1385 | { |
1386 | tree raises; | |
1387 | /* Don't complain about calls to op new. */ | |
1388 | if (decl && DECL_ARTIFICIAL (decl)) | |
1389 | return; | |
1390 | for (raises = TYPE_RAISES_EXCEPTIONS (fntype); raises; | |
1391 | raises = TREE_CHAIN (raises)) | |
1392 | { | |
1393 | tree type = TREE_VALUE (raises); | |
1394 | if (type && !COMPLETE_TYPE_P (type)) | |
1395 | { | |
1396 | if (decl) | |
1397 | error | |
1398 | ("call to function `%D' which throws incomplete type `%#T'", | |
1399 | decl, type); | |
1400 | else | |
1401 | error ("call to function which throws incomplete type `%#T'", | |
1402 | decl); | |
1403 | } | |
1404 | } | |
1405 | } |