Home | History | Annotate | Line # | Download | only in lint1
decl.c revision 1.68.10.1
      1  1.68.10.1  pgoyette /* $NetBSD: decl.c,v 1.68.10.1 2018/09/30 01:45:59 pgoyette Exp $ */
      2        1.2       cgd 
      3        1.1       cgd /*
      4       1.12       cgd  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
      5        1.1       cgd  * Copyright (c) 1994, 1995 Jochen Pohl
      6        1.1       cgd  * All Rights Reserved.
      7        1.1       cgd  *
      8        1.1       cgd  * Redistribution and use in source and binary forms, with or without
      9        1.1       cgd  * modification, are permitted provided that the following conditions
     10        1.1       cgd  * are met:
     11        1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     12        1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     13        1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     14        1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     15        1.1       cgd  *    documentation and/or other materials provided with the distribution.
     16        1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     17        1.1       cgd  *    must display the following acknowledgement:
     18        1.1       cgd  *      This product includes software developed by Jochen Pohl for
     19        1.1       cgd  *	The NetBSD Project.
     20        1.1       cgd  * 4. The name of the author may not be used to endorse or promote products
     21        1.1       cgd  *    derived from this software without specific prior written permission.
     22        1.1       cgd  *
     23        1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     24        1.1       cgd  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     25        1.1       cgd  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     26        1.1       cgd  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     27        1.1       cgd  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     28        1.1       cgd  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     29        1.1       cgd  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     30        1.1       cgd  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     31        1.1       cgd  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     32        1.1       cgd  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     33        1.1       cgd  */
     34        1.1       cgd 
     35       1.33       jmc #if HAVE_NBTOOL_CONFIG_H
     36       1.33       jmc #include "nbtool_config.h"
     37       1.33       jmc #endif
     38       1.33       jmc 
     39       1.13  christos #include <sys/cdefs.h>
     40       1.30        tv #if defined(__RCSID) && !defined(lint)
     41  1.68.10.1  pgoyette __RCSID("$NetBSD: decl.c,v 1.68.10.1 2018/09/30 01:45:59 pgoyette Exp $");
     42        1.1       cgd #endif
     43        1.1       cgd 
     44        1.1       cgd #include <sys/param.h>
     45        1.1       cgd #include <limits.h>
     46        1.1       cgd #include <stdlib.h>
     47        1.1       cgd #include <string.h>
     48        1.1       cgd 
     49        1.1       cgd #include "lint1.h"
     50        1.1       cgd 
     51        1.1       cgd const	char *unnamed = "<unnamed>";
     52        1.1       cgd 
     53        1.1       cgd /* shared type structures for arithmtic types and void */
     54        1.1       cgd static	type_t	*typetab;
     55        1.1       cgd 
     56        1.1       cgd /* value of next enumerator during declaration of enum types */
     57        1.1       cgd int	enumval;
     58        1.1       cgd 
     59        1.1       cgd /*
     60        1.1       cgd  * pointer to top element of a stack which contains informations local
     61        1.1       cgd  * to nested declarations
     62        1.1       cgd  */
     63        1.1       cgd dinfo_t	*dcs;
     64        1.1       cgd 
     65       1.22     lukem static	type_t	*tdeferr(type_t *, tspec_t);
     66       1.22     lukem static	void	settdsym(type_t *, sym_t *);
     67       1.22     lukem static	tspec_t	mrgtspec(tspec_t, tspec_t);
     68       1.22     lukem static	void	align(int, int);
     69       1.22     lukem static	sym_t	*newtag(sym_t *, scl_t, int, int);
     70       1.22     lukem static	int	eqargs(type_t *, type_t *, int *);
     71       1.22     lukem static	int	mnoarg(type_t *, int *);
     72       1.22     lukem static	int	chkosdef(sym_t *, sym_t *);
     73       1.22     lukem static	int	chkptdecl(sym_t *, sym_t *);
     74       1.22     lukem static	sym_t	*nsfunc(sym_t *, sym_t *);
     75       1.22     lukem static	void	osfunc(sym_t *, sym_t *);
     76       1.22     lukem static	void	ledecl(sym_t *);
     77       1.22     lukem static	int	chkinit(sym_t *);
     78       1.22     lukem static	void	chkausg(int, sym_t *);
     79       1.22     lukem static	void	chkvusg(int, sym_t *);
     80       1.22     lukem static	void	chklusg(sym_t *);
     81       1.22     lukem static	void	chktusg(sym_t *);
     82       1.22     lukem static	void	chkglvar(sym_t *);
     83       1.22     lukem static	void	glchksz(sym_t *);
     84        1.1       cgd 
     85        1.1       cgd /*
     86        1.1       cgd  * initializes all global vars used in declarations
     87        1.1       cgd  */
     88        1.1       cgd void
     89       1.22     lukem initdecl(void)
     90        1.1       cgd {
     91       1.29   thorpej 	int i;
     92        1.1       cgd 
     93        1.1       cgd 	/* declaration stack */
     94        1.1       cgd 	dcs = xcalloc(1, sizeof (dinfo_t));
     95        1.3       jpo 	dcs->d_ctx = EXTERN;
     96        1.3       jpo 	dcs->d_ldlsym = &dcs->d_dlsyms;
     97        1.1       cgd 
     98        1.1       cgd 	/* type information and classification */
     99       1.29   thorpej 	inittyp();
    100       1.22     lukem 
    101        1.1       cgd 	/* shared type structures */
    102        1.1       cgd 	typetab = xcalloc(NTSPEC, sizeof (type_t));
    103        1.1       cgd 	for (i = 0; i < NTSPEC; i++)
    104        1.1       cgd 		typetab[i].t_tspec = NOTSPEC;
    105       1.34      yamt 	typetab[BOOL].t_tspec = BOOL;
    106        1.1       cgd 	typetab[CHAR].t_tspec = CHAR;
    107        1.1       cgd 	typetab[SCHAR].t_tspec = SCHAR;
    108        1.1       cgd 	typetab[UCHAR].t_tspec = UCHAR;
    109        1.1       cgd 	typetab[SHORT].t_tspec = SHORT;
    110        1.1       cgd 	typetab[USHORT].t_tspec = USHORT;
    111        1.1       cgd 	typetab[INT].t_tspec = INT;
    112        1.1       cgd 	typetab[UINT].t_tspec = UINT;
    113        1.1       cgd 	typetab[LONG].t_tspec = LONG;
    114        1.1       cgd 	typetab[ULONG].t_tspec = ULONG;
    115        1.1       cgd 	typetab[QUAD].t_tspec = QUAD;
    116        1.1       cgd 	typetab[UQUAD].t_tspec = UQUAD;
    117        1.1       cgd 	typetab[FLOAT].t_tspec = FLOAT;
    118        1.1       cgd 	typetab[DOUBLE].t_tspec = DOUBLE;
    119        1.1       cgd 	typetab[LDOUBLE].t_tspec = LDOUBLE;
    120       1.39  christos 	typetab[FCOMPLEX].t_tspec = FCOMPLEX;
    121       1.39  christos 	typetab[DCOMPLEX].t_tspec = DCOMPLEX;
    122       1.42      matt 	typetab[LCOMPLEX].t_tspec = LCOMPLEX;
    123       1.39  christos 	typetab[COMPLEX].t_tspec = COMPLEX;
    124        1.1       cgd 	typetab[VOID].t_tspec = VOID;
    125        1.1       cgd 	/*
    126        1.1       cgd 	 * Next two are not real types. They are only used by the parser
    127        1.1       cgd 	 * to return keywords "signed" and "unsigned"
    128        1.1       cgd 	 */
    129        1.1       cgd 	typetab[SIGNED].t_tspec = SIGNED;
    130        1.1       cgd 	typetab[UNSIGN].t_tspec = UNSIGN;
    131        1.1       cgd }
    132        1.1       cgd 
    133        1.1       cgd /*
    134        1.1       cgd  * Returns a shared type structure vor arithmetic types and void.
    135        1.1       cgd  *
    136        1.1       cgd  * It's important do duplicate this structure (using duptyp() or tdupdyp())
    137        1.1       cgd  * if it is to be modified (adding qualifiers or anything else).
    138        1.1       cgd  */
    139        1.1       cgd type_t *
    140       1.22     lukem gettyp(tspec_t t)
    141        1.1       cgd {
    142       1.22     lukem 
    143        1.1       cgd 	return (&typetab[t]);
    144        1.1       cgd }
    145        1.1       cgd 
    146        1.1       cgd type_t *
    147       1.22     lukem duptyp(const type_t *tp)
    148        1.1       cgd {
    149        1.1       cgd 	type_t	*ntp;
    150        1.1       cgd 
    151        1.1       cgd 	ntp = getblk(sizeof (type_t));
    152        1.1       cgd 	STRUCT_ASSIGN(*ntp, *tp);
    153        1.1       cgd 	return (ntp);
    154        1.1       cgd }
    155        1.1       cgd 
    156        1.1       cgd /*
    157        1.1       cgd  * Use tduptyp() instead of duptyp() inside expressions (if the
    158        1.1       cgd  * allocated memory should be freed after the expr).
    159        1.1       cgd  */
    160        1.1       cgd type_t *
    161       1.22     lukem tduptyp(const type_t *tp)
    162        1.1       cgd {
    163        1.1       cgd 	type_t	*ntp;
    164        1.1       cgd 
    165        1.1       cgd 	ntp = tgetblk(sizeof (type_t));
    166        1.1       cgd 	STRUCT_ASSIGN(*ntp, *tp);
    167        1.1       cgd 	return (ntp);
    168        1.1       cgd }
    169        1.1       cgd 
    170        1.1       cgd /*
    171        1.1       cgd  * Returns 1 if the argument is void or an incomplete array,
    172        1.1       cgd  * struct, union or enum type.
    173        1.1       cgd  */
    174        1.1       cgd int
    175       1.22     lukem incompl(type_t *tp)
    176        1.1       cgd {
    177        1.1       cgd 	tspec_t	t;
    178        1.1       cgd 
    179        1.1       cgd 	if ((t = tp->t_tspec) == VOID) {
    180        1.1       cgd 		return (1);
    181        1.1       cgd 	} else if (t == ARRAY) {
    182        1.1       cgd 		return (tp->t_aincompl);
    183        1.1       cgd 	} else if (t == STRUCT || t == UNION) {
    184        1.1       cgd 		return (tp->t_str->sincompl);
    185        1.1       cgd 	} else if (t == ENUM) {
    186        1.1       cgd 		return (tp->t_enum->eincompl);
    187        1.1       cgd 	}
    188        1.1       cgd 	return (0);
    189        1.1       cgd }
    190        1.1       cgd 
    191        1.1       cgd /*
    192        1.1       cgd  * Set the flag for (in)complete array, struct, union or enum
    193        1.1       cgd  * types.
    194        1.1       cgd  */
    195        1.1       cgd void
    196       1.22     lukem setcompl(type_t *tp, int ic)
    197        1.1       cgd {
    198        1.1       cgd 	tspec_t	t;
    199        1.1       cgd 
    200        1.1       cgd 	if ((t = tp->t_tspec) == ARRAY) {
    201        1.1       cgd 		tp->t_aincompl = ic;
    202        1.1       cgd 	} else if (t == STRUCT || t == UNION) {
    203        1.1       cgd 		tp->t_str->sincompl = ic;
    204        1.1       cgd 	} else {
    205        1.1       cgd 		if (t != ENUM)
    206       1.31  christos 			LERROR("setcompl()");
    207        1.1       cgd 		tp->t_enum->eincompl = ic;
    208        1.1       cgd 	}
    209        1.1       cgd }
    210        1.1       cgd 
    211        1.1       cgd /*
    212        1.3       jpo  * Remember the storage class of the current declaration in dcs->d_scl
    213        1.1       cgd  * (the top element of the declaration stack) and detect multiple
    214        1.1       cgd  * storage classes.
    215        1.1       cgd  */
    216        1.1       cgd void
    217       1.22     lukem addscl(scl_t sc)
    218        1.1       cgd {
    219       1.22     lukem 
    220        1.4       jpo 	if (sc == INLINE) {
    221        1.4       jpo 		if (dcs->d_inline)
    222        1.4       jpo 			/* duplicate '%s' */
    223        1.4       jpo 			warning(10, "inline");
    224        1.4       jpo 		dcs->d_inline = 1;
    225        1.4       jpo 		return;
    226        1.4       jpo 	}
    227        1.3       jpo 	if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
    228        1.3       jpo 	    dcs->d_smod != NOTSPEC || dcs->d_lmod != NOTSPEC) {
    229        1.1       cgd 		/* storage class after type is obsolescent */
    230        1.1       cgd 		warning(83);
    231        1.1       cgd 	}
    232        1.3       jpo 	if (dcs->d_scl == NOSCL) {
    233        1.3       jpo 		dcs->d_scl = sc;
    234        1.1       cgd 	} else {
    235        1.1       cgd 		/*
    236        1.1       cgd 		 * multiple storage classes. An error will be reported in
    237        1.1       cgd 		 * deftyp().
    238        1.1       cgd 		 */
    239        1.3       jpo 		dcs->d_mscl = 1;
    240        1.1       cgd 	}
    241        1.1       cgd }
    242        1.1       cgd 
    243        1.1       cgd /*
    244        1.1       cgd  * Remember the type, modifier or typedef name returned by the parser
    245        1.1       cgd  * in *dcs (top element of decl stack). This information is used in
    246        1.1       cgd  * deftyp() to build the type used for all declarators in this
    247        1.1       cgd  * declaration.
    248        1.1       cgd  *
    249        1.1       cgd  * Is tp->t_typedef 1, the type comes from a previously defined typename.
    250        1.1       cgd  * Otherwise it comes from a type specifier (int, long, ...) or a
    251        1.1       cgd  * struct/union/enum tag.
    252        1.1       cgd  */
    253        1.1       cgd void
    254       1.22     lukem addtype(type_t *tp)
    255        1.1       cgd {
    256        1.1       cgd 	tspec_t	t;
    257       1.49  christos #ifdef DEBUG
    258       1.49  christos 	char buf[1024];
    259       1.68  christos 	printf("%s: %s\n", __func__, tyname(buf, sizeof(buf), tp));
    260       1.49  christos #endif
    261        1.1       cgd 	if (tp->t_typedef) {
    262        1.3       jpo 		if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
    263        1.3       jpo 		    dcs->d_lmod != NOTSPEC || dcs->d_smod != NOTSPEC) {
    264        1.1       cgd 			/*
    265        1.1       cgd 			 * something like "typedef int a; int a b;"
    266        1.1       cgd 			 * This should not happen with current grammar.
    267        1.1       cgd 			 */
    268       1.31  christos 			LERROR("addtype()");
    269        1.1       cgd 		}
    270        1.3       jpo 		dcs->d_type = tp;
    271        1.1       cgd 		return;
    272        1.1       cgd 	}
    273        1.1       cgd 
    274        1.1       cgd 	t = tp->t_tspec;
    275        1.1       cgd 
    276        1.1       cgd 	if (t == STRUCT || t == UNION || t == ENUM) {
    277        1.1       cgd 		/*
    278        1.1       cgd 		 * something like "int struct a ..."
    279        1.1       cgd 		 * struct/union/enum with anything else is not allowed
    280        1.1       cgd 		 */
    281        1.3       jpo 		if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
    282        1.3       jpo 		    dcs->d_lmod != NOTSPEC || dcs->d_smod != NOTSPEC) {
    283        1.1       cgd 			/*
    284        1.1       cgd 			 * remember that an error must be reported in
    285        1.1       cgd 			 * deftyp().
    286        1.1       cgd 			 */
    287        1.3       jpo 			dcs->d_terr = 1;
    288        1.3       jpo 			dcs->d_atyp = dcs->d_lmod = dcs->d_smod = NOTSPEC;
    289        1.1       cgd 		}
    290        1.3       jpo 		dcs->d_type = tp;
    291        1.1       cgd 		return;
    292        1.1       cgd 	}
    293        1.1       cgd 
    294        1.3       jpo 	if (dcs->d_type != NULL && !dcs->d_type->t_typedef) {
    295        1.1       cgd 		/*
    296        1.1       cgd 		 * something like "struct a int"
    297        1.1       cgd 		 * struct/union/enum with anything else is not allowed
    298        1.1       cgd 		 */
    299        1.3       jpo 		dcs->d_terr = 1;
    300        1.1       cgd 		return;
    301        1.1       cgd 	}
    302        1.1       cgd 
    303       1.39  christos 	if (t == COMPLEX) {
    304       1.39  christos 		if (dcs->d_cmod == FLOAT)
    305       1.39  christos 			t = FCOMPLEX;
    306       1.42      matt 		else if (dcs->d_cmod == DOUBLE) {
    307       1.39  christos 			t = DCOMPLEX;
    308       1.42      matt 		} else
    309       1.41  christos 			error(308, basictyname(dcs->d_cmod));
    310       1.39  christos 		dcs->d_cmod = NOTSPEC;
    311       1.39  christos 	}
    312       1.39  christos 
    313        1.3       jpo 	if (t == LONG && dcs->d_lmod == LONG) {
    314        1.1       cgd 		/* "long long" or "long ... long" */
    315        1.1       cgd 		t = QUAD;
    316        1.3       jpo 		dcs->d_lmod = NOTSPEC;
    317        1.9       jpo 		if (!quadflg)
    318        1.9       jpo 			/* %s C does not support 'long long' */
    319       1.32     perry 			(void)c99ism(265, tflag ? "traditional" : "c89");
    320        1.1       cgd 	}
    321        1.1       cgd 
    322        1.3       jpo 	if (dcs->d_type != NULL && dcs->d_type->t_typedef) {
    323        1.1       cgd 		/* something like "typedef int a; a long ..." */
    324        1.3       jpo 		dcs->d_type = tdeferr(dcs->d_type, t);
    325        1.1       cgd 		return;
    326        1.1       cgd 	}
    327        1.1       cgd 
    328        1.1       cgd 	/* now it can be only a combination of arithmetic types and void */
    329        1.1       cgd 	if (t == SIGNED || t == UNSIGN) {
    330       1.43  dholland 		/* remember specifiers "signed" & "unsigned" in dcs->d_smod */
    331        1.3       jpo 		if (dcs->d_smod != NOTSPEC)
    332        1.1       cgd 			/*
    333       1.25       wiz 			 * more than one "signed" and/or "unsigned"; print
    334        1.1       cgd 			 * an error in deftyp()
    335        1.1       cgd 			 */
    336        1.3       jpo 			dcs->d_terr = 1;
    337        1.3       jpo 		dcs->d_smod = t;
    338        1.1       cgd 	} else if (t == SHORT || t == LONG || t == QUAD) {
    339        1.1       cgd 		/*
    340        1.1       cgd 		 * remember specifiers "short", "long" and "long long" in
    341        1.3       jpo 		 * dcs->d_lmod
    342        1.1       cgd 		 */
    343        1.3       jpo 		if (dcs->d_lmod != NOTSPEC)
    344        1.1       cgd 			/* more than one, print error in deftyp() */
    345        1.3       jpo 			dcs->d_terr = 1;
    346        1.3       jpo 		dcs->d_lmod = t;
    347       1.39  christos 	} else if (t == FLOAT || t == DOUBLE) {
    348       1.42      matt 		if (dcs->d_lmod == NOTSPEC || dcs->d_lmod == LONG) {
    349       1.42      matt 			if (dcs->d_cmod != NOTSPEC
    350       1.42      matt 			    || (t == FLOAT && dcs->d_lmod == LONG))
    351       1.40  christos 				dcs->d_terr = 1;
    352       1.40  christos 			dcs->d_cmod = t;
    353       1.40  christos 		} else {
    354       1.40  christos 			if (dcs->d_atyp != NOTSPEC)
    355       1.40  christos 				dcs->d_terr = 1;
    356       1.40  christos 			dcs->d_atyp = t;
    357       1.40  christos 		}
    358       1.68  christos 	} else if (t == PTR) {
    359       1.68  christos 		dcs->d_type = tp;
    360        1.1       cgd 	} else {
    361        1.1       cgd 		/*
    362       1.39  christos 		 * remember specifiers "void", "char", "int",
    363       1.39  christos 		 * or "_Complex" int dcs->d_atyp
    364        1.1       cgd 		 */
    365        1.3       jpo 		if (dcs->d_atyp != NOTSPEC)
    366        1.1       cgd 			/* more than one, print error in deftyp() */
    367        1.3       jpo 			dcs->d_terr = 1;
    368        1.3       jpo 		dcs->d_atyp = t;
    369        1.1       cgd 	}
    370        1.1       cgd }
    371        1.1       cgd 
    372        1.1       cgd /*
    373        1.1       cgd  * called if a list of declaration specifiers contains a typedef name
    374        1.1       cgd  * and other specifiers (except struct, union, enum, typedef name)
    375        1.1       cgd  */
    376        1.1       cgd static type_t *
    377       1.22     lukem tdeferr(type_t *td, tspec_t t)
    378        1.1       cgd {
    379        1.1       cgd 	tspec_t	t2;
    380        1.1       cgd 
    381        1.1       cgd 	t2 = td->t_tspec;
    382        1.1       cgd 
    383        1.1       cgd 	switch (t) {
    384        1.1       cgd 	case SIGNED:
    385        1.1       cgd 	case UNSIGN:
    386        1.1       cgd 		if (t2 == CHAR || t2 == SHORT || t2 == INT || t2 == LONG ||
    387        1.1       cgd 		    t2 == QUAD) {
    388        1.1       cgd 			if (!tflag)
    389        1.1       cgd 				/* modifying typedef with ... */
    390        1.1       cgd 				warning(5, ttab[t].tt_name);
    391        1.1       cgd 			td = duptyp(gettyp(mrgtspec(t2, t)));
    392        1.1       cgd 			td->t_typedef = 1;
    393        1.1       cgd 			return (td);
    394        1.1       cgd 		}
    395        1.1       cgd 		break;
    396        1.1       cgd 	case SHORT:
    397        1.1       cgd 		if (t2 == INT || t2 == UINT) {
    398        1.1       cgd 			/* modifying typedef with ... */
    399        1.1       cgd 			warning(5, "short");
    400        1.1       cgd 			td = duptyp(gettyp(t2 == INT ? SHORT : USHORT));
    401        1.1       cgd 			td->t_typedef = 1;
    402        1.1       cgd 			return (td);
    403        1.1       cgd 		}
    404        1.1       cgd 		break;
    405        1.1       cgd 	case LONG:
    406        1.1       cgd 		if (t2 == INT || t2 == UINT || t2 == LONG || t2 == ULONG ||
    407       1.42      matt 		    t2 == FLOAT || t2 == DOUBLE || t2 == DCOMPLEX) {
    408        1.1       cgd 			/* modifying typedef with ... */
    409        1.1       cgd 			warning(5, "long");
    410        1.1       cgd 			if (t2 == INT) {
    411        1.1       cgd 				td = gettyp(LONG);
    412        1.1       cgd 			} else if (t2 == UINT) {
    413        1.1       cgd 				td = gettyp(ULONG);
    414        1.1       cgd 			} else if (t2 == LONG) {
    415        1.1       cgd 				td = gettyp(QUAD);
    416        1.1       cgd 			} else if (t2 == ULONG) {
    417        1.1       cgd 				td = gettyp(UQUAD);
    418        1.1       cgd 			} else if (t2 == FLOAT) {
    419        1.1       cgd 				td = gettyp(DOUBLE);
    420        1.1       cgd 			} else if (t2 == DOUBLE) {
    421        1.1       cgd 				td = gettyp(LDOUBLE);
    422       1.42      matt 			} else if (t2 == DCOMPLEX) {
    423       1.42      matt 				td = gettyp(LCOMPLEX);
    424        1.1       cgd 			}
    425        1.1       cgd 			td = duptyp(td);
    426        1.1       cgd 			td->t_typedef = 1;
    427        1.1       cgd 			return (td);
    428        1.1       cgd 		}
    429        1.1       cgd 		break;
    430       1.57  christos 		/* LINTED206: (enumeration values not handled in switch) */
    431       1.13  christos 	case NOTSPEC:
    432       1.13  christos 	case USHORT:
    433       1.13  christos 	case UCHAR:
    434       1.13  christos 	case SCHAR:
    435       1.13  christos 	case CHAR:
    436       1.34      yamt 	case BOOL:
    437       1.13  christos 	case FUNC:
    438       1.13  christos 	case ARRAY:
    439       1.13  christos 	case PTR:
    440       1.13  christos 	case ENUM:
    441       1.13  christos 	case UNION:
    442       1.13  christos 	case STRUCT:
    443       1.13  christos 	case VOID:
    444       1.13  christos 	case LDOUBLE:
    445       1.39  christos 	case FLOAT:
    446       1.13  christos 	case DOUBLE:
    447       1.13  christos 	case UQUAD:
    448       1.13  christos 	case QUAD:
    449  1.68.10.1  pgoyette #ifdef INT128_SIZE
    450  1.68.10.1  pgoyette 	case UINT128:
    451  1.68.10.1  pgoyette 	case INT128:
    452  1.68.10.1  pgoyette #endif
    453       1.13  christos 	case ULONG:
    454       1.13  christos 	case UINT:
    455       1.13  christos 	case INT:
    456       1.39  christos 	case FCOMPLEX:
    457       1.39  christos 	case DCOMPLEX:
    458       1.42      matt 	case LCOMPLEX:
    459       1.39  christos 	case COMPLEX:
    460       1.28   thorpej 		break;
    461       1.28   thorpej 
    462       1.28   thorpej 	case NTSPEC:	/* this value unused */
    463       1.13  christos 		break;
    464        1.1       cgd 	}
    465        1.1       cgd 
    466        1.1       cgd 	/* Anything other is not accepted. */
    467        1.1       cgd 
    468        1.3       jpo 	dcs->d_terr = 1;
    469        1.1       cgd 	return (td);
    470        1.1       cgd }
    471        1.1       cgd 
    472        1.1       cgd /*
    473        1.1       cgd  * Remember the symbol of a typedef name (2nd arg) in a struct, union
    474        1.1       cgd  * or enum tag if the typedef name is the first defined for this tag.
    475        1.1       cgd  *
    476        1.1       cgd  * If the tag is unnamed, the typdef name is used for identification
    477       1.25       wiz  * of this tag in lint2. Although its possible that more than one typedef
    478        1.1       cgd  * name is defined for one tag, the first name defined should be unique
    479        1.1       cgd  * if the tag is unnamed.
    480        1.1       cgd  */
    481        1.1       cgd static void
    482       1.22     lukem settdsym(type_t *tp, sym_t *sym)
    483        1.1       cgd {
    484        1.1       cgd 	tspec_t	t;
    485        1.1       cgd 
    486        1.1       cgd 	if ((t = tp->t_tspec) == STRUCT || t == UNION) {
    487        1.1       cgd 		if (tp->t_str->stdef == NULL)
    488        1.1       cgd 			tp->t_str->stdef = sym;
    489        1.1       cgd 	} else if (t == ENUM) {
    490        1.1       cgd 		if (tp->t_enum->etdef == NULL)
    491        1.1       cgd 			tp->t_enum->etdef = sym;
    492        1.1       cgd 	}
    493        1.1       cgd }
    494        1.1       cgd 
    495       1.65  christos static size_t
    496       1.65  christos bitfieldsize(sym_t **mem)
    497       1.65  christos {
    498       1.65  christos 	size_t len = (*mem)->s_type->t_flen;
    499       1.65  christos 	while (*mem && (*mem)->s_type->t_isfield) {
    500       1.65  christos 		len += (*mem)->s_type->t_flen;
    501       1.65  christos 		*mem = (*mem)->s_nxt;
    502       1.65  christos 	}
    503       1.65  christos 	return ((len + INT_SIZE - 1) / INT_SIZE) * INT_SIZE;
    504       1.65  christos }
    505       1.65  christos 
    506       1.48  christos static void
    507       1.48  christos setpackedsize(type_t *tp)
    508       1.47  christos {
    509       1.47  christos 	str_t *sp;
    510       1.47  christos 	sym_t *mem;
    511       1.47  christos 	char buf[256];
    512       1.47  christos 
    513       1.47  christos 	switch (tp->t_tspec) {
    514       1.47  christos 	case STRUCT:
    515       1.47  christos 	case UNION:
    516       1.47  christos 		sp = tp->t_str;
    517       1.47  christos 		sp->size = 0;
    518       1.47  christos 		for (mem = sp->memb; mem != NULL; mem = mem->s_nxt) {
    519       1.51  christos 			if (mem->s_type->t_isfield) {
    520       1.65  christos 				sp->size += bitfieldsize(&mem);
    521       1.51  christos 				if (mem == NULL)
    522       1.51  christos 					break;
    523       1.51  christos 			}
    524       1.50  christos 			size_t x = (size_t)tsize(mem->s_type);
    525       1.51  christos 			if (tp->t_tspec == STRUCT)
    526       1.51  christos 				sp->size += x;
    527       1.51  christos 			else if (x > sp->size)
    528       1.47  christos 				sp->size = x;
    529       1.47  christos 		}
    530       1.47  christos 		break;
    531       1.47  christos 	default:
    532       1.47  christos 		warning(326, "packed", tyname(buf, sizeof(buf), tp));
    533       1.47  christos 		break;
    534       1.47  christos 	}
    535       1.47  christos }
    536       1.47  christos 
    537       1.48  christos void
    538       1.48  christos addpacked(void)
    539       1.48  christos {
    540       1.49  christos 	if (dcs->d_type == NULL)
    541       1.48  christos 		dcs->d_ispacked = 1;
    542       1.49  christos 	else
    543       1.48  christos 		setpackedsize(dcs->d_type);
    544       1.48  christos }
    545       1.48  christos 
    546       1.67  christos void
    547       1.67  christos addused(void)
    548       1.67  christos {
    549       1.67  christos 	dcs->d_used = 1;
    550       1.67  christos }
    551       1.67  christos 
    552        1.1       cgd /*
    553        1.1       cgd  * Remember a qualifier which is part of the declaration specifiers
    554        1.1       cgd  * (and not the declarator) in the top element of the declaration stack.
    555        1.1       cgd  * Also detect multiple qualifiers of the same kind.
    556        1.1       cgd 
    557       1.21     lukem  * The remembered qualifier is used by deftyp() to construct the type
    558        1.1       cgd  * for all declarators.
    559        1.1       cgd  */
    560        1.1       cgd void
    561       1.22     lukem addqual(tqual_t q)
    562        1.1       cgd {
    563       1.22     lukem 
    564        1.1       cgd 	if (q == CONST) {
    565        1.3       jpo 		if (dcs->d_const) {
    566        1.1       cgd 			/* duplicate "%s" */
    567        1.1       cgd 			warning(10, "const");
    568        1.1       cgd 		}
    569        1.3       jpo 		dcs->d_const = 1;
    570        1.1       cgd 	} else {
    571        1.1       cgd 		if (q != VOLATILE)
    572       1.31  christos 			LERROR("addqual()");
    573        1.3       jpo 		if (dcs->d_volatile) {
    574        1.1       cgd 			/* duplicate "%s" */
    575        1.1       cgd 			warning(10, "volatile");
    576        1.1       cgd 		}
    577        1.3       jpo 		dcs->d_volatile = 1;
    578        1.1       cgd 	}
    579        1.1       cgd }
    580        1.1       cgd 
    581        1.1       cgd /*
    582        1.1       cgd  * Go to the next declaration level (structs, nested structs, blocks,
    583        1.1       cgd  * argument declaration lists ...)
    584        1.1       cgd  */
    585        1.1       cgd void
    586       1.22     lukem pushdecl(scl_t sc)
    587        1.1       cgd {
    588        1.1       cgd 	dinfo_t	*di;
    589        1.1       cgd 
    590        1.1       cgd 	/* put a new element on the declaration stack */
    591        1.1       cgd 	di = xcalloc(1, sizeof (dinfo_t));
    592        1.3       jpo 	di->d_nxt = dcs;
    593        1.1       cgd 	dcs = di;
    594        1.3       jpo 	di->d_ctx = sc;
    595        1.3       jpo 	di->d_ldlsym = &di->d_dlsyms;
    596       1.47  christos 	if (dflag)
    597       1.47  christos 		(void)printf("pushdecl(%p %d)\n", dcs, (int)sc);
    598       1.47  christos 
    599        1.1       cgd }
    600        1.1       cgd 
    601        1.1       cgd /*
    602        1.1       cgd  * Go back to previous declaration level
    603        1.1       cgd  */
    604        1.1       cgd void
    605       1.22     lukem popdecl(void)
    606        1.1       cgd {
    607        1.1       cgd 	dinfo_t	*di;
    608        1.1       cgd 
    609        1.1       cgd 	if (dflag)
    610       1.47  christos 		(void)printf("popdecl(%p %d)\n", dcs, (int)dcs->d_ctx);
    611        1.1       cgd 
    612        1.3       jpo 	if (dcs->d_nxt == NULL)
    613       1.31  christos 		LERROR("popdecl()");
    614        1.1       cgd 	di = dcs;
    615        1.3       jpo 	dcs = di->d_nxt;
    616        1.3       jpo 	switch (di->d_ctx) {
    617        1.1       cgd 	case EXTERN:
    618        1.1       cgd 		/* there is nothing after external declarations */
    619       1.31  christos 		LERROR("popdecl()");
    620        1.1       cgd 		/* NOTREACHED */
    621        1.1       cgd 	case MOS:
    622        1.1       cgd 	case MOU:
    623        1.1       cgd 	case ENUMCON:
    624        1.1       cgd 		/*
    625        1.1       cgd 		 * Symbols declared in (nested) structs or enums are
    626        1.1       cgd 		 * part of the next level (they are removed from the
    627        1.1       cgd 		 * symbol table if the symbols of the outher level are
    628        1.1       cgd 		 * removed)
    629        1.1       cgd 		 */
    630        1.3       jpo 		if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
    631        1.3       jpo 			dcs->d_ldlsym = di->d_ldlsym;
    632        1.1       cgd 		break;
    633        1.1       cgd 	case ARG:
    634        1.1       cgd 		/*
    635        1.3       jpo 		 * All symbols in dcs->d_dlsyms are introduced in old style
    636        1.1       cgd 		 * argument declarations (it's not clean, but possible).
    637        1.1       cgd 		 * They are appended to the list of symbols declared in
    638        1.1       cgd 		 * an old style argument identifier list or a new style
    639        1.1       cgd 		 * parameter type list.
    640        1.1       cgd 		 */
    641        1.3       jpo 		if (di->d_dlsyms != NULL) {
    642        1.3       jpo 			*di->d_ldlsym = dcs->d_fpsyms;
    643        1.3       jpo 			dcs->d_fpsyms = di->d_dlsyms;
    644        1.1       cgd 		}
    645        1.1       cgd 		break;
    646        1.1       cgd 	case ABSTRACT:
    647        1.1       cgd 		/*
    648        1.1       cgd 		 * casts and sizeof
    649        1.1       cgd 		 * Append all symbols declared in the abstract declaration
    650        1.1       cgd 		 * to the list of symbols declared in the surounding decl.
    651        1.1       cgd 		 * or block.
    652        1.1       cgd 		 * XXX I'm not sure whether they should be removed from the
    653        1.1       cgd 		 * symbol table now or later.
    654        1.1       cgd 		 */
    655        1.3       jpo 		if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
    656        1.3       jpo 			dcs->d_ldlsym = di->d_ldlsym;
    657        1.1       cgd 		break;
    658        1.1       cgd 	case AUTO:
    659        1.1       cgd 		/* check usage of local vars */
    660       1.10       jpo 		chkusage(di);
    661        1.1       cgd 		/* FALLTHROUGH */
    662        1.1       cgd 	case PARG:
    663        1.1       cgd 		/* usage of arguments will be checked by funcend() */
    664        1.3       jpo 		rmsyms(di->d_dlsyms);
    665        1.1       cgd 		break;
    666        1.1       cgd 	default:
    667       1.31  christos 		LERROR("popdecl()");
    668        1.1       cgd 	}
    669        1.1       cgd 	free(di);
    670        1.1       cgd }
    671        1.1       cgd 
    672        1.1       cgd /*
    673       1.10       jpo  * Set flag d_asm in all declaration stack elements up to the
    674       1.10       jpo  * outermost one.
    675       1.10       jpo  *
    676       1.10       jpo  * This is used to mark compound statements which have, possibly in
    677       1.10       jpo  * nested compound statements, asm statements. For these compound
    678       1.10       jpo  * statements no warnings about unused or unitialized variables are
    679       1.10       jpo  * printed.
    680       1.10       jpo  *
    681       1.10       jpo  * There is no need to clear d_asm in dinfo structs with context AUTO,
    682       1.10       jpo  * because these structs are freed at the end of the compound statement.
    683       1.62  dholland  * But it must be cleared in the outermost dinfo struct, which has
    684       1.10       jpo  * context EXTERN. This could be done in clrtyp() and would work for
    685       1.10       jpo  * C, but not for C++ (due to mixed statements and declarations). Thus
    686       1.10       jpo  * we clear it in glclup(), which is used to do some cleanup after
    687       1.10       jpo  * global declarations/definitions.
    688       1.10       jpo  */
    689       1.10       jpo void
    690       1.22     lukem setasm(void)
    691       1.10       jpo {
    692       1.10       jpo 	dinfo_t	*di;
    693       1.10       jpo 
    694       1.10       jpo 	for (di = dcs; di != NULL; di = di->d_nxt)
    695       1.10       jpo 		di->d_asm = 1;
    696       1.10       jpo }
    697       1.10       jpo 
    698       1.10       jpo /*
    699        1.1       cgd  * Clean all elements of the top element of declaration stack which
    700        1.1       cgd  * will be used by the next declaration
    701        1.1       cgd  */
    702        1.1       cgd void
    703       1.22     lukem clrtyp(void)
    704        1.1       cgd {
    705       1.22     lukem 
    706       1.39  christos 	dcs->d_atyp = dcs->d_cmod = dcs->d_smod = dcs->d_lmod = NOTSPEC;
    707        1.3       jpo 	dcs->d_scl = NOSCL;
    708        1.3       jpo 	dcs->d_type = NULL;
    709        1.3       jpo 	dcs->d_const = dcs->d_volatile = 0;
    710        1.4       jpo 	dcs->d_inline = 0;
    711        1.3       jpo 	dcs->d_mscl = dcs->d_terr = 0;
    712        1.3       jpo 	dcs->d_nedecl = 0;
    713        1.7       jpo 	dcs->d_notyp = 0;
    714        1.1       cgd }
    715        1.1       cgd 
    716        1.1       cgd /*
    717        1.1       cgd  * Create a type structure from the informations gathered in
    718        1.1       cgd  * the declaration stack.
    719        1.1       cgd  * Complain about storage classes which are not possible in current
    720        1.1       cgd  * context.
    721        1.1       cgd  */
    722        1.1       cgd void
    723       1.22     lukem deftyp(void)
    724        1.1       cgd {
    725       1.39  christos 	tspec_t	t, s, l, c;
    726        1.1       cgd 	type_t	*tp;
    727        1.1       cgd 	scl_t	scl;
    728        1.1       cgd 
    729       1.39  christos 	t = dcs->d_atyp;	/* BOOL, CHAR, INT, COMPLEX, VOID */
    730       1.34      yamt 	s = dcs->d_smod;	/* SIGNED, UNSIGNED */
    731       1.34      yamt 	l = dcs->d_lmod;	/* SHORT, LONG, QUAD */
    732       1.39  christos 	c = dcs->d_cmod;	/* FLOAT, DOUBLE */
    733        1.3       jpo 	tp = dcs->d_type;
    734        1.3       jpo 	scl = dcs->d_scl;
    735        1.1       cgd 
    736       1.68  christos #ifdef DEBUG
    737       1.68  christos 	char buf[1024];
    738       1.68  christos 	printf("%s: %s\n", __func__, tyname(buf, sizeof(buf), tp));
    739       1.68  christos #endif
    740       1.39  christos 	if (t == NOTSPEC && s == NOTSPEC && l == NOTSPEC && c == NOTSPEC &&
    741       1.39  christos 	    tp == NULL)
    742       1.39  christos 		dcs->d_notyp = 1;
    743       1.43  dholland 	if (t == NOTSPEC && s == NOTSPEC && (l == NOTSPEC || l == LONG) &&
    744       1.43  dholland 	    tp == NULL)
    745       1.39  christos 		t = c;
    746        1.1       cgd 
    747        1.1       cgd 	if (tp != NULL && (t != NOTSPEC || s != NOTSPEC || l != NOTSPEC)) {
    748        1.1       cgd 		/* should never happen */
    749       1.31  christos 		LERROR("deftyp()");
    750        1.1       cgd 	}
    751        1.1       cgd 
    752        1.1       cgd 	if (tp == NULL) {
    753        1.1       cgd 		switch (t) {
    754       1.34      yamt 		case BOOL:
    755       1.34      yamt 			break;
    756        1.1       cgd 		case NOTSPEC:
    757        1.1       cgd 			t = INT;
    758        1.1       cgd 			/* FALLTHROUGH */
    759        1.1       cgd 		case INT:
    760        1.1       cgd 			if (s == NOTSPEC)
    761        1.1       cgd 				s = SIGNED;
    762        1.1       cgd 			break;
    763        1.1       cgd 		case CHAR:
    764        1.1       cgd 			if (l != NOTSPEC) {
    765        1.3       jpo 				dcs->d_terr = 1;
    766        1.1       cgd 				l = NOTSPEC;
    767        1.1       cgd 			}
    768        1.1       cgd 			break;
    769        1.1       cgd 		case FLOAT:
    770        1.1       cgd 			if (l == LONG) {
    771        1.1       cgd 				l = NOTSPEC;
    772        1.1       cgd 				t = DOUBLE;
    773        1.1       cgd 				if (!tflag)
    774        1.1       cgd 					/* use 'double' instead of ...  */
    775        1.1       cgd 					warning(6);
    776        1.1       cgd 			}
    777        1.1       cgd 			break;
    778        1.1       cgd 		case DOUBLE:
    779        1.1       cgd 			if (l == LONG) {
    780       1.59  christos 		case LDOUBLE:
    781        1.1       cgd 				l = NOTSPEC;
    782        1.1       cgd 				t = LDOUBLE;
    783        1.1       cgd 				if (tflag)
    784        1.1       cgd 					/* 'long double' is illegal in ... */
    785        1.1       cgd 					warning(266);
    786        1.1       cgd 			}
    787        1.1       cgd 			break;
    788       1.42      matt 		case DCOMPLEX:
    789       1.42      matt 			if (l == LONG) {
    790       1.42      matt 				l = NOTSPEC;
    791       1.42      matt 				t = LCOMPLEX;
    792       1.42      matt 				if (tflag)
    793       1.42      matt 					/* 'long double' is illegal in ... */
    794       1.42      matt 					warning(266);
    795       1.42      matt 			}
    796       1.42      matt 			break;
    797        1.1       cgd 		case VOID:
    798       1.39  christos 		case FCOMPLEX:
    799       1.42      matt 		case LCOMPLEX:
    800        1.1       cgd 			break;
    801        1.1       cgd 		default:
    802       1.59  christos 			LERROR("deftyp(%s)", basictyname(t));
    803        1.1       cgd 		}
    804        1.1       cgd 		if (t != INT && t != CHAR && (s != NOTSPEC || l != NOTSPEC)) {
    805        1.3       jpo 			dcs->d_terr = 1;
    806        1.1       cgd 			l = s = NOTSPEC;
    807        1.1       cgd 		}
    808        1.1       cgd 		if (l != NOTSPEC)
    809        1.1       cgd 			t = l;
    810        1.3       jpo 		dcs->d_type = gettyp(mrgtspec(t, s));
    811        1.1       cgd 	}
    812        1.1       cgd 
    813        1.3       jpo 	if (dcs->d_mscl) {
    814        1.1       cgd 		/* only one storage class allowed */
    815        1.1       cgd 		error(7);
    816        1.1       cgd 	}
    817        1.3       jpo 	if (dcs->d_terr) {
    818        1.1       cgd 		/* illegal type combination */
    819        1.1       cgd 		error(4);
    820        1.1       cgd 	}
    821        1.1       cgd 
    822        1.3       jpo 	if (dcs->d_ctx == EXTERN) {
    823        1.1       cgd 		if (scl == REG || scl == AUTO) {
    824        1.1       cgd 			/* illegal storage class */
    825        1.1       cgd 			error(8);
    826        1.1       cgd 			scl = NOSCL;
    827        1.1       cgd 		}
    828        1.3       jpo 	} else if (dcs->d_ctx == ARG || dcs->d_ctx == PARG) {
    829        1.1       cgd 		if (scl != NOSCL && scl != REG) {
    830        1.1       cgd 			/* only "register" valid ... */
    831        1.1       cgd 			error(9);
    832        1.1       cgd 			scl = NOSCL;
    833        1.1       cgd 		}
    834        1.1       cgd 	}
    835        1.1       cgd 
    836        1.3       jpo 	dcs->d_scl = scl;
    837        1.1       cgd 
    838        1.3       jpo 	if (dcs->d_const && dcs->d_type->t_const) {
    839        1.3       jpo 		if (!dcs->d_type->t_typedef)
    840       1.31  christos 			LERROR("deftyp()");
    841        1.1       cgd 		/* typedef already qualified with "%s" */
    842        1.1       cgd 		warning(68, "const");
    843        1.1       cgd 	}
    844        1.3       jpo 	if (dcs->d_volatile && dcs->d_type->t_volatile) {
    845        1.3       jpo 		if (!dcs->d_type->t_typedef)
    846       1.31  christos 			LERROR("deftyp()");
    847        1.1       cgd 		/* typedef already qualified with "%s" */
    848        1.1       cgd 		warning(68, "volatile");
    849        1.1       cgd 	}
    850        1.1       cgd 
    851        1.3       jpo 	if (dcs->d_const || dcs->d_volatile) {
    852        1.3       jpo 		dcs->d_type = duptyp(dcs->d_type);
    853        1.3       jpo 		dcs->d_type->t_const |= dcs->d_const;
    854        1.3       jpo 		dcs->d_type->t_volatile |= dcs->d_volatile;
    855        1.1       cgd 	}
    856        1.1       cgd }
    857        1.1       cgd 
    858        1.1       cgd /*
    859        1.1       cgd  * Merge type specifiers (char, ..., long long, signed, unsigned).
    860        1.1       cgd  */
    861        1.1       cgd static tspec_t
    862       1.22     lukem mrgtspec(tspec_t t, tspec_t s)
    863        1.1       cgd {
    864       1.22     lukem 
    865        1.1       cgd 	if (s == SIGNED || s == UNSIGN) {
    866        1.1       cgd 		if (t == CHAR) {
    867        1.1       cgd 			t = s == SIGNED ? SCHAR : UCHAR;
    868        1.1       cgd 		} else if (t == SHORT) {
    869        1.1       cgd 			t = s == SIGNED ? SHORT : USHORT;
    870        1.1       cgd 		} else if (t == INT) {
    871        1.1       cgd 			t = s == SIGNED ? INT : UINT;
    872        1.1       cgd 		} else if (t == LONG) {
    873        1.1       cgd 			t = s == SIGNED ? LONG : ULONG;
    874        1.1       cgd 		} else if (t == QUAD) {
    875        1.1       cgd 			t = s == SIGNED ? QUAD : UQUAD;
    876        1.1       cgd 		}
    877        1.1       cgd 	}
    878        1.1       cgd 
    879        1.1       cgd 	return (t);
    880        1.1       cgd }
    881        1.1       cgd 
    882        1.1       cgd /*
    883        1.1       cgd  * Return the length of a type in bit.
    884        1.1       cgd  *
    885        1.1       cgd  * Printing a message if the outhermost dimension of an array is 0 must
    886        1.1       cgd  * be done by the caller. All other problems are reported by length()
    887        1.1       cgd  * if name is not NULL.
    888        1.1       cgd  */
    889        1.1       cgd int
    890       1.22     lukem length(type_t *tp, const char *name)
    891        1.1       cgd {
    892        1.1       cgd 	int	elem, elsz;
    893        1.1       cgd 
    894        1.1       cgd 	elem = 1;
    895       1.18  christos 	while (tp && tp->t_tspec == ARRAY) {
    896        1.1       cgd 		elem *= tp->t_dim;
    897        1.1       cgd 		tp = tp->t_subt;
    898        1.1       cgd 	}
    899       1.18  christos 	if (tp == NULL)
    900       1.18  christos 		return -1;
    901       1.18  christos 
    902        1.1       cgd 	switch (tp->t_tspec) {
    903        1.1       cgd 	case FUNC:
    904        1.1       cgd 		/* compiler takes size of function */
    905       1.52     joerg 		LERROR("%s", msgs[12]);
    906        1.1       cgd 		/* NOTREACHED */
    907        1.1       cgd 	case STRUCT:
    908        1.1       cgd 	case UNION:
    909        1.1       cgd 		if (incompl(tp) && name != NULL) {
    910        1.1       cgd 			/* incomplete structure or union %s: %s */
    911        1.1       cgd 			error(31, tp->t_str->stag->s_name, name);
    912        1.1       cgd 		}
    913        1.1       cgd 		elsz = tp->t_str->size;
    914        1.1       cgd 		break;
    915        1.1       cgd 	case ENUM:
    916        1.1       cgd 		if (incompl(tp) && name != NULL) {
    917        1.1       cgd 			/* incomplete enum type: %s */
    918        1.1       cgd 			warning(13, name);
    919        1.1       cgd 		}
    920        1.1       cgd 		/* FALLTHROUGH */
    921        1.1       cgd 	default:
    922        1.1       cgd 		elsz = size(tp->t_tspec);
    923        1.1       cgd 		if (elsz <= 0)
    924       1.61  christos 			LERROR("length(%d)", elsz);
    925        1.1       cgd 		break;
    926        1.1       cgd 	}
    927        1.1       cgd 	return (elem * elsz);
    928        1.1       cgd }
    929        1.1       cgd 
    930        1.1       cgd /*
    931        1.1       cgd  * Get the alignment of the given Type in bits.
    932        1.1       cgd  */
    933        1.1       cgd int
    934       1.22     lukem getbound(type_t *tp)
    935        1.1       cgd {
    936       1.46  christos 	size_t	a;
    937        1.1       cgd 	tspec_t	t;
    938        1.1       cgd 
    939       1.18  christos 	while (tp && tp->t_tspec == ARRAY)
    940        1.1       cgd 		tp = tp->t_subt;
    941        1.1       cgd 
    942       1.18  christos 	if (tp == NULL)
    943       1.18  christos 		return -1;
    944       1.18  christos 
    945        1.1       cgd 	if ((t = tp->t_tspec) == STRUCT || t == UNION) {
    946        1.1       cgd 		a = tp->t_str->align;
    947        1.1       cgd 	} else if (t == FUNC) {
    948        1.1       cgd 		/* compiler takes alignment of function */
    949        1.1       cgd 		error(14);
    950       1.53  christos 		a = WORST_ALIGN(1) * CHAR_BIT;
    951        1.1       cgd 	} else {
    952        1.1       cgd 		if ((a = size(t)) == 0) {
    953        1.1       cgd 			a = CHAR_BIT;
    954       1.53  christos 		} else if (a > WORST_ALIGN(1) * CHAR_BIT) {
    955       1.53  christos 			a = WORST_ALIGN(1) * CHAR_BIT;
    956        1.1       cgd 		}
    957        1.1       cgd 	}
    958       1.53  christos 	if (a < CHAR_BIT || a > WORST_ALIGN(1) * CHAR_BIT)
    959       1.31  christos 		LERROR("getbound()");
    960        1.1       cgd 	return (a);
    961        1.1       cgd }
    962        1.1       cgd 
    963        1.1       cgd /*
    964        1.1       cgd  * Concatenate two lists of symbols by s_nxt. Used by declarations of
    965        1.1       cgd  * struct/union/enum elements and parameters.
    966        1.1       cgd  */
    967        1.1       cgd sym_t *
    968       1.22     lukem lnklst(sym_t *l1, sym_t *l2)
    969        1.1       cgd {
    970        1.1       cgd 	sym_t	*l;
    971        1.1       cgd 
    972        1.1       cgd 	if ((l = l1) == NULL)
    973        1.1       cgd 		return (l2);
    974        1.1       cgd 	while (l1->s_nxt != NULL)
    975        1.1       cgd 		l1 = l1->s_nxt;
    976        1.1       cgd 	l1->s_nxt = l2;
    977        1.1       cgd 	return (l);
    978        1.1       cgd }
    979        1.1       cgd 
    980        1.1       cgd /*
    981        1.1       cgd  * Check if the type of the given symbol is valid and print an error
    982        1.1       cgd  * message if it is not.
    983        1.1       cgd  *
    984        1.1       cgd  * Invalid types are:
    985        1.1       cgd  * - arrays of incomlete types or functions
    986        1.1       cgd  * - functions returning arrays or functions
    987        1.1       cgd  * - void types other than type of function or pointer
    988        1.1       cgd  */
    989        1.1       cgd void
    990       1.22     lukem chktyp(sym_t *sym)
    991        1.1       cgd {
    992        1.1       cgd 	tspec_t	to, t;
    993        1.1       cgd 	type_t	**tpp, *tp;
    994        1.1       cgd 
    995        1.1       cgd 	tpp = &sym->s_type;
    996        1.1       cgd 	to = NOTSPEC;
    997        1.1       cgd 	while ((tp = *tpp) != NULL) {
    998        1.1       cgd 		t = tp->t_tspec;
    999        1.1       cgd 		/*
   1000        1.1       cgd 		 * If this is the type of an old style function definition,
   1001        1.1       cgd 		 * a better warning is printed in funcdef().
   1002        1.1       cgd 		 */
   1003        1.1       cgd 		if (t == FUNC && !tp->t_proto &&
   1004        1.1       cgd 		    !(to == NOTSPEC && sym->s_osdef)) {
   1005        1.1       cgd 			if (sflag && hflag)
   1006        1.1       cgd 				/* function declaration is not a prototype */
   1007        1.1       cgd 				warning(287);
   1008        1.1       cgd 		}
   1009        1.1       cgd 		if (to == FUNC) {
   1010        1.1       cgd 			if (t == FUNC || t == ARRAY) {
   1011        1.1       cgd 				/* function returns illegal type */
   1012        1.1       cgd 				error(15);
   1013        1.1       cgd 				if (t == FUNC) {
   1014        1.1       cgd 					*tpp = incref(*tpp, PTR);
   1015        1.1       cgd 				} else {
   1016        1.1       cgd 					*tpp = incref((*tpp)->t_subt, PTR);
   1017        1.1       cgd 				}
   1018        1.1       cgd 				return;
   1019        1.1       cgd 			} else if (tp->t_const || tp->t_volatile) {
   1020        1.1       cgd 				if (sflag) {	/* XXX oder better !tflag ? */
   1021        1.1       cgd 					/* function cannot return const... */
   1022        1.1       cgd 					warning(228);
   1023        1.1       cgd 				}
   1024        1.1       cgd 			}
   1025        1.1       cgd 		} if (to == ARRAY) {
   1026        1.1       cgd 			if (t == FUNC) {
   1027        1.1       cgd 				/* array of function is illegal */
   1028        1.1       cgd 				error(16);
   1029        1.1       cgd 				*tpp = gettyp(INT);
   1030        1.1       cgd 				return;
   1031        1.1       cgd 			} else if (t == ARRAY && tp->t_dim == 0) {
   1032        1.1       cgd 				/* null dimension */
   1033        1.1       cgd 				error(17);
   1034        1.1       cgd 				return;
   1035        1.1       cgd 			} else if (t == VOID) {
   1036        1.1       cgd 				/* illegal use of void */
   1037        1.1       cgd 				error(18);
   1038        1.1       cgd 				*tpp = gettyp(INT);
   1039        1.1       cgd #if 0	/* errors are produced by length() */
   1040        1.1       cgd 			} else if (incompl(tp)) {
   1041        1.1       cgd 				/* array of incomplete type */
   1042        1.1       cgd 				if (sflag) {
   1043        1.1       cgd 					error(301);
   1044        1.1       cgd 				} else {
   1045        1.1       cgd 					warning(301);
   1046        1.1       cgd 				}
   1047        1.1       cgd #endif
   1048        1.1       cgd 			}
   1049        1.1       cgd 		} else if (to == NOTSPEC && t == VOID) {
   1050        1.3       jpo 			if (dcs->d_ctx == PARG) {
   1051        1.1       cgd 				if (sym->s_scl != ABSTRACT) {
   1052        1.1       cgd 					if (sym->s_name == unnamed)
   1053       1.31  christos 						LERROR("chktyp()");
   1054        1.1       cgd 					/* void param cannot have name: %s */
   1055        1.1       cgd 					error(61, sym->s_name);
   1056        1.1       cgd 					*tpp = gettyp(INT);
   1057        1.1       cgd 				}
   1058        1.3       jpo 			} else if (dcs->d_ctx == ABSTRACT) {
   1059        1.1       cgd 				/* ok */
   1060        1.1       cgd 			} else if (sym->s_scl != TYPEDEF) {
   1061        1.1       cgd 				/* void type for %s */
   1062        1.1       cgd 				error(19, sym->s_name);
   1063        1.1       cgd 				*tpp = gettyp(INT);
   1064        1.1       cgd 			}
   1065        1.1       cgd 		}
   1066        1.1       cgd 		if (t == VOID && to != PTR) {
   1067        1.1       cgd 			if (tp->t_const || tp->t_volatile) {
   1068        1.1       cgd 				/* inappropriate qualifiers with "void" */
   1069        1.1       cgd 				warning(69);
   1070        1.1       cgd 				tp->t_const = tp->t_volatile = 0;
   1071        1.1       cgd 			}
   1072        1.1       cgd 		}
   1073        1.1       cgd 		tpp = &tp->t_subt;
   1074        1.1       cgd 		to = t;
   1075        1.1       cgd 	}
   1076        1.1       cgd }
   1077        1.1       cgd 
   1078        1.1       cgd /*
   1079        1.1       cgd  * Process the declarator of a struct/union element.
   1080        1.1       cgd  */
   1081        1.1       cgd sym_t *
   1082       1.22     lukem decl1str(sym_t *dsym)
   1083        1.1       cgd {
   1084        1.1       cgd 	type_t	*tp;
   1085        1.1       cgd 	tspec_t	t;
   1086       1.13  christos 	int	sz, len;
   1087       1.13  christos 	int	o = 0;	/* Appease gcc */
   1088        1.1       cgd 	scl_t	sc;
   1089        1.1       cgd 
   1090        1.1       cgd 	if ((sc = dsym->s_scl) != MOS && sc != MOU)
   1091       1.31  christos 		LERROR("decl1str()");
   1092        1.1       cgd 
   1093        1.3       jpo 	if (dcs->d_rdcsym != NULL) {
   1094        1.3       jpo 		if ((sc = dcs->d_rdcsym->s_scl) != MOS && sc != MOU)
   1095        1.1       cgd 			/* should be ensured by storesym() */
   1096       1.31  christos 			LERROR("decl1str()");
   1097        1.3       jpo 		if (dsym->s_styp == dcs->d_rdcsym->s_styp) {
   1098        1.1       cgd 			/* duplicate member name: %s */
   1099        1.1       cgd 			error(33, dsym->s_name);
   1100        1.3       jpo 			rmsym(dcs->d_rdcsym);
   1101        1.1       cgd 		}
   1102        1.1       cgd 	}
   1103        1.1       cgd 
   1104        1.1       cgd 	chktyp(dsym);
   1105        1.1       cgd 
   1106        1.1       cgd 	t = (tp = dsym->s_type)->t_tspec;
   1107        1.1       cgd 
   1108        1.1       cgd 	if (dsym->s_field) {
   1109        1.1       cgd 		/*
   1110        1.1       cgd 		 * bit field
   1111        1.1       cgd 		 *
   1112        1.1       cgd 		 * only unsigned und signed int are protable bit-field types
   1113        1.1       cgd 		 *(at least in ANSI C, in traditional C only unsigned int)
   1114        1.1       cgd 		 */
   1115        1.1       cgd 		if (t == CHAR || t == UCHAR || t == SCHAR ||
   1116        1.1       cgd 		    t == SHORT || t == USHORT || t == ENUM) {
   1117       1.26   thorpej 			if (bitfieldtype_ok == 0) {
   1118       1.26   thorpej 				if (sflag) {
   1119       1.31  christos 					char buf[64];
   1120       1.26   thorpej 					/*
   1121       1.26   thorpej 					 * bit-field type '%s' invalid in
   1122       1.26   thorpej 					 * ANSI C
   1123       1.26   thorpej 					 */
   1124       1.31  christos 					warning(273,
   1125       1.31  christos 					    tyname(buf, sizeof(buf), tp));
   1126       1.26   thorpej 				} else if (pflag) {
   1127       1.26   thorpej 					/* nonportable bit-field type */
   1128       1.26   thorpej 					warning(34);
   1129       1.26   thorpej 				}
   1130        1.1       cgd 			}
   1131        1.3       jpo 		} else if (t == INT && dcs->d_smod == NOTSPEC) {
   1132       1.26   thorpej 			if (pflag && bitfieldtype_ok == 0) {
   1133        1.1       cgd 				/* nonportable bit-field type */
   1134        1.1       cgd 				warning(34);
   1135        1.1       cgd 			}
   1136        1.1       cgd 		} else if (t != INT && t != UINT) {
   1137       1.26   thorpej 			/*
   1138       1.26   thorpej 			 * Non-integer types are always illegal for
   1139       1.26   thorpej 			 * bitfields, regardless of BITFIELDTYPE.
   1140       1.27   thorpej 			 * Integer types not dealt with above are
   1141       1.27   thorpej 			 * okay only if BITFIELDTYPE is in effect.
   1142       1.26   thorpej 			 */
   1143       1.27   thorpej 			if (bitfieldtype_ok == 0 || isityp(t) == 0) {
   1144       1.26   thorpej 				/* illegal bit-field type */
   1145       1.58  christos 				warning(35);
   1146       1.26   thorpej 				sz = tp->t_flen;
   1147       1.26   thorpej 				dsym->s_type = tp = duptyp(gettyp(t = INT));
   1148       1.26   thorpej 				if ((tp->t_flen = sz) > size(t))
   1149       1.26   thorpej 					tp->t_flen = size(t);
   1150       1.26   thorpej 			}
   1151        1.1       cgd 		}
   1152       1.46  christos 		if ((len = tp->t_flen) < 0 || len > (ssize_t)size(t)) {
   1153        1.1       cgd 			/* illegal bit-field size */
   1154        1.1       cgd 			error(36);
   1155        1.1       cgd 			tp->t_flen = size(t);
   1156        1.1       cgd 		} else if (len == 0 && dsym->s_name != unnamed) {
   1157        1.1       cgd 			/* zero size bit-field */
   1158        1.1       cgd 			error(37);
   1159        1.1       cgd 			tp->t_flen = size(t);
   1160        1.1       cgd 		}
   1161        1.1       cgd 		if (dsym->s_scl == MOU) {
   1162        1.1       cgd 			/* illegal use of bit-field */
   1163        1.1       cgd 			error(41);
   1164        1.1       cgd 			dsym->s_type->t_isfield = 0;
   1165        1.1       cgd 			dsym->s_field = 0;
   1166        1.1       cgd 		}
   1167        1.1       cgd 	} else if (t == FUNC) {
   1168        1.1       cgd 		/* function illegal in structure or union */
   1169        1.1       cgd 		error(38);
   1170        1.1       cgd 		dsym->s_type = tp = incref(tp, t = PTR);
   1171        1.1       cgd 	}
   1172        1.1       cgd 
   1173        1.1       cgd 	/*
   1174        1.1       cgd 	 * bit-fields of length 0 are not warned about because length()
   1175        1.1       cgd 	 * does not return the length of the bit-field but the length
   1176        1.1       cgd 	 * of the type the bit-field is packed in (its ok)
   1177        1.1       cgd 	 */
   1178        1.1       cgd 	if ((sz = length(dsym->s_type, dsym->s_name)) == 0) {
   1179       1.36  christos 		if (t == ARRAY && dsym->s_type->t_dim == 0) {
   1180        1.1       cgd 			/* illegal zero sized structure member: %s */
   1181       1.36  christos 			c99ism(39, dsym->s_name);
   1182        1.1       cgd 		}
   1183        1.1       cgd 	}
   1184        1.1       cgd 
   1185        1.3       jpo 	if (dcs->d_ctx == MOU) {
   1186        1.3       jpo 		o = dcs->d_offset;
   1187        1.3       jpo 		dcs->d_offset = 0;
   1188        1.1       cgd 	}
   1189        1.1       cgd 	if (dsym->s_field) {
   1190        1.1       cgd 		align(getbound(tp), tp->t_flen);
   1191        1.3       jpo 		dsym->s_value.v_quad = (dcs->d_offset / size(t)) * size(t);
   1192        1.3       jpo 		tp->t_foffs = dcs->d_offset - (int)dsym->s_value.v_quad;
   1193        1.3       jpo 		dcs->d_offset += tp->t_flen;
   1194        1.1       cgd 	} else {
   1195        1.1       cgd 		align(getbound(tp), 0);
   1196        1.3       jpo 		dsym->s_value.v_quad = dcs->d_offset;
   1197        1.3       jpo 		dcs->d_offset += sz;
   1198        1.1       cgd 	}
   1199        1.3       jpo 	if (dcs->d_ctx == MOU) {
   1200        1.3       jpo 		if (o > dcs->d_offset)
   1201        1.3       jpo 			dcs->d_offset = o;
   1202        1.1       cgd 	}
   1203        1.1       cgd 
   1204        1.1       cgd 	chkfdef(dsym, 0);
   1205       1.26   thorpej 
   1206       1.26   thorpej 	/*
   1207       1.26   thorpej 	 * Clear the BITFIELDTYPE indicator after processing each
   1208       1.26   thorpej 	 * structure element.
   1209       1.26   thorpej 	 */
   1210       1.26   thorpej 	bitfieldtype_ok = 0;
   1211        1.1       cgd 
   1212        1.1       cgd 	return (dsym);
   1213        1.1       cgd }
   1214        1.1       cgd 
   1215        1.1       cgd /*
   1216        1.1       cgd  * Aligns next structure element as required.
   1217        1.1       cgd  *
   1218        1.1       cgd  * al contains the required alignment, len the length of a bit-field.
   1219        1.1       cgd  */
   1220        1.1       cgd static void
   1221       1.22     lukem align(int al, int len)
   1222        1.1       cgd {
   1223        1.1       cgd 	int	no;
   1224        1.1       cgd 
   1225        1.1       cgd 	/*
   1226        1.1       cgd 	 * The alignment of the current element becomes the alignment of
   1227        1.1       cgd 	 * the struct/union if it is larger than the current alignment
   1228        1.1       cgd 	 * of the struct/union.
   1229        1.1       cgd 	 */
   1230        1.3       jpo 	if (al > dcs->d_stralign)
   1231        1.3       jpo 		dcs->d_stralign = al;
   1232       1.22     lukem 
   1233        1.3       jpo 	no = (dcs->d_offset + (al - 1)) & ~(al - 1);
   1234        1.3       jpo 	if (len == 0 || dcs->d_offset + len > no)
   1235        1.3       jpo 		dcs->d_offset = no;
   1236        1.1       cgd }
   1237        1.1       cgd 
   1238        1.1       cgd /*
   1239        1.1       cgd  * Remember the width of the field in its type structure.
   1240        1.1       cgd  */
   1241        1.1       cgd sym_t *
   1242       1.22     lukem bitfield(sym_t *dsym, int len)
   1243        1.1       cgd {
   1244       1.22     lukem 
   1245        1.1       cgd 	if (dsym == NULL) {
   1246        1.1       cgd 		dsym = getblk(sizeof (sym_t));
   1247        1.1       cgd 		dsym->s_name = unnamed;
   1248        1.1       cgd 		dsym->s_kind = FMOS;
   1249        1.1       cgd 		dsym->s_scl = MOS;
   1250       1.20  sommerfe 		dsym->s_type = gettyp(UINT);
   1251        1.1       cgd 		dsym->s_blklev = -1;
   1252        1.1       cgd 	}
   1253        1.1       cgd 	dsym->s_type = duptyp(dsym->s_type);
   1254        1.1       cgd 	dsym->s_type->t_isfield = 1;
   1255        1.1       cgd 	dsym->s_type->t_flen = len;
   1256        1.1       cgd 	dsym->s_field = 1;
   1257        1.1       cgd 	return (dsym);
   1258        1.1       cgd }
   1259        1.1       cgd 
   1260        1.1       cgd /*
   1261        1.1       cgd  * Collect informations about a sequence of asterisks and qualifiers
   1262        1.1       cgd  * in a list of type pqinf_t.
   1263        1.1       cgd  * Qualifiers refer always to the left asterisk. The rightmost asterisk
   1264        1.1       cgd  * will be at the top of the list.
   1265        1.1       cgd  */
   1266        1.1       cgd pqinf_t *
   1267       1.22     lukem mergepq(pqinf_t *p1, pqinf_t *p2)
   1268        1.1       cgd {
   1269        1.1       cgd 	pqinf_t	*p;
   1270        1.1       cgd 
   1271        1.1       cgd 	if (p2->p_pcnt != 0) {
   1272        1.1       cgd 		/* left '*' at the end of the list */
   1273       1.22     lukem 		for (p = p2; p->p_nxt != NULL; p = p->p_nxt)
   1274       1.22     lukem 			continue;
   1275        1.1       cgd 		p->p_nxt = p1;
   1276        1.1       cgd 		return (p2);
   1277        1.1       cgd 	} else {
   1278        1.1       cgd 		if (p2->p_const) {
   1279        1.1       cgd 			if (p1->p_const) {
   1280        1.1       cgd 				/* duplicate %s */
   1281        1.1       cgd 				warning(10, "const");
   1282        1.1       cgd 			}
   1283        1.1       cgd 			p1->p_const = 1;
   1284        1.1       cgd 		}
   1285        1.1       cgd 		if (p2->p_volatile) {
   1286        1.1       cgd 			if (p1->p_volatile) {
   1287        1.1       cgd 				/* duplicate %s */
   1288        1.1       cgd 				warning(10, "volatile");
   1289        1.1       cgd 			}
   1290        1.1       cgd 			p1->p_volatile = 1;
   1291        1.1       cgd 		}
   1292        1.1       cgd 		free(p2);
   1293        1.1       cgd 		return (p1);
   1294        1.1       cgd 	}
   1295        1.1       cgd }
   1296        1.1       cgd 
   1297        1.1       cgd /*
   1298        1.1       cgd  * Followint 3 functions extend the type of a declarator with
   1299        1.1       cgd  * pointer, function and array types.
   1300        1.1       cgd  *
   1301        1.3       jpo  * The current type is the Type built by deftyp() (dcs->d_type) and
   1302        1.1       cgd  * pointer, function and array types already added for this
   1303        1.1       cgd  * declarator. The new type extension is inserted between both.
   1304        1.1       cgd  */
   1305        1.1       cgd sym_t *
   1306       1.22     lukem addptr(sym_t *decl, pqinf_t *pi)
   1307        1.1       cgd {
   1308        1.1       cgd 	type_t	**tpp, *tp;
   1309        1.1       cgd 	pqinf_t	*npi;
   1310        1.1       cgd 
   1311        1.1       cgd 	tpp = &decl->s_type;
   1312       1.18  christos 	while (*tpp && *tpp != dcs->d_type)
   1313        1.1       cgd 		tpp = &(*tpp)->t_subt;
   1314       1.18  christos 	if (*tpp == NULL)
   1315       1.18  christos 		return decl;
   1316        1.1       cgd 
   1317        1.1       cgd 	while (pi != NULL) {
   1318        1.1       cgd 		*tpp = tp = getblk(sizeof (type_t));
   1319        1.1       cgd 		tp->t_tspec = PTR;
   1320        1.1       cgd 		tp->t_const = pi->p_const;
   1321        1.1       cgd 		tp->t_volatile = pi->p_volatile;
   1322        1.3       jpo 		*(tpp = &tp->t_subt) = dcs->d_type;
   1323        1.1       cgd 		npi = pi->p_nxt;
   1324        1.1       cgd 		free(pi);
   1325        1.1       cgd 		pi = npi;
   1326        1.1       cgd 	}
   1327        1.1       cgd 	return (decl);
   1328        1.1       cgd }
   1329        1.1       cgd 
   1330        1.1       cgd /*
   1331        1.1       cgd  * If a dimension was specified, dim is 1, otherwise 0
   1332        1.1       cgd  * n is the specified dimension
   1333        1.1       cgd  */
   1334        1.1       cgd sym_t *
   1335       1.22     lukem addarray(sym_t *decl, int dim, int n)
   1336        1.1       cgd {
   1337        1.1       cgd 	type_t	**tpp, *tp;
   1338        1.1       cgd 
   1339        1.1       cgd 	tpp = &decl->s_type;
   1340       1.18  christos 	while (*tpp && *tpp != dcs->d_type)
   1341        1.1       cgd 		tpp = &(*tpp)->t_subt;
   1342       1.18  christos 	if (*tpp == NULL)
   1343       1.18  christos 	    return decl;
   1344        1.1       cgd 
   1345        1.1       cgd 	*tpp = tp = getblk(sizeof (type_t));
   1346        1.1       cgd 	tp->t_tspec = ARRAY;
   1347        1.3       jpo 	tp->t_subt = dcs->d_type;
   1348        1.1       cgd 	tp->t_dim = n;
   1349        1.1       cgd 
   1350        1.1       cgd 	if (n < 0) {
   1351       1.36  christos 		/* negative array dimension */
   1352       1.36  christos 		error(20, n);
   1353        1.1       cgd 		n = 0;
   1354        1.1       cgd 	} else if (n == 0 && dim) {
   1355       1.36  christos 		/* zero array dimension */
   1356       1.36  christos 		c99ism(322, dim);
   1357        1.1       cgd 	} else if (n == 0 && !dim) {
   1358        1.1       cgd 		/* is incomplete type */
   1359        1.1       cgd 		setcompl(tp, 1);
   1360        1.1       cgd 	}
   1361        1.1       cgd 
   1362        1.1       cgd 	return (decl);
   1363        1.1       cgd }
   1364        1.1       cgd 
   1365        1.1       cgd sym_t *
   1366       1.22     lukem addfunc(sym_t *decl, sym_t *args)
   1367        1.1       cgd {
   1368        1.1       cgd 	type_t	**tpp, *tp;
   1369        1.1       cgd 
   1370        1.3       jpo 	if (dcs->d_proto) {
   1371        1.1       cgd 		if (tflag)
   1372        1.1       cgd 			/* function prototypes are illegal in traditional C */
   1373        1.1       cgd 			warning(270);
   1374        1.1       cgd 		args = nsfunc(decl, args);
   1375        1.1       cgd 	} else {
   1376        1.1       cgd 		osfunc(decl, args);
   1377        1.1       cgd 	}
   1378        1.1       cgd 
   1379        1.1       cgd 	/*
   1380        1.1       cgd 	 * The symbols are removed from the symbol table by popdecl() after
   1381        1.1       cgd 	 * addfunc(). To be able to restore them if this is a function
   1382        1.1       cgd 	 * definition, a pointer to the list of all symbols is stored in
   1383        1.6       jpo 	 * dcs->d_nxt->d_fpsyms. Also a list of the arguments (concatenated
   1384        1.6       jpo 	 * by s_nxt) is stored in dcs->d_nxt->d_fargs.
   1385        1.3       jpo 	 * (dcs->d_nxt must be used because *dcs is the declaration stack
   1386        1.1       cgd 	 * element created for the list of params and is removed after
   1387        1.1       cgd 	 * addfunc())
   1388        1.1       cgd 	 */
   1389        1.3       jpo 	if (dcs->d_nxt->d_ctx == EXTERN &&
   1390        1.3       jpo 	    decl->s_type == dcs->d_nxt->d_type) {
   1391        1.3       jpo 		dcs->d_nxt->d_fpsyms = dcs->d_dlsyms;
   1392        1.3       jpo 		dcs->d_nxt->d_fargs = args;
   1393        1.1       cgd 	}
   1394        1.1       cgd 
   1395        1.1       cgd 	tpp = &decl->s_type;
   1396       1.18  christos 	while (*tpp && *tpp != dcs->d_nxt->d_type)
   1397        1.1       cgd 		tpp = &(*tpp)->t_subt;
   1398       1.18  christos 	if (*tpp == NULL)
   1399       1.18  christos 	    return decl;
   1400        1.1       cgd 
   1401        1.1       cgd 	*tpp = tp = getblk(sizeof (type_t));
   1402        1.1       cgd 	tp->t_tspec = FUNC;
   1403        1.3       jpo 	tp->t_subt = dcs->d_nxt->d_type;
   1404        1.3       jpo 	if ((tp->t_proto = dcs->d_proto) != 0)
   1405        1.1       cgd 		tp->t_args = args;
   1406        1.3       jpo 	tp->t_vararg = dcs->d_vararg;
   1407        1.1       cgd 
   1408        1.1       cgd 	return (decl);
   1409        1.1       cgd }
   1410        1.1       cgd 
   1411        1.1       cgd /*
   1412        1.1       cgd  * Called for new style function declarations.
   1413        1.1       cgd  */
   1414        1.1       cgd /* ARGSUSED */
   1415        1.1       cgd static sym_t *
   1416       1.22     lukem nsfunc(sym_t *decl, sym_t *args)
   1417        1.1       cgd {
   1418        1.1       cgd 	sym_t	*arg, *sym;
   1419        1.1       cgd 	scl_t	sc;
   1420        1.1       cgd 	int	n;
   1421        1.1       cgd 
   1422        1.1       cgd 	/*
   1423        1.1       cgd 	 * Declarations of structs/unions/enums in param lists are legal,
   1424        1.1       cgd 	 * but senseless.
   1425        1.1       cgd 	 */
   1426        1.3       jpo 	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
   1427        1.1       cgd 		sc = sym->s_scl;
   1428        1.1       cgd 		if (sc == STRTAG || sc == UNIONTAG || sc == ENUMTAG) {
   1429        1.1       cgd 			/* dubious tag declaration: %s %s */
   1430        1.1       cgd 			warning(85, scltoa(sc), sym->s_name);
   1431        1.1       cgd 		}
   1432        1.1       cgd 	}
   1433        1.1       cgd 
   1434        1.1       cgd 	n = 1;
   1435        1.1       cgd 	for (arg = args; arg != NULL; arg = arg->s_nxt) {
   1436        1.1       cgd 		if (arg->s_type->t_tspec == VOID) {
   1437        1.1       cgd 			if (n > 1 || arg->s_nxt != NULL) {
   1438        1.1       cgd 				/* "void" must be sole parameter */
   1439        1.1       cgd 				error(60);
   1440        1.1       cgd 				arg->s_type = gettyp(INT);
   1441        1.1       cgd 			}
   1442        1.1       cgd 		}
   1443        1.1       cgd 		n++;
   1444        1.1       cgd 	}
   1445        1.1       cgd 
   1446        1.1       cgd 	/* return NULL if first param is VOID */
   1447        1.1       cgd 	return (args != NULL && args->s_type->t_tspec != VOID ? args : NULL);
   1448        1.1       cgd }
   1449        1.1       cgd 
   1450        1.1       cgd /*
   1451        1.1       cgd  * Called for old style function declarations.
   1452        1.1       cgd  */
   1453        1.1       cgd static void
   1454       1.22     lukem osfunc(sym_t *decl, sym_t *args)
   1455        1.1       cgd {
   1456       1.22     lukem 
   1457        1.1       cgd 	/*
   1458        1.1       cgd 	 * Remember list of params only if this is really seams to be
   1459        1.1       cgd 	 * a function definition.
   1460        1.1       cgd 	 */
   1461        1.3       jpo 	if (dcs->d_nxt->d_ctx == EXTERN &&
   1462        1.3       jpo 	    decl->s_type == dcs->d_nxt->d_type) {
   1463        1.1       cgd 		/*
   1464        1.1       cgd 		 * We assume that this becomes a function definition. If
   1465       1.22     lukem 		 * we are wrong, its corrected in chkfdef().
   1466        1.1       cgd 		 */
   1467        1.1       cgd 		if (args != NULL) {
   1468        1.1       cgd 			decl->s_osdef = 1;
   1469        1.1       cgd 			decl->s_args = args;
   1470        1.1       cgd 		}
   1471        1.1       cgd 	} else {
   1472        1.1       cgd 		if (args != NULL)
   1473        1.1       cgd 			/* function prototype parameters must have types */
   1474        1.1       cgd 			warning(62);
   1475        1.1       cgd 	}
   1476        1.1       cgd }
   1477        1.1       cgd 
   1478        1.1       cgd /*
   1479        1.1       cgd  * Lists of Identifiers in functions declarations are allowed only if
   1480        1.1       cgd  * its also a function definition. If this is not the case, print a
   1481        1.1       cgd  * error message.
   1482        1.1       cgd  */
   1483        1.1       cgd void
   1484       1.22     lukem chkfdef(sym_t *sym, int msg)
   1485        1.1       cgd {
   1486       1.22     lukem 
   1487        1.1       cgd 	if (sym->s_osdef) {
   1488        1.1       cgd 		if (msg) {
   1489        1.1       cgd 			/* incomplete or misplaced function definition */
   1490        1.1       cgd 			error(22);
   1491        1.1       cgd 		}
   1492        1.1       cgd 		sym->s_osdef = 0;
   1493        1.1       cgd 		sym->s_args = NULL;
   1494        1.1       cgd 	}
   1495        1.1       cgd }
   1496        1.1       cgd 
   1497        1.1       cgd /*
   1498        1.1       cgd  * Process the name in a declarator.
   1499        1.1       cgd  * If the symbol does already exists, a new one is created.
   1500        1.1       cgd  * The symbol becomes one of the storage classes EXTERN, STATIC, AUTO or
   1501        1.1       cgd  * TYPEDEF.
   1502        1.1       cgd  * s_def and s_reg are valid after dname().
   1503        1.1       cgd  */
   1504        1.1       cgd sym_t *
   1505       1.22     lukem dname(sym_t *sym)
   1506        1.1       cgd {
   1507       1.14   mycroft 	scl_t	sc = NOSCL;
   1508        1.1       cgd 
   1509        1.1       cgd 	if (sym->s_scl == NOSCL) {
   1510        1.3       jpo 		dcs->d_rdcsym = NULL;
   1511        1.1       cgd 	} else if (sym->s_defarg) {
   1512        1.1       cgd 		sym->s_defarg = 0;
   1513        1.3       jpo 		dcs->d_rdcsym = NULL;
   1514        1.1       cgd 	} else {
   1515        1.3       jpo 		dcs->d_rdcsym = sym;
   1516        1.1       cgd 		sym = pushdown(sym);
   1517        1.1       cgd 	}
   1518        1.1       cgd 
   1519        1.3       jpo 	switch (dcs->d_ctx) {
   1520        1.1       cgd 	case MOS:
   1521        1.1       cgd 	case MOU:
   1522        1.1       cgd 		/* Parent setzen */
   1523        1.3       jpo 		sym->s_styp = dcs->d_tagtyp->t_str;
   1524        1.1       cgd 		sym->s_def = DEF;
   1525        1.1       cgd 		sym->s_value.v_tspec = INT;
   1526        1.3       jpo 		sc = dcs->d_ctx;
   1527        1.1       cgd 		break;
   1528        1.1       cgd 	case EXTERN:
   1529        1.1       cgd 		/*
   1530        1.1       cgd 		 * static and external symbols without "extern" are
   1531        1.1       cgd 		 * considered to be tentative defined, external
   1532        1.1       cgd 		 * symbols with "extern" are declared, and typedef names
   1533        1.1       cgd 		 * are defined. Tentative defined and declared symbols
   1534        1.1       cgd 		 * may become defined if an initializer is present or
   1535        1.1       cgd 		 * this is a function definition.
   1536        1.1       cgd 		 */
   1537        1.3       jpo 		if ((sc = dcs->d_scl) == NOSCL) {
   1538        1.1       cgd 			sc = EXTERN;
   1539        1.1       cgd 			sym->s_def = TDEF;
   1540        1.1       cgd 		} else if (sc == STATIC) {
   1541        1.1       cgd 			sym->s_def = TDEF;
   1542        1.1       cgd 		} else if (sc == TYPEDEF) {
   1543        1.1       cgd 			sym->s_def = DEF;
   1544        1.1       cgd 		} else if (sc == EXTERN) {
   1545        1.1       cgd 			sym->s_def = DECL;
   1546        1.1       cgd 		} else {
   1547       1.31  christos 			LERROR("dname()");
   1548        1.1       cgd 		}
   1549        1.1       cgd 		break;
   1550        1.1       cgd 	case PARG:
   1551        1.1       cgd 		sym->s_arg = 1;
   1552        1.1       cgd 		/* FALLTHROUGH */
   1553        1.1       cgd 	case ARG:
   1554        1.3       jpo 		if ((sc = dcs->d_scl) == NOSCL) {
   1555        1.1       cgd 			sc = AUTO;
   1556        1.1       cgd 		} else if (sc == REG) {
   1557        1.1       cgd 			sym->s_reg = 1;
   1558        1.1       cgd 			sc = AUTO;
   1559        1.1       cgd 		} else {
   1560       1.31  christos 			LERROR("dname()");
   1561        1.1       cgd 		}
   1562        1.1       cgd 		sym->s_def = DEF;
   1563        1.1       cgd 		break;
   1564        1.1       cgd 	case AUTO:
   1565        1.3       jpo 		if ((sc = dcs->d_scl) == NOSCL) {
   1566        1.1       cgd 			/*
   1567        1.1       cgd 			 * XXX somewhat ugly because we dont know whether
   1568        1.1       cgd 			 * this is AUTO or EXTERN (functions). If we are
   1569        1.1       cgd 			 * wrong it must be corrected in decl1loc(), where
   1570       1.23       wiz 			 * we have the necessary type information.
   1571        1.1       cgd 			 */
   1572        1.1       cgd 			sc = AUTO;
   1573        1.1       cgd 			sym->s_def = DEF;
   1574        1.1       cgd 		} else if (sc == AUTO || sc == STATIC || sc == TYPEDEF) {
   1575        1.1       cgd 			sym->s_def = DEF;
   1576        1.1       cgd 		} else if (sc == REG) {
   1577        1.1       cgd 			sym->s_reg = 1;
   1578        1.1       cgd 			sc = AUTO;
   1579        1.1       cgd 			sym->s_def = DEF;
   1580        1.1       cgd 		} else if (sc == EXTERN) {
   1581        1.1       cgd 			sym->s_def = DECL;
   1582        1.1       cgd 		} else {
   1583       1.31  christos 			LERROR("dname()");
   1584        1.1       cgd 		}
   1585        1.1       cgd 		break;
   1586        1.1       cgd 	default:
   1587       1.31  christos 		LERROR("dname()");
   1588        1.1       cgd 	}
   1589        1.1       cgd 	sym->s_scl = sc;
   1590        1.1       cgd 
   1591        1.3       jpo 	sym->s_type = dcs->d_type;
   1592        1.1       cgd 
   1593        1.3       jpo 	dcs->d_fpsyms = NULL;
   1594        1.1       cgd 
   1595        1.1       cgd 	return (sym);
   1596        1.1       cgd }
   1597        1.1       cgd 
   1598        1.1       cgd /*
   1599        1.1       cgd  * Process a name in the list of formal params in an old style function
   1600        1.1       cgd  * definition.
   1601        1.1       cgd  */
   1602        1.1       cgd sym_t *
   1603       1.22     lukem iname(sym_t *sym)
   1604        1.1       cgd {
   1605       1.22     lukem 
   1606        1.1       cgd 	if (sym->s_scl != NOSCL) {
   1607        1.1       cgd 		if (blklev == sym->s_blklev) {
   1608        1.1       cgd 			/* redeclaration of formal parameter %s */
   1609        1.1       cgd 			error(21, sym->s_name);
   1610        1.1       cgd 			if (!sym->s_defarg)
   1611       1.31  christos 				LERROR("iname()");
   1612        1.1       cgd 		}
   1613        1.1       cgd 		sym = pushdown(sym);
   1614        1.1       cgd 	}
   1615        1.1       cgd 	sym->s_type = gettyp(INT);
   1616        1.1       cgd 	sym->s_scl = AUTO;
   1617        1.1       cgd 	sym->s_def = DEF;
   1618        1.1       cgd 	sym->s_defarg = sym->s_arg = 1;
   1619        1.1       cgd 	return (sym);
   1620        1.1       cgd }
   1621        1.1       cgd 
   1622        1.1       cgd /*
   1623        1.1       cgd  * Create the type of a tag.
   1624        1.1       cgd  *
   1625        1.1       cgd  * tag points to the symbol table entry of the tag
   1626        1.1       cgd  * kind is the kind of the tag (STRUCT/UNION/ENUM)
   1627        1.1       cgd  * decl is 1 if the type of the tag will be completed in this declaration
   1628        1.1       cgd  * (the following token is T_LBRACE)
   1629        1.1       cgd  * semi is 1 if the following token is T_SEMI
   1630        1.1       cgd  */
   1631        1.1       cgd type_t *
   1632       1.22     lukem mktag(sym_t *tag, tspec_t kind, int decl, int semi)
   1633        1.1       cgd {
   1634       1.14   mycroft 	scl_t	scl = NOSCL;
   1635        1.1       cgd 	type_t	*tp;
   1636        1.1       cgd 
   1637        1.1       cgd 	if (kind == STRUCT) {
   1638        1.1       cgd 		scl = STRTAG;
   1639        1.1       cgd 	} else if (kind == UNION) {
   1640        1.1       cgd 		scl = UNIONTAG;
   1641        1.1       cgd 	} else if (kind == ENUM) {
   1642        1.1       cgd 		scl = ENUMTAG;
   1643        1.1       cgd 	} else {
   1644       1.31  christos 		LERROR("mktag()");
   1645        1.1       cgd 	}
   1646        1.1       cgd 
   1647        1.1       cgd 	if (tag != NULL) {
   1648        1.1       cgd 		if (tag->s_scl != NOSCL) {
   1649        1.1       cgd 			tag = newtag(tag, scl, decl, semi);
   1650        1.1       cgd 		} else {
   1651        1.1       cgd 			/* a new tag, no empty declaration */
   1652        1.3       jpo 			dcs->d_nxt->d_nedecl = 1;
   1653        1.1       cgd 			if (scl == ENUMTAG && !decl) {
   1654        1.1       cgd 				if (!tflag && (sflag || pflag))
   1655        1.1       cgd 					/* forward reference to enum type */
   1656        1.1       cgd 					warning(42);
   1657        1.1       cgd 			}
   1658        1.1       cgd 		}
   1659        1.1       cgd 		if (tag->s_scl == NOSCL) {
   1660        1.1       cgd 			tag->s_scl = scl;
   1661        1.1       cgd 			tag->s_type = tp = getblk(sizeof (type_t));
   1662       1.48  christos 			tp->t_ispacked = dcs->d_ispacked;
   1663        1.1       cgd 		} else {
   1664        1.1       cgd 			tp = tag->s_type;
   1665        1.1       cgd 		}
   1666        1.1       cgd 	} else {
   1667        1.1       cgd 		tag = getblk(sizeof (sym_t));
   1668        1.1       cgd 		tag->s_name = unnamed;
   1669       1.12       cgd 		UNIQUE_CURR_POS(tag->s_dpos);
   1670        1.1       cgd 		tag->s_kind = FTAG;
   1671        1.1       cgd 		tag->s_scl = scl;
   1672        1.1       cgd 		tag->s_blklev = -1;
   1673        1.1       cgd 		tag->s_type = tp = getblk(sizeof (type_t));
   1674       1.49  christos 		tp->t_ispacked = dcs->d_ispacked;
   1675        1.3       jpo 		dcs->d_nxt->d_nedecl = 1;
   1676        1.1       cgd 	}
   1677        1.1       cgd 
   1678        1.1       cgd 	if (tp->t_tspec == NOTSPEC) {
   1679        1.1       cgd 		tp->t_tspec = kind;
   1680        1.1       cgd 		if (kind != ENUM) {
   1681        1.1       cgd 			tp->t_str = getblk(sizeof (str_t));
   1682        1.1       cgd 			tp->t_str->align = CHAR_BIT;
   1683        1.1       cgd 			tp->t_str->stag = tag;
   1684        1.1       cgd 		} else {
   1685        1.1       cgd 			tp->t_isenum = 1;
   1686       1.55  christos 			tp->t_enum = getblk(sizeof(*tp->t_enum));
   1687        1.1       cgd 			tp->t_enum->etag = tag;
   1688        1.1       cgd 		}
   1689        1.1       cgd 		/* ist unvollstaendiger Typ */
   1690        1.1       cgd 		setcompl(tp, 1);
   1691        1.1       cgd 	}
   1692        1.1       cgd 	return (tp);
   1693        1.1       cgd }
   1694        1.1       cgd 
   1695        1.1       cgd /*
   1696        1.1       cgd  * Checks all possible cases of tag redeclarations.
   1697        1.1       cgd  * decl is 1 if T_LBRACE follows
   1698        1.1       cgd  * semi is 1 if T_SEMI follows
   1699        1.1       cgd  */
   1700        1.1       cgd static sym_t *
   1701       1.22     lukem newtag(sym_t *tag, scl_t scl, int decl, int semi)
   1702        1.1       cgd {
   1703       1.22     lukem 
   1704        1.1       cgd 	if (tag->s_blklev < blklev) {
   1705        1.1       cgd 		if (semi) {
   1706        1.1       cgd 			/* "struct a;" */
   1707        1.1       cgd 			if (!tflag) {
   1708        1.1       cgd 				if (!sflag)
   1709        1.1       cgd 					/* decl. introduces new type ... */
   1710        1.1       cgd 					warning(44, scltoa(scl), tag->s_name);
   1711        1.1       cgd 				tag = pushdown(tag);
   1712        1.1       cgd 			} else if (tag->s_scl != scl) {
   1713        1.1       cgd 				/* base type is really "%s %s" */
   1714        1.1       cgd 				warning(45, scltoa(tag->s_scl), tag->s_name);
   1715        1.1       cgd 			}
   1716        1.3       jpo 			dcs->d_nxt->d_nedecl = 1;
   1717        1.1       cgd 		} else if (decl) {
   1718       1.22     lukem 			/* "struct a { ... } " */
   1719        1.1       cgd 			if (hflag)
   1720        1.1       cgd 				/* redefinition hides earlier one: %s */
   1721        1.1       cgd 				warning(43, tag->s_name);
   1722        1.1       cgd 			tag = pushdown(tag);
   1723        1.3       jpo 			dcs->d_nxt->d_nedecl = 1;
   1724        1.1       cgd 		} else if (tag->s_scl != scl) {
   1725        1.1       cgd 			/* base type is really "%s %s" */
   1726        1.1       cgd 			warning(45, scltoa(tag->s_scl), tag->s_name);
   1727        1.1       cgd 			/* declaration introduces new type in ANSI C: %s %s */
   1728        1.1       cgd 			if (!sflag)
   1729        1.1       cgd 				warning(44, scltoa(scl), tag->s_name);
   1730        1.1       cgd 			tag = pushdown(tag);
   1731        1.3       jpo 			dcs->d_nxt->d_nedecl = 1;
   1732        1.1       cgd 		}
   1733        1.1       cgd 	} else {
   1734        1.1       cgd 		if (tag->s_scl != scl) {
   1735        1.1       cgd 			/* (%s) tag redeclared */
   1736        1.1       cgd 			error(46, scltoa(tag->s_scl));
   1737        1.6       jpo 			prevdecl(-1, tag);
   1738        1.1       cgd 			tag = pushdown(tag);
   1739        1.3       jpo 			dcs->d_nxt->d_nedecl = 1;
   1740        1.1       cgd 		} else if (decl && !incompl(tag->s_type)) {
   1741        1.1       cgd 			/* (%s) tag redeclared */
   1742        1.1       cgd 			error(46, scltoa(tag->s_scl));
   1743        1.6       jpo 			prevdecl(-1, tag);
   1744        1.1       cgd 			tag = pushdown(tag);
   1745        1.3       jpo 			dcs->d_nxt->d_nedecl = 1;
   1746        1.1       cgd 		} else if (semi || decl) {
   1747        1.3       jpo 			dcs->d_nxt->d_nedecl = 1;
   1748        1.1       cgd 		}
   1749        1.1       cgd 	}
   1750        1.1       cgd 	return (tag);
   1751        1.1       cgd }
   1752        1.1       cgd 
   1753        1.1       cgd const char *
   1754       1.22     lukem scltoa(scl_t sc)
   1755        1.1       cgd {
   1756        1.1       cgd 	const	char *s;
   1757        1.1       cgd 
   1758        1.1       cgd 	switch (sc) {
   1759        1.1       cgd 	case EXTERN:	s = "extern";	break;
   1760        1.1       cgd 	case STATIC:	s = "static";	break;
   1761        1.1       cgd 	case AUTO:	s = "auto";	break;
   1762        1.1       cgd 	case REG:	s = "register";	break;
   1763        1.1       cgd 	case TYPEDEF:	s = "typedef";	break;
   1764        1.1       cgd 	case STRTAG:	s = "struct";	break;
   1765        1.1       cgd 	case UNIONTAG:	s = "union";	break;
   1766        1.1       cgd 	case ENUMTAG:	s = "enum";	break;
   1767       1.31  christos 	default:	LERROR("tagttoa()");
   1768        1.1       cgd 	}
   1769        1.1       cgd 	return (s);
   1770        1.1       cgd }
   1771        1.1       cgd 
   1772        1.1       cgd /*
   1773        1.1       cgd  * tp points to the type of the, tag, fmem to the list of members/enums.
   1774        1.1       cgd  */
   1775        1.1       cgd type_t *
   1776       1.22     lukem compltag(type_t *tp, sym_t *fmem)
   1777        1.1       cgd {
   1778        1.1       cgd 	tspec_t	t;
   1779        1.1       cgd 	str_t	*sp;
   1780        1.1       cgd 	int	n;
   1781        1.1       cgd 	sym_t	*mem;
   1782        1.1       cgd 
   1783        1.1       cgd 	/* from now a complete type */
   1784        1.1       cgd 	setcompl(tp, 0);
   1785        1.1       cgd 
   1786        1.1       cgd 	if ((t = tp->t_tspec) != ENUM) {
   1787        1.3       jpo 		align(dcs->d_stralign, 0);
   1788        1.1       cgd 		sp = tp->t_str;
   1789        1.3       jpo 		sp->align = dcs->d_stralign;
   1790        1.1       cgd 		sp->memb = fmem;
   1791       1.48  christos 		if (tp->t_ispacked)
   1792       1.48  christos 			setpackedsize(tp);
   1793       1.48  christos 		else
   1794       1.48  christos 			sp->size = dcs->d_offset;
   1795       1.63  christos 
   1796        1.1       cgd 		if (sp->size == 0) {
   1797        1.1       cgd 			/* zero sized %s */
   1798       1.37  christos 			(void)c99ism(47, ttab[t].tt_name);
   1799       1.63  christos 		}
   1800       1.63  christos 
   1801       1.63  christos 		n = 0;
   1802       1.63  christos 		for (mem = fmem; mem != NULL; mem = mem->s_nxt) {
   1803       1.63  christos 			/* bind anonymous members to the structure */
   1804       1.63  christos 			if (mem->s_styp == NULL) {
   1805       1.63  christos 				mem->s_styp = sp;
   1806       1.65  christos 				if (mem->s_type->t_isfield) {
   1807       1.65  christos 					sp->size += bitfieldsize(&mem);
   1808       1.65  christos 					if (mem == NULL)
   1809       1.65  christos 						break;
   1810       1.65  christos 				}
   1811       1.63  christos 				sp->size += tsize(mem->s_type);
   1812       1.63  christos 			}
   1813       1.63  christos 			if (mem->s_name != unnamed)
   1814       1.63  christos 				n++;
   1815       1.63  christos 		}
   1816       1.63  christos 
   1817       1.64  christos 		if (n == 0 && sp->size != 0) {
   1818       1.63  christos 			/* %s has no named members */
   1819       1.64  christos 			warning(65, t == STRUCT ? "structure" : "union");
   1820        1.1       cgd 		}
   1821        1.1       cgd 	} else {
   1822        1.1       cgd 		tp->t_enum->elem = fmem;
   1823        1.1       cgd 	}
   1824        1.1       cgd 	return (tp);
   1825        1.1       cgd }
   1826        1.1       cgd 
   1827        1.1       cgd /*
   1828        1.1       cgd  * Processes the name of an enumerator in en enum declaration.
   1829        1.1       cgd  *
   1830        1.1       cgd  * sym points to the enumerator
   1831        1.1       cgd  * val is the value of the enumerator
   1832       1.16     soren  * impl is 1 if the value of the enumerator was not explicit specified.
   1833        1.1       cgd  */
   1834        1.1       cgd sym_t *
   1835       1.22     lukem ename(sym_t *sym, int val, int impl)
   1836        1.1       cgd {
   1837       1.22     lukem 
   1838        1.1       cgd 	if (sym->s_scl) {
   1839        1.1       cgd 		if (sym->s_blklev == blklev) {
   1840        1.1       cgd 			/* no hflag, because this is illegal!!! */
   1841        1.1       cgd 			if (sym->s_arg) {
   1842        1.1       cgd 				/* enumeration constant hides parameter: %s */
   1843        1.1       cgd 				warning(57, sym->s_name);
   1844        1.1       cgd 			} else {
   1845        1.1       cgd 				/* redeclaration of %s */
   1846        1.1       cgd 				error(27, sym->s_name);
   1847        1.1       cgd 				/*
   1848        1.1       cgd 				 * inside blocks it should not too complicated
   1849        1.1       cgd 				 * to find the position of the previous
   1850        1.1       cgd 				 * declaration
   1851        1.1       cgd 				 */
   1852        1.1       cgd 				if (blklev == 0)
   1853        1.6       jpo 					prevdecl(-1, sym);
   1854        1.1       cgd 			}
   1855        1.1       cgd 		} else {
   1856        1.1       cgd 			if (hflag)
   1857        1.1       cgd 				/* redefinition hides earlier one: %s */
   1858        1.1       cgd 				warning(43, sym->s_name);
   1859        1.1       cgd 		}
   1860        1.1       cgd 		sym = pushdown(sym);
   1861        1.1       cgd 	}
   1862        1.1       cgd 	sym->s_scl = ENUMCON;
   1863        1.3       jpo 	sym->s_type = dcs->d_tagtyp;
   1864        1.1       cgd 	sym->s_value.v_tspec = INT;
   1865        1.1       cgd 	sym->s_value.v_quad = val;
   1866       1.54  christos 	if (impl && val - 1 == TARG_INT_MAX) {
   1867        1.1       cgd 		/* overflow in enumeration values: %s */
   1868        1.1       cgd 		warning(48, sym->s_name);
   1869        1.1       cgd 	}
   1870        1.1       cgd 	enumval = val + 1;
   1871        1.1       cgd 	return (sym);
   1872        1.1       cgd }
   1873        1.1       cgd 
   1874        1.1       cgd /*
   1875        1.1       cgd  * Process a single external declarator.
   1876        1.1       cgd  */
   1877        1.1       cgd void
   1878       1.22     lukem decl1ext(sym_t *dsym, int initflg)
   1879        1.1       cgd {
   1880       1.44  dholland 	int	dowarn, rval, redec;
   1881        1.1       cgd 	sym_t	*rdsym;
   1882        1.1       cgd 
   1883        1.1       cgd 	chkfdef(dsym, 1);
   1884        1.1       cgd 
   1885        1.1       cgd 	chktyp(dsym);
   1886        1.1       cgd 
   1887        1.1       cgd 	if (initflg && !(initerr = chkinit(dsym)))
   1888        1.1       cgd 		dsym->s_def = DEF;
   1889        1.1       cgd 
   1890        1.1       cgd 	/*
   1891        1.1       cgd 	 * Declarations of functions are marked as "tentative" in dname().
   1892        1.1       cgd 	 * This is wrong because there are no tentative function
   1893        1.1       cgd 	 * definitions.
   1894        1.1       cgd 	 */
   1895        1.1       cgd 	if (dsym->s_type->t_tspec == FUNC && dsym->s_def == TDEF)
   1896        1.1       cgd 		dsym->s_def = DECL;
   1897        1.1       cgd 
   1898        1.4       jpo 	if (dcs->d_inline) {
   1899        1.4       jpo 		if (dsym->s_type->t_tspec == FUNC) {
   1900        1.4       jpo 			dsym->s_inline = 1;
   1901        1.4       jpo 		} else {
   1902        1.4       jpo 			/* variable declared inline: %s */
   1903        1.5       jpo 			warning(268, dsym->s_name);
   1904        1.4       jpo 		}
   1905        1.4       jpo 	}
   1906        1.4       jpo 
   1907        1.1       cgd 	/* Write the declaration into the output file */
   1908        1.1       cgd 	if (plibflg && llibflg &&
   1909        1.1       cgd 	    dsym->s_type->t_tspec == FUNC && dsym->s_type->t_proto) {
   1910        1.1       cgd 		/*
   1911        1.1       cgd 		 * With both LINTLIBRARY and PROTOLIB the prototyp is
   1912        1.1       cgd 		 * written as a function definition to the output file.
   1913        1.1       cgd 		 */
   1914        1.1       cgd 		rval = dsym->s_type->t_subt->t_tspec != VOID;
   1915        1.6       jpo 		outfdef(dsym, &dsym->s_dpos, rval, 0, NULL);
   1916        1.1       cgd 	} else {
   1917        1.4       jpo 		outsym(dsym, dsym->s_scl, dsym->s_def);
   1918        1.1       cgd 	}
   1919        1.1       cgd 
   1920        1.3       jpo 	if ((rdsym = dcs->d_rdcsym) != NULL) {
   1921        1.1       cgd 
   1922        1.1       cgd 		/*
   1923        1.1       cgd 		 * If the old symbol stems from a old style function definition
   1924        1.1       cgd 		 * we have remembered the params in rdsmy->s_args and compare
   1925        1.1       cgd 		 * them with the params of the prototype.
   1926        1.1       cgd 		 */
   1927        1.6       jpo 		if (rdsym->s_osdef && dsym->s_type->t_proto) {
   1928        1.6       jpo 			redec = chkosdef(rdsym, dsym);
   1929        1.6       jpo 		} else {
   1930        1.6       jpo 			redec = 0;
   1931        1.6       jpo 		}
   1932        1.1       cgd 
   1933       1.44  dholland 		if (!redec && !isredec(dsym, (dowarn = 0, &dowarn))) {
   1934       1.22     lukem 
   1935       1.44  dholland 			if (dowarn) {
   1936        1.1       cgd 				/* redeclaration of %s */
   1937        1.6       jpo 				(*(sflag ? error : warning))(27, dsym->s_name);
   1938        1.6       jpo 				prevdecl(-1, rdsym);
   1939        1.1       cgd 			}
   1940        1.1       cgd 
   1941        1.1       cgd 			/*
   1942        1.1       cgd 			 * Overtake the rememberd params if the new symbol
   1943        1.4       jpo 			 * is not a prototype.
   1944        1.1       cgd 			 */
   1945        1.1       cgd 			if (rdsym->s_osdef && !dsym->s_type->t_proto) {
   1946        1.1       cgd 				dsym->s_osdef = rdsym->s_osdef;
   1947        1.1       cgd 				dsym->s_args = rdsym->s_args;
   1948        1.1       cgd 				STRUCT_ASSIGN(dsym->s_dpos, rdsym->s_dpos);
   1949        1.1       cgd 			}
   1950        1.1       cgd 
   1951        1.1       cgd 			/*
   1952        1.1       cgd 			 * Remember the position of the declaration if the
   1953        1.4       jpo 			 * old symbol was a prototype and the new is not.
   1954        1.4       jpo 			 * Also remember the position if the old symbol
   1955        1.1       cgd 			 * was defined and the new is not.
   1956        1.1       cgd 			 */
   1957        1.1       cgd 			if (rdsym->s_type->t_proto && !dsym->s_type->t_proto) {
   1958        1.1       cgd 				STRUCT_ASSIGN(dsym->s_dpos, rdsym->s_dpos);
   1959        1.1       cgd 			} else if (rdsym->s_def == DEF && dsym->s_def != DEF) {
   1960        1.1       cgd 				STRUCT_ASSIGN(dsym->s_dpos, rdsym->s_dpos);
   1961        1.1       cgd 			}
   1962        1.1       cgd 
   1963        1.1       cgd 			/*
   1964        1.1       cgd 			 * Copy informations about usage of the name into
   1965        1.1       cgd 			 * the new symbol.
   1966        1.1       cgd 			 */
   1967        1.1       cgd 			cpuinfo(dsym, rdsym);
   1968        1.1       cgd 
   1969        1.1       cgd 			/* Once a name is defined, it remains defined. */
   1970        1.1       cgd 			if (rdsym->s_def == DEF)
   1971        1.1       cgd 				dsym->s_def = DEF;
   1972        1.1       cgd 
   1973        1.4       jpo 			/* once a function is inline, it remains inline */
   1974        1.4       jpo 			if (rdsym->s_inline)
   1975        1.4       jpo 				dsym->s_inline = 1;
   1976        1.4       jpo 
   1977        1.1       cgd 			compltyp(dsym, rdsym);
   1978        1.1       cgd 
   1979        1.1       cgd 		}
   1980       1.22     lukem 
   1981        1.1       cgd 		rmsym(rdsym);
   1982        1.1       cgd 	}
   1983        1.1       cgd 
   1984        1.1       cgd 	if (dsym->s_scl == TYPEDEF) {
   1985        1.1       cgd 		dsym->s_type = duptyp(dsym->s_type);
   1986        1.1       cgd 		dsym->s_type->t_typedef = 1;
   1987        1.1       cgd 		settdsym(dsym->s_type, dsym);
   1988        1.1       cgd 	}
   1989        1.1       cgd 
   1990        1.1       cgd }
   1991        1.1       cgd 
   1992        1.1       cgd /*
   1993        1.1       cgd  * Copies informations about usage into a new symbol table entry of
   1994        1.1       cgd  * the same symbol.
   1995        1.1       cgd  */
   1996        1.1       cgd void
   1997       1.22     lukem cpuinfo(sym_t *sym, sym_t *rdsym)
   1998        1.1       cgd {
   1999       1.22     lukem 
   2000        1.1       cgd 	sym->s_spos = rdsym->s_spos;
   2001        1.1       cgd 	sym->s_upos = rdsym->s_upos;
   2002        1.1       cgd 	sym->s_set = rdsym->s_set;
   2003        1.1       cgd 	sym->s_used = rdsym->s_used;
   2004        1.1       cgd }
   2005        1.1       cgd 
   2006        1.1       cgd /*
   2007        1.1       cgd  * Prints an error and returns 1 if a symbol is redeclared/redefined.
   2008        1.1       cgd  * Otherwise returns 0 and, in some cases of minor problems, prints
   2009        1.1       cgd  * a warning.
   2010        1.1       cgd  */
   2011        1.1       cgd int
   2012       1.44  dholland isredec(sym_t *dsym, int *dowarn)
   2013        1.1       cgd {
   2014        1.1       cgd 	sym_t	*rsym;
   2015        1.1       cgd 
   2016        1.3       jpo 	if ((rsym = dcs->d_rdcsym)->s_scl == ENUMCON) {
   2017        1.1       cgd 		/* redeclaration of %s */
   2018        1.1       cgd 		error(27, dsym->s_name);
   2019        1.6       jpo 		prevdecl(-1, rsym);
   2020        1.1       cgd 		return (1);
   2021        1.1       cgd 	}
   2022        1.1       cgd 	if (rsym->s_scl == TYPEDEF) {
   2023        1.1       cgd 		/* typedef redeclared: %s */
   2024        1.1       cgd 		error(89, dsym->s_name);
   2025        1.6       jpo 		prevdecl(-1, rsym);
   2026        1.1       cgd 		return (1);
   2027        1.1       cgd 	}
   2028        1.1       cgd 	if (dsym->s_scl == TYPEDEF) {
   2029        1.1       cgd 		/* redeclaration of %s */
   2030        1.1       cgd 		error(27, dsym->s_name);
   2031        1.6       jpo 		prevdecl(-1, rsym);
   2032        1.1       cgd 		return (1);
   2033        1.1       cgd 	}
   2034        1.1       cgd 	if (rsym->s_def == DEF && dsym->s_def == DEF) {
   2035        1.1       cgd 		/* redefinition of %s */
   2036        1.1       cgd 		error(28, dsym->s_name);
   2037        1.6       jpo 		prevdecl(-1, rsym);
   2038        1.1       cgd 		return(1);
   2039        1.1       cgd 	}
   2040       1.44  dholland 	if (!eqtype(rsym->s_type, dsym->s_type, 0, 0, dowarn)) {
   2041        1.1       cgd 		/* redeclaration of %s */
   2042        1.1       cgd 		error(27, dsym->s_name);
   2043        1.6       jpo 		prevdecl(-1, rsym);
   2044        1.1       cgd 		return(1);
   2045        1.1       cgd 	}
   2046        1.1       cgd 	if (rsym->s_scl == EXTERN && dsym->s_scl == EXTERN)
   2047        1.1       cgd 		return(0);
   2048        1.1       cgd 	if (rsym->s_scl == STATIC && dsym->s_scl == STATIC)
   2049        1.1       cgd 		return(0);
   2050        1.1       cgd 	if (rsym->s_scl == STATIC && dsym->s_def == DECL)
   2051        1.1       cgd 		return(0);
   2052        1.1       cgd 	if (rsym->s_scl == EXTERN && rsym->s_def == DEF) {
   2053        1.1       cgd 		/*
   2054       1.66     kamil 		 * All cases except "int a = 1; static int a;" are caught
   2055        1.1       cgd 		 * above with or without a warning
   2056        1.1       cgd 		 */
   2057        1.1       cgd 		/* redeclaration of %s */
   2058        1.1       cgd 		error(27, dsym->s_name);
   2059        1.6       jpo 		prevdecl(-1, rsym);
   2060        1.1       cgd 		return(1);
   2061        1.1       cgd 	}
   2062        1.1       cgd 	if (rsym->s_scl == EXTERN) {
   2063        1.1       cgd 		/* previously declared extern, becomes static: %s */
   2064        1.1       cgd 		warning(29, dsym->s_name);
   2065        1.6       jpo 		prevdecl(-1, rsym);
   2066        1.1       cgd 		return(0);
   2067        1.1       cgd 	}
   2068        1.1       cgd 	/*
   2069        1.1       cgd 	 * Now its on of:
   2070        1.1       cgd 	 * "static a; int a;", "static a; int a = 1;", "static a = 1; int a;"
   2071        1.1       cgd 	 */
   2072        1.1       cgd 	/* redeclaration of %s; ANSI C requires "static" */
   2073        1.1       cgd 	if (sflag) {
   2074        1.1       cgd 		warning(30, dsym->s_name);
   2075        1.6       jpo 		prevdecl(-1, rsym);
   2076        1.1       cgd 	}
   2077        1.1       cgd 	dsym->s_scl = STATIC;
   2078        1.1       cgd 	return (0);
   2079        1.1       cgd }
   2080        1.1       cgd 
   2081       1.45  christos static int
   2082       1.45  christos chkqual(type_t *tp1, type_t *tp2, int ignqual)
   2083       1.45  christos {
   2084       1.45  christos 	if (tp1->t_const != tp2->t_const && !ignqual && !tflag)
   2085       1.45  christos 		return 0;
   2086       1.45  christos 
   2087       1.45  christos 	if (tp1->t_volatile != tp2->t_volatile && !ignqual && !tflag)
   2088       1.45  christos 		return 0;
   2089       1.45  christos 
   2090       1.45  christos 	return 1;
   2091       1.45  christos }
   2092       1.45  christos 
   2093       1.45  christos int
   2094       1.45  christos eqptrtype(type_t *tp1, type_t *tp2, int ignqual)
   2095       1.45  christos {
   2096       1.45  christos 	if (tp1->t_tspec != VOID && tp2->t_tspec != VOID)
   2097       1.45  christos 		return 0;
   2098       1.45  christos 
   2099       1.45  christos 	if (!chkqual(tp1, tp2, ignqual))
   2100       1.45  christos 		return 0;
   2101       1.45  christos 
   2102       1.45  christos 	return 1;
   2103       1.45  christos }
   2104       1.45  christos 
   2105       1.45  christos 
   2106        1.1       cgd /*
   2107        1.1       cgd  * Checks if two types are compatible. Returns 0 if not, otherwise 1.
   2108        1.1       cgd  *
   2109        1.1       cgd  * ignqual	ignore qualifiers of type; used for function params
   2110       1.15   mycroft  * promot	promote left type; used for comparison of params of
   2111        1.1       cgd  *		old style function definitions with params of prototypes.
   2112       1.44  dholland  * *dowarn	set to 1 if an old style function declaration is not
   2113        1.1       cgd  *		compatible with a prototype
   2114        1.1       cgd  */
   2115        1.1       cgd int
   2116       1.44  dholland eqtype(type_t *tp1, type_t *tp2, int ignqual, int promot, int *dowarn)
   2117        1.1       cgd {
   2118        1.1       cgd 	tspec_t	t;
   2119        1.1       cgd 
   2120        1.1       cgd 	while (tp1 != NULL && tp2 != NULL) {
   2121        1.1       cgd 
   2122        1.1       cgd 		t = tp1->t_tspec;
   2123        1.1       cgd 		if (promot) {
   2124        1.1       cgd 			if (t == FLOAT) {
   2125        1.1       cgd 				t = DOUBLE;
   2126        1.1       cgd 			} else if (t == CHAR || t == SCHAR) {
   2127        1.1       cgd 				t = INT;
   2128        1.1       cgd 			} else if (t == UCHAR) {
   2129        1.1       cgd 				t = tflag ? UINT : INT;
   2130        1.1       cgd 			} else if (t == SHORT) {
   2131        1.1       cgd 				t = INT;
   2132        1.1       cgd 			} else if (t == USHORT) {
   2133        1.1       cgd 				/* CONSTCOND */
   2134       1.54  christos 				t = TARG_INT_MAX < TARG_USHRT_MAX || tflag ? UINT : INT;
   2135        1.1       cgd 			}
   2136        1.1       cgd 		}
   2137        1.1       cgd 
   2138        1.1       cgd 		if (t != tp2->t_tspec)
   2139        1.1       cgd 			return (0);
   2140        1.1       cgd 
   2141       1.45  christos 		if (!chkqual(tp1, tp2, ignqual))
   2142       1.45  christos 			return 0;
   2143        1.1       cgd 
   2144        1.1       cgd 		if (t == STRUCT || t == UNION)
   2145        1.1       cgd 			return (tp1->t_str == tp2->t_str);
   2146        1.1       cgd 
   2147        1.1       cgd 		if (t == ARRAY && tp1->t_dim != tp2->t_dim) {
   2148        1.1       cgd 			if (tp1->t_dim != 0 && tp2->t_dim != 0)
   2149        1.1       cgd 				return (0);
   2150        1.1       cgd 		}
   2151        1.1       cgd 
   2152        1.1       cgd 		/* dont check prototypes for traditional */
   2153        1.1       cgd 		if (t == FUNC && !tflag) {
   2154        1.1       cgd 			if (tp1->t_proto && tp2->t_proto) {
   2155       1.44  dholland 				if (!eqargs(tp1, tp2, dowarn))
   2156        1.1       cgd 					return (0);
   2157        1.1       cgd 			} else if (tp1->t_proto) {
   2158       1.44  dholland 				if (!mnoarg(tp1, dowarn))
   2159        1.1       cgd 					return (0);
   2160        1.1       cgd 			} else if (tp2->t_proto) {
   2161       1.44  dholland 				if (!mnoarg(tp2, dowarn))
   2162        1.1       cgd 					return (0);
   2163        1.1       cgd 			}
   2164        1.1       cgd 		}
   2165        1.1       cgd 
   2166        1.1       cgd 		tp1 = tp1->t_subt;
   2167        1.1       cgd 		tp2 = tp2->t_subt;
   2168        1.1       cgd 		ignqual = promot = 0;
   2169        1.1       cgd 
   2170        1.1       cgd 	}
   2171        1.1       cgd 
   2172        1.1       cgd 	return (tp1 == tp2);
   2173        1.1       cgd }
   2174        1.1       cgd 
   2175        1.1       cgd /*
   2176        1.6       jpo  * Compares the parameter types of two prototypes.
   2177        1.1       cgd  */
   2178        1.1       cgd static int
   2179       1.44  dholland eqargs(type_t *tp1, type_t *tp2, int *dowarn)
   2180        1.1       cgd {
   2181        1.1       cgd 	sym_t	*a1, *a2;
   2182        1.1       cgd 
   2183        1.1       cgd 	if (tp1->t_vararg != tp2->t_vararg)
   2184        1.1       cgd 		return (0);
   2185        1.1       cgd 
   2186        1.1       cgd 	a1 = tp1->t_args;
   2187        1.1       cgd 	a2 = tp2->t_args;
   2188        1.1       cgd 
   2189        1.1       cgd 	while (a1 != NULL && a2 != NULL) {
   2190        1.1       cgd 
   2191       1.44  dholland 		if (eqtype(a1->s_type, a2->s_type, 1, 0, dowarn) == 0)
   2192        1.1       cgd 			return (0);
   2193        1.1       cgd 
   2194        1.1       cgd 		a1 = a1->s_nxt;
   2195        1.1       cgd 		a2 = a2->s_nxt;
   2196        1.1       cgd 
   2197        1.1       cgd 	}
   2198        1.1       cgd 
   2199        1.1       cgd 	return (a1 == a2);
   2200        1.1       cgd }
   2201        1.1       cgd 
   2202        1.1       cgd /*
   2203        1.1       cgd  * mnoarg() (matches functions with no argument type information)
   2204        1.1       cgd  * returns 1 if all parameters of a prototype are compatible with
   2205        1.1       cgd  * and old style function declaration.
   2206        1.1       cgd  * This is the case if following conditions are met:
   2207        1.1       cgd  *	1. the prototype must have a fixed number of parameters
   2208        1.1       cgd  *	2. no parameter is of type float
   2209        1.1       cgd  *	3. no parameter is converted to another type if integer promotion
   2210        1.1       cgd  *	   is applied on it
   2211        1.1       cgd  */
   2212        1.1       cgd static int
   2213       1.44  dholland mnoarg(type_t *tp, int *dowarn)
   2214        1.1       cgd {
   2215        1.1       cgd 	sym_t	*arg;
   2216        1.1       cgd 	tspec_t	t;
   2217        1.1       cgd 
   2218        1.1       cgd 	if (tp->t_vararg) {
   2219       1.44  dholland 		if (dowarn != NULL)
   2220       1.44  dholland 			*dowarn = 1;
   2221        1.1       cgd 	}
   2222        1.1       cgd 	for (arg = tp->t_args; arg != NULL; arg = arg->s_nxt) {
   2223        1.1       cgd 		if ((t = arg->s_type->t_tspec) == FLOAT ||
   2224        1.1       cgd 		    t == CHAR || t == SCHAR || t == UCHAR ||
   2225        1.1       cgd 		    t == SHORT || t == USHORT) {
   2226       1.44  dholland 			if (dowarn != NULL)
   2227       1.44  dholland 				*dowarn = 1;
   2228        1.1       cgd 		}
   2229        1.1       cgd 	}
   2230        1.1       cgd 	return (1);
   2231        1.1       cgd }
   2232        1.1       cgd 
   2233        1.1       cgd /*
   2234        1.1       cgd  * Compares a prototype declaration with the remembered arguments of
   2235        1.1       cgd  * a previous old style function definition.
   2236        1.1       cgd  */
   2237        1.6       jpo static int
   2238       1.22     lukem chkosdef(sym_t *rdsym, sym_t *dsym)
   2239        1.1       cgd {
   2240        1.1       cgd 	sym_t	*args, *pargs, *arg, *parg;
   2241        1.1       cgd 	int	narg, nparg, n;
   2242       1.44  dholland 	int	dowarn, msg;
   2243        1.1       cgd 
   2244        1.1       cgd 	args = rdsym->s_args;
   2245        1.1       cgd 	pargs = dsym->s_type->t_args;
   2246        1.1       cgd 
   2247        1.6       jpo 	msg = 0;
   2248        1.1       cgd 
   2249        1.1       cgd 	narg = nparg = 0;
   2250        1.1       cgd 	for (arg = args; arg != NULL; arg = arg->s_nxt)
   2251        1.1       cgd 		narg++;
   2252        1.1       cgd 	for (parg = pargs; parg != NULL; parg = parg->s_nxt)
   2253        1.1       cgd 		nparg++;
   2254        1.1       cgd 	if (narg != nparg) {
   2255        1.1       cgd 		/* prototype does not match old-style definition */
   2256        1.1       cgd 		error(63);
   2257        1.6       jpo 		msg = 1;
   2258        1.1       cgd 		goto end;
   2259        1.1       cgd 	}
   2260        1.1       cgd 
   2261        1.1       cgd 	arg = args;
   2262        1.1       cgd 	parg = pargs;
   2263        1.1       cgd 	n = 1;
   2264        1.1       cgd 	while (narg--) {
   2265       1.44  dholland 		dowarn = 0;
   2266        1.1       cgd 		/*
   2267        1.1       cgd 		 * If it does not match due to promotion and sflag is
   2268        1.1       cgd 		 * not set we print only a warning.
   2269        1.1       cgd 		 */
   2270       1.44  dholland 		if (!eqtype(arg->s_type, parg->s_type, 1, 1, &dowarn) || dowarn) {
   2271        1.1       cgd 			/* prototype does not match old-style def., arg #%d */
   2272        1.1       cgd 			error(299, n);
   2273        1.6       jpo 			msg = 1;
   2274        1.1       cgd 		}
   2275        1.1       cgd 		arg = arg->s_nxt;
   2276        1.1       cgd 		parg = parg->s_nxt;
   2277        1.1       cgd 		n++;
   2278        1.1       cgd 	}
   2279        1.1       cgd 
   2280        1.1       cgd  end:
   2281        1.6       jpo 	if (msg)
   2282        1.7       jpo 		/* old style definition */
   2283        1.7       jpo 		prevdecl(300, rdsym);
   2284        1.6       jpo 
   2285        1.6       jpo 	return (msg);
   2286        1.1       cgd }
   2287        1.1       cgd 
   2288        1.1       cgd /*
   2289        1.1       cgd  * Complets a type by copying the dimension and prototype information
   2290        1.1       cgd  * from a second compatible type.
   2291        1.1       cgd  *
   2292        1.1       cgd  * Following lines are legal:
   2293        1.1       cgd  *  "typedef a[]; a b; a b[10]; a c; a c[20];"
   2294        1.1       cgd  *  "typedef ft(); ft f; f(int); ft g; g(long);"
   2295        1.1       cgd  * This means that, if a type is completed, the type structure must
   2296        1.1       cgd  * be duplicated.
   2297        1.1       cgd  */
   2298        1.1       cgd void
   2299       1.22     lukem compltyp(sym_t *dsym, sym_t *ssym)
   2300        1.1       cgd {
   2301        1.1       cgd 	type_t	**dstp, *src;
   2302        1.1       cgd 	type_t	*dst;
   2303        1.1       cgd 
   2304        1.1       cgd 	dstp = &dsym->s_type;
   2305        1.1       cgd 	src = ssym->s_type;
   2306        1.1       cgd 
   2307        1.1       cgd 	while ((dst = *dstp) != NULL) {
   2308        1.1       cgd 		if (src == NULL || dst->t_tspec != src->t_tspec)
   2309       1.31  christos 			LERROR("compltyp()");
   2310        1.1       cgd 		if (dst->t_tspec == ARRAY) {
   2311        1.1       cgd 			if (dst->t_dim == 0 && src->t_dim != 0) {
   2312        1.1       cgd 				*dstp = dst = duptyp(dst);
   2313        1.1       cgd 				dst->t_dim = src->t_dim;
   2314        1.1       cgd 				/* now a complete Typ */
   2315        1.1       cgd 				setcompl(dst, 0);
   2316        1.1       cgd 			}
   2317        1.1       cgd 		} else if (dst->t_tspec == FUNC) {
   2318        1.1       cgd 			if (!dst->t_proto && src->t_proto) {
   2319        1.1       cgd 				*dstp = dst = duptyp(dst);
   2320        1.1       cgd 				dst->t_proto = 1;
   2321        1.1       cgd 				dst->t_args = src->t_args;
   2322        1.1       cgd 			}
   2323        1.1       cgd 		}
   2324        1.1       cgd 		dstp = &dst->t_subt;
   2325        1.1       cgd 		src = src->t_subt;
   2326        1.1       cgd 	}
   2327        1.1       cgd }
   2328        1.1       cgd 
   2329        1.1       cgd /*
   2330        1.1       cgd  * Completes the declaration of a single argument.
   2331        1.1       cgd  */
   2332        1.1       cgd sym_t *
   2333       1.22     lukem decl1arg(sym_t *sym, int initflg)
   2334        1.1       cgd {
   2335        1.1       cgd 	tspec_t	t;
   2336        1.1       cgd 
   2337        1.1       cgd 	chkfdef(sym, 1);
   2338        1.1       cgd 
   2339        1.1       cgd 	chktyp(sym);
   2340        1.1       cgd 
   2341        1.3       jpo 	if (dcs->d_rdcsym != NULL && dcs->d_rdcsym->s_blklev == blklev) {
   2342        1.1       cgd 		/* redeclaration of formal parameter %s */
   2343        1.1       cgd 		error(237, sym->s_name);
   2344        1.3       jpo 		rmsym(dcs->d_rdcsym);
   2345        1.1       cgd 		sym->s_arg = 1;
   2346        1.1       cgd 	}
   2347        1.1       cgd 
   2348        1.1       cgd 	if (!sym->s_arg) {
   2349        1.1       cgd 		/* declared argument %s is missing */
   2350        1.1       cgd 		error(53, sym->s_name);
   2351        1.1       cgd 		sym->s_arg = 1;
   2352        1.1       cgd 	}
   2353        1.1       cgd 
   2354        1.1       cgd 	if (initflg) {
   2355        1.1       cgd 		/* cannot initialize parameter: %s */
   2356        1.1       cgd 		error(52, sym->s_name);
   2357        1.1       cgd 		initerr = 1;
   2358        1.1       cgd 	}
   2359        1.1       cgd 
   2360        1.1       cgd 	if ((t = sym->s_type->t_tspec) == ARRAY) {
   2361        1.1       cgd 		sym->s_type = incref(sym->s_type->t_subt, PTR);
   2362        1.1       cgd 	} else if (t == FUNC) {
   2363        1.1       cgd 		if (tflag)
   2364        1.1       cgd 			/* a function is declared as an argument: %s */
   2365        1.1       cgd 			warning(50, sym->s_name);
   2366        1.1       cgd 		sym->s_type = incref(sym->s_type, PTR);
   2367        1.1       cgd 	} else if (t == FLOAT) {
   2368        1.1       cgd 		if (tflag)
   2369        1.1       cgd 			sym->s_type = gettyp(DOUBLE);
   2370        1.1       cgd 	}
   2371        1.1       cgd 
   2372        1.4       jpo 	if (dcs->d_inline)
   2373        1.4       jpo 		/* argument declared inline: %s */
   2374        1.5       jpo 		warning(269, sym->s_name);
   2375        1.4       jpo 
   2376        1.1       cgd 	/*
   2377        1.1       cgd 	 * Arguments must have complete types. lengths() prints the needed
   2378        1.1       cgd 	 * error messages (null dimension is impossible because arrays are
   2379        1.1       cgd 	 * converted to pointers).
   2380        1.1       cgd 	 */
   2381        1.1       cgd 	if (sym->s_type->t_tspec != VOID)
   2382        1.1       cgd 		(void)length(sym->s_type, sym->s_name);
   2383        1.1       cgd 
   2384       1.67  christos 	sym->s_used = dcs->d_used;
   2385        1.1       cgd 	setsflg(sym);
   2386        1.1       cgd 
   2387        1.1       cgd 	return (sym);
   2388        1.1       cgd }
   2389        1.1       cgd 
   2390        1.1       cgd /*
   2391        1.1       cgd  * Does some checks for lint directives which apply to functions.
   2392        1.1       cgd  * Processes arguments in old style function definitions which default
   2393        1.1       cgd  * to int.
   2394        1.1       cgd  * Checks compatiblility of old style function definition with previous
   2395        1.1       cgd  * prototype.
   2396        1.1       cgd  */
   2397        1.1       cgd void
   2398       1.22     lukem cluparg(void)
   2399        1.1       cgd {
   2400        1.1       cgd 	sym_t	*args, *arg, *pargs, *parg;
   2401        1.6       jpo 	int	narg, nparg, n, msg;
   2402        1.1       cgd 	tspec_t	t;
   2403        1.1       cgd 
   2404        1.1       cgd 	args = funcsym->s_args;
   2405        1.1       cgd 	pargs = funcsym->s_type->t_args;
   2406        1.1       cgd 
   2407        1.1       cgd 	/* check for illegal combinations of lint directives */
   2408        1.1       cgd 	if (prflstrg != -1 && scflstrg != -1) {
   2409        1.1       cgd 		/* can't be used together: ** PRINTFLIKE ** ** SCANFLIKE ** */
   2410        1.1       cgd 		warning(289);
   2411        1.1       cgd 		prflstrg = scflstrg = -1;
   2412        1.1       cgd 	}
   2413        1.1       cgd 	if (nvararg != -1 && (prflstrg != -1 || scflstrg != -1)) {
   2414        1.1       cgd 		/* dubious use of ** VARARGS ** with ** %s ** */
   2415        1.1       cgd 		warning(288, prflstrg != -1 ? "PRINTFLIKE" : "SCANFLIKE");
   2416        1.1       cgd 		nvararg = -1;
   2417        1.1       cgd 	}
   2418        1.1       cgd 
   2419        1.1       cgd 	/*
   2420        1.1       cgd 	 * check if the argument of a lint directive is compatible with the
   2421        1.1       cgd 	 * number of arguments.
   2422        1.1       cgd 	 */
   2423        1.1       cgd 	narg = 0;
   2424        1.3       jpo 	for (arg = dcs->d_fargs; arg != NULL; arg = arg->s_nxt)
   2425        1.1       cgd 		narg++;
   2426        1.1       cgd 	if (nargusg > narg) {
   2427        1.1       cgd 		/* argument number mismatch with directive: ** %s ** */
   2428        1.1       cgd 		warning(283, "ARGSUSED");
   2429        1.1       cgd 		nargusg = 0;
   2430        1.1       cgd 	}
   2431        1.1       cgd 	if (nvararg > narg) {
   2432        1.1       cgd 		/* argument number mismatch with directive: ** %s ** */
   2433        1.1       cgd 		warning(283, "VARARGS");
   2434        1.1       cgd 		nvararg = 0;
   2435        1.1       cgd 	}
   2436        1.1       cgd 	if (prflstrg > narg) {
   2437        1.1       cgd 		/* argument number mismatch with directive: ** %s ** */
   2438        1.1       cgd 		warning(283, "PRINTFLIKE");
   2439        1.1       cgd 		prflstrg = -1;
   2440        1.1       cgd 	} else if (prflstrg == 0) {
   2441        1.1       cgd 		prflstrg = -1;
   2442        1.1       cgd 	}
   2443        1.1       cgd 	if (scflstrg > narg) {
   2444        1.1       cgd 		/* argument number mismatch with directive: ** %s ** */
   2445        1.1       cgd 		warning(283, "SCANFLIKE");
   2446        1.1       cgd 		scflstrg = -1;
   2447        1.1       cgd 	} else if (scflstrg == 0) {
   2448        1.1       cgd 		scflstrg = -1;
   2449        1.1       cgd 	}
   2450        1.1       cgd 	if (prflstrg != -1 || scflstrg != -1) {
   2451        1.1       cgd 		narg = prflstrg != -1 ? prflstrg : scflstrg;
   2452        1.6       jpo 		arg = dcs->d_fargs;
   2453        1.6       jpo 		for (n = 1; n < narg; n++)
   2454        1.6       jpo 			arg = arg->s_nxt;
   2455        1.1       cgd 		if (arg->s_type->t_tspec != PTR ||
   2456        1.1       cgd 		    ((t = arg->s_type->t_subt->t_tspec) != CHAR &&
   2457        1.1       cgd 		     t != UCHAR && t != SCHAR)) {
   2458        1.1       cgd 			/* arg. %d must be 'char *' for PRINTFLIKE/SCANFLIKE */
   2459        1.1       cgd 			warning(293, narg);
   2460        1.1       cgd 			prflstrg = scflstrg = -1;
   2461        1.1       cgd 		}
   2462        1.1       cgd 	}
   2463        1.1       cgd 
   2464        1.1       cgd 	/*
   2465        1.1       cgd 	 * print a warning for each argument off an old style function
   2466        1.1       cgd 	 * definition which defaults to int
   2467        1.1       cgd 	 */
   2468        1.1       cgd 	for (arg = args; arg != NULL; arg = arg->s_nxt) {
   2469        1.1       cgd 		if (arg->s_defarg) {
   2470        1.1       cgd 			/* argument type defaults to int: %s */
   2471        1.1       cgd 			warning(32, arg->s_name);
   2472        1.1       cgd 			arg->s_defarg = 0;
   2473        1.1       cgd 			setsflg(arg);
   2474        1.1       cgd 		}
   2475        1.1       cgd 	}
   2476        1.1       cgd 
   2477        1.1       cgd 	/*
   2478        1.1       cgd 	 * If this is an old style function definition and a prototyp
   2479        1.1       cgd 	 * exists, compare the types of arguments.
   2480        1.1       cgd 	 */
   2481        1.1       cgd 	if (funcsym->s_osdef && funcsym->s_type->t_proto) {
   2482        1.1       cgd 		/*
   2483        1.1       cgd 		 * If the number of arguments does not macht, we need not
   2484        1.1       cgd 		 * continue.
   2485        1.1       cgd 		 */
   2486        1.1       cgd 		narg = nparg = 0;
   2487        1.6       jpo 		msg = 0;
   2488        1.1       cgd 		for (parg = pargs; parg != NULL; parg = parg->s_nxt)
   2489        1.1       cgd 			nparg++;
   2490        1.1       cgd 		for (arg = args; arg != NULL; arg = arg->s_nxt)
   2491        1.1       cgd 			narg++;
   2492        1.1       cgd 		if (narg != nparg) {
   2493        1.1       cgd 			/* parameter mismatch: %d declared, %d defined */
   2494        1.1       cgd 			error(51, nparg, narg);
   2495        1.6       jpo 			msg = 1;
   2496        1.1       cgd 		} else {
   2497        1.1       cgd 			parg = pargs;
   2498        1.1       cgd 			arg = args;
   2499        1.1       cgd 			while (narg--) {
   2500        1.6       jpo 				msg |= chkptdecl(arg, parg);
   2501        1.1       cgd 				parg = parg->s_nxt;
   2502        1.1       cgd 				arg = arg->s_nxt;
   2503        1.1       cgd 			}
   2504        1.1       cgd 		}
   2505        1.6       jpo 		if (msg)
   2506        1.1       cgd 			/* prototype declaration */
   2507        1.6       jpo 			prevdecl(285, dcs->d_rdcsym);
   2508        1.6       jpo 
   2509        1.6       jpo 		/* from now the prototype is valid */
   2510        1.6       jpo 		funcsym->s_osdef = 0;
   2511        1.6       jpo 		funcsym->s_args = NULL;
   2512       1.22     lukem 
   2513        1.1       cgd 	}
   2514        1.1       cgd 
   2515        1.1       cgd }
   2516        1.1       cgd 
   2517        1.1       cgd /*
   2518        1.1       cgd  * Checks compatibility of an old style function definition with a previous
   2519        1.1       cgd  * prototype declaration.
   2520        1.1       cgd  * Returns 1 if the position of the previous declaration should be reported.
   2521        1.1       cgd  */
   2522        1.1       cgd static int
   2523       1.22     lukem chkptdecl(sym_t *arg, sym_t *parg)
   2524        1.1       cgd {
   2525        1.1       cgd 	type_t	*tp, *ptp;
   2526       1.44  dholland 	int	dowarn, msg;
   2527        1.1       cgd 
   2528        1.1       cgd 	tp = arg->s_type;
   2529        1.1       cgd 	ptp = parg->s_type;
   2530        1.1       cgd 
   2531        1.6       jpo 	msg = 0;
   2532       1.44  dholland 	dowarn = 0;
   2533        1.6       jpo 
   2534       1.44  dholland 	if (!eqtype(tp, ptp, 1, 1, &dowarn)) {
   2535       1.44  dholland 		if (eqtype(tp, ptp, 1, 0, &dowarn)) {
   2536        1.6       jpo 			/* type does not match prototype: %s */
   2537        1.6       jpo 			msg = gnuism(58, arg->s_name);
   2538        1.6       jpo 		} else {
   2539        1.6       jpo 			/* type does not match prototype: %s */
   2540        1.6       jpo 			error(58, arg->s_name);
   2541        1.6       jpo 			msg = 1;
   2542        1.6       jpo 		}
   2543       1.44  dholland 	} else if (dowarn) {
   2544        1.1       cgd 		/* type does not match prototype: %s */
   2545        1.6       jpo 		(*(sflag ? error : warning))(58, arg->s_name);
   2546        1.6       jpo 		msg = 1;
   2547        1.1       cgd 	}
   2548        1.6       jpo 
   2549        1.6       jpo 	return (msg);
   2550        1.1       cgd }
   2551        1.1       cgd 
   2552        1.1       cgd /*
   2553        1.1       cgd  * Completes a single local declaration/definition.
   2554        1.1       cgd  */
   2555        1.1       cgd void
   2556       1.22     lukem decl1loc(sym_t *dsym, int initflg)
   2557        1.1       cgd {
   2558       1.22     lukem 
   2559        1.1       cgd 	/* Correct a mistake done in dname(). */
   2560        1.1       cgd 	if (dsym->s_type->t_tspec == FUNC) {
   2561        1.1       cgd 		dsym->s_def = DECL;
   2562        1.3       jpo 		if (dcs->d_scl == NOSCL)
   2563        1.1       cgd 			dsym->s_scl = EXTERN;
   2564        1.1       cgd 	}
   2565        1.1       cgd 
   2566        1.1       cgd 	if (dsym->s_type->t_tspec == FUNC) {
   2567        1.1       cgd 		if (dsym->s_scl == STATIC) {
   2568        1.1       cgd 			/* dubious static function at block level: %s */
   2569        1.1       cgd 			warning(93, dsym->s_name);
   2570        1.1       cgd 			dsym->s_scl = EXTERN;
   2571        1.1       cgd 		} else if (dsym->s_scl != EXTERN && dsym->s_scl != TYPEDEF) {
   2572        1.1       cgd 			/* function has illegal storage class: %s */
   2573        1.1       cgd 			error(94, dsym->s_name);
   2574        1.1       cgd 			dsym->s_scl = EXTERN;
   2575        1.1       cgd 		}
   2576        1.1       cgd 	}
   2577        1.1       cgd 
   2578        1.4       jpo 	/*
   2579        1.4       jpo 	 * functions may be declared inline at local scope, although
   2580        1.4       jpo 	 * this has no effect for a later definition of the same
   2581        1.4       jpo 	 * function.
   2582        1.4       jpo 	 * XXX it should have an effect if tflag is set. this would
   2583        1.4       jpo 	 * also be the way gcc behaves.
   2584        1.4       jpo 	 */
   2585        1.4       jpo 	if (dcs->d_inline) {
   2586        1.4       jpo 		if (dsym->s_type->t_tspec == FUNC) {
   2587        1.4       jpo 			dsym->s_inline = 1;
   2588        1.4       jpo 		} else {
   2589        1.4       jpo 			/* variable declared inline: %s */
   2590        1.5       jpo 			warning(268, dsym->s_name);
   2591        1.4       jpo 		}
   2592        1.4       jpo 	}
   2593        1.4       jpo 
   2594        1.1       cgd 	chkfdef(dsym, 1);
   2595        1.1       cgd 
   2596        1.1       cgd 	chktyp(dsym);
   2597        1.1       cgd 
   2598        1.3       jpo 	if (dcs->d_rdcsym != NULL && dsym->s_scl == EXTERN)
   2599        1.1       cgd 		ledecl(dsym);
   2600        1.1       cgd 
   2601        1.1       cgd 	if (dsym->s_scl == EXTERN) {
   2602        1.1       cgd 		/*
   2603        1.1       cgd 		 * XXX wenn die statische Variable auf Ebene 0 erst
   2604        1.1       cgd 		 * spaeter definiert wird, haben wir die Brille auf.
   2605        1.1       cgd 		 */
   2606        1.1       cgd 		if (dsym->s_xsym == NULL) {
   2607        1.4       jpo 			outsym(dsym, EXTERN, dsym->s_def);
   2608        1.1       cgd 		} else {
   2609        1.4       jpo 			outsym(dsym, dsym->s_xsym->s_scl, dsym->s_def);
   2610        1.1       cgd 		}
   2611        1.1       cgd 	}
   2612        1.1       cgd 
   2613        1.3       jpo 	if (dcs->d_rdcsym != NULL) {
   2614        1.1       cgd 
   2615        1.3       jpo 		if (dcs->d_rdcsym->s_blklev == 0) {
   2616        1.1       cgd 
   2617        1.1       cgd 			switch (dsym->s_scl) {
   2618        1.1       cgd 			case AUTO:
   2619        1.1       cgd 				/* automatic hides external declaration: %s */
   2620        1.1       cgd 				if (hflag)
   2621        1.1       cgd 					warning(86, dsym->s_name);
   2622        1.1       cgd 				break;
   2623        1.1       cgd 			case STATIC:
   2624        1.1       cgd 				/* static hides external declaration: %s */
   2625        1.1       cgd 				if (hflag)
   2626        1.1       cgd 					warning(87, dsym->s_name);
   2627        1.1       cgd 				break;
   2628        1.1       cgd 			case TYPEDEF:
   2629        1.1       cgd 				/* typedef hides  external declaration: %s */
   2630        1.1       cgd 				if (hflag)
   2631        1.1       cgd 					warning(88, dsym->s_name);
   2632        1.1       cgd 				break;
   2633        1.1       cgd 			case EXTERN:
   2634        1.1       cgd 				/*
   2635        1.1       cgd 				 * Warnings and errors are printed in ledecl()
   2636        1.1       cgd 				 */
   2637        1.1       cgd 				break;
   2638        1.1       cgd 			default:
   2639       1.31  christos 				LERROR("decl1loc()");
   2640        1.1       cgd 			}
   2641        1.1       cgd 
   2642        1.3       jpo 		} else if (dcs->d_rdcsym->s_blklev == blklev) {
   2643        1.1       cgd 
   2644        1.1       cgd 			/* no hflag, because its illegal! */
   2645        1.3       jpo 			if (dcs->d_rdcsym->s_arg) {
   2646        1.7       jpo 				/*
   2647        1.7       jpo 				 * if !tflag, a "redeclaration of %s" error
   2648        1.7       jpo 				 * is produced below
   2649        1.7       jpo 				 */
   2650        1.7       jpo 				if (tflag) {
   2651        1.7       jpo 					if (hflag)
   2652        1.7       jpo 						/* decl. hides parameter: %s */
   2653        1.7       jpo 						warning(91, dsym->s_name);
   2654        1.7       jpo 					rmsym(dcs->d_rdcsym);
   2655        1.7       jpo 				}
   2656        1.1       cgd 			}
   2657        1.1       cgd 
   2658        1.3       jpo 		} else if (dcs->d_rdcsym->s_blklev < blklev) {
   2659        1.1       cgd 
   2660        1.1       cgd 			if (hflag)
   2661        1.1       cgd 				/* declaration hides earlier one: %s */
   2662        1.1       cgd 				warning(95, dsym->s_name);
   2663       1.22     lukem 
   2664        1.1       cgd 		}
   2665        1.1       cgd 
   2666        1.3       jpo 		if (dcs->d_rdcsym->s_blklev == blklev) {
   2667        1.1       cgd 
   2668        1.1       cgd 			/* redeclaration of %s */
   2669        1.1       cgd 			error(27, dsym->s_name);
   2670        1.3       jpo 			rmsym(dcs->d_rdcsym);
   2671        1.1       cgd 
   2672        1.1       cgd 		}
   2673        1.1       cgd 
   2674        1.1       cgd 	}
   2675        1.1       cgd 
   2676        1.1       cgd 	if (initflg && !(initerr = chkinit(dsym))) {
   2677        1.1       cgd 		dsym->s_def = DEF;
   2678        1.1       cgd 		setsflg(dsym);
   2679        1.1       cgd 	}
   2680        1.1       cgd 
   2681        1.1       cgd 	if (dsym->s_scl == TYPEDEF) {
   2682        1.1       cgd 		dsym->s_type = duptyp(dsym->s_type);
   2683        1.1       cgd 		dsym->s_type->t_typedef = 1;
   2684        1.1       cgd 		settdsym(dsym->s_type, dsym);
   2685        1.1       cgd 	}
   2686        1.1       cgd 
   2687        1.1       cgd 	/*
   2688        1.1       cgd 	 * Before we can check the size we must wait for a initialisation
   2689        1.1       cgd 	 * which may follow.
   2690        1.1       cgd 	 */
   2691        1.1       cgd }
   2692        1.1       cgd 
   2693        1.1       cgd /*
   2694        1.1       cgd  * Processes (re)declarations of external Symbols inside blocks.
   2695        1.1       cgd  */
   2696        1.1       cgd static void
   2697       1.22     lukem ledecl(sym_t *dsym)
   2698        1.1       cgd {
   2699       1.44  dholland 	int	eqt, dowarn;
   2700        1.1       cgd 	sym_t	*esym;
   2701        1.1       cgd 
   2702        1.1       cgd 	/* look for a symbol with the same name */
   2703        1.3       jpo 	esym = dcs->d_rdcsym;
   2704        1.1       cgd 	while (esym != NULL && esym->s_blklev != 0) {
   2705        1.1       cgd 		while ((esym = esym->s_link) != NULL) {
   2706        1.1       cgd 			if (esym->s_kind != FVFT)
   2707        1.1       cgd 				continue;
   2708        1.1       cgd 			if (strcmp(dsym->s_name, esym->s_name) == 0)
   2709        1.1       cgd 				break;
   2710        1.1       cgd 		}
   2711        1.1       cgd 	}
   2712        1.1       cgd 	if (esym == NULL)
   2713        1.1       cgd 		return;
   2714        1.1       cgd 	if (esym->s_scl != EXTERN && esym->s_scl != STATIC) {
   2715        1.1       cgd 		/* gcc accepts this without a warning, pcc prints an error. */
   2716        1.1       cgd 		/* redeclaration of %s */
   2717        1.1       cgd 		warning(27, dsym->s_name);
   2718        1.6       jpo 		prevdecl(-1, esym);
   2719        1.1       cgd 		return;
   2720        1.1       cgd 	}
   2721        1.1       cgd 
   2722       1.44  dholland 	dowarn = 0;
   2723       1.44  dholland 	eqt = eqtype(esym->s_type, dsym->s_type, 0, 0, &dowarn);
   2724        1.1       cgd 
   2725       1.44  dholland 	if (!eqt || dowarn) {
   2726        1.1       cgd 		if (esym->s_scl == EXTERN) {
   2727        1.1       cgd 			/* inconsistent redeclaration of extern: %s */
   2728        1.1       cgd 			warning(90, dsym->s_name);
   2729        1.6       jpo 			prevdecl(-1, esym);
   2730        1.1       cgd 		} else {
   2731        1.1       cgd 			/* inconsistent redeclaration of static: %s */
   2732        1.1       cgd 			warning(92, dsym->s_name);
   2733        1.6       jpo 			prevdecl(-1, esym);
   2734        1.1       cgd 		}
   2735        1.1       cgd 	}
   2736        1.1       cgd 
   2737        1.1       cgd 	if (eqt) {
   2738        1.1       cgd 		/*
   2739        1.1       cgd 		 * Remember the external symbol so we can update usage
   2740        1.1       cgd 		 * information at the end of the block.
   2741        1.1       cgd 		 */
   2742        1.1       cgd 		dsym->s_xsym = esym;
   2743        1.1       cgd 	}
   2744        1.1       cgd }
   2745        1.1       cgd 
   2746        1.1       cgd /*
   2747        1.1       cgd  * Print an error or a warning if the symbol cant be initialized due
   2748        1.1       cgd  * to type/storage class. Returnvalue is 1 if an error has been
   2749        1.1       cgd  * detected.
   2750        1.1       cgd  */
   2751        1.1       cgd static int
   2752       1.22     lukem chkinit(sym_t *sym)
   2753        1.1       cgd {
   2754       1.44  dholland 	int	erred;
   2755        1.1       cgd 
   2756       1.44  dholland 	erred = 0;
   2757        1.1       cgd 
   2758        1.1       cgd 	if (sym->s_type->t_tspec == FUNC) {
   2759        1.1       cgd 		/* cannot initialize function: %s */
   2760        1.1       cgd 		error(24, sym->s_name);
   2761       1.44  dholland 		erred = 1;
   2762        1.1       cgd 	} else if (sym->s_scl == TYPEDEF) {
   2763        1.1       cgd 		/* cannot initialize typedef: %s */
   2764        1.1       cgd 		error(25, sym->s_name);
   2765       1.44  dholland 		erred = 1;
   2766        1.1       cgd 	} else if (sym->s_scl == EXTERN && sym->s_def == DECL) {
   2767        1.1       cgd 		/* cannot initialize "extern" declaration: %s */
   2768        1.3       jpo 		if (dcs->d_ctx == EXTERN) {
   2769        1.1       cgd 			warning(26, sym->s_name);
   2770        1.1       cgd 		} else {
   2771        1.1       cgd 			error(26, sym->s_name);
   2772       1.44  dholland 			erred = 1;
   2773        1.1       cgd 		}
   2774        1.1       cgd 	}
   2775        1.1       cgd 
   2776       1.44  dholland 	return (erred);
   2777        1.1       cgd }
   2778        1.1       cgd 
   2779        1.1       cgd /*
   2780        1.1       cgd  * Create a symbole for an abstract declaration.
   2781        1.1       cgd  */
   2782        1.1       cgd sym_t *
   2783       1.22     lukem aname(void)
   2784        1.1       cgd {
   2785        1.1       cgd 	sym_t	*sym;
   2786        1.1       cgd 
   2787        1.3       jpo 	if (dcs->d_ctx != ABSTRACT && dcs->d_ctx != PARG)
   2788       1.31  christos 		LERROR("aname()");
   2789        1.1       cgd 
   2790        1.1       cgd 	sym = getblk(sizeof (sym_t));
   2791        1.1       cgd 
   2792        1.1       cgd 	sym->s_name = unnamed;
   2793        1.1       cgd 	sym->s_def = DEF;
   2794        1.1       cgd 	sym->s_scl = ABSTRACT;
   2795        1.1       cgd 	sym->s_blklev = -1;
   2796        1.1       cgd 
   2797        1.3       jpo 	if (dcs->d_ctx == PARG)
   2798        1.1       cgd 		sym->s_arg = 1;
   2799        1.1       cgd 
   2800        1.3       jpo 	sym->s_type = dcs->d_type;
   2801        1.3       jpo 	dcs->d_rdcsym = NULL;
   2802        1.3       jpo 	dcs->d_vararg = 0;
   2803        1.1       cgd 
   2804        1.1       cgd 	return (sym);
   2805        1.1       cgd }
   2806        1.1       cgd 
   2807        1.1       cgd /*
   2808        1.1       cgd  * Removes anything which has nothing to do on global level.
   2809        1.1       cgd  */
   2810        1.1       cgd void
   2811       1.22     lukem globclup(void)
   2812        1.1       cgd {
   2813       1.22     lukem 
   2814        1.3       jpo 	while (dcs->d_nxt != NULL)
   2815        1.1       cgd 		popdecl();
   2816        1.1       cgd 
   2817        1.1       cgd 	cleanup();
   2818        1.1       cgd 	blklev = 0;
   2819        1.1       cgd 	mblklev = 0;
   2820        1.1       cgd 
   2821        1.1       cgd 	/*
   2822        1.1       cgd 	 * remove all informations about pending lint directives without
   2823        1.1       cgd 	 * warnings.
   2824        1.1       cgd 	 */
   2825       1.10       jpo 	glclup(1);
   2826        1.1       cgd }
   2827        1.1       cgd 
   2828        1.1       cgd /*
   2829        1.1       cgd  * Process an abstract type declaration
   2830        1.1       cgd  */
   2831        1.1       cgd sym_t *
   2832       1.22     lukem decl1abs(sym_t *sym)
   2833        1.1       cgd {
   2834       1.22     lukem 
   2835        1.1       cgd 	chkfdef(sym, 1);
   2836        1.1       cgd 	chktyp(sym);
   2837        1.1       cgd 	return (sym);
   2838        1.1       cgd }
   2839        1.1       cgd 
   2840        1.1       cgd /*
   2841        1.1       cgd  * Checks size after declarations of variables and their initialisation.
   2842        1.1       cgd  */
   2843        1.1       cgd void
   2844       1.22     lukem chksz(sym_t *dsym)
   2845        1.1       cgd {
   2846       1.22     lukem 
   2847        1.1       cgd 	/*
   2848        1.1       cgd 	 * check size only for symbols which are defined and no function and
   2849        1.1       cgd 	 * not typedef name
   2850        1.1       cgd 	 */
   2851        1.1       cgd 	if (dsym->s_def != DEF)
   2852        1.1       cgd 		return;
   2853        1.1       cgd 	if (dsym->s_scl == TYPEDEF)
   2854        1.1       cgd 		return;
   2855        1.1       cgd 	if (dsym->s_type->t_tspec == FUNC)
   2856        1.1       cgd 		return;
   2857        1.1       cgd 
   2858        1.1       cgd 	if (length(dsym->s_type, dsym->s_name) == 0 &&
   2859        1.1       cgd 	    dsym->s_type->t_tspec == ARRAY && dsym->s_type->t_dim == 0) {
   2860        1.1       cgd 		/* empty array declaration: %s */
   2861        1.1       cgd 		if (tflag) {
   2862        1.1       cgd 			warning(190, dsym->s_name);
   2863        1.1       cgd 		} else {
   2864        1.1       cgd 			error(190, dsym->s_name);
   2865        1.1       cgd 		}
   2866        1.1       cgd 	}
   2867        1.1       cgd }
   2868        1.1       cgd 
   2869        1.1       cgd /*
   2870        1.1       cgd  * Mark an object as set if it is not already
   2871        1.1       cgd  */
   2872        1.1       cgd void
   2873       1.22     lukem setsflg(sym_t *sym)
   2874        1.1       cgd {
   2875       1.22     lukem 
   2876        1.1       cgd 	if (!sym->s_set) {
   2877        1.1       cgd 		sym->s_set = 1;
   2878       1.12       cgd 		UNIQUE_CURR_POS(sym->s_spos);
   2879        1.1       cgd 	}
   2880        1.1       cgd }
   2881        1.1       cgd 
   2882        1.1       cgd /*
   2883        1.1       cgd  * Mark an object as used if it is not already
   2884        1.1       cgd  */
   2885        1.1       cgd void
   2886       1.22     lukem setuflg(sym_t *sym, int fcall, int szof)
   2887        1.1       cgd {
   2888       1.22     lukem 
   2889        1.1       cgd 	if (!sym->s_used) {
   2890        1.1       cgd 		sym->s_used = 1;
   2891       1.12       cgd 		UNIQUE_CURR_POS(sym->s_upos);
   2892        1.1       cgd 	}
   2893        1.1       cgd 	/*
   2894        1.1       cgd 	 * for function calls another record is written
   2895        1.1       cgd 	 *
   2896        1.1       cgd 	 * XXX Should symbols used in sizeof() treated as used or not?
   2897        1.1       cgd 	 * Probably not, because there is no sense to declare an
   2898        1.1       cgd 	 * external variable only to get their size.
   2899        1.1       cgd 	 */
   2900        1.1       cgd 	if (!fcall && !szof && sym->s_kind == FVFT && sym->s_scl == EXTERN)
   2901        1.1       cgd 		outusg(sym);
   2902        1.1       cgd }
   2903        1.1       cgd 
   2904        1.1       cgd /*
   2905        1.1       cgd  * Prints warnings for a list of variables and labels (concatenated
   2906        1.1       cgd  * with s_dlnxt) if these are not used or only set.
   2907        1.1       cgd  */
   2908        1.1       cgd void
   2909       1.22     lukem chkusage(dinfo_t *di)
   2910        1.1       cgd {
   2911        1.1       cgd 	sym_t	*sym;
   2912       1.56  christos 	int	mklwarn;
   2913        1.1       cgd 
   2914       1.57  christos 	/* for this warning LINTED has no effect */
   2915       1.56  christos 	mklwarn = lwarn;
   2916       1.56  christos 	lwarn = LWARN_ALL;
   2917        1.1       cgd 
   2918       1.38  christos #ifdef DEBUG
   2919       1.56  christos 	printf("%s, %d: >temp lwarn = %d\n", curr_pos.p_file, curr_pos.p_line,
   2920       1.56  christos 	    lwarn);
   2921       1.38  christos #endif
   2922       1.10       jpo 	for (sym = di->d_dlsyms; sym != NULL; sym = sym->s_dlnxt)
   2923       1.10       jpo 		chkusg1(di->d_asm, sym);
   2924       1.56  christos 	lwarn = mklwarn;
   2925       1.38  christos #ifdef DEBUG
   2926       1.56  christos 	printf("%s, %d: <temp lwarn = %d\n", curr_pos.p_file, curr_pos.p_line,
   2927       1.56  christos 	    lwarn);
   2928       1.38  christos #endif
   2929        1.1       cgd }
   2930        1.1       cgd 
   2931        1.1       cgd /*
   2932        1.1       cgd  * Prints a warning for a single variable or label if it is not used or
   2933        1.1       cgd  * only set.
   2934        1.1       cgd  */
   2935        1.1       cgd void
   2936       1.22     lukem chkusg1(int novar, sym_t *sym)
   2937        1.1       cgd {
   2938        1.1       cgd 	pos_t	cpos;
   2939        1.1       cgd 
   2940        1.1       cgd 	if (sym->s_blklev == -1)
   2941        1.1       cgd 		return;
   2942        1.1       cgd 
   2943        1.1       cgd 	STRUCT_ASSIGN(cpos, curr_pos);
   2944        1.1       cgd 
   2945        1.1       cgd 	if (sym->s_kind == FVFT) {
   2946        1.1       cgd 		if (sym->s_arg) {
   2947       1.10       jpo 			chkausg(novar, sym);
   2948        1.1       cgd 		} else {
   2949       1.10       jpo 			chkvusg(novar, sym);
   2950        1.1       cgd 		}
   2951        1.1       cgd 	} else if (sym->s_kind == FLAB) {
   2952        1.1       cgd 		chklusg(sym);
   2953        1.1       cgd 	} else if (sym->s_kind == FTAG) {
   2954        1.1       cgd 		chktusg(sym);
   2955        1.1       cgd 	}
   2956        1.1       cgd 
   2957        1.1       cgd 	STRUCT_ASSIGN(curr_pos, cpos);
   2958        1.1       cgd }
   2959        1.1       cgd 
   2960        1.1       cgd static void
   2961       1.22     lukem chkausg(int novar, sym_t *arg)
   2962        1.1       cgd {
   2963       1.22     lukem 
   2964        1.1       cgd 	if (!arg->s_set)
   2965       1.31  christos 		LERROR("chkausg()");
   2966        1.1       cgd 
   2967       1.10       jpo 	if (novar)
   2968       1.10       jpo 		return;
   2969       1.10       jpo 
   2970        1.1       cgd 	if (!arg->s_used && vflag) {
   2971        1.1       cgd 		STRUCT_ASSIGN(curr_pos, arg->s_dpos);
   2972        1.1       cgd 		/* argument %s unused in function %s */
   2973        1.1       cgd 		warning(231, arg->s_name, funcsym->s_name);
   2974        1.1       cgd 	}
   2975        1.1       cgd }
   2976        1.1       cgd 
   2977        1.1       cgd static void
   2978       1.22     lukem chkvusg(int novar, sym_t *sym)
   2979        1.1       cgd {
   2980        1.1       cgd 	scl_t	sc;
   2981        1.1       cgd 	sym_t	*xsym;
   2982        1.1       cgd 
   2983        1.1       cgd 	if (blklev == 0 || sym->s_blklev == 0)
   2984       1.31  christos 		LERROR("chkvusg()");
   2985        1.1       cgd 
   2986        1.1       cgd 	/* errors in expressions easily cause lots of these warnings */
   2987        1.1       cgd 	if (nerr != 0)
   2988        1.1       cgd 		return;
   2989        1.1       cgd 
   2990        1.1       cgd 	/*
   2991       1.10       jpo 	 * XXX Only variables are checkd, although types should
   2992        1.1       cgd 	 * probably also be checked
   2993        1.1       cgd 	 */
   2994        1.1       cgd 	if ((sc = sym->s_scl) != EXTERN && sc != STATIC &&
   2995        1.1       cgd 	    sc != AUTO && sc != REG) {
   2996        1.1       cgd 		return;
   2997        1.1       cgd 	}
   2998       1.10       jpo 
   2999       1.10       jpo 	if (novar)
   3000       1.10       jpo 		return;
   3001        1.1       cgd 
   3002        1.1       cgd 	if (sc == EXTERN) {
   3003        1.1       cgd 		if (!sym->s_used && !sym->s_set) {
   3004        1.1       cgd 			STRUCT_ASSIGN(curr_pos, sym->s_dpos);
   3005        1.1       cgd 			/* %s unused in function %s */
   3006        1.1       cgd 			warning(192, sym->s_name, funcsym->s_name);
   3007        1.1       cgd 		}
   3008        1.1       cgd 	} else {
   3009        1.1       cgd 		if (sym->s_set && !sym->s_used) {
   3010        1.1       cgd 			STRUCT_ASSIGN(curr_pos, sym->s_spos);
   3011        1.1       cgd 			/* %s set but not used in function %s */
   3012        1.1       cgd 			warning(191, sym->s_name, funcsym->s_name);
   3013        1.1       cgd 		} else if (!sym->s_used) {
   3014        1.1       cgd 			STRUCT_ASSIGN(curr_pos, sym->s_dpos);
   3015        1.1       cgd 			/* %s unused in function %s */
   3016        1.1       cgd 			warning(192, sym->s_name, funcsym->s_name);
   3017        1.1       cgd 		}
   3018        1.1       cgd 	}
   3019        1.1       cgd 
   3020        1.1       cgd 	if (sc == EXTERN) {
   3021        1.1       cgd 		/*
   3022        1.1       cgd 		 * information about usage is taken over into the symbol
   3023        1.1       cgd 		 * tabel entry at level 0 if the symbol was locally declared
   3024        1.1       cgd 		 * as an external symbol.
   3025        1.1       cgd 		 *
   3026        1.1       cgd 		 * XXX This is wrong for symbols declared static at level 0
   3027        1.1       cgd 		 * if the usage information stems from sizeof(). This is
   3028        1.1       cgd 		 * because symbols at level 0 only used in sizeof() are
   3029        1.1       cgd 		 * considered to not be used.
   3030        1.1       cgd 		 */
   3031        1.1       cgd 		if ((xsym = sym->s_xsym) != NULL) {
   3032        1.1       cgd 			if (sym->s_used && !xsym->s_used) {
   3033        1.1       cgd 				xsym->s_used = 1;
   3034        1.1       cgd 				STRUCT_ASSIGN(xsym->s_upos, sym->s_upos);
   3035        1.1       cgd 			}
   3036        1.1       cgd 			if (sym->s_set && !xsym->s_set) {
   3037        1.1       cgd 				xsym->s_set = 1;
   3038        1.1       cgd 				STRUCT_ASSIGN(xsym->s_spos, sym->s_spos);
   3039        1.1       cgd 			}
   3040        1.1       cgd 		}
   3041        1.1       cgd 	}
   3042        1.1       cgd }
   3043        1.1       cgd 
   3044        1.1       cgd static void
   3045       1.22     lukem chklusg(sym_t *lab)
   3046        1.1       cgd {
   3047       1.22     lukem 
   3048        1.1       cgd 	if (blklev != 1 || lab->s_blklev != 1)
   3049       1.31  christos 		LERROR("chklusg()");
   3050        1.1       cgd 
   3051        1.1       cgd 	if (lab->s_set && !lab->s_used) {
   3052        1.1       cgd 		STRUCT_ASSIGN(curr_pos, lab->s_spos);
   3053        1.1       cgd 		/* label %s unused in function %s */
   3054        1.1       cgd 		warning(192, lab->s_name, funcsym->s_name);
   3055        1.1       cgd 	} else if (!lab->s_set) {
   3056        1.1       cgd 		STRUCT_ASSIGN(curr_pos, lab->s_upos);
   3057        1.1       cgd 		/* undefined label %s */
   3058        1.1       cgd 		warning(23, lab->s_name);
   3059        1.1       cgd 	}
   3060        1.1       cgd }
   3061        1.1       cgd 
   3062        1.1       cgd static void
   3063       1.22     lukem chktusg(sym_t *sym)
   3064        1.1       cgd {
   3065       1.22     lukem 
   3066        1.1       cgd 	if (!incompl(sym->s_type))
   3067        1.1       cgd 		return;
   3068        1.1       cgd 
   3069        1.1       cgd 	/* complain alwasy about incomplet tags declared inside blocks */
   3070        1.3       jpo 	if (!zflag || dcs->d_ctx != EXTERN)
   3071        1.1       cgd 		return;
   3072        1.1       cgd 
   3073        1.1       cgd 	STRUCT_ASSIGN(curr_pos, sym->s_dpos);
   3074        1.1       cgd 	switch (sym->s_type->t_tspec) {
   3075        1.1       cgd 	case STRUCT:
   3076        1.1       cgd 		/* struct %s never defined */
   3077        1.1       cgd 		warning(233, sym->s_name);
   3078        1.1       cgd 		break;
   3079        1.1       cgd 	case UNION:
   3080        1.1       cgd 		/* union %s never defined */
   3081        1.1       cgd 		warning(234, sym->s_name);
   3082        1.1       cgd 		break;
   3083        1.1       cgd 	case ENUM:
   3084        1.1       cgd 		/* enum %s never defined */
   3085        1.1       cgd 		warning(235, sym->s_name);
   3086        1.1       cgd 		break;
   3087        1.1       cgd 	default:
   3088       1.31  christos 		LERROR("chktusg()");
   3089        1.1       cgd 	}
   3090        1.1       cgd }
   3091        1.1       cgd 
   3092        1.1       cgd /*
   3093        1.1       cgd  * Called after the entire translation unit has been parsed.
   3094        1.1       cgd  * Changes tentative definitions in definitions.
   3095        1.1       cgd  * Performs some tests on global Symbols. Detected Problems are:
   3096        1.1       cgd  * - defined variables of incomplete type
   3097        1.1       cgd  * - constant variables which are not initialized
   3098        1.1       cgd  * - static symbols which are never used
   3099        1.1       cgd  */
   3100        1.1       cgd void
   3101       1.22     lukem chkglsyms(void)
   3102        1.1       cgd {
   3103        1.1       cgd 	sym_t	*sym;
   3104        1.1       cgd 	pos_t	cpos;
   3105        1.1       cgd 
   3106        1.3       jpo 	if (blklev != 0 || dcs->d_nxt != NULL)
   3107        1.1       cgd 		norecover();
   3108        1.1       cgd 
   3109        1.1       cgd 	STRUCT_ASSIGN(cpos, curr_pos);
   3110        1.1       cgd 
   3111        1.3       jpo 	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
   3112        1.1       cgd 		if (sym->s_blklev == -1)
   3113        1.1       cgd 			continue;
   3114        1.1       cgd 		if (sym->s_kind == FVFT) {
   3115        1.1       cgd 			chkglvar(sym);
   3116        1.1       cgd 		} else if (sym->s_kind == FTAG) {
   3117        1.1       cgd 			chktusg(sym);
   3118        1.1       cgd 		} else {
   3119        1.1       cgd 			if (sym->s_kind != FMOS)
   3120       1.31  christos 				LERROR("chkglsyms()");
   3121        1.1       cgd 		}
   3122        1.1       cgd 	}
   3123        1.1       cgd 
   3124        1.1       cgd 	STRUCT_ASSIGN(curr_pos, cpos);
   3125        1.1       cgd }
   3126        1.1       cgd 
   3127        1.1       cgd static void
   3128       1.22     lukem chkglvar(sym_t *sym)
   3129        1.1       cgd {
   3130       1.22     lukem 
   3131        1.1       cgd 	if (sym->s_scl == TYPEDEF || sym->s_scl == ENUMCON)
   3132        1.1       cgd 		return;
   3133       1.22     lukem 
   3134        1.1       cgd 	if (sym->s_scl != EXTERN && sym->s_scl != STATIC)
   3135       1.31  christos 		LERROR("chkglvar()");
   3136        1.1       cgd 
   3137        1.1       cgd 	glchksz(sym);
   3138        1.1       cgd 
   3139        1.1       cgd 	if (sym->s_scl == STATIC) {
   3140        1.1       cgd 		if (sym->s_type->t_tspec == FUNC) {
   3141        1.1       cgd 			if (sym->s_used && sym->s_def != DEF) {
   3142        1.1       cgd 				STRUCT_ASSIGN(curr_pos, sym->s_upos);
   3143        1.1       cgd 				/* static func. called but not def.. */
   3144        1.1       cgd 				error(225, sym->s_name);
   3145        1.1       cgd 			}
   3146        1.1       cgd 		}
   3147        1.1       cgd 		if (!sym->s_used) {
   3148        1.1       cgd 			STRUCT_ASSIGN(curr_pos, sym->s_dpos);
   3149        1.1       cgd 			if (sym->s_type->t_tspec == FUNC) {
   3150        1.1       cgd 				if (sym->s_def == DEF) {
   3151        1.4       jpo 					if (!sym->s_inline)
   3152        1.4       jpo 						/* static function %s unused */
   3153        1.4       jpo 						warning(236, sym->s_name);
   3154        1.1       cgd 				} else {
   3155        1.1       cgd 					/* static function %s decl. but ... */
   3156        1.1       cgd 					warning(290, sym->s_name);
   3157        1.1       cgd 				}
   3158        1.1       cgd 			} else if (!sym->s_set) {
   3159        1.1       cgd 				/* static variable %s unused */
   3160        1.1       cgd 				warning(226, sym->s_name);
   3161        1.1       cgd 			} else {
   3162        1.1       cgd 				/* static variable %s set but not used */
   3163        1.1       cgd 				warning(307, sym->s_name);
   3164        1.1       cgd 			}
   3165        1.1       cgd 		}
   3166        1.1       cgd 		if (!tflag && sym->s_def == TDEF && sym->s_type->t_const) {
   3167        1.1       cgd 			STRUCT_ASSIGN(curr_pos, sym->s_dpos);
   3168        1.1       cgd 			/* const object %s should have initializer */
   3169        1.1       cgd 			warning(227, sym->s_name);
   3170        1.1       cgd 		}
   3171        1.1       cgd 	}
   3172        1.1       cgd }
   3173        1.1       cgd 
   3174        1.1       cgd static void
   3175       1.22     lukem glchksz(sym_t *sym)
   3176        1.1       cgd {
   3177       1.22     lukem 
   3178        1.1       cgd 	if (sym->s_def == TDEF) {
   3179        1.1       cgd 		if (sym->s_type->t_tspec == FUNC)
   3180        1.1       cgd 			/*
   3181       1.24       wiz 			 * this can happen if an syntax error occurred
   3182        1.1       cgd 			 * after a function declaration
   3183        1.1       cgd 			 */
   3184        1.1       cgd 			return;
   3185        1.1       cgd 		STRUCT_ASSIGN(curr_pos, sym->s_dpos);
   3186        1.1       cgd 		if (length(sym->s_type, sym->s_name) == 0 &&
   3187        1.1       cgd 		    sym->s_type->t_tspec == ARRAY && sym->s_type->t_dim == 0) {
   3188        1.1       cgd 			/* empty array declaration: %s */
   3189        1.1       cgd 			if (tflag || (sym->s_scl == EXTERN && !sflag)) {
   3190        1.1       cgd 				warning(190, sym->s_name);
   3191        1.1       cgd 			} else {
   3192        1.1       cgd 				error(190, sym->s_name);
   3193        1.1       cgd 			}
   3194        1.1       cgd 		}
   3195        1.1       cgd 	}
   3196        1.1       cgd }
   3197        1.1       cgd 
   3198        1.1       cgd /*
   3199        1.1       cgd  * Prints information about location of previous definition/declaration.
   3200        1.1       cgd  */
   3201        1.1       cgd void
   3202       1.22     lukem prevdecl(int msg, sym_t *psym)
   3203        1.1       cgd {
   3204        1.1       cgd 	pos_t	cpos;
   3205        1.1       cgd 
   3206        1.1       cgd 	if (!rflag)
   3207        1.1       cgd 		return;
   3208        1.1       cgd 
   3209        1.1       cgd 	STRUCT_ASSIGN(cpos, curr_pos);
   3210        1.1       cgd 	STRUCT_ASSIGN(curr_pos, psym->s_dpos);
   3211        1.6       jpo 	if (msg != -1) {
   3212        1.6       jpo 		message(msg, psym->s_name);
   3213        1.6       jpo 	} else if (psym->s_def == DEF || psym->s_def == TDEF) {
   3214        1.1       cgd 		/* previous definition of %s */
   3215        1.1       cgd 		message(261, psym->s_name);
   3216        1.1       cgd 	} else {
   3217        1.1       cgd 		/* previous declaration of %s */
   3218        1.1       cgd 		message(260, psym->s_name);
   3219        1.1       cgd 	}
   3220        1.1       cgd 	STRUCT_ASSIGN(curr_pos, cpos);
   3221        1.1       cgd }
   3222