Home | History | Annotate | Line # | Download | only in lint1
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