 @@ -1,14 +1,14 @@
-/*	$NetBSD: decl.c,v 1.8 2021/07/15 21:56:51 rillig Exp $	*/
+/*	$NetBSD: decl.c,v 1.9 2021/07/15 23:07:05 rillig Exp $	*/
 # 3 "decl.c"
 /*
  * Tests for declarations, especially the distinction between the
  * declaration-specifiers and the declarators.
  */
 /*
  * Even though 'const' comes after 'char' and is therefore quite close to the
  * first identifier, it applies to both identifiers.
  */
 void
 specifier_qualifier(void)
 @@ -135,29 +135,33 @@ unsigned long cover_abstract_declaration
 unsigned long cover_abstract_declarator_typeof =
     sizeof(const typeof(cover_abstract_declaration_declmods));
 _Bool bool;
 char plain_char;
 signed char signed_char;
 unsigned char unsigned_char;
 short signed_short;
 unsigned short unsigned_short;
 int signed_int;
 unsigned int unsigned_int;
 long signed_long;
 unsigned long unsigned_long;
 struct {
 	int member;
 } unnamed_struct;
 /*
  * Before decl.c 1.201 from 2021-07-15, lint crashed with an internal error
  * in end_type.
  */
 unsigned long sizes =
     sizeof(const typeof(bool)) +
     sizeof(const typeof(plain_char)) +
     sizeof(const typeof(signed_char)) +
     sizeof(const typeof(unsigned_char)) +
     sizeof(const typeof(signed_short)) +
     sizeof(const typeof(unsigned_short)) +
     sizeof(const typeof(signed_int)) +
     sizeof(const typeof(unsigned_int)) +
     sizeof(const typeof(signed_long)) +
-    sizeof(const typeof(unsigned_long));
+    sizeof(const typeof(unsigned_long)) +
     sizeof(const typeof(unnamed_struct));

 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.203 2021/07/15 22:47:17 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.204 2021/07/15 23:07:05 rillig 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
 @@ -28,27 +28,27 @@
  * 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.203 2021/07/15 22:47:17 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.204 2021/07/15 23:07:05 rillig 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 arithmetic types and void */
 static	type_t	*typetab;
 @@ -736,120 +736,125 @@ dcs_adjust_storage_class(void)
 			/* illegal storage class */
 			error(8);
 			dcs->d_scl = NOSCL;
+		}
 	} else if (dcs->d_ctx == ARG || dcs->d_ctx == PROTO_ARG) {
 		if (dcs->d_scl != NOSCL && dcs->d_scl != REG) {
 			/* only register valid as formal parameter storage... */
 			error(9);
 			dcs->d_scl = NOSCL;
+		}
+	}
+}
-/*
+/* Merge the declaration specifiers from dcs into dcs->d_type. */
- * Create a type structure from the information gathered in
+static void
- * the declaration stack.
+dcs_merge_declaration_specifiers(void)
  * Complain about storage classes which are not possible in current
  * context.
  */
 void
 end_type(void)
+{
 	tspec_t	t, s, l, c;
 	type_t	*tp;
 	t = dcs->d_abstract_type; /* VOID, BOOL, CHAR, INT or COMPLEX */
 	c = dcs->d_complex_mod;	/* FLOAT or DOUBLE */
 	s = dcs->d_sign_mod;	/* SIGNED or UNSIGN */
 	l = dcs->d_rank_mod;	/* SHORT, LONG or QUAD */
 	tp = dcs->d_type;
 #ifdef DEBUG
 	printf("%s: %s\n", __func__, type_name(tp));
 #endif
 	if (t == NOTSPEC && s == NOTSPEC && l == NOTSPEC && c == NOTSPEC &&
 	    tp == NULL)
 		dcs->d_notyp = true;
 	if (t == NOTSPEC && s == NOTSPEC && (l == NOTSPEC || l == LONG) &&
 	    tp == NULL)
 		t = c;
 	if (tp != NULL) {
 		lint_assert(t == NOTSPEC);
 		lint_assert(s == NOTSPEC);
 		lint_assert(l == NOTSPEC);
 		return;
+	}
-	if (tp == NULL) {
+	switch (t) {
-		switch (t) {
+	case BOOL:
-		case BOOL:
+		break;
-			break;
+	case NOTSPEC:
-		case NOTSPEC:
+		t = INT;
-			t = INT;
+		/* FALLTHROUGH */
-			/* FALLTHROUGH */
+	case INT:
-		case INT:
+		if (s == NOTSPEC)
-			if (s == NOTSPEC)
+			s = SIGNED;
-				s = SIGNED;
+		break;
-			break;
+	case CHAR:
-		case CHAR:
+		if (l != NOTSPEC) {
-			if (l != NOTSPEC) {
+			dcs->d_terr = true;
 				dcs->d_terr = true;
 				l = NOTSPEC;
 			break;
 		case FLOAT:
 			if (l == LONG) {
 				l = NOTSPEC;
 				t = DOUBLE;
 				if (!tflag)
 					/* use 'double' instead of 'long ... */
 					warning(6);
 			break;
 		case DOUBLE:
 			if (l != LONG)
 				break;
 			/* FALLTHROUGH */
 		case LDOUBLE:
 			l = NOTSPEC;
 			t = LDOUBLE;
 			if (tflag)
 				/* 'long double' is illegal in ... */
 				warning(266);
 			break;
 		case DCOMPLEX:
 			if (l == LONG) {
 				l = NOTSPEC;
 				t = LCOMPLEX;
 			break;
 		case VOID:
 		case FCOMPLEX:
 		case LCOMPLEX:
 			break;
 		default:
 			if (is_integer(t))
 				break;
 			INTERNAL_ERROR("end_type(%s)", tspec_name(t));
+		}
-		if (t != INT && t != CHAR && (s != NOTSPEC || l != NOTSPEC)) {
+		break;
-			dcs->d_terr = true;
+	case FLOAT:
-			l = s = NOTSPEC;
+		if (l == LONG) {
 			l = NOTSPEC;
 			t = DOUBLE;
 			if (!tflag)
 				/* use 'double' instead of 'long float' */
 				warning(6);
+		}
-		if (l != NOTSPEC)
+		break;
-			t = l;
+	case DOUBLE:
-		dcs->d_type = gettyp(merge_type_specifiers(t, s));
+		if (l != LONG)
 			break;
 		/* FALLTHROUGH */
 	case LDOUBLE:
 		l = NOTSPEC;
 		t = LDOUBLE;
 		if (tflag)
 			/* 'long double' is illegal in traditional C */
 			warning(266);
 		break;
 	case DCOMPLEX:
 		if (l == LONG) {
 			l = NOTSPEC;
 			t = LCOMPLEX;
+		}
 		break;
 	case VOID:
 	case FCOMPLEX:
 	case LCOMPLEX:
 		break;
 	default:
 		lint_assert(is_integer(t));
+	}
 	if (t != INT && t != CHAR && (s != NOTSPEC || l != NOTSPEC)) {
 		dcs->d_terr = true;
 		l = s = NOTSPEC;
+	}
 	if (l != NOTSPEC)
 		t = l;
 	dcs->d_type = gettyp(merge_type_specifiers(t, s));
+}
 /*
  * Create a type structure from the information gathered in
  * the declaration stack.
  * Complain about storage classes which are not possible in current
  * context.
  */
 void
 end_type(void)
+{
 	dcs_merge_declaration_specifiers();
 	if (dcs->d_mscl) {
 		/* only one storage class allowed */
 		error(7);
+	}
 	if (dcs->d_terr) {
 		/* illegal type combination */
 		error(4);
+	}
 	dcs_adjust_storage_class();
 	if (dcs->d_const && dcs->d_type->t_const) {