 @@ -1,1509 +1,1516 @@
-/* $NetBSD: decl.c,v 1.50 2009/10/02 21:04:03 christos Exp $ */
+/* $NetBSD: decl.c,v 1.51 2009/10/02 21:49:30 christos Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by Jochen Pohl for
  *	The NetBSD Project.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: decl.c,v 1.50 2009/10/02 21:04:03 christos Exp $");
+__RCSID("$NetBSD: decl.c,v 1.51 2009/10/02 21:49:30 christos Exp $");
 #endif
 #include <sys/param.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 const	char *unnamed = "<unnamed>";
 /* shared type structures for arithmtic types and void */
 static	type_t	*typetab;
 /* value of next enumerator during declaration of enum types */
 int	enumval;
 /*
  * pointer to top element of a stack which contains informations local
  * to nested declarations
  */
 dinfo_t	*dcs;
 static	type_t	*tdeferr(type_t *, tspec_t);
 static	void	settdsym(type_t *, sym_t *);
 static	tspec_t	mrgtspec(tspec_t, tspec_t);
 static	void	align(int, int);
 static	sym_t	*newtag(sym_t *, scl_t, int, int);
 static	int	eqargs(type_t *, type_t *, int *);
 static	int	mnoarg(type_t *, int *);
 static	int	chkosdef(sym_t *, sym_t *);
 static	int	chkptdecl(sym_t *, sym_t *);
 static	sym_t	*nsfunc(sym_t *, sym_t *);
 static	void	osfunc(sym_t *, sym_t *);
 static	void	ledecl(sym_t *);
 static	int	chkinit(sym_t *);
 static	void	chkausg(int, sym_t *);
 static	void	chkvusg(int, sym_t *);
 static	void	chklusg(sym_t *);
 static	void	chktusg(sym_t *);
 static	void	chkglvar(sym_t *);
 static	void	glchksz(sym_t *);
 /*
  * initializes all global vars used in declarations
  */
 void
 initdecl(void)
+{
 	int i;
 	/* declaration stack */
 	dcs = xcalloc(1, sizeof (dinfo_t));
 	dcs->d_ctx = EXTERN;
 	dcs->d_ldlsym = &dcs->d_dlsyms;
 	/* type information and classification */
 	inittyp();
 	/* shared type structures */
 	typetab = xcalloc(NTSPEC, sizeof (type_t));
 	for (i = 0; i < NTSPEC; i++)
 		typetab[i].t_tspec = NOTSPEC;
 	typetab[BOOL].t_tspec = BOOL;
 	typetab[CHAR].t_tspec = CHAR;
 	typetab[SCHAR].t_tspec = SCHAR;
 	typetab[UCHAR].t_tspec = UCHAR;
 	typetab[SHORT].t_tspec = SHORT;
 	typetab[USHORT].t_tspec = USHORT;
 	typetab[INT].t_tspec = INT;
 	typetab[UINT].t_tspec = UINT;
 	typetab[LONG].t_tspec = LONG;
 	typetab[ULONG].t_tspec = ULONG;
 	typetab[QUAD].t_tspec = QUAD;
 	typetab[UQUAD].t_tspec = UQUAD;
 	typetab[FLOAT].t_tspec = FLOAT;
 	typetab[DOUBLE].t_tspec = DOUBLE;
 	typetab[LDOUBLE].t_tspec = LDOUBLE;
 	typetab[FCOMPLEX].t_tspec = FCOMPLEX;
 	typetab[DCOMPLEX].t_tspec = DCOMPLEX;
 	typetab[LCOMPLEX].t_tspec = LCOMPLEX;
 	typetab[COMPLEX].t_tspec = COMPLEX;
 	typetab[VOID].t_tspec = VOID;
 	/*
 	 * Next two are not real types. They are only used by the parser
 	 * to return keywords "signed" and "unsigned"
 	 */
 	typetab[SIGNED].t_tspec = SIGNED;
 	typetab[UNSIGN].t_tspec = UNSIGN;
+}
 /*
  * Returns a shared type structure vor arithmetic types and void.
+ *
  * It's important do duplicate this structure (using duptyp() or tdupdyp())
  * if it is to be modified (adding qualifiers or anything else).
  */
 type_t *
 gettyp(tspec_t t)
+{
 	return (&typetab[t]);
+}
 type_t *
 duptyp(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = getblk(sizeof (type_t));
 	STRUCT_ASSIGN(*ntp, *tp);
 	return (ntp);
+}
 /*
  * Use tduptyp() instead of duptyp() inside expressions (if the
  * allocated memory should be freed after the expr).
  */
 type_t *
 tduptyp(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = tgetblk(sizeof (type_t));
 	STRUCT_ASSIGN(*ntp, *tp);
 	return (ntp);
+}
 /*
  * Returns 1 if the argument is void or an incomplete array,
  * struct, union or enum type.
  */
 int
 incompl(type_t *tp)
+{
 	tspec_t	t;
 	if ((t = tp->t_tspec) == VOID) {
 		return (1);
 	} else if (t == ARRAY) {
 		return (tp->t_aincompl);
 	} else if (t == STRUCT || t == UNION) {
 		return (tp->t_str->sincompl);
 	} else if (t == ENUM) {
 		return (tp->t_enum->eincompl);
+	}
 	return (0);
+}
 /*
  * Set the flag for (in)complete array, struct, union or enum
  * types.
  */
 void
 setcompl(type_t *tp, int ic)
+{
 	tspec_t	t;
 	if ((t = tp->t_tspec) == ARRAY) {
 		tp->t_aincompl = ic;
 	} else if (t == STRUCT || t == UNION) {
 		tp->t_str->sincompl = ic;
 	} else {
 		if (t != ENUM)
 			LERROR("setcompl()");
 		tp->t_enum->eincompl = ic;
+	}
+}
 /*
  * Remember the storage class of the current declaration in dcs->d_scl
  * (the top element of the declaration stack) and detect multiple
  * storage classes.
  */
 void
 addscl(scl_t sc)
+{
 	if (sc == INLINE) {
 		if (dcs->d_inline)
 			/* duplicate '%s' */
 			warning(10, "inline");
 		dcs->d_inline = 1;
 		return;
+	}
 	if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
 	    dcs->d_smod != NOTSPEC || dcs->d_lmod != NOTSPEC) {
 		/* storage class after type is obsolescent */
 		warning(83);
+	}
 	if (dcs->d_scl == NOSCL) {
 		dcs->d_scl = sc;
 	} else {
 		/*
 		 * multiple storage classes. An error will be reported in
 		 * deftyp().
 		 */
 		dcs->d_mscl = 1;
+	}
+}
 /*
  * Remember the type, modifier or typedef name returned by the parser
  * in *dcs (top element of decl stack). This information is used in
  * deftyp() to build the type used for all declarators in this
  * declaration.
+ *
  * Is tp->t_typedef 1, the type comes from a previously defined typename.
  * Otherwise it comes from a type specifier (int, long, ...) or a
  * struct/union/enum tag.
  */
 void
 addtype(type_t *tp)
+{
 	tspec_t	t;
 #ifdef DEBUG
 	char buf[1024];
 	printf("addtype %s\n", tyname(buf, sizeof(buf), tp));
 #endif
 	if (tp->t_typedef) {
 		if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
 		    dcs->d_lmod != NOTSPEC || dcs->d_smod != NOTSPEC) {
 			/*
 			 * something like "typedef int a; int a b;"
 			 * This should not happen with current grammar.
 			 */
 			LERROR("addtype()");
+		}
 		dcs->d_type = tp;
 		return;
+	}
 	t = tp->t_tspec;
 	if (t == STRUCT || t == UNION || t == ENUM) {
 		/*
 		 * something like "int struct a ..."
 		 * struct/union/enum with anything else is not allowed
 		 */
 		if (dcs->d_type != NULL || dcs->d_atyp != NOTSPEC ||
 		    dcs->d_lmod != NOTSPEC || dcs->d_smod != NOTSPEC) {
 			/*
 			 * remember that an error must be reported in
 			 * deftyp().
 			 */
 			dcs->d_terr = 1;
 			dcs->d_atyp = dcs->d_lmod = dcs->d_smod = NOTSPEC;
+		}
 		dcs->d_type = tp;
 		return;
+	}
 	if (dcs->d_type != NULL && !dcs->d_type->t_typedef) {
 		/*
 		 * something like "struct a int"
 		 * struct/union/enum with anything else is not allowed
 		 */
 		dcs->d_terr = 1;
 		return;
+	}
 	if (t == COMPLEX) {
 		if (dcs->d_cmod == FLOAT)
 			t = FCOMPLEX;
 		else if (dcs->d_cmod == DOUBLE) {
 			t = DCOMPLEX;
 		} else
 			error(308, basictyname(dcs->d_cmod));
 		dcs->d_cmod = NOTSPEC;
+	}
 	if (t == LONG && dcs->d_lmod == LONG) {
 		/* "long long" or "long ... long" */
 		t = QUAD;
 		dcs->d_lmod = NOTSPEC;
 		if (!quadflg)
 			/* %s C does not support 'long long' */
 			(void)c99ism(265, tflag ? "traditional" : "c89");
+	}
 	if (dcs->d_type != NULL && dcs->d_type->t_typedef) {
 		/* something like "typedef int a; a long ..." */
 		dcs->d_type = tdeferr(dcs->d_type, t);
 		return;
+	}
 	/* now it can be only a combination of arithmetic types and void */
 	if (t == SIGNED || t == UNSIGN) {
 		/* remember specifiers "signed" & "unsigned" in dcs->d_smod */
 		if (dcs->d_smod != NOTSPEC)
 			/*
 			 * more than one "signed" and/or "unsigned"; print
 			 * an error in deftyp()
 			 */
 			dcs->d_terr = 1;
 		dcs->d_smod = t;
 	} else if (t == SHORT || t == LONG || t == QUAD) {
 		/*
 		 * remember specifiers "short", "long" and "long long" in
 		 * dcs->d_lmod
 		 */
 		if (dcs->d_lmod != NOTSPEC)
 			/* more than one, print error in deftyp() */
 			dcs->d_terr = 1;
 		dcs->d_lmod = t;
 	} else if (t == FLOAT || t == DOUBLE) {
 		if (dcs->d_lmod == NOTSPEC || dcs->d_lmod == LONG) {
 			if (dcs->d_cmod != NOTSPEC
 			    || (t == FLOAT && dcs->d_lmod == LONG))
 				dcs->d_terr = 1;
 			dcs->d_cmod = t;
 		} else {
 			if (dcs->d_atyp != NOTSPEC)
 				dcs->d_terr = 1;
 			dcs->d_atyp = t;
+		}
 	} else {
 		/*
 		 * remember specifiers "void", "char", "int",
 		 * or "_Complex" int dcs->d_atyp
 		 */
 		if (dcs->d_atyp != NOTSPEC)
 			/* more than one, print error in deftyp() */
 			dcs->d_terr = 1;
 		dcs->d_atyp = t;
+	}
+}
 /*
  * called if a list of declaration specifiers contains a typedef name
  * and other specifiers (except struct, union, enum, typedef name)
  */
 static type_t *
 tdeferr(type_t *td, tspec_t t)
+{
 	tspec_t	t2;
 	t2 = td->t_tspec;
 	switch (t) {
 	case SIGNED:
 	case UNSIGN:
 		if (t2 == CHAR || t2 == SHORT || t2 == INT || t2 == LONG ||
 		    t2 == QUAD) {
 			if (!tflag)
 				/* modifying typedef with ... */
 				warning(5, ttab[t].tt_name);
 			td = duptyp(gettyp(mrgtspec(t2, t)));
 			td->t_typedef = 1;
 			return (td);
+		}
 		break;
 	case SHORT:
 		if (t2 == INT || t2 == UINT) {
 			/* modifying typedef with ... */
 			warning(5, "short");
 			td = duptyp(gettyp(t2 == INT ? SHORT : USHORT));
 			td->t_typedef = 1;
 			return (td);
+		}
 		break;
 	case LONG:
 		if (t2 == INT || t2 == UINT || t2 == LONG || t2 == ULONG ||
 		    t2 == FLOAT || t2 == DOUBLE || t2 == DCOMPLEX) {
 			/* modifying typedef with ... */
 			warning(5, "long");
 			if (t2 == INT) {
 				td = gettyp(LONG);
 			} else if (t2 == UINT) {
 				td = gettyp(ULONG);
 			} else if (t2 == LONG) {
 				td = gettyp(QUAD);
 			} else if (t2 == ULONG) {
 				td = gettyp(UQUAD);
 			} else if (t2 == FLOAT) {
 				td = gettyp(DOUBLE);
 			} else if (t2 == DOUBLE) {
 				td = gettyp(LDOUBLE);
 			} else if (t2 == DCOMPLEX) {
 				td = gettyp(LCOMPLEX);
+			}
 			td = duptyp(td);
 			td->t_typedef = 1;
 			return (td);
+		}
 		break;
 		/* LINTED (enumeration values not handled in switch) */
 	case NOTSPEC:
 	case USHORT:
 	case UCHAR:
 	case SCHAR:
 	case CHAR:
 	case BOOL:
 	case FUNC:
 	case ARRAY:
 	case PTR:
 	case ENUM:
 	case UNION:
 	case STRUCT:
 	case VOID:
 	case LDOUBLE:
 	case FLOAT:
 	case DOUBLE:
 	case UQUAD:
 	case QUAD:
 	case ULONG:
 	case UINT:
 	case INT:
 	case FCOMPLEX:
 	case DCOMPLEX:
 	case LCOMPLEX:
 	case COMPLEX:
 		break;
 	case NTSPEC:	/* this value unused */
 		break;
+	}
 	/* Anything other is not accepted. */
 	dcs->d_terr = 1;
 	return (td);
+}
 /*
  * Remember the symbol of a typedef name (2nd arg) in a struct, union
  * or enum tag if the typedef name is the first defined for this tag.
+ *
  * If the tag is unnamed, the typdef name is used for identification
  * of this tag in lint2. Although its possible that more than one typedef
  * name is defined for one tag, the first name defined should be unique
  * if the tag is unnamed.
  */
 static void
 settdsym(type_t *tp, sym_t *sym)
+{
 	tspec_t	t;
 	if ((t = tp->t_tspec) == STRUCT || t == UNION) {
 		if (tp->t_str->stdef == NULL)
 			tp->t_str->stdef = sym;
 	} else if (t == ENUM) {
 		if (tp->t_enum->etdef == NULL)
 			tp->t_enum->etdef = sym;
+	}
+}
 static void
 setpackedsize(type_t *tp)
+{
 	str_t *sp;
 	sym_t *mem;
 	char buf[256];
 	switch (tp->t_tspec) {
 	case STRUCT:
 		sp = tp->t_str;
 		sp->size = 0;
 		for (mem = sp->memb; mem != NULL; mem = mem->s_nxt) {
 			size_t x = (size_t)tsize(mem->s_type);
 			sp->size += x;
 		break;
 	case UNION:
 		sp = tp->t_str;
 		sp->size = 0;
 		for (mem = sp->memb; mem != NULL; mem = mem->s_nxt) {
 			if (mem->s_type->t_isfield) {
 				size_t len = mem->s_type->t_flen;
 				while (mem && mem->s_type->t_isfield) {
 					len += mem->s_type->t_flen;
 					mem = mem->s_nxt;
+				}
 				len = ((len + INT_SIZE - 1) /
 				    INT_SIZE) * INT_SIZE;
 				sp->size += len;
 				if (mem == NULL)
 					break;
+			}
 			size_t x = (size_t)tsize(mem->s_type);
-			if (x > sp->size)
+			if (tp->t_tspec == STRUCT)
 				sp->size += x;
 			else if (x > sp->size)
 				sp->size = x;
+		}
 		break;
 	default:
 		warning(326, "packed", tyname(buf, sizeof(buf), tp));
 		break;
+	}
+}
 void
 addpacked(void)
+{
 	if (dcs->d_type == NULL)
 		dcs->d_ispacked = 1;
 	else
 		setpackedsize(dcs->d_type);
+}
 /*
  * Remember a qualifier which is part of the declaration specifiers
  * (and not the declarator) in the top element of the declaration stack.
  * Also detect multiple qualifiers of the same kind.
  * The remembered qualifier is used by deftyp() to construct the type
  * for all declarators.
  */
 void
 addqual(tqual_t q)
+{
 	if (q == CONST) {
 		if (dcs->d_const) {
 			/* duplicate "%s" */
 			warning(10, "const");
+		}
 		dcs->d_const = 1;
 	} else {
 		if (q != VOLATILE)
 			LERROR("addqual()");
 		if (dcs->d_volatile) {
 			/* duplicate "%s" */
 			warning(10, "volatile");
+		}
 		dcs->d_volatile = 1;
+	}
+}
 /*
  * Go to the next declaration level (structs, nested structs, blocks,
  * argument declaration lists ...)
  */
 void
 pushdecl(scl_t sc)
+{
 	dinfo_t	*di;
 	/* put a new element on the declaration stack */
 	di = xcalloc(1, sizeof (dinfo_t));
 	di->d_nxt = dcs;
 	dcs = di;
 	di->d_ctx = sc;
 	di->d_ldlsym = &di->d_dlsyms;
 	if (dflag)
 		(void)printf("pushdecl(%p %d)\n", dcs, (int)sc);
+}
 /*
  * Go back to previous declaration level
  */
 void
 popdecl(void)
+{
 	dinfo_t	*di;
 	if (dflag)
 		(void)printf("popdecl(%p %d)\n", dcs, (int)dcs->d_ctx);
 	if (dcs->d_nxt == NULL)
 		LERROR("popdecl()");
 	di = dcs;
 	dcs = di->d_nxt;
 	switch (di->d_ctx) {
 	case EXTERN:
 		/* there is nothing after external declarations */
 		LERROR("popdecl()");
 		/* NOTREACHED */
 	case MOS:
 	case MOU:
 	case ENUMCON:
 		/*
 		 * Symbols declared in (nested) structs or enums are
 		 * part of the next level (they are removed from the
 		 * symbol table if the symbols of the outher level are
 		 * removed)
 		 */
 		if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
 			dcs->d_ldlsym = di->d_ldlsym;
 		break;
 	case ARG:
 		/*
 		 * All symbols in dcs->d_dlsyms are introduced in old style
 		 * argument declarations (it's not clean, but possible).
 		 * They are appended to the list of symbols declared in
 		 * an old style argument identifier list or a new style
 		 * parameter type list.
 		 */
 		if (di->d_dlsyms != NULL) {
 			*di->d_ldlsym = dcs->d_fpsyms;
 			dcs->d_fpsyms = di->d_dlsyms;
+		}
 		break;
 	case ABSTRACT:
 		/*
 		 * casts and sizeof
 		 * Append all symbols declared in the abstract declaration
 		 * to the list of symbols declared in the surounding decl.
 		 * or block.
 		 * XXX I'm not sure whether they should be removed from the
 		 * symbol table now or later.
 		 */
 		if ((*dcs->d_ldlsym = di->d_dlsyms) != NULL)
 			dcs->d_ldlsym = di->d_ldlsym;
 		break;
 	case AUTO:
 		/* check usage of local vars */
 		chkusage(di);
 		/* FALLTHROUGH */
 	case PARG:
 		/* usage of arguments will be checked by funcend() */
 		rmsyms(di->d_dlsyms);
 		break;
 	default:
 		LERROR("popdecl()");
+	}
 	free(di);
+}
 /*
  * Set flag d_asm in all declaration stack elements up to the
  * outermost one.
+ *
  * This is used to mark compound statements which have, possibly in
  * nested compound statements, asm statements. For these compound
  * statements no warnings about unused or unitialized variables are
  * printed.
+ *
  * There is no need to clear d_asm in dinfo structs with context AUTO,
  * because these structs are freed at the end of the compound statement.
  * But it must be cleard in the outermost dinfo struct, which has
  * context EXTERN. This could be done in clrtyp() and would work for
  * C, but not for C++ (due to mixed statements and declarations). Thus
  * we clear it in glclup(), which is used to do some cleanup after
  * global declarations/definitions.
  */
 void
 setasm(void)
+{
 	dinfo_t	*di;
 	for (di = dcs; di != NULL; di = di->d_nxt)
 		di->d_asm = 1;
+}
 /*
  * Clean all elements of the top element of declaration stack which
  * will be used by the next declaration
  */
 void
 clrtyp(void)
+{
 	dcs->d_atyp = dcs->d_cmod = dcs->d_smod = dcs->d_lmod = NOTSPEC;
 	dcs->d_scl = NOSCL;
 	dcs->d_type = NULL;
 	dcs->d_const = dcs->d_volatile = 0;
 	dcs->d_inline = 0;
 	dcs->d_mscl = dcs->d_terr = 0;
 	dcs->d_nedecl = 0;
 	dcs->d_notyp = 0;
+}
 /*
  * Create a type structure from the informations gathered in
  * the declaration stack.
  * Complain about storage classes which are not possible in current
  * context.
  */
 void
 deftyp(void)
+{
 	tspec_t	t, s, l, c;
 	type_t	*tp;
 	scl_t	scl;
 	t = dcs->d_atyp;	/* BOOL, CHAR, INT, COMPLEX, VOID */
 	s = dcs->d_smod;	/* SIGNED, UNSIGNED */
 	l = dcs->d_lmod;	/* SHORT, LONG, QUAD */
 	c = dcs->d_cmod;	/* FLOAT, DOUBLE */
 	tp = dcs->d_type;
 	scl = dcs->d_scl;
 	if (t == NOTSPEC && s == NOTSPEC && l == NOTSPEC && c == NOTSPEC &&
 	    tp == NULL)
 		dcs->d_notyp = 1;
 	if (t == NOTSPEC && s == NOTSPEC && (l == NOTSPEC || l == LONG) &&
 	    tp == NULL)
 		t = c;
 	if (tp != NULL && (t != NOTSPEC || s != NOTSPEC || l != NOTSPEC)) {
 		/* should never happen */
 		LERROR("deftyp()");
+	}
 	if (tp == NULL) {
 		switch (t) {
 		case BOOL:
 			break;
 		case NOTSPEC:
 			t = INT;
 			/* FALLTHROUGH */
 		case INT:
 			if (s == NOTSPEC)
 				s = SIGNED;
 			break;
 		case CHAR:
 			if (l != NOTSPEC) {
 				dcs->d_terr = 1;
 				l = NOTSPEC;
+			}
 			break;
 		case FLOAT:
 			if (l == LONG) {
 				l = NOTSPEC;
 				t = DOUBLE;
 				if (!tflag)
 					/* use 'double' instead of ...  */
 					warning(6);
+			}
 			break;
 		case DOUBLE:
 			if (l == LONG) {
 				l = NOTSPEC;
 				t = LDOUBLE;
 				if (tflag)
 					/* 'long double' is illegal in ... */
 					warning(266);
+			}
 			break;
 		case DCOMPLEX:
 			if (l == LONG) {
 				l = NOTSPEC;
 				t = LCOMPLEX;
 				if (tflag)
 					/* 'long double' is illegal in ... */
 					warning(266);
+			}
 			break;
 		case VOID:
 		case FCOMPLEX:
 		case LCOMPLEX:
 			break;
 		default:
 			LERROR("deftyp()");
+		}
 		if (t != INT && t != CHAR && (s != NOTSPEC || l != NOTSPEC)) {
 			dcs->d_terr = 1;
 			l = s = NOTSPEC;
+		}
 		if (l != NOTSPEC)
 			t = l;
 		dcs->d_type = gettyp(mrgtspec(t, s));
+	}
 	if (dcs->d_mscl) {
 		/* only one storage class allowed */
 		error(7);
+	}
 	if (dcs->d_terr) {
 		/* illegal type combination */
 		error(4);
+	}
 	if (dcs->d_ctx == EXTERN) {
 		if (scl == REG || scl == AUTO) {
 			/* illegal storage class */
 			error(8);
 			scl = NOSCL;
+		}
 	} else if (dcs->d_ctx == ARG || dcs->d_ctx == PARG) {
 		if (scl != NOSCL && scl != REG) {
 			/* only "register" valid ... */
 			error(9);
 			scl = NOSCL;
+		}
+	}
 	dcs->d_scl = scl;
 	if (dcs->d_const && dcs->d_type->t_const) {
 		if (!dcs->d_type->t_typedef)
 			LERROR("deftyp()");
 		/* typedef already qualified with "%s" */
 		warning(68, "const");
+	}
 	if (dcs->d_volatile && dcs->d_type->t_volatile) {
 		if (!dcs->d_type->t_typedef)
 			LERROR("deftyp()");
 		/* typedef already qualified with "%s" */
 		warning(68, "volatile");
+	}
 	if (dcs->d_const || dcs->d_volatile) {
 		dcs->d_type = duptyp(dcs->d_type);
 		dcs->d_type->t_const |= dcs->d_const;
 		dcs->d_type->t_volatile |= dcs->d_volatile;
+	}
+}
 /*
  * Merge type specifiers (char, ..., long long, signed, unsigned).
  */
 static tspec_t
 mrgtspec(tspec_t t, tspec_t s)
+{
 	if (s == SIGNED || s == UNSIGN) {
 		if (t == CHAR) {
 			t = s == SIGNED ? SCHAR : UCHAR;
 		} else if (t == SHORT) {
 			t = s == SIGNED ? SHORT : USHORT;
 		} else if (t == INT) {
 			t = s == SIGNED ? INT : UINT;
 		} else if (t == LONG) {
 			t = s == SIGNED ? LONG : ULONG;
 		} else if (t == QUAD) {
 			t = s == SIGNED ? QUAD : UQUAD;
+		}
+	}
 	return (t);
+}
 /*
  * Return the length of a type in bit.
+ *
  * Printing a message if the outhermost dimension of an array is 0 must
  * be done by the caller. All other problems are reported by length()
  * if name is not NULL.
  */
 int
 length(type_t *tp, const char *name)
+{
 	int	elem, elsz;
 	elem = 1;
 	while (tp && tp->t_tspec == ARRAY) {
 		elem *= tp->t_dim;
 		tp = tp->t_subt;
+	}
 	if (tp == NULL)
 		return -1;
 	switch (tp->t_tspec) {
 	case FUNC:
 		/* compiler takes size of function */
 		LERROR(msgs[12]);
 		/* NOTREACHED */
 	case STRUCT:
 	case UNION:
 		if (incompl(tp) && name != NULL) {
 			/* incomplete structure or union %s: %s */
 			error(31, tp->t_str->stag->s_name, name);
+		}
 		elsz = tp->t_str->size;
 		break;
 	case ENUM:
 		if (incompl(tp) && name != NULL) {
 			/* incomplete enum type: %s */
 			warning(13, name);
+		}
 		/* FALLTHROUGH */
 	default:
 		elsz = size(tp->t_tspec);
 		if (elsz <= 0)
 			LERROR("length()");
 		break;
+	}
 	return (elem * elsz);
+}
 /*
  * Get the alignment of the given Type in bits.
  */
 int
 getbound(type_t *tp)
+{
 	size_t	a;
 	tspec_t	t;
 	while (tp && tp->t_tspec == ARRAY)
 		tp = tp->t_subt;
 	if (tp == NULL)
 		return -1;
 	if ((t = tp->t_tspec) == STRUCT || t == UNION) {
 		a = tp->t_str->align;
 	} else if (t == FUNC) {
 		/* compiler takes alignment of function */
 		error(14);
 		a = ALIGN(1) * CHAR_BIT;
 	} else {
 		if ((a = size(t)) == 0) {
 			a = CHAR_BIT;
 		} else if (a > ALIGN(1) * CHAR_BIT) {
 			a = ALIGN(1) * CHAR_BIT;
+		}
+	}
 	if (a < CHAR_BIT || a > ALIGN(1) * CHAR_BIT)
 		LERROR("getbound()");
 	return (a);
+}
 /*
  * Concatenate two lists of symbols by s_nxt. Used by declarations of
  * struct/union/enum elements and parameters.
  */
 sym_t *
 lnklst(sym_t *l1, sym_t *l2)
+{
 	sym_t	*l;
 	if ((l = l1) == NULL)
 		return (l2);
 	while (l1->s_nxt != NULL)
 		l1 = l1->s_nxt;
 	l1->s_nxt = l2;
 	return (l);
+}
 /*
  * Check if the type of the given symbol is valid and print an error
  * message if it is not.
+ *
  * Invalid types are:
  * - arrays of incomlete types or functions
  * - functions returning arrays or functions
  * - void types other than type of function or pointer
  */
 void
 chktyp(sym_t *sym)
+{
 	tspec_t	to, t;
 	type_t	**tpp, *tp;
 	tpp = &sym->s_type;
 	to = NOTSPEC;
 	while ((tp = *tpp) != NULL) {
 		t = tp->t_tspec;
 		/*
 		 * If this is the type of an old style function definition,
 		 * a better warning is printed in funcdef().
 		 */
 		if (t == FUNC && !tp->t_proto &&
 		    !(to == NOTSPEC && sym->s_osdef)) {
 			if (sflag && hflag)
 				/* function declaration is not a prototype */
 				warning(287);
+		}
 		if (to == FUNC) {
 			if (t == FUNC || t == ARRAY) {
 				/* function returns illegal type */
 				error(15);
 				if (t == FUNC) {
 					*tpp = incref(*tpp, PTR);
 				} else {
 					*tpp = incref((*tpp)->t_subt, PTR);
+				}
 				return;
 			} else if (tp->t_const || tp->t_volatile) {
 				if (sflag) {	/* XXX oder better !tflag ? */
 					/* function cannot return const... */
 					warning(228);
+				}
+			}
 		} if (to == ARRAY) {
 			if (t == FUNC) {
 				/* array of function is illegal */
 				error(16);
 				*tpp = gettyp(INT);
 				return;
 			} else if (t == ARRAY && tp->t_dim == 0) {
 				/* null dimension */
 				error(17);
 				return;
 			} else if (t == VOID) {
 				/* illegal use of void */
 				error(18);
 				*tpp = gettyp(INT);
 #if 0	/* errors are produced by length() */
 			} else if (incompl(tp)) {
 				/* array of incomplete type */
 				if (sflag) {
 					error(301);
 				} else {
 					warning(301);
+				}
 #endif
+			}
 		} else if (to == NOTSPEC && t == VOID) {
 			if (dcs->d_ctx == PARG) {
 				if (sym->s_scl != ABSTRACT) {
 					if (sym->s_name == unnamed)
 						LERROR("chktyp()");
 					/* void param cannot have name: %s */
 					error(61, sym->s_name);
 					*tpp = gettyp(INT);
+				}
 			} else if (dcs->d_ctx == ABSTRACT) {
 				/* ok */
 			} else if (sym->s_scl != TYPEDEF) {
 				/* void type for %s */
 				error(19, sym->s_name);
 				*tpp = gettyp(INT);
+			}
+		}
 		if (t == VOID && to != PTR) {
 			if (tp->t_const || tp->t_volatile) {
 				/* inappropriate qualifiers with "void" */
 				warning(69);
 				tp->t_const = tp->t_volatile = 0;
+			}
+		}
 		tpp = &tp->t_subt;
 		to = t;
+	}
+}
 /*
  * Process the declarator of a struct/union element.
  */
 sym_t *
 decl1str(sym_t *dsym)
+{
 	type_t	*tp;
 	tspec_t	t;
 	int	sz, len;
 	int	o = 0;	/* Appease gcc */
 	scl_t	sc;
 	if ((sc = dsym->s_scl) != MOS && sc != MOU)
 		LERROR("decl1str()");
 	if (dcs->d_rdcsym != NULL) {
 		if ((sc = dcs->d_rdcsym->s_scl) != MOS && sc != MOU)
 			/* should be ensured by storesym() */
 			LERROR("decl1str()");
 		if (dsym->s_styp == dcs->d_rdcsym->s_styp) {
 			/* duplicate member name: %s */
 			error(33, dsym->s_name);
 			rmsym(dcs->d_rdcsym);
+		}
+	}
 	chktyp(dsym);
 	t = (tp = dsym->s_type)->t_tspec;
 	if (dsym->s_field) {
 		/*
 		 * bit field
+		 *
 		 * only unsigned und signed int are protable bit-field types
 		 *(at least in ANSI C, in traditional C only unsigned int)
 		 */
 		if (t == CHAR || t == UCHAR || t == SCHAR ||
 		    t == SHORT || t == USHORT || t == ENUM) {
 			if (bitfieldtype_ok == 0) {
 				if (sflag) {
 					char buf[64];
 					/*
 					 * bit-field type '%s' invalid in
 					 * ANSI C
 					 */
 					warning(273,
 					    tyname(buf, sizeof(buf), tp));
 				} else if (pflag) {
 					/* nonportable bit-field type */
 					warning(34);
+				}
+			}
 		} else if (t == INT && dcs->d_smod == NOTSPEC) {
 			if (pflag && bitfieldtype_ok == 0) {
 				/* nonportable bit-field type */
 				warning(34);
+			}
 		} else if (t != INT && t != UINT) {
 			/*
 			 * Non-integer types are always illegal for
 			 * bitfields, regardless of BITFIELDTYPE.
 			 * Integer types not dealt with above are
 			 * okay only if BITFIELDTYPE is in effect.
 			 */
 			if (bitfieldtype_ok == 0 || isityp(t) == 0) {
 				/* illegal bit-field type */
 				error(35);
 				sz = tp->t_flen;
 				dsym->s_type = tp = duptyp(gettyp(t = INT));
 				if ((tp->t_flen = sz) > size(t))
 					tp->t_flen = size(t);
+			}
+		}
 		if ((len = tp->t_flen) < 0 || len > (ssize_t)size(t)) {
 			/* illegal bit-field size */
 			error(36);
 			tp->t_flen = size(t);
 		} else if (len == 0 && dsym->s_name != unnamed) {
 			/* zero size bit-field */
 			error(37);
 			tp->t_flen = size(t);
+		}
 		if (dsym->s_scl == MOU) {
 			/* illegal use of bit-field */
 			error(41);
 			dsym->s_type->t_isfield = 0;
 			dsym->s_field = 0;
+		}
 	} else if (t == FUNC) {
 		/* function illegal in structure or union */
 		error(38);
 		dsym->s_type = tp = incref(tp, t = PTR);
+	}
 	/*
 	 * bit-fields of length 0 are not warned about because length()
 	 * does not return the length of the bit-field but the length
 	 * of the type the bit-field is packed in (its ok)
 	 */
 	if ((sz = length(dsym->s_type, dsym->s_name)) == 0) {
 		if (t == ARRAY && dsym->s_type->t_dim == 0) {
 			/* illegal zero sized structure member: %s */
 			c99ism(39, dsym->s_name);
+		}
+	}
 	if (dcs->d_ctx == MOU) {
 		o = dcs->d_offset;
 		dcs->d_offset = 0;
+	}
 	if (dsym->s_field) {
 		align(getbound(tp), tp->t_flen);
 		dsym->s_value.v_quad = (dcs->d_offset / size(t)) * size(t);
 		tp->t_foffs = dcs->d_offset - (int)dsym->s_value.v_quad;
 		dcs->d_offset += tp->t_flen;
 	} else {
 		align(getbound(tp), 0);
 		dsym->s_value.v_quad = dcs->d_offset;
 		dcs->d_offset += sz;
+	}
 	if (dcs->d_ctx == MOU) {
 		if (o > dcs->d_offset)
 			dcs->d_offset = o;
+	}
 	chkfdef(dsym, 0);
 	/*
 	 * Clear the BITFIELDTYPE indicator after processing each
 	 * structure element.
 	 */
 	bitfieldtype_ok = 0;
 	return (dsym);
+}
 /*
  * Aligns next structure element as required.
+ *
  * al contains the required alignment, len the length of a bit-field.
  */
 static void
 align(int al, int len)
+{
 	int	no;
 	/*
 	 * The alignment of the current element becomes the alignment of
 	 * the struct/union if it is larger than the current alignment
 	 * of the struct/union.
 	 */
 	if (al > dcs->d_stralign)
 		dcs->d_stralign = al;
 	no = (dcs->d_offset + (al - 1)) & ~(al - 1);
 	if (len == 0 || dcs->d_offset + len > no)
 		dcs->d_offset = no;
+}
 /*
  * Remember the width of the field in its type structure.
  */
 sym_t *
 bitfield(sym_t *dsym, int len)
+{
 	if (dsym == NULL) {
 		dsym = getblk(sizeof (sym_t));
 		dsym->s_name = unnamed;
 		dsym->s_kind = FMOS;
 		dsym->s_scl = MOS;
 		dsym->s_type = gettyp(UINT);
 		dsym->s_blklev = -1;
+	}
 	dsym->s_type = duptyp(dsym->s_type);
 	dsym->s_type->t_isfield = 1;
 	dsym->s_type->t_flen = len;
 	dsym->s_field = 1;
 	return (dsym);
+}
 /*
  * Collect informations about a sequence of asterisks and qualifiers
  * in a list of type pqinf_t.
  * Qualifiers refer always to the left asterisk. The rightmost asterisk
  * will be at the top of the list.
  */
 pqinf_t *
 mergepq(pqinf_t *p1, pqinf_t *p2)
+{
 	pqinf_t	*p;
 	if (p2->p_pcnt != 0) {
 		/* left '*' at the end of the list */
 		for (p = p2; p->p_nxt != NULL; p = p->p_nxt)
 			continue;
 		p->p_nxt = p1;
 		return (p2);
 	} else {
 		if (p2->p_const) {
 			if (p1->p_const) {
 				/* duplicate %s */
 				warning(10, "const");
+			}
 			p1->p_const = 1;
+		}
 		if (p2->p_volatile) {
 			if (p1->p_volatile) {
 				/* duplicate %s */
 				warning(10, "volatile");
+			}
 			p1->p_volatile = 1;
+		}
 		free(p2);
 		return (p1);
+	}
+}
 /*
  * Followint 3 functions extend the type of a declarator with
  * pointer, function and array types.
+ *
  * The current type is the Type built by deftyp() (dcs->d_type) and
  * pointer, function and array types already added for this
  * declarator. The new type extension is inserted between both.
  */
 sym_t *
 addptr(sym_t *decl, pqinf_t *pi)
+{
 	type_t	**tpp, *tp;
 	pqinf_t	*npi;
 	tpp = &decl->s_type;
 	while (*tpp && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 		return decl;
 	while (pi != NULL) {
 		*tpp = tp = getblk(sizeof (type_t));
 		tp->t_tspec = PTR;
 		tp->t_const = pi->p_const;
 		tp->t_volatile = pi->p_volatile;
 		*(tpp = &tp->t_subt) = dcs->d_type;
 		npi = pi->p_nxt;
 		free(pi);
 		pi = npi;
+	}
 	return (decl);
+}
 /*
  * If a dimension was specified, dim is 1, otherwise 0
  * n is the specified dimension
  */
 sym_t *
 addarray(sym_t *decl, int dim, int n)
+{
 	type_t	**tpp, *tp;
 	tpp = &decl->s_type;
 	while (*tpp && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 	    return decl;
 	*tpp = tp = getblk(sizeof (type_t));
 	tp->t_tspec = ARRAY;
 	tp->t_subt = dcs->d_type;
 	tp->t_dim = n;
 	if (n < 0) {
 		/* negative array dimension */
 		error(20, n);
 		n = 0;
 	} else if (n == 0 && dim) {
 		/* zero array dimension */
 		c99ism(322, dim);
 	} else if (n == 0 && !dim) {
 		/* is incomplete type */
 		setcompl(tp, 1);
+	}
 	return (decl);
+}
 sym_t *
 addfunc(sym_t *decl, sym_t *args)
+{
 	type_t	**tpp, *tp;
 	if (dcs->d_proto) {
 		if (tflag)
 			/* function prototypes are illegal in traditional C */
 			warning(270);
 		args = nsfunc(decl, args);
 	} else {
 		osfunc(decl, args);
+	}
 	/*
 	 * The symbols are removed from the symbol table by popdecl() after
 	 * addfunc(). To be able to restore them if this is a function
 	 * definition, a pointer to the list of all symbols is stored in
 	 * dcs->d_nxt->d_fpsyms. Also a list of the arguments (concatenated
 	 * by s_nxt) is stored in dcs->d_nxt->d_fargs.
 	 * (dcs->d_nxt must be used because *dcs is the declaration stack
 	 * element created for the list of params and is removed after
 	 * addfunc())
 	 */
 	if (dcs->d_nxt->d_ctx == EXTERN &&
 	    decl->s_type == dcs->d_nxt->d_type) {
 		dcs->d_nxt->d_fpsyms = dcs->d_dlsyms;
 		dcs->d_nxt->d_fargs = args;
+	}
 	tpp = &decl->s_type;
 	while (*tpp && *tpp != dcs->d_nxt->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 	    return decl;
 	*tpp = tp = getblk(sizeof (type_t));
 	tp->t_tspec = FUNC;
 	tp->t_subt = dcs->d_nxt->d_type;
 	if ((tp->t_proto = dcs->d_proto) != 0)
 		tp->t_args = args;
 	tp->t_vararg = dcs->d_vararg;
 	return (decl);
+}
 /*
  * Called for new style function declarations.
  */
 /* ARGSUSED */
 static sym_t *
 nsfunc(sym_t *decl, sym_t *args)
+{
 	sym_t	*arg, *sym;
 	scl_t	sc;
 	int	n;
 	/*
 	 * Declarations of structs/unions/enums in param lists are legal,
 	 * but senseless.
 	 */
 	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
 		sc = sym->s_scl;
 		if (sc == STRTAG || sc == UNIONTAG || sc == ENUMTAG) {
 			/* dubious tag declaration: %s %s */
 			warning(85, scltoa(sc), sym->s_name);
+		}
+	}
 	n = 1;
 	for (arg = args; arg != NULL; arg = arg->s_nxt) {
 		if (arg->s_type->t_tspec == VOID) {
 			if (n > 1 || arg->s_nxt != NULL) {
 				/* "void" must be sole parameter */
 				error(60);
 				arg->s_type = gettyp(INT);
+			}
+		}
 		n++;
+	}
 	/* return NULL if first param is VOID */
 	return (args != NULL && args->s_type->t_tspec != VOID ? args : NULL);
+}
 /*
  * Called for old style function declarations.
  */
 static void
 osfunc(sym_t *decl, sym_t *args)
+{
 	/*
 	 * Remember list of params only if this is really seams to be
 	 * a function definition.
 	 */
 	if (dcs->d_nxt->d_ctx == EXTERN &&
 	    decl->s_type == dcs->d_nxt->d_type) {
 		/*
 		 * We assume that this becomes a function definition. If
 		 * we are wrong, its corrected in chkfdef().
 		 */
 		if (args != NULL) {
 			decl->s_osdef = 1;
 			decl->s_args = args;
+		}
 	} else {
 		if (args != NULL)
 			/* function prototype parameters must have types */
 			warning(62);
+	}
+}
 /*
  * Lists of Identifiers in functions declarations are allowed only if
  * its also a function definition. If this is not the case, print a
  * error message.
  */
 void
 chkfdef(sym_t *sym, int msg)
+{
 	if (sym->s_osdef) {
 		if (msg) {
 			/* incomplete or misplaced function definition */
 			error(22);
+		}
 		sym->s_osdef = 0;
 		sym->s_args = NULL;
+	}
+}
 /*
  * Process the name in a declarator.
  * If the symbol does already exists, a new one is created.
  * The symbol becomes one of the storage classes EXTERN, STATIC, AUTO or
  * TYPEDEF.
  * s_def and s_reg are valid after dname().
  */
 sym_t *
 dname(sym_t *sym)
+{
 	scl_t	sc = NOSCL;
 	if (sym->s_scl == NOSCL) {
 		dcs->d_rdcsym = NULL;
 	} else if (sym->s_defarg) {
 		sym->s_defarg = 0;
 		dcs->d_rdcsym = NULL;
 	} else {
 		dcs->d_rdcsym = sym;
 		sym = pushdown(sym);
+	}
 	switch (dcs->d_ctx) {
 	case MOS:
 	case MOU:
 		/* Parent setzen */
 		sym->s_styp = dcs->d_tagtyp->t_str;
 		sym->s_def = DEF;
 		sym->s_value.v_tspec = INT;
 		sc = dcs->d_ctx;
 		break;
 	case EXTERN:
 		/*
 		 * static and external symbols without "extern" are
 		 * considered to be tentative defined, external
 		 * symbols with "extern" are declared, and typedef names
 		 * are defined. Tentative defined and declared symbols
 		 * may become defined if an initializer is present or
 		 * this is a function definition.
 		 */
 		if ((sc = dcs->d_scl) == NOSCL) {