 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.107 2021/01/03 18:48:37 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.108 2021/01/03 19:10:47 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.107 2021/01/03 18:48:37 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.108 2021/01/03 19:10:47 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 arithmtic types and void */
 static	type_t	*typetab;
 @@ -484,46 +484,46 @@ settdsym(type_t *tp, sym_t *sym)
 	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 size_t
 bitfieldsize(sym_t **mem)
+{
 	size_t len = (*mem)->s_type->t_flen;
-	while (*mem && (*mem)->s_type->t_isfield) {
+	while (*mem && (*mem)->s_type->t_bitfield) {
 		len += (*mem)->s_type->t_flen;
 		*mem = (*mem)->s_next;
+	}
 	return ((len + INT_SIZE - 1) / INT_SIZE) * INT_SIZE;
+}
 static void
 setpackedsize(type_t *tp)
+{
 	str_t *sp;
 	sym_t *mem;
 	switch (tp->t_tspec) {
 	case STRUCT:
 	case UNION:
 		sp = tp->t_str;
 		sp->size = 0;
 		for (mem = sp->memb; mem != NULL; mem = mem->s_next) {
-			if (mem->s_type->t_isfield) {
+			if (mem->s_type->t_bitfield) {
 				sp->size += bitfieldsize(&mem);
 				if (mem == NULL)
 					break;
+			}
 			size_t x = (size_t)tsize(mem->s_type);
 			if (tp->t_tspec == STRUCT)
 				sp->size += x;
 			else if (x > sp->size)
 				sp->size = x;
+		}
 		break;
 	default:
 		/* %s attribute ignored for %s */
 @@ -1138,27 +1138,27 @@ declarator_1_struct_union(sym_t *dsym)
+		}
 		if ((len = tp->t_flen) < 0 || len > (ssize_t)size(t)) {
 			/* illegal bit-field size: %d */
 			error(36, len);
 			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_type->t_bitfield = false;
 			dsym->s_bitfield = 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 (it's ok)
 	 */
 @@ -1228,27 +1228,27 @@ align(int al, int len)
 sym_t *
 bitfield(sym_t *dsym, int len)
+{
 	if (dsym == NULL) {
 		dsym = getblk(sizeof (sym_t));
 		dsym->s_name = unnamed;
 		dsym->s_kind = FMEMBER;
 		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_bitfield = true;
 	dsym->s_type->t_flen = len;
 	dsym->s_bitfield = 1;
 	return dsym;
+}
 /*
  * Collect information about a sequence of asterisks and qualifiers in a
  * list of type pqinf_t.
  * Qualifiers always refer to the left asterisk.
  * The rightmost asterisk will be at the top of the list.
  */
 pqinf_t *
 merge_pointers_and_qualifiers(pqinf_t *p1, pqinf_t *p2)
 @@ -1777,27 +1777,27 @@ complete_tag_struct_or_union(type_t *tp,
 	else
 		sp->size = dcs->d_offset;
 	if (sp->size == 0) {
 		/* zero sized %s is a C9X feature */
 		c99ism(47, ttab[t].tt_name);
+	}
 	n = 0;
 	for (mem = fmem; mem != NULL; mem = mem->s_next) {
 		/* bind anonymous members to the structure */
 		if (mem->s_styp == NULL) {
 			mem->s_styp = sp;
-			if (mem->s_type->t_isfield) {
+			if (mem->s_type->t_bitfield) {
 				sp->size += bitfieldsize(&mem);
 				if (mem == NULL)
 					break;
+			}
 			sp->size += tsize(mem->s_type);
+		}
 		if (mem->s_name != unnamed)
 			n++;
+	}
 	if (n == 0 && sp->size != 0) {
 		/* %s has no named members */
 		warning(65, t == STRUCT ? "structure" : "union");

 @@ -1,14 +1,14 @@
-/*	$NetBSD: init.c,v 1.58 2021/01/03 17:42:45 rillig Exp $	*/
+/*	$NetBSD: init.c,v 1.59 2021/01/03 19:10:47 rillig Exp $	*/
 /*
  * 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.
 @@ -27,27 +27,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: init.c,v 1.58 2021/01/03 17:42:45 rillig Exp $");
+__RCSID("$NetBSD: init.c,v 1.59 2021/01/03 19:10:47 rillig Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 /*
  * Type of stack which is used for initialisation of aggregate types.
+ *
  * XXX: Since C99, a stack is an inappropriate data structure for modelling
  * an initialization, since the designators don't have to be listed in a
 @@ -623,37 +623,37 @@ mkinit(tnode_t *tn)
 	lint_assert(tspec_is_scalar(lt));
 	if (!typeok(INIT, 0, ln, tn))
 		return;
 	/*
 	 * Store the tree memory. This is necessary because otherwise
 	 * expr() would free it.
 	 */
 	tmem = tsave();
 	expr(tn, 1, 0, 1);
 	trestor(tmem);
-	if (tspec_is_int(lt) && ln->tn_type->t_isfield && !tspec_is_int(rt)) {
+	if (tspec_is_int(lt) && ln->tn_type->t_bitfield && !tspec_is_int(rt)) {
 		/*
 		 * Bit-fields can be initialized in trad. C only by integer
 		 * constants.
 		 */
 		if (tflag)
 			/* bit-field initialisation is illegal in trad. C */
 			warning(186);
+	}
-	if (lt != rt || (initstk->i_type->t_isfield && tn->tn_op == CON))
+	if (lt != rt || (initstk->i_type->t_bitfield && tn->tn_op == CON))
 		tn = convert(INIT, 0, initstk->i_type, tn);
 	if (tn != NULL && tn->tn_op != CON) {
 		sym = NULL;
 		offs = 0;
 		if (conaddr(tn, &sym, &offs) == -1) {
 			if (sc == AUTO || sc == REG) {
 				/* non-constant initializer */
 				c99ism(177);
 			} else {
 				/* non-constant initializer */
 				error(177);
+			}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.119 2021/01/03 18:35:51 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.120 2021/01/03 19:10:47 rillig Exp $	*/
 /*
  * 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.
 @@ -27,27 +27,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: tree.c,v 1.119 2021/01/03 18:35:51 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.120 2021/01/03 19:10:47 rillig Exp $");
 #endif
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 static	tnode_t	*new_int_const_node(tspec_t, int64_t);
 @@ -749,27 +749,27 @@ typeok(op_t op, int arg, tnode_t *ln, tn
 		olt = tn->tn_type->t_tspec;
 		for (tn=rn; tn->tn_op==CVT && !tn->tn_cast; tn=tn->tn_left)
 			continue;
 		ort = tn->tn_type->t_tspec;
+	}
 	switch (op) {
 	case POINT:
 		/*
 		 * Most errors required by ANSI C are reported in
 		 * struct_or_union_member().
 		 * Here we only must check for totally wrong things.
 		 */
-		if (lt == FUNC || lt == VOID || ltp->t_isfield ||
+		if (lt == FUNC || lt == VOID || ltp->t_bitfield ||
 		    ((lt != STRUCT && lt != UNION) && !ln->tn_lvalue)) {
 			/* Without tflag we got already an error */
 			if (tflag)
 				/* unacceptable operand of '%s' */
 				error(111, mp->m_name);
 			return 0;
+		}
 		/* Now we have an object we can create a pointer to */
 		break;
 	case ARROW:
 		if (lt != PTR && !(tflag && tspec_is_int(lt))) {
 			/* Without tflag we got already an error */
 			if (tflag)
 @@ -805,27 +805,27 @@ typeok(op_t op, int arg, tnode_t *ln, tn
 			/* ok, a warning comes later (in build_ampersand()) */
 		} else if (!ln->tn_lvalue) {
 			if (ln->tn_op == CVT && ln->tn_cast &&
 			    ln->tn_left->tn_op == LOAD) {
 				if (ln->tn_type->t_tspec == PTR)
 					break;
 				/* a cast does not yield an lvalue */
 				error(163);
+			}
 			/* %soperand of '%s' must be lvalue */
 			error(114, "", mp->m_name);
 			return 0;
 		} else if (tspec_is_scalar(lt)) {
-			if (ltp->t_isfield) {
+			if (ltp->t_bitfield) {
 				/* cannot take address of bit-field */
 				error(112);
 				return 0;
+			}
 		} else if (lt != STRUCT && lt != UNION) {
 			/* unacceptable operand of '%s' */
 			error(111, mp->m_name);
 			return 0;
+		}
 		if (ln->tn_op == NAME && ln->tn_sym->s_reg) {
 			/* cannot take address of register %s */
 			error(113, ln->tn_sym->s_name);
 			return 0;
 @@ -1520,27 +1520,27 @@ promote(op_t op, int farg, tnode_t *tn)
 	u_int	len;
 	t = tn->tn_type->t_tspec;
 	if (!tspec_is_arith(t))
 		return tn;
 	if (!tflag) {
 		/*
 		 * ANSI C requires that the result is always of type INT
 		 * if INT can represent all possible values of the previous
 		 * type.
 		 */
-		if (tn->tn_type->t_isfield) {
+		if (tn->tn_type->t_bitfield) {
 			len = tn->tn_type->t_flen;
 			if (size(INT) > len) {
 				t = INT;
 			} else {
 				lint_assert(len == size(INT));
 				if (tspec_is_uint(t)) {
 					t = UINT;
 				} else {
 					t = INT;
+				}
+			}
 		} else if (t == CHAR || t == UCHAR || t == SCHAR) {
 			t = (size(CHAR) < size(INT) || t != UCHAR) ?
 @@ -2018,34 +2018,34 @@ cvtcon(op_t op, int arg, type_t *tp, val
 		warning(157);
 		v->v_ansiu = 0;
+	}
 	switch (nt) {
 	case FLOAT:
 	case FCOMPLEX:
 	case DOUBLE:
 	case DCOMPLEX:
 	case LDOUBLE:
 	case LCOMPLEX:
 		break;
 	default:
-		sz = tp->t_isfield ? tp->t_flen : size(nt);
+		sz = tp->t_bitfield ? tp->t_flen : size(nt);
 		nv->v_quad = xsign(nv->v_quad, nt, sz);
 		break;
+	}
 	if (rchk && op != CVT) {
 		osz = size(ot);
-		nsz = tp->t_isfield ? tp->t_flen : size(nt);
+		nsz = tp->t_bitfield ? tp->t_flen : size(nt);
 		xmask = qlmasks[nsz] ^ qlmasks[osz];
 		xmsk1 = qlmasks[nsz] ^ qlmasks[osz - 1];
 		/*
 		 * For bitwise operations we are not interested in the
 		 * value, but in the bits itself.
 		 */
 		if (op == ORASS || op == OR || op == XOR) {
 			/*
 			 * Print a warning if bits which were set are
 			 * lost due to the conversion.
 			 * This can happen with operator ORASS only.
 			 */
 			if (nsz < osz && (v->v_quad & xmask) != 0) {
 @@ -2097,55 +2097,55 @@ cvtcon(op_t op, int arg, type_t *tp, val
 			 * msb of the target for signed types are considered
 			 * to be significant bits. Loss of significant bits
 			 * means that at least on of the bits was set in an
 			 * unsigned type or that at least one, but not all of
 			 * the bits was set in an signed type.
 			 * Loss of significant bits means that it is not
 			 * possible, also not with necessary casts, to convert
 			 * back to the original type. A example for a
 			 * necessary cast is:
 			 *	char c;	int	i; c = 128;
 			 *	i = c;			** yields -128 **
 			 *	i = (unsigned char)c;	** yields 128 **
 			 */
-			if (op == ASSIGN && tp->t_isfield) {
+			if (op == ASSIGN && tp->t_bitfield) {
 				/* precision lost in bit-field assignment */
 				warning(166);
 			} else if (op == ASSIGN) {
 				/* constant truncated by assignment */
 				warning(165);
-			} else if (op == INIT && tp->t_isfield) {
+			} else if (op == INIT && tp->t_bitfield) {
 				/* bit-field initializer does not fit */
 				warning(180);
 			} else if (op == INIT) {
 				/* initializer does not fit */
 				warning(178);
 			} else if (op == CASE) {
 				/* case label affected by conversion */
 				warning(196);
 			} else if (op == FARG) {
 				/* conv. of '%s' to '%s' is out of range, ... */
 				warning(295,
 				    type_name(gettyp(ot)), type_name(tp), arg);
 			} else {
 				/* conversion of '%s' to '%s' is out of range */
 				warning(119,
 				    type_name(gettyp(ot)), type_name(tp));
+			}
 		} else if (nv->v_quad != v->v_quad) {
-			if (op == ASSIGN && tp->t_isfield) {
+			if (op == ASSIGN && tp->t_bitfield) {
 				/* precision lost in bit-field assignment */
 				warning(166);
-			} else if (op == INIT && tp->t_isfield) {
+			} else if (op == INIT && tp->t_bitfield) {
 				/* bit-field initializer out of range */
 				warning(11);
 			} else if (op == CASE) {
 				/* case label affected by conversion */
 				warning(196);
 			} else if (op == FARG) {
 				/* conv. of '%s' to '%s' is out of range, ... */
 				warning(295,
 				    type_name(gettyp(ot)), type_name(tp), arg);
 			} else {
 				/* conversion of '%s' to '%s' is out of range */
 				warning(119,
 				    type_name(gettyp(ot)), type_name(tp));
 @@ -2299,27 +2299,27 @@ build_struct_access(op_t op, tnode_t *ln
 		ln = convert(NOOP, 0, tincref(gettyp(VOID), PTR), ln);
+	}
 #if PTRDIFF_IS_LONG
 	ctn = new_int_const_node(LONG, rn->tn_sym->s_value.v_quad / CHAR_BIT);
 #else
 	ctn = new_int_const_node(INT, rn->tn_sym->s_value.v_quad / CHAR_BIT);
 #endif
 	ntn = new_tnode(PLUS, tincref(rn->tn_type, PTR), ln, ctn);
 	if (ln->tn_op == CON)
 		ntn = fold(ntn);
-	if (rn->tn_type->t_isfield) {
+	if (rn->tn_type->t_bitfield) {
 		ntn = new_tnode(FSEL, ntn->tn_type->t_subt, ntn, NULL);
 	} else {
 		ntn = new_tnode(STAR, ntn->tn_type->t_subt, ntn, NULL);
+	}
 	if (nolval)
 		ntn->tn_lvalue = 0;
 	return ntn;
+}
 /*
  * Create a node for INCAFT, INCBEF, DECAFT and DECBEF.
 @@ -2581,27 +2581,27 @@ build_assignment(op_t op, tnode_t *ln, t
 			return NULL;
+		}
+	}
 	if (op == SHLASS) {
 		if (psize(lt) < psize(rt)) {
 			if (hflag)
 				/* semantics of '%s' change in ANSI C; ... */
 				warning(118, "<<=");
+		}
 	} else if (op != SHRASS) {
 		if (op == ASSIGN || lt != PTR) {
 			if (lt != rt ||
-			    (ln->tn_type->t_isfield && rn->tn_op == CON)) {
+			    (ln->tn_type->t_bitfield && rn->tn_op == CON)) {
 				rn = convert(op, 0, ln->tn_type, rn);
 				rt = lt;
+			}
+		}
+	}
 	ntn = new_tnode(op, ln->tn_type, ln, rn);
 	return ntn;
+}
 /*
  * Get length of type tp->t_subt.
 @@ -3036,27 +3036,27 @@ tsize(type_t *tp)
 			error(143);
 			elsz = 1;
 		} else {
 			elsz = tp->t_str->size;
+		}
 		break;
 	case ENUM:
 		if (incompl(tp)) {
 			/* cannot take size/alignment of incomplete type */
 			warning(143);
+		}
 		/* FALLTHROUGH */
 	default:
-		if (tp->t_isfield) {
+		if (tp->t_bitfield) {
 			/* cannot take size/alignment of bit-field */
 			error(145);
+		}
 		if (tp->t_tspec == VOID) {
 			/* cannot take size/alignment of void */
 			error(146);
 			elsz = 1;
 		} else {
 			elsz = size(tp->t_tspec);
 			lint_assert(elsz > 0);
+		}
 		break;
+	}
 @@ -3082,27 +3082,27 @@ build_alignof(type_t *tp)
 		return 0;
 	case STRUCT:
 	case UNION:
 		if (incompl(tp)) {
 			/* cannot take size/alignment of incomplete type */
 			error(143);
 			return 0;
+		}
 		break;
 	case ENUM:
 		break;
 	default:
-		if (tp->t_isfield) {
+		if (tp->t_bitfield) {
 			/* cannot take size/alignment of bit-field */
 			error(145);
 			return 0;
+		}
 		if (tp->t_tspec == VOID) {
 			/* cannot take size/alignment of void */
 			error(146);
 			return 0;
+		}
 		break;
+	}
 #if SIZEOF_IS_ULONG

 @@ -1,14 +1,14 @@
-/* $NetBSD: lint1.h,v 1.49 2021/01/03 18:48:37 rillig Exp $ */
+/* $NetBSD: lint1.h,v 1.50 2021/01/03 19:10:47 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
 @@ -146,27 +146,27 @@ typedef	struct {
 /*
  * Types are represented by concatenation of structures of type type_t
  * via t_subt.
  */
 struct type {
 	tspec_t	t_tspec;	/* type specifier */
 	bool	t_aincompl : 1;	/* incomplete array type */
 	bool	t_const : 1;	/* const modifier */
 	bool	t_volatile : 1;	/* volatile modifier */
 	bool	t_proto : 1;	/* function prototype (t_args valid) */
 	bool	t_vararg : 1;	/* prototype with ... */
 	bool	t_typedef : 1;	/* type defined with typedef */
-	bool	t_isfield : 1;	/* type is bitfield */
+	bool	t_bitfield : 1;
 	bool	t_isenum : 1;	/* type is (or was) enum (t_enum valid) */
 	bool	t_ispacked : 1;	/* type is packed */
 	union {
 		int	_t_dim;		/* dimension */
 		str_t	*_t_str;	/* struct/union tag */
 		tenum_t	*_t_enum;	/* enum tag */
 		struct	sym *_t_args;	/* arguments (if t_proto) */
 	} t_u;
 	struct {
 		u_int	_t_flen : 8;	/* length of bit-field */
 		u_int	_t_foffs : 24;	/* offset of bit-field */
 	} t_b;
 	struct	type *t_subt;	/* element type (arrays), return value