xref: /netbsd-src/usr.bin/xlint/lint1/init.c (revision 6937eff333b197fb14840f0e58df0f7a0edfd51a)
1 /*	$NetBSD: init.c,v 1.271 2024/11/13 04:32:49 rillig Exp $	*/
2 
3 /*
4  * Copyright (c) 1994, 1995 Jochen Pohl
5  * Copyright (c) 2021 Roland Illig
6  * All Rights Reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This product includes software developed by Jochen Pohl for
19  *	The NetBSD Project.
20  * 4. The name of the author may not be used to endorse or promote products
21  *    derived from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34 
35 #if HAVE_NBTOOL_CONFIG_H
36 #include "nbtool_config.h"
37 #endif
38 
39 #include <sys/cdefs.h>
40 #if defined(__RCSID)
41 __RCSID("$NetBSD: init.c,v 1.271 2024/11/13 04:32:49 rillig Exp $");
42 #endif
43 
44 #include <stdlib.h>
45 #include <string.h>
46 
47 #include "lint1.h"
48 
49 
50 /*
51  * Initialization of global or local objects, like in:
52  *
53  *	int number = 12345;
54  *	int number_with_braces = { 12345 };
55  *	int array_of_unknown_size[] = { 111, 222, 333 };
56  *	struct { int x, y; } point = { .y = 4, .x = 3 };
57  *
58  * During an initialization, the grammar parser calls these functions:
59  *
60  *	begin_initialization
61  *		init_lbrace			for each '{'
62  *		add_designator_member		for each '.member' before '='
63  *		add_designator_subscript	for each '[123]' before '='
64  *		init_expr			for each expression
65  *		init_rbrace			for each '}'
66  *	end_initialization
67  *
68  * Each '{' begins a new brace level, each '}' ends the current brace level.
69  * Each brace level has an associated "current object", which is the starting
70  * point for resolving the optional designations such as '.member[3]'.
71  *
72  * See also:
73  *	C99 6.7.8 "Initialization"
74  *	C11 6.7.9 "Initialization"
75  *	d_c99_init.c for more examples
76  */
77 
78 
79 /*
80  * Everything that happens between a '{' and the corresponding '}', as part
81  * of an initialization.
82  *
83  * Each brace level has a "current object".  For the outermost brace level,
84  * it is the same as the object to be initialized.  Each nested '{' begins a
85  * nested brace level, for the sub-object pointed to by the designator of the
86  * outer brace level.
87  *
88  * C99 6.7.8p17
89  */
90 typedef struct brace_level {
91 	/* The type of the "current object". */
92 	const type_t	*bl_type;
93 
94 	/*
95 	 * The path from the "current object" to the sub-object that is
96 	 * initialized by the next expression.
97 	 *
98 	 * Initially, the designation is empty.  Before handling an expression,
99 	 * the designation is updated to point to the corresponding sub-object
100 	 * to be initialized.  After handling an expression, the designation is
101 	 * marked as done.  It is later advanced as necessary.
102 	 */
103 	designation	bl_designation;
104 
105 	struct brace_level *bl_enclosing;
106 } brace_level;
107 
108 /* An ongoing initialization. */
109 typedef struct initialization {
110 	/* The symbol that is to be initialized. */
111 	sym_t		*in_sym;
112 
113 	/* The innermost brace level. */
114 	brace_level	*in_brace_level;
115 
116 	/*
117 	 * The maximum subscript that has ever been seen for an array of
118 	 * unknown size, which can only occur at the outermost brace level.
119 	 */
120 	size_t		in_max_subscript;
121 
122 	/*
123 	 * Is set when a structural error occurred in the initialization. If
124 	 * set, the rest of the initialization is still parsed, but the
125 	 * initialization assignments are not checked.
126 	 */
127 	bool		in_err;
128 
129 	struct initialization *in_enclosing;
130 } initialization;
131 
132 
133 static void *
134 unconst_cast(const void *p)
135 {
136 	void *r;
137 
138 	memcpy(&r, &p, sizeof(r));
139 	return r;
140 }
141 
142 static bool
143 has_automatic_storage_duration(const sym_t *sym)
144 {
145 
146 	return sym->s_scl == AUTO || sym->s_scl == REG;
147 }
148 
149 /*
150  * Test whether rn is a string literal that can initialize ltp.
151  *
152  * See also:
153  *	C99 6.7.8p14		for plain character strings
154  *	C99 6.7.8p15		for wide character strings
155  */
156 static bool
157 can_init_character_array(const type_t *ltp, const tnode_t *rn)
158 {
159 
160 	if (!(ltp != NULL && ltp->t_tspec == ARRAY && rn->tn_op == STRING))
161 		return false;
162 
163 	tspec_t lst = ltp->t_subt->t_tspec;
164 	tspec_t rst = rn->tn_type->t_subt->t_tspec;
165 
166 	return rst == CHAR
167 	    ? lst == CHAR || lst == UCHAR || lst == SCHAR
168 	    : lst == WCHAR_TSPEC;
169 }
170 
171 static const sym_t *
172 skip_unnamed(const sym_t *m)
173 {
174 
175 	while (m != NULL && m->s_name == unnamed
176 	    && !is_struct_or_union(m->s_type->t_tspec))
177 		m = m->s_next;
178 	return m;
179 }
180 
181 static const sym_t *
182 first_named_member(const type_t *tp)
183 {
184 
185 	lint_assert(is_struct_or_union(tp->t_tspec));
186 	return skip_unnamed(tp->u.sou->sou_first_member);
187 }
188 
189 static void
190 update_type_of_array_of_unknown_size(sym_t *sym, size_t size)
191 {
192 
193 	type_t *tp = block_dup_type(sym->s_type);
194 	tp->u.dimension = (int)size;
195 	tp->t_incomplete_array = false;
196 	sym->s_type = tp;
197 	debug_step("completed array type is '%s'", type_name(sym->s_type));
198 	outsym(sym, sym->s_scl, sym->s_def);
199 }
200 
201 static void
202 check_bit_field_init(const tnode_t *ln, tspec_t lt, tspec_t rt)
203 {
204 
205 	if (!allow_c90 &&
206 	    is_integer(lt) &&
207 	    ln->tn_type->t_bitfield &&
208 	    !is_integer(rt))
209 		/* bit-field initializer must be an integer in ... */
210 		warning(186);
211 }
212 
213 static void
214 check_non_constant_initializer(const tnode_t *tn, const sym_t *sym)
215 {
216 
217 	if (tn == NULL || tn->tn_op == CON)
218 		return;
219 
220 	const sym_t *unused_sym;
221 	ptrdiff_t unused_offs;
222 	if (constant_addr(tn, &unused_sym, &unused_offs))
223 		return;
224 
225 	if (has_automatic_storage_duration(sym)) {
226 		/* non-constant initializer */
227 		c99ism(177);
228 	} else {
229 		/* non-constant initializer */
230 		error(177);
231 	}
232 }
233 
234 static void
235 check_trad_no_auto_aggregate(const sym_t *sym)
236 {
237 
238 	if (has_automatic_storage_duration(sym) &&
239 	    !is_scalar(sym->s_type->t_tspec)) {
240 		/* no automatic aggregate initialization in traditional C */
241 		warning(188);
242 	}
243 }
244 
245 static void
246 check_init_expr(const type_t *ltp, sym_t *lsym, tnode_t *rn)
247 {
248 
249 	type_t *lutp = expr_unqualified_type(ltp);
250 
251 	/* Create a temporary node for the left side. */
252 	tnode_t *ln = expr_zero_alloc(sizeof(*ln), "tnode");
253 	ln->tn_op = NAME;
254 	ln->tn_type = lutp;
255 	ln->tn_lvalue = true;
256 	ln->u.sym = lsym;
257 
258 	rn = cconv(rn);
259 
260 	debug_step("typeok '%s', '%s'",
261 	    type_name(ln->tn_type), type_name(rn->tn_type));
262 	if (!typeok(INIT, 0, ln, rn))
263 		return;
264 
265 	memory_pool saved_mem = expr_save_memory();
266 	expr(rn, true, false, true, false, "init");
267 	expr_restore_memory(saved_mem);
268 
269 	tspec_t lt = ln->tn_type->t_tspec;
270 	tspec_t rt = rn->tn_type->t_tspec;
271 	check_bit_field_init(ln, lt, rt);
272 
273 	if (lt != rt || (ltp->t_bitfield && rn->tn_op == CON))
274 		rn = convert(INIT, 0, unconst_cast(ltp), rn);
275 
276 	check_non_constant_initializer(rn, lsym);
277 }
278 
279 
280 static const type_t *
281 designator_type(const designator *dr, const type_t *tp)
282 {
283 
284 	switch (tp->t_tspec) {
285 	case STRUCT:
286 	case UNION:
287 		if (dr->dr_kind != DK_MEMBER) {
288 			const sym_t *fmem = first_named_member(tp);
289 			/* syntax error '%s' */
290 			error(249, "designator '[...]' is only for arrays");
291 			return fmem != NULL ? fmem->s_type : NULL;
292 		}
293 
294 		lint_assert(dr->dr_member != NULL);
295 		return dr->dr_member->s_type;
296 	case ARRAY:
297 		if (dr->dr_kind != DK_SUBSCRIPT) {
298 			/* syntax error '%s' */
299 			error(249,
300 			    "designator '.member' is only for struct/union");
301 		}
302 		if (!tp->t_incomplete_array)
303 			lint_assert(
304 			    dr->dr_subscript < (size_t)tp->u.dimension);
305 		return tp->t_subt;
306 	default:
307 		if (dr->dr_kind != DK_SCALAR)
308 			/* syntax error '%s' */
309 			error(249, "scalar type cannot use designator");
310 		return tp;
311 	}
312 }
313 
314 
315 #ifdef DEBUG
316 static void
317 designator_debug(const designator *dr)
318 {
319 
320 	if (dr->dr_kind == DK_MEMBER) {
321 		lint_assert(dr->dr_subscript == 0);
322 		debug_printf(".%s",
323 		    dr->dr_member != NULL
324 			? dr->dr_member->s_name
325 			: "<end>");
326 	} else if (dr->dr_kind == DK_SUBSCRIPT) {
327 		lint_assert(dr->dr_member == NULL);
328 		debug_printf("[%zu]", dr->dr_subscript);
329 	} else {
330 		lint_assert(dr->dr_member == NULL);
331 		lint_assert(dr->dr_subscript == 0);
332 		debug_printf("<scalar>");
333 	}
334 
335 	if (dr->dr_done)
336 		debug_printf(" (done)");
337 }
338 
339 static void
340 designation_debug(const designation *dn)
341 {
342 
343 	if (dn->dn_len == 0) {
344 		debug_step("designation: (empty)");
345 		return;
346 	}
347 
348 	debug_printf("designation: ");
349 	for (size_t i = 0; i < dn->dn_len; i++)
350 		designator_debug(dn->dn_items + i);
351 	debug_printf("\n");
352 }
353 #else
354 #define designation_debug(dn) do { } while (false)
355 #endif
356 
357 static designator *
358 designation_last(designation *dn)
359 {
360 
361 	lint_assert(dn->dn_len > 0);
362 	return &dn->dn_items[dn->dn_len - 1];
363 }
364 
365 void
366 designation_push(designation *dn, designator_kind kind,
367 		 const sym_t *member, size_t subscript)
368 {
369 
370 	if (dn->dn_len == dn->dn_cap) {
371 		dn->dn_cap += 4;
372 		dn->dn_items = xrealloc(dn->dn_items,
373 		    dn->dn_cap * sizeof(dn->dn_items[0]));
374 	}
375 
376 	designator *dr = &dn->dn_items[dn->dn_len++];
377 	dr->dr_kind = kind;
378 	dr->dr_member = member;
379 	dr->dr_subscript = subscript;
380 	dr->dr_done = false;
381 	designation_debug(dn);
382 }
383 
384 /*
385  * Extend the designation as appropriate for the given type.
386  *
387  * C11 6.7.9p17
388  */
389 static bool
390 designation_descend(designation *dn, const type_t *tp)
391 {
392 
393 	if (is_struct_or_union(tp->t_tspec)) {
394 		const sym_t *member = first_named_member(tp);
395 		if (member == NULL)
396 			return false;
397 		designation_push(dn, DK_MEMBER, member, 0);
398 	} else if (tp->t_tspec == ARRAY)
399 		designation_push(dn, DK_SUBSCRIPT, NULL, 0);
400 	else
401 		designation_push(dn, DK_SCALAR, NULL, 0);
402 	return true;
403 }
404 
405 /*
406  * Starting at the type of the current object, resolve the type of the
407  * sub-object by following each designator in the list.
408  *
409  * C99 6.7.8p18
410  */
411 static const type_t *
412 designation_type(const designation *dn, const type_t *tp)
413 {
414 
415 	for (size_t i = 0; i < dn->dn_len && tp != NULL; i++)
416 		tp = designator_type(dn->dn_items + i, tp);
417 	return tp;
418 }
419 
420 static const type_t *
421 designation_parent_type(const designation *dn, const type_t *tp)
422 {
423 
424 	for (size_t i = 0; i + 1 < dn->dn_len && tp != NULL; i++)
425 		tp = designator_type(dn->dn_items + i, tp);
426 	return tp;
427 }
428 
429 
430 static brace_level *
431 brace_level_new(const type_t *tp, brace_level *enclosing)
432 {
433 
434 	brace_level *bl = xcalloc(1, sizeof(*bl));
435 	bl->bl_type = tp;
436 	bl->bl_enclosing = enclosing;
437 
438 	return bl;
439 }
440 
441 static void
442 brace_level_free(brace_level *bl)
443 {
444 
445 	free(bl->bl_designation.dn_items);
446 	free(bl);
447 }
448 
449 #ifdef DEBUG
450 static void
451 brace_level_debug(const brace_level *bl)
452 {
453 
454 	lint_assert(bl->bl_type != NULL);
455 
456 	debug_printf("type '%s'\n", type_name(bl->bl_type));
457 	debug_indent_inc();
458 	designation_debug(&bl->bl_designation);
459 	debug_indent_dec();
460 }
461 #else
462 #define brace_level_debug(level) do { } while (false)
463 #endif
464 
465 /* Return the type of the sub-object that is currently being initialized. */
466 static const type_t *
467 brace_level_sub_type(const brace_level *bl)
468 {
469 
470 	return designation_type(&bl->bl_designation, bl->bl_type);
471 }
472 
473 /*
474  * After initializing a sub-object, advance the designation to point after
475  * the sub-object that has just been initialized.
476  *
477  * C99 6.7.8p17
478  * C11 6.7.9p17
479  */
480 static void
481 brace_level_advance(brace_level *bl, size_t *max_subscript)
482 {
483 
484 	debug_enter();
485 	designation *dn = &bl->bl_designation;
486 	const type_t *tp = designation_parent_type(dn, bl->bl_type);
487 
488 	if (bl->bl_designation.dn_len == 0)
489 		(void)designation_descend(dn, bl->bl_type);
490 
491 	designator *dr = designation_last(dn);
492 	switch (tp->t_tspec) {
493 	case STRUCT:
494 		lint_assert(dr->dr_member != NULL);
495 		dr->dr_member = skip_unnamed(dr->dr_member->s_next);
496 		if (dr->dr_member == NULL)
497 			dr->dr_done = true;
498 		break;
499 	case UNION:
500 		dr->dr_member = NULL;
501 		dr->dr_done = true;
502 		break;
503 	case ARRAY:
504 		dr->dr_subscript++;
505 		if (tp->t_incomplete_array &&
506 		    dr->dr_subscript > *max_subscript)
507 			*max_subscript = dr->dr_subscript;
508 		if (!tp->t_incomplete_array &&
509 		    dr->dr_subscript >= (size_t)tp->u.dimension)
510 			dr->dr_done = true;
511 		break;
512 	default:
513 		dr->dr_done = true;
514 		break;
515 	}
516 	designation_debug(dn);
517 	debug_leave();
518 }
519 
520 static void
521 warn_too_many_initializers(designator_kind kind, const type_t *tp)
522 {
523 
524 	if (kind == DK_MEMBER)
525 		/* too many struct/union initializers */
526 		error(172);
527 	else if (kind == DK_SUBSCRIPT) {
528 		lint_assert(tp->t_tspec == ARRAY);
529 		lint_assert(!tp->t_incomplete_array);
530 		/* too many array initializers, expected %d */
531 		error(173, tp->u.dimension);
532 	} else
533 		/* too many initializers for '%s' */
534 		error(174, type_name(tp));
535 }
536 
537 static bool
538 brace_level_pop_done(brace_level *bl, size_t *max_subscript)
539 {
540 	designation *dn = &bl->bl_designation;
541 	designator_kind dr_kind = designation_last(dn)->dr_kind;
542 	const type_t *sub_type = designation_parent_type(dn, bl->bl_type);
543 
544 	while (designation_last(dn)->dr_done) {
545 		dn->dn_len--;
546 		designation_debug(dn);
547 		if (dn->dn_len == 0) {
548 			warn_too_many_initializers(dr_kind, sub_type);
549 			return false;
550 		}
551 		brace_level_advance(bl, max_subscript);
552 	}
553 	return true;
554 }
555 
556 static void
557 brace_level_pop_final(brace_level *bl, size_t *max_subscript)
558 {
559 	designation *dn = &bl->bl_designation;
560 
561 	while (dn->dn_len > 0 && designation_last(dn)->dr_done) {
562 		dn->dn_len--;
563 		designation_debug(dn);
564 		if (dn->dn_len == 0)
565 			return;
566 		brace_level_advance(bl, max_subscript);
567 	}
568 }
569 
570 /* Make the designation point to the sub-object to be initialized next. */
571 static bool
572 brace_level_goto(brace_level *bl, const tnode_t *rn, size_t *max_subscript)
573 {
574 
575 	designation *dn = &bl->bl_designation;
576 	if (dn->dn_len == 0 && can_init_character_array(bl->bl_type, rn))
577 		return true;
578 	if (dn->dn_len == 0 && !designation_descend(dn, bl->bl_type))
579 		return false;
580 
581 again:
582 	if (!brace_level_pop_done(bl, max_subscript))
583 		return false;
584 
585 	const type_t *ltp = brace_level_sub_type(bl);
586 	if (types_compatible(ltp, rn->tn_type, true, false, NULL))
587 		return true;
588 
589 	if (is_struct_or_union(ltp->t_tspec) || ltp->t_tspec == ARRAY) {
590 		if (can_init_character_array(ltp, rn))
591 			return true;
592 		if (!designation_descend(dn, ltp))
593 			return false;
594 		goto again;
595 	}
596 
597 	return true;
598 }
599 
600 
601 static initialization *
602 initialization_new(sym_t *sym, initialization *enclosing)
603 {
604 
605 	initialization *in = xcalloc(1, sizeof(*in));
606 	in->in_sym = sym;
607 	in->in_enclosing = enclosing;
608 
609 	return in;
610 }
611 
612 static void
613 initialization_free(initialization *in)
614 {
615 	brace_level *bl, *next;
616 
617 	for (bl = in->in_brace_level; bl != NULL; bl = next) {
618 		next = bl->bl_enclosing;
619 		brace_level_free(bl);
620 	}
621 
622 	free(in);
623 }
624 
625 #ifdef DEBUG
626 static void
627 initialization_debug(const initialization *in)
628 {
629 
630 	if (in->in_err)
631 		debug_step("initialization error");
632 	if (in->in_brace_level == NULL) {
633 		debug_step("no brace level");
634 		return;
635 	}
636 
637 	const brace_level *bl;
638 	size_t i = 0;
639 	for (bl = in->in_brace_level; bl != NULL; bl = bl->bl_enclosing) {
640 		debug_printf("brace level %zu: ", i);
641 		brace_level_debug(bl);
642 		i++;
643 	}
644 }
645 #else
646 #define initialization_debug(in) do { } while (false)
647 #endif
648 
649 /*
650  * Return the type of the object or sub-object that is currently being
651  * initialized.
652  */
653 static const type_t *
654 initialization_sub_type(initialization *in)
655 {
656 
657 	if (in->in_brace_level == NULL)
658 		return in->in_sym->s_type;
659 
660 	const type_t *tp = brace_level_sub_type(in->in_brace_level);
661 	if (tp == NULL)
662 		in->in_err = true;
663 	return tp;
664 }
665 
666 static void
667 initialization_lbrace(initialization *in)
668 {
669 
670 	if (in->in_err)
671 		return;
672 
673 	debug_enter();
674 
675 	const type_t *tp = initialization_sub_type(in);
676 	if (tp == NULL)
677 		goto done;
678 
679 	brace_level *outer_bl = in->in_brace_level;
680 	if (!allow_c90 && outer_bl == NULL)
681 		check_trad_no_auto_aggregate(in->in_sym);
682 
683 	if (!allow_c90 && tp->t_tspec == UNION)
684 		/* initialization of union is illegal in traditional C */
685 		warning(238);
686 
687 	if (is_struct_or_union(tp->t_tspec) && tp->u.sou->sou_incomplete) {
688 		/* initialization of incomplete type '%s' */
689 		error(175, type_name(tp));
690 		in->in_err = true;
691 		goto done;
692 	}
693 
694 	if (outer_bl != NULL && outer_bl->bl_designation.dn_len == 0) {
695 		designation *dn = &outer_bl->bl_designation;
696 		(void)designation_descend(dn, outer_bl->bl_type);
697 		tp = designation_type(dn, outer_bl->bl_type);
698 	}
699 
700 	in->in_brace_level = brace_level_new(tp, outer_bl);
701 	if (is_struct_or_union(tp->t_tspec) &&
702 	    first_named_member(tp) == NULL) {
703 		/* cannot initialize struct/union with no named member */
704 		error(179);
705 		in->in_err = true;
706 	}
707 
708 done:
709 	initialization_debug(in);
710 	debug_leave();
711 }
712 
713 static void
714 initialization_rbrace(initialization *in)
715 {
716 
717 	debug_enter();
718 
719 	if (in->in_brace_level != NULL)
720 		brace_level_pop_final(in->in_brace_level,
721 		    &in->in_max_subscript);
722 
723 	/* C99 6.7.8p22 */
724 	if (in->in_sym->s_type->t_incomplete_array &&
725 	    in->in_brace_level->bl_enclosing == NULL) {
726 
727 		/* prevent "empty array declaration for '%s' [190]" */
728 		size_t dim = in->in_max_subscript;
729 		if (dim == 0 && in->in_err)
730 			dim = 1;
731 
732 		update_type_of_array_of_unknown_size(in->in_sym, dim);
733 	}
734 
735 	if (in->in_err)
736 		goto done;
737 
738 	brace_level *inner_bl = in->in_brace_level;
739 	brace_level *outer_bl = inner_bl->bl_enclosing;
740 	in->in_brace_level = outer_bl;
741 	brace_level_free(inner_bl);
742 
743 	if (outer_bl != NULL)
744 		brace_level_advance(outer_bl, &in->in_max_subscript);
745 
746 done:
747 	initialization_debug(in);
748 	debug_leave();
749 }
750 
751 static void
752 initialization_add_designator_member(initialization *in, const char *name)
753 {
754 
755 	if (in->in_err)
756 		return;
757 
758 	brace_level *bl = in->in_brace_level;
759 	lint_assert(bl != NULL);
760 
761 	const type_t *tp = brace_level_sub_type(bl);
762 	if (is_struct_or_union(tp->t_tspec))
763 		goto proceed;
764 	else if (tp->t_tspec == ARRAY)
765 		/* syntax error '%s' */
766 		error(249, "designator '.member' is only for struct/union");
767 	else
768 		/* syntax error '%s' */
769 		error(249, "scalar type cannot use designator");
770 	in->in_err = true;
771 	return;
772 
773 proceed:;
774 	const sym_t *member = find_member(tp->u.sou, name);
775 	if (member == NULL) {
776 		/* type '%s' does not have member '%s' */
777 		error(101, type_name(tp), name);
778 		in->in_err = true;
779 		return;
780 	}
781 
782 	designation_push(&bl->bl_designation, DK_MEMBER, member, 0);
783 }
784 
785 static void
786 initialization_add_designator_subscript(initialization *in, size_t subscript)
787 {
788 
789 	if (in->in_err)
790 		return;
791 
792 	brace_level *bl = in->in_brace_level;
793 	lint_assert(bl != NULL);
794 
795 	const type_t *tp = brace_level_sub_type(bl);
796 	if (tp->t_tspec != ARRAY) {
797 		/* syntax error '%s' */
798 		error(249, "designator '[...]' is only for arrays");
799 		in->in_err = true;
800 		return;
801 	}
802 
803 	if (!tp->t_incomplete_array && subscript >= (size_t)tp->u.dimension) {
804 		/* array subscript %ju cannot be > %d */
805 		error(168, (uintmax_t)subscript, tp->u.dimension - 1);
806 		subscript = 0;	/* suppress further errors */
807 	}
808 
809 	if (tp->t_incomplete_array && subscript > in->in_max_subscript)
810 		in->in_max_subscript = subscript;
811 
812 	designation_push(&bl->bl_designation, DK_SUBSCRIPT, NULL, subscript);
813 }
814 
815 /*
816  * Initialize an object with automatic storage duration that has an
817  * initializer expression without braces.
818  */
819 static bool
820 initialization_expr_using_op(initialization *in, tnode_t *rn)
821 {
822 
823 	if (!has_automatic_storage_duration(in->in_sym))
824 		return false;
825 	if (in->in_brace_level != NULL)
826 		return false;
827 	if (in->in_sym->s_type->t_tspec == ARRAY)
828 		return false;
829 
830 	debug_step("handing over to INIT");
831 
832 	tnode_t *ln = build_name(in->in_sym, false);
833 	ln->tn_type = expr_unqualified_type(ln->tn_type);
834 
835 	tnode_t *tn = build_binary(ln, INIT, false /* XXX */, rn);
836 	expr(tn, false, false, false, false, "init");
837 
838 	return true;
839 }
840 
841 /* Initialize a character array or wchar_t array with a string literal. */
842 static bool
843 initialization_init_array_from_string(initialization *in, tnode_t *tn)
844 {
845 
846 	if (tn->tn_op != STRING)
847 		return false;
848 
849 	const type_t *tp = initialization_sub_type(in);
850 
851 	if (!can_init_character_array(tp, tn))
852 		return false;
853 
854 	size_t len = tn->u.str_literals->len;
855 	if (tn->u.str_literals->data != NULL) {
856 		quoted_iterator it = { .end = 0 };
857 		for (len = 0; quoted_next(tn->u.str_literals, &it); len++)
858 			continue;
859 	}
860 
861 	if (!tp->t_incomplete_array && (size_t)tp->u.dimension < len)
862 		/* string literal too long (%ju) for target array (%ju) */
863 		warning(187, (uintmax_t)len, (uintmax_t)tp->u.dimension);
864 
865 	brace_level *bl = in->in_brace_level;
866 	if (bl != NULL && bl->bl_designation.dn_len == 0)
867 		(void)designation_descend(&bl->bl_designation, bl->bl_type);
868 	if (bl != NULL)
869 		brace_level_advance(bl, &in->in_max_subscript);
870 
871 	if (tp->t_incomplete_array)
872 		update_type_of_array_of_unknown_size(in->in_sym, len + 1);
873 
874 	return true;
875 }
876 
877 /*
878  * Initialize a single sub-object as part of the currently ongoing
879  * initialization.
880  */
881 static void
882 initialization_expr(initialization *in, tnode_t *tn)
883 {
884 
885 	if (in->in_err || tn == NULL)
886 		return;
887 
888 	debug_enter();
889 
890 	brace_level *bl = in->in_brace_level;
891 	if (bl != NULL && !brace_level_goto(bl, tn, &in->in_max_subscript)) {
892 		in->in_err = true;
893 		goto done;
894 	}
895 	if (in->in_sym->s_type->t_tspec == AUTO_TYPE)
896 		in->in_sym->s_type = block_dup_type(tn->tn_type);
897 	if (initialization_expr_using_op(in, tn))
898 		goto done;
899 	if (initialization_init_array_from_string(in, tn))
900 		goto done;
901 	if (in->in_err)
902 		goto done;
903 
904 	const type_t *tp = initialization_sub_type(in);
905 	if (tp == NULL)
906 		goto done;
907 
908 	if (bl == NULL && !is_scalar(tp->t_tspec)) {
909 		/* {}-enclosed or constant initializer of type '%s' required */
910 		error(181, type_name(in->in_sym->s_type));
911 		goto done;
912 	}
913 
914 	debug_step("expecting '%s', expression has '%s'",
915 	    type_name(tp), type_name(tn->tn_type));
916 	check_init_expr(tp, in->in_sym, tn);
917 	if (bl != NULL)
918 		brace_level_advance(bl, &in->in_max_subscript);
919 
920 done:
921 	initialization_debug(in);
922 	debug_leave();
923 }
924 
925 
926 static initialization *init;
927 
928 
929 sym_t *
930 current_initsym(void)
931 {
932 
933 	return init->in_sym;
934 }
935 
936 void
937 begin_initialization(sym_t *sym)
938 {
939 
940 	debug_step("begin initialization of '%s'", type_name(sym->s_type));
941 	debug_indent_inc();
942 
943 	init = initialization_new(sym, init);
944 }
945 
946 void
947 end_initialization(void)
948 {
949 
950 	initialization *in = init;
951 	init = in->in_enclosing;
952 	initialization_free(in);
953 
954 	debug_indent_dec();
955 	debug_step("end initialization");
956 }
957 
958 void
959 begin_designation(void)
960 {
961 
962 	initialization *in = init;
963 	if (in->in_err)
964 		return;
965 
966 	designation *dn = &in->in_brace_level->bl_designation;
967 	dn->dn_len = 0;
968 	designation_debug(dn);
969 }
970 
971 void
972 add_designator_member(sbuf_t *sb)
973 {
974 
975 	initialization_add_designator_member(init, sb->sb_name);
976 }
977 
978 void
979 add_designator_subscript(range_t range)
980 {
981 
982 	initialization_add_designator_subscript(init, range.hi);
983 }
984 
985 void
986 init_lbrace(void)
987 {
988 
989 	initialization_lbrace(init);
990 }
991 
992 void
993 init_expr(tnode_t *tn)
994 {
995 
996 	initialization_expr(init, tn);
997 }
998 
999 void
1000 init_rbrace(void)
1001 {
1002 
1003 	initialization_rbrace(init);
1004 }
1005