init.c revision 1.18 1 1.18 jmc /* $NetBSD: init.c,v 1.18 2004/06/20 22:20:17 jmc Exp $ */
2 1.2 cgd
3 1.1 cgd /*
4 1.1 cgd * Copyright (c) 1994, 1995 Jochen Pohl
5 1.1 cgd * All Rights Reserved.
6 1.1 cgd *
7 1.1 cgd * Redistribution and use in source and binary forms, with or without
8 1.1 cgd * modification, are permitted provided that the following conditions
9 1.1 cgd * are met:
10 1.1 cgd * 1. Redistributions of source code must retain the above copyright
11 1.1 cgd * notice, this list of conditions and the following disclaimer.
12 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
13 1.1 cgd * notice, this list of conditions and the following disclaimer in the
14 1.1 cgd * documentation and/or other materials provided with the distribution.
15 1.1 cgd * 3. All advertising materials mentioning features or use of this software
16 1.1 cgd * must display the following acknowledgement:
17 1.1 cgd * This product includes software developed by Jochen Pohl for
18 1.1 cgd * The NetBSD Project.
19 1.1 cgd * 4. The name of the author may not be used to endorse or promote products
20 1.1 cgd * derived from this software without specific prior written permission.
21 1.1 cgd *
22 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 1.1 cgd * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 1.1 cgd * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 1.1 cgd * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 1.1 cgd * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 1.1 cgd * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 1.1 cgd * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 1.1 cgd * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 1.1 cgd * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 1.1 cgd * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 1.1 cgd */
33 1.1 cgd
34 1.18 jmc #if HAVE_NBTOOL_CONFIG_H
35 1.18 jmc #include "nbtool_config.h"
36 1.18 jmc #endif
37 1.18 jmc
38 1.5 christos #include <sys/cdefs.h>
39 1.10 tv #if defined(__RCSID) && !defined(lint)
40 1.18 jmc __RCSID("$NetBSD: init.c,v 1.18 2004/06/20 22:20:17 jmc Exp $");
41 1.1 cgd #endif
42 1.1 cgd
43 1.1 cgd #include <stdlib.h>
44 1.17 thorpej #include <string.h>
45 1.14 christos #include <ctype.h>
46 1.1 cgd
47 1.1 cgd #include "lint1.h"
48 1.1 cgd
49 1.1 cgd /*
50 1.8 wiz * initerr is set as soon as a fatal error occurred in an initialisation.
51 1.1 cgd * The effect is that the rest of the initialisation is ignored (parsed
52 1.1 cgd * by yacc, expression trees built, but no initialisation takes place).
53 1.1 cgd */
54 1.1 cgd int initerr;
55 1.1 cgd
56 1.1 cgd /* Pointer to the symbol which is to be initialized. */
57 1.1 cgd sym_t *initsym;
58 1.1 cgd
59 1.1 cgd /* Points to the top element of the initialisation stack. */
60 1.1 cgd istk_t *initstk;
61 1.1 cgd
62 1.12 christos typedef struct namlist {
63 1.12 christos const char *n_name;
64 1.12 christos struct namlist *n_prev;
65 1.12 christos struct namlist *n_next;
66 1.12 christos } namlist_t;
67 1.12 christos
68 1.12 christos /* Points to a c9x named member; */
69 1.12 christos namlist_t *namedmem = NULL;
70 1.12 christos
71 1.1 cgd
72 1.7 lukem static void popi2(void);
73 1.7 lukem static void popinit(int);
74 1.7 lukem static void pushinit(void);
75 1.7 lukem static void testinit(void);
76 1.7 lukem static void nextinit(int);
77 1.7 lukem static int strginit(tnode_t *);
78 1.12 christos static void memberpop(void);
79 1.12 christos
80 1.12 christos #ifndef DEBUG
81 1.12 christos #define DPRINTF(a)
82 1.12 christos #else
83 1.12 christos #define DPRINTF(a) printf a
84 1.12 christos #endif
85 1.12 christos
86 1.12 christos void
87 1.12 christos memberpush(sb)
88 1.12 christos sbuf_t *sb;
89 1.12 christos {
90 1.12 christos namlist_t *nam = xcalloc(1, sizeof (namlist_t));
91 1.12 christos nam->n_name = sb->sb_name;
92 1.12 christos DPRINTF(("memberpush = %s\n", nam->n_name));
93 1.12 christos if (namedmem == NULL) {
94 1.12 christos nam->n_prev = nam->n_next = nam;
95 1.12 christos namedmem = nam;
96 1.12 christos } else {
97 1.12 christos namedmem->n_prev->n_next = nam;
98 1.12 christos nam->n_prev = namedmem->n_prev;
99 1.12 christos nam->n_next = namedmem;
100 1.12 christos namedmem->n_prev = nam;
101 1.12 christos }
102 1.12 christos #if 0
103 1.12 christos nam->n_next = namedmem;
104 1.12 christos namedmem = nam;
105 1.12 christos #endif
106 1.12 christos }
107 1.12 christos
108 1.12 christos static void
109 1.12 christos memberpop()
110 1.12 christos {
111 1.12 christos DPRINTF(("memberpop = %s\n", namedmem->n_name));
112 1.12 christos if (namedmem->n_next == namedmem) {
113 1.12 christos free(namedmem);
114 1.12 christos namedmem = NULL;
115 1.12 christos } else {
116 1.12 christos namlist_t *nam = namedmem;
117 1.12 christos namedmem = namedmem->n_next;
118 1.12 christos free(nam);
119 1.12 christos }
120 1.12 christos #if 0
121 1.12 christos namedmem = namedmem->n_next;
122 1.12 christos free(nam);
123 1.12 christos #endif
124 1.12 christos }
125 1.1 cgd
126 1.1 cgd
127 1.1 cgd /*
128 1.1 cgd * Initialize the initialisation stack by putting an entry for the variable
129 1.1 cgd * which is to be initialized on it.
130 1.1 cgd */
131 1.1 cgd void
132 1.7 lukem prepinit(void)
133 1.1 cgd {
134 1.1 cgd istk_t *istk;
135 1.1 cgd
136 1.1 cgd if (initerr)
137 1.1 cgd return;
138 1.1 cgd
139 1.1 cgd /* free memory used in last initialisation */
140 1.1 cgd while ((istk = initstk) != NULL) {
141 1.1 cgd initstk = istk->i_nxt;
142 1.1 cgd free(istk);
143 1.1 cgd }
144 1.1 cgd
145 1.1 cgd /*
146 1.1 cgd * If the type which is to be initialized is an incomplete type,
147 1.1 cgd * it must be duplicated.
148 1.1 cgd */
149 1.1 cgd if (initsym->s_type->t_tspec == ARRAY && incompl(initsym->s_type))
150 1.1 cgd initsym->s_type = duptyp(initsym->s_type);
151 1.1 cgd
152 1.1 cgd istk = initstk = xcalloc(1, sizeof (istk_t));
153 1.1 cgd istk->i_subt = initsym->s_type;
154 1.1 cgd istk->i_cnt = 1;
155 1.1 cgd
156 1.1 cgd }
157 1.1 cgd
158 1.1 cgd static void
159 1.7 lukem popi2(void)
160 1.1 cgd {
161 1.12 christos #ifdef DEBUG
162 1.12 christos char buf[64];
163 1.12 christos #endif
164 1.1 cgd istk_t *istk;
165 1.1 cgd sym_t *m;
166 1.1 cgd
167 1.1 cgd initstk = (istk = initstk)->i_nxt;
168 1.1 cgd if (initstk == NULL)
169 1.11 christos LERROR("popi2()");
170 1.1 cgd free(istk);
171 1.1 cgd
172 1.1 cgd istk = initstk;
173 1.1 cgd
174 1.1 cgd istk->i_cnt--;
175 1.1 cgd if (istk->i_cnt < 0)
176 1.11 christos LERROR("popi2()");
177 1.1 cgd
178 1.16 christos DPRINTF(("popi2(): %d %s\n", istk->i_cnt,
179 1.16 christos namedmem ? namedmem->n_name : "*null*"));
180 1.12 christos if (istk->i_cnt >= 0 && namedmem != NULL) {
181 1.12 christos DPRINTF(("popi2(): %d %s %s\n", istk->i_cnt,
182 1.12 christos tyname(buf, sizeof(buf), istk->i_type), namedmem->n_name));
183 1.12 christos for (m = istk->i_type->t_str->memb; m != NULL; m = m->s_nxt) {
184 1.12 christos if (m->s_field && m->s_name == unnamed)
185 1.12 christos continue;
186 1.12 christos if (strcmp(m->s_name, namedmem->n_name) == 0) {
187 1.12 christos istk->i_subt = m->s_type;
188 1.12 christos istk->i_cnt++;
189 1.12 christos memberpop();
190 1.12 christos return;
191 1.12 christos }
192 1.12 christos }
193 1.12 christos error(101, namedmem->n_name);
194 1.12 christos memberpop();
195 1.12 christos istk->i_namedmem = 1;
196 1.12 christos return;
197 1.12 christos }
198 1.1 cgd /*
199 1.1 cgd * If the removed element was a structure member, we must go
200 1.1 cgd * to the next structure member.
201 1.1 cgd */
202 1.12 christos if (istk->i_cnt > 0 && istk->i_type->t_tspec == STRUCT &&
203 1.12 christos !istk->i_namedmem) {
204 1.1 cgd do {
205 1.1 cgd m = istk->i_mem = istk->i_mem->s_nxt;
206 1.1 cgd if (m == NULL)
207 1.11 christos LERROR("popi2()");
208 1.1 cgd } while (m->s_field && m->s_name == unnamed);
209 1.1 cgd istk->i_subt = m->s_type;
210 1.1 cgd }
211 1.1 cgd }
212 1.1 cgd
213 1.1 cgd static void
214 1.7 lukem popinit(int brace)
215 1.1 cgd {
216 1.12 christos DPRINTF(("popinit(%d)\n", brace));
217 1.7 lukem
218 1.1 cgd if (brace) {
219 1.1 cgd /*
220 1.1 cgd * Take all entries, including the first which requires
221 1.1 cgd * a closing brace, from the stack.
222 1.1 cgd */
223 1.1 cgd do {
224 1.1 cgd brace = initstk->i_brace;
225 1.1 cgd popi2();
226 1.1 cgd } while (!brace);
227 1.1 cgd } else {
228 1.1 cgd /*
229 1.1 cgd * Take all entries which cannot be used for further
230 1.1 cgd * initializers from the stack, but do this only if
231 1.1 cgd * they do not require a closing brace.
232 1.1 cgd */
233 1.1 cgd while (!initstk->i_brace &&
234 1.1 cgd initstk->i_cnt == 0 && !initstk->i_nolimit) {
235 1.1 cgd popi2();
236 1.1 cgd }
237 1.1 cgd }
238 1.1 cgd }
239 1.1 cgd
240 1.1 cgd static void
241 1.7 lukem pushinit(void)
242 1.1 cgd {
243 1.12 christos #ifdef DEBUG
244 1.12 christos char buf[64];
245 1.12 christos #endif
246 1.1 cgd istk_t *istk;
247 1.1 cgd int cnt;
248 1.1 cgd sym_t *m;
249 1.1 cgd
250 1.1 cgd istk = initstk;
251 1.1 cgd
252 1.1 cgd /* Extend an incomplete array type by one element */
253 1.1 cgd if (istk->i_cnt == 0) {
254 1.12 christos DPRINTF(("pushinit(extend) %s\n", tyname(buf, sizeof(buf),
255 1.12 christos istk->i_type)));
256 1.1 cgd /*
257 1.1 cgd * Inside of other aggregate types must not be an incomplete
258 1.1 cgd * type.
259 1.1 cgd */
260 1.1 cgd if (istk->i_nxt->i_nxt != NULL)
261 1.11 christos LERROR("pushinit()");
262 1.1 cgd istk->i_cnt = 1;
263 1.1 cgd if (istk->i_type->t_tspec != ARRAY)
264 1.11 christos LERROR("pushinit()");
265 1.1 cgd istk->i_type->t_dim++;
266 1.1 cgd /* from now its an complete type */
267 1.1 cgd setcompl(istk->i_type, 0);
268 1.1 cgd }
269 1.1 cgd
270 1.1 cgd if (istk->i_cnt <= 0)
271 1.11 christos LERROR("pushinit()");
272 1.1 cgd if (istk->i_type != NULL && issclt(istk->i_type->t_tspec))
273 1.11 christos LERROR("pushinit()");
274 1.1 cgd
275 1.1 cgd initstk = xcalloc(1, sizeof (istk_t));
276 1.1 cgd initstk->i_nxt = istk;
277 1.1 cgd initstk->i_type = istk->i_subt;
278 1.1 cgd if (initstk->i_type->t_tspec == FUNC)
279 1.11 christos LERROR("pushinit()");
280 1.1 cgd
281 1.12 christos again:
282 1.1 cgd istk = initstk;
283 1.1 cgd
284 1.12 christos DPRINTF(("pushinit(%s)\n", tyname(buf, sizeof(buf), istk->i_type)));
285 1.1 cgd switch (istk->i_type->t_tspec) {
286 1.1 cgd case ARRAY:
287 1.16 christos if (namedmem) {
288 1.16 christos DPRINTF(("pushinit ARRAY %s\n", namedmem->n_name));
289 1.16 christos free(istk);
290 1.16 christos initstk = initstk->i_nxt;
291 1.16 christos goto again;
292 1.16 christos }
293 1.1 cgd if (incompl(istk->i_type) && istk->i_nxt->i_nxt != NULL) {
294 1.1 cgd /* initialisation of an incomplete type */
295 1.1 cgd error(175);
296 1.1 cgd initerr = 1;
297 1.1 cgd return;
298 1.1 cgd }
299 1.1 cgd istk->i_subt = istk->i_type->t_subt;
300 1.1 cgd istk->i_nolimit = incompl(istk->i_type);
301 1.1 cgd istk->i_cnt = istk->i_type->t_dim;
302 1.16 christos DPRINTF(("elements array %s[%d] %s\n",
303 1.16 christos tyname(buf, sizeof(buf), istk->i_subt), istk->i_cnt,
304 1.16 christos namedmem ? namedmem->n_name : "*none*"));
305 1.1 cgd break;
306 1.1 cgd case UNION:
307 1.1 cgd if (tflag)
308 1.1 cgd /* initialisation of union is illegal in trad. C */
309 1.1 cgd warning(238);
310 1.1 cgd /* FALLTHROUGH */
311 1.1 cgd case STRUCT:
312 1.1 cgd if (incompl(istk->i_type)) {
313 1.1 cgd /* initialisation of an incomplete type */
314 1.1 cgd error(175);
315 1.1 cgd initerr = 1;
316 1.1 cgd return;
317 1.1 cgd }
318 1.1 cgd cnt = 0;
319 1.16 christos DPRINTF(("2. member lookup %s %s\n",
320 1.16 christos tyname(buf, sizeof(buf), istk->i_type),
321 1.16 christos namedmem ? namedmem->n_name : "*none*"));
322 1.1 cgd for (m = istk->i_type->t_str->memb; m != NULL; m = m->s_nxt) {
323 1.1 cgd if (m->s_field && m->s_name == unnamed)
324 1.1 cgd continue;
325 1.12 christos if (namedmem != NULL) {
326 1.12 christos DPRINTF(("pushinit():[member:%s, looking:%s]\n",
327 1.12 christos m->s_name, namedmem->n_name));
328 1.12 christos if (strcmp(m->s_name, namedmem->n_name) == 0) {
329 1.12 christos cnt++;
330 1.12 christos break;
331 1.12 christos } else
332 1.12 christos continue;
333 1.12 christos }
334 1.1 cgd if (++cnt == 1) {
335 1.1 cgd istk->i_mem = m;
336 1.1 cgd istk->i_subt = m->s_type;
337 1.1 cgd }
338 1.1 cgd }
339 1.12 christos if (namedmem != NULL) {
340 1.12 christos istk->i_namedmem = 1;
341 1.12 christos if (m == NULL) {
342 1.12 christos error(101, namedmem->n_name);
343 1.12 christos initerr = 1;
344 1.12 christos } else {
345 1.12 christos istk->i_mem = m;
346 1.12 christos istk->i_subt = m->s_type;
347 1.12 christos }
348 1.12 christos memberpop();
349 1.12 christos cnt = istk->i_type->t_tspec == STRUCT ? 2 : 1;
350 1.12 christos }
351 1.1 cgd if (cnt == 0) {
352 1.1 cgd /* cannot init. struct/union with no named member */
353 1.1 cgd error(179);
354 1.1 cgd initerr = 1;
355 1.1 cgd return;
356 1.1 cgd }
357 1.1 cgd istk->i_cnt = istk->i_type->t_tspec == STRUCT ? cnt : 1;
358 1.1 cgd break;
359 1.1 cgd default:
360 1.12 christos if (namedmem) {
361 1.12 christos DPRINTF(("pushinit(): pop\n"));
362 1.12 christos free(istk);
363 1.12 christos initstk = initstk->i_nxt;
364 1.12 christos goto again;
365 1.12 christos }
366 1.1 cgd istk->i_cnt = 1;
367 1.1 cgd break;
368 1.1 cgd }
369 1.1 cgd }
370 1.1 cgd
371 1.1 cgd static void
372 1.7 lukem testinit(void)
373 1.1 cgd {
374 1.1 cgd istk_t *istk;
375 1.1 cgd
376 1.1 cgd istk = initstk;
377 1.1 cgd
378 1.1 cgd /*
379 1.1 cgd * If a closing brace is expected we have at least one initializer
380 1.1 cgd * too much.
381 1.1 cgd */
382 1.12 christos if (istk->i_cnt == 0 && !istk->i_nolimit && !istk->i_namedmem) {
383 1.1 cgd switch (istk->i_type->t_tspec) {
384 1.1 cgd case ARRAY:
385 1.1 cgd /* too many array initializers */
386 1.1 cgd error(173);
387 1.1 cgd break;
388 1.1 cgd case STRUCT:
389 1.1 cgd case UNION:
390 1.1 cgd /* too many struct/union initializers */
391 1.1 cgd error(172);
392 1.1 cgd break;
393 1.1 cgd default:
394 1.1 cgd /* too many initializers */
395 1.1 cgd error(174);
396 1.1 cgd break;
397 1.1 cgd }
398 1.1 cgd initerr = 1;
399 1.1 cgd }
400 1.1 cgd }
401 1.1 cgd
402 1.1 cgd static void
403 1.7 lukem nextinit(int brace)
404 1.1 cgd {
405 1.12 christos char buf[64];
406 1.7 lukem
407 1.12 christos DPRINTF(("nextinit(%d)\n", brace));
408 1.1 cgd if (!brace) {
409 1.1 cgd if (initstk->i_type == NULL &&
410 1.1 cgd !issclt(initstk->i_subt->t_tspec)) {
411 1.1 cgd /* {}-enclosed initializer required */
412 1.1 cgd error(181);
413 1.1 cgd }
414 1.1 cgd /*
415 1.1 cgd * Make sure an entry with a scalar type is at the top
416 1.1 cgd * of the stack.
417 1.1 cgd */
418 1.1 cgd if (!initerr)
419 1.1 cgd testinit();
420 1.1 cgd while (!initerr && (initstk->i_type == NULL ||
421 1.1 cgd !issclt(initstk->i_type->t_tspec))) {
422 1.1 cgd if (!initerr)
423 1.1 cgd pushinit();
424 1.1 cgd }
425 1.1 cgd } else {
426 1.1 cgd if (initstk->i_type != NULL &&
427 1.1 cgd issclt(initstk->i_type->t_tspec)) {
428 1.1 cgd /* invalid initializer */
429 1.12 christos error(176, tyname(buf, sizeof(buf), initstk->i_type));
430 1.1 cgd initerr = 1;
431 1.1 cgd }
432 1.1 cgd if (!initerr)
433 1.1 cgd testinit();
434 1.1 cgd if (!initerr)
435 1.1 cgd pushinit();
436 1.1 cgd if (!initerr)
437 1.1 cgd initstk->i_brace = 1;
438 1.1 cgd }
439 1.1 cgd }
440 1.1 cgd
441 1.1 cgd void
442 1.7 lukem initlbr(void)
443 1.1 cgd {
444 1.7 lukem
445 1.1 cgd if (initerr)
446 1.1 cgd return;
447 1.1 cgd
448 1.1 cgd if ((initsym->s_scl == AUTO || initsym->s_scl == REG) &&
449 1.1 cgd initstk->i_nxt == NULL) {
450 1.1 cgd if (tflag && !issclt(initstk->i_subt->t_tspec))
451 1.1 cgd /* no automatic aggregate initialization in trad. C*/
452 1.1 cgd warning(188);
453 1.1 cgd }
454 1.1 cgd
455 1.1 cgd /*
456 1.1 cgd * Remove all entries which cannot be used for further initializers
457 1.1 cgd * and do not expect a closing brace.
458 1.1 cgd */
459 1.1 cgd popinit(0);
460 1.1 cgd
461 1.1 cgd nextinit(1);
462 1.1 cgd }
463 1.1 cgd
464 1.1 cgd void
465 1.7 lukem initrbr(void)
466 1.1 cgd {
467 1.7 lukem
468 1.1 cgd if (initerr)
469 1.1 cgd return;
470 1.1 cgd
471 1.1 cgd popinit(1);
472 1.1 cgd }
473 1.1 cgd
474 1.1 cgd void
475 1.7 lukem mkinit(tnode_t *tn)
476 1.1 cgd {
477 1.1 cgd ptrdiff_t offs;
478 1.1 cgd sym_t *sym;
479 1.1 cgd tspec_t lt, rt;
480 1.1 cgd tnode_t *ln;
481 1.1 cgd struct mbl *tmem;
482 1.1 cgd scl_t sc;
483 1.12 christos #ifdef DEBUG
484 1.12 christos char buf[64];
485 1.12 christos #endif
486 1.1 cgd
487 1.12 christos DPRINTF(("mkinit(%s)\n", tyname(buf, sizeof(buf), tn->tn_type)));
488 1.1 cgd if (initerr || tn == NULL)
489 1.1 cgd goto end;
490 1.1 cgd
491 1.1 cgd sc = initsym->s_scl;
492 1.1 cgd
493 1.1 cgd /*
494 1.13 christos * Do not test for automatic aggregate initialisation. If the
495 1.9 wiz * initializer starts with a brace we have the warning already.
496 1.1 cgd * If not, an error will be printed that the initializer must
497 1.1 cgd * be enclosed by braces.
498 1.1 cgd */
499 1.1 cgd
500 1.1 cgd /*
501 1.1 cgd * Local initialisation of non-array-types with only one expression
502 1.1 cgd * without braces is done by ASSIGN
503 1.1 cgd */
504 1.1 cgd if ((sc == AUTO || sc == REG) &&
505 1.1 cgd initsym->s_type->t_tspec != ARRAY && initstk->i_nxt == NULL) {
506 1.1 cgd ln = getnnode(initsym, 0);
507 1.1 cgd ln->tn_type = tduptyp(ln->tn_type);
508 1.1 cgd ln->tn_type->t_const = 0;
509 1.1 cgd tn = build(ASSIGN, ln, tn);
510 1.15 christos expr(tn, 0, 0, 1);
511 1.1 cgd goto end;
512 1.1 cgd }
513 1.1 cgd
514 1.1 cgd /*
515 1.1 cgd * Remove all entries which cannot be used for further initializers
516 1.1 cgd * and do not require a closing brace.
517 1.1 cgd */
518 1.1 cgd popinit(0);
519 1.1 cgd
520 1.1 cgd /* Initialisations by strings are done in strginit(). */
521 1.1 cgd if (strginit(tn))
522 1.1 cgd goto end;
523 1.1 cgd
524 1.1 cgd nextinit(0);
525 1.1 cgd if (initerr || tn == NULL)
526 1.1 cgd goto end;
527 1.1 cgd
528 1.1 cgd initstk->i_cnt--;
529 1.14 christos DPRINTF(("mkinit() cnt=%d tn=%p\n", initstk->i_cnt, tn));
530 1.1 cgd /* Create a temporary node for the left side. */
531 1.1 cgd ln = tgetblk(sizeof (tnode_t));
532 1.1 cgd ln->tn_op = NAME;
533 1.1 cgd ln->tn_type = tduptyp(initstk->i_type);
534 1.1 cgd ln->tn_type->t_const = 0;
535 1.1 cgd ln->tn_lvalue = 1;
536 1.1 cgd ln->tn_sym = initsym; /* better than nothing */
537 1.1 cgd
538 1.1 cgd tn = cconv(tn);
539 1.1 cgd
540 1.1 cgd lt = ln->tn_type->t_tspec;
541 1.1 cgd rt = tn->tn_type->t_tspec;
542 1.1 cgd
543 1.1 cgd if (!issclt(lt))
544 1.11 christos LERROR("mkinit()");
545 1.1 cgd
546 1.1 cgd if (!typeok(INIT, 0, ln, tn))
547 1.1 cgd goto end;
548 1.1 cgd
549 1.1 cgd /*
550 1.1 cgd * Store the tree memory. This is nessesary because otherwise
551 1.1 cgd * expr() would free it.
552 1.1 cgd */
553 1.1 cgd tmem = tsave();
554 1.15 christos expr(tn, 1, 0, 1);
555 1.1 cgd trestor(tmem);
556 1.7 lukem
557 1.1 cgd if (isityp(lt) && ln->tn_type->t_isfield && !isityp(rt)) {
558 1.1 cgd /*
559 1.1 cgd * Bit-fields can be initialized in trad. C only by integer
560 1.1 cgd * constants.
561 1.1 cgd */
562 1.1 cgd if (tflag)
563 1.1 cgd /* bit-field initialisation is illegal in trad. C */
564 1.1 cgd warning(186);
565 1.1 cgd }
566 1.1 cgd
567 1.1 cgd if (lt != rt || (initstk->i_type->t_isfield && tn->tn_op == CON))
568 1.1 cgd tn = convert(INIT, 0, initstk->i_type, tn);
569 1.1 cgd
570 1.1 cgd if (tn != NULL && tn->tn_op != CON) {
571 1.1 cgd sym = NULL;
572 1.1 cgd offs = 0;
573 1.1 cgd if (conaddr(tn, &sym, &offs) == -1) {
574 1.3 jpo if (sc == AUTO || sc == REG) {
575 1.1 cgd /* non-constant initializer */
576 1.4 jpo (void)gnuism(177);
577 1.1 cgd } else {
578 1.1 cgd /* non-constant initializer */
579 1.1 cgd error(177);
580 1.1 cgd }
581 1.1 cgd }
582 1.1 cgd }
583 1.1 cgd
584 1.1 cgd end:
585 1.14 christos /*
586 1.14 christos * We only free the block, if we are not a compound declaration
587 1.14 christos * We know that the only symbols that start with a digit are the
588 1.14 christos * ones we allocate with mktempsym() for compound declarations
589 1.14 christos */
590 1.14 christos if (!isdigit((unsigned char)initsym->s_name[0]))
591 1.14 christos tfreeblk();
592 1.1 cgd }
593 1.1 cgd
594 1.1 cgd
595 1.1 cgd static int
596 1.7 lukem strginit(tnode_t *tn)
597 1.1 cgd {
598 1.1 cgd tspec_t t;
599 1.1 cgd istk_t *istk;
600 1.1 cgd int len;
601 1.1 cgd strg_t *strg;
602 1.1 cgd
603 1.1 cgd if (tn->tn_op != STRING)
604 1.1 cgd return (0);
605 1.1 cgd
606 1.1 cgd istk = initstk;
607 1.1 cgd strg = tn->tn_strg;
608 1.1 cgd
609 1.1 cgd /*
610 1.1 cgd * Check if we have an array type which can be initialized by
611 1.1 cgd * the string.
612 1.1 cgd */
613 1.12 christos if (istk->i_subt != NULL && istk->i_subt->t_tspec == ARRAY) {
614 1.1 cgd t = istk->i_subt->t_subt->t_tspec;
615 1.1 cgd if (!((strg->st_tspec == CHAR &&
616 1.1 cgd (t == CHAR || t == UCHAR || t == SCHAR)) ||
617 1.1 cgd (strg->st_tspec == WCHAR && t == WCHAR))) {
618 1.1 cgd return (0);
619 1.1 cgd }
620 1.1 cgd /* Put the array at top of stack */
621 1.1 cgd pushinit();
622 1.1 cgd istk = initstk;
623 1.1 cgd } else if (istk->i_type != NULL && istk->i_type->t_tspec == ARRAY) {
624 1.1 cgd t = istk->i_type->t_subt->t_tspec;
625 1.1 cgd if (!((strg->st_tspec == CHAR &&
626 1.1 cgd (t == CHAR || t == UCHAR || t == SCHAR)) ||
627 1.1 cgd (strg->st_tspec == WCHAR && t == WCHAR))) {
628 1.1 cgd return (0);
629 1.1 cgd }
630 1.1 cgd /*
631 1.1 cgd * If the array is already partly initialized, we are
632 1.1 cgd * wrong here.
633 1.1 cgd */
634 1.1 cgd if (istk->i_cnt != istk->i_type->t_dim)
635 1.1 cgd return (0);
636 1.1 cgd } else {
637 1.1 cgd return (0);
638 1.1 cgd }
639 1.1 cgd
640 1.1 cgd /* Get length without trailing NUL character. */
641 1.1 cgd len = strg->st_len;
642 1.1 cgd
643 1.1 cgd if (istk->i_nolimit) {
644 1.1 cgd istk->i_nolimit = 0;
645 1.1 cgd istk->i_type->t_dim = len + 1;
646 1.1 cgd /* from now complete type */
647 1.1 cgd setcompl(istk->i_type, 0);
648 1.1 cgd } else {
649 1.1 cgd if (istk->i_type->t_dim < len) {
650 1.1 cgd /* non-null byte ignored in string initializer */
651 1.1 cgd warning(187);
652 1.1 cgd }
653 1.1 cgd }
654 1.1 cgd
655 1.1 cgd /* In every case the array is initialized completely. */
656 1.1 cgd istk->i_cnt = 0;
657 1.1 cgd
658 1.1 cgd return (1);
659 1.1 cgd }
660