 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent.c,v 1.38 2021/03/09 19:14:39 rillig Exp $	*/
+/*	$NetBSD: indent.c,v 1.39 2021/03/09 19:23:08 rillig Exp $	*/
 /*-
  * SPDX-License-Identifier: BSD-4-Clause
+ *
  * Copyright (c) 1985 Sun Microsystems, Inc.
  * Copyright (c) 1976 Board of Trustees of the University of Illinois.
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  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
 @@ -36,27 +36,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #if 0
 #ifndef lint
 static char sccsid[] = "@(#)indent.c	5.17 (Berkeley) 6/7/93";
 #endif /* not lint */
 #endif
 #include <sys/cdefs.h>
 #ifndef lint
 #if defined(__NetBSD__)
-__RCSID("$NetBSD: indent.c,v 1.38 2021/03/09 19:14:39 rillig Exp $");
+__RCSID("$NetBSD: indent.c,v 1.39 2021/03/09 19:23:08 rillig Exp $");
 #elif defined(__FreeBSD__)
 __FBSDID("$FreeBSD: head/usr.bin/indent/indent.c 340138 2018-11-04 19:24:49Z oshogbo $");
 #endif
 #endif
 #include <sys/param.h>
 #if HAVE_CAPSICUM
 #include <sys/capsicum.h>
 #include <capsicum_helpers.h>
 #endif
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 @@ -585,27 +585,27 @@ check_type:
 	    if (opt.verbose) {
 		printf("There were %d output lines and %d comments\n",
 		       ps.out_lines, ps.out_coms);
 		printf("(Lines with comments)/(Lines with code): %6.3f\n",
 		       (1.0 * ps.com_lines) / code_lines);
+	    }
 	    fflush(output);
 	    exit(found_err);
+	}
 	if (
 		(type_code != comment) &&
 		(type_code != newline) &&
-		(type_code != preesc) &&
+		(type_code != preprocessing) &&
 		(type_code != form_feed)) {
 	    if (force_nl &&
 		    (type_code != semicolon) &&
 		    (type_code != lbrace || !opt.btype_2)) {
 		/* we should force a broken line here */
 		if (opt.verbose)
 		    diag(0, "Line broken");
 		dump_line();
 		ps.want_blank = false;	/* dont insert blank at line start */
 		force_nl = false;
+	    }
 	    ps.in_stmt = true;	/* turn on flag which causes an extra level of
 				 * indentation. this is turned off by a ; or
 @@ -760,27 +760,27 @@ check_type:
 	case binary_op:		/* any binary operation */
+	    {
 		int len = e_token - s_token;
 		check_size_code(len + 1);
 		if (ps.want_blank)
 		    *e_code++ = ' ';
 		memcpy(e_code, token, len);
 		e_code += len;
+	    }
 	    ps.want_blank = true;
 	    break;
-	case postop:		/* got a trailing ++ or -- */
+	case postfix_op:	/* got a trailing ++ or -- */
 	    *e_code++ = token[0];
 	    *e_code++ = token[1];
 	    ps.want_blank = true;
 	    break;
 	case question:		/* got a ? */
 	    squest++;		/* this will be used when a later colon
 				 * appears so we can distinguish the
 				 * <c>?<n>:<n> construct */
 	    if (ps.want_blank)
 		*e_code++ = ' ';
 	    *e_code++ = '?';
 	    ps.want_blank = true;
 @@ -1022,31 +1022,31 @@ check_type:
 		if (e_code != s_code) {	/* make sure this starts a line */
 		    if (opt.verbose)
 			diag(0, "Line broken");
 		    dump_line();
 		    ps.want_blank = false;
+		}
 		force_nl = true;/* also, following stuff must go onto new line */
 		last_else = 0;
 		parse(keyword_do);
+	    }
 	    goto copy_id;	/* move the token into line */
 	case type_def:
-	case storage:
+	case storage_class:
 	    prefix_blankline_requested = 0;
 	    goto copy_id;
-	case structure:
+	case keyword_struct_union_enum:
 	    if (ps.p_l_follow > 0)
 		goto copy_id;
 	    /* FALLTHROUGH */
 	case decl:		/* we have a declaration type (int, etc.) */
 	    parse(decl);	/* let parser worry about indentation */
 	    if (ps.last_token == rparen && ps.tos <= 1) {
 		if (s_code != e_code) {
 		    dump_line();
 		    ps.want_blank = 0;
+		}
+	    }
 	    if (ps.in_parameter_declaration && opt.indent_parameters && ps.dec_nest == 0) {
 		ps.ind_level = ps.i_l_follow = 1;
 @@ -1104,27 +1104,27 @@ check_type:
+	    {
 		int len = e_token - s_token;
 		check_size_code(len + 1);
 		if (ps.want_blank)
 		    *e_code++ = ' ';
 		memcpy(e_code, s_token, len);
 		e_code += len;
+	    }
 	    if (type_code != funcname)
 		ps.want_blank = true;
 	    break;
-	case strpfx:
+	case string_prefix:
+	    {
 		int len = e_token - s_token;
 		check_size_code(len + 1);
 		if (ps.want_blank)
 		    *e_code++ = ' ';
 		memcpy(e_code, token, len);
 		e_code += len;
+	    }
 	    ps.want_blank = false;
 	    break;
 	case period:		/* treat a period kind of like a binary
 @@ -1144,27 +1144,27 @@ check_type:
 		ps.dumped_decl_indent = true;
+	    }
 	    *e_code++ = ',';
 	    if (ps.p_l_follow == 0) {
 		if (ps.block_init_level <= 0)
 		    ps.block_init = 0;
 		if (break_comma && (!opt.leave_comma ||
 		    count_spaces_until(compute_code_target(), s_code, e_code) >
 		    opt.max_col - opt.tabsize))
 		    force_nl = true;
+	    }
 	    break;
-	case preesc:		/* got the character '#' */
+	case preprocessing:	/* '#' */
 	    if ((s_com != e_com) ||
 		    (s_lab != e_lab) ||
 		    (s_code != e_code))
 		dump_line();
 	    check_size_label(1);
 	    *e_lab++ = '#';	/* move whole line to 'label' buffer */
+	    {
 		int         in_comment = 0;
 		int         com_start = 0;
 		char        quote = 0;
 		int         com_end = 0;
 		while (*buf_ptr == ' ' || *buf_ptr == '\t') {
 @@ -1298,27 +1298,29 @@ check_type:
+	    }
 	    break;		/* subsequent processing of the newline
 				 * character will cause the line to be printed */
 	case comment:		/* we have gotten a / followed by * this is a biggie */
 	    pr_comment();
 	    break;
 	default:
 	    break;
 	}			/* end of big switch stmt */
 	*e_code = '\0';		/* make sure code section is null terminated */
-	if (type_code != comment && type_code != newline && type_code != preesc)
+	if (type_code != comment &&
 	    type_code != newline &&
 	    type_code != preprocessing)
 	    ps.last_token = type_code;
     }				/* end of main while (1) loop */
+}
 /*
  * copy input file to backup file if in_name is /blah/blah/blah/file, then
  * backup file will be ".Bfile" then make the backup file the input and
  * original input file the output
  */
 static void
 bakcopy(void)
+{
     int         n,

 @@ -1,14 +1,14 @@
-/*	$NetBSD: indent_codes.h,v 1.10 2021/03/09 19:14:39 rillig Exp $	*/
+/*	$NetBSD: indent_codes.h,v 1.11 2021/03/09 19:23:08 rillig Exp $	*/
 /*-
  * SPDX-License-Identifier: BSD-4-Clause
+ *
  * Copyright (c) 1985 Sun Microsystems, Inc.
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
  * 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
 @@ -37,46 +37,46 @@
  * SUCH DAMAGE.
+ *
  *	@(#)indent_codes.h	8.1 (Berkeley) 6/6/93
  * $FreeBSD: head/usr.bin/indent/indent_codes.h 334564 2018-06-03 16:21:15Z pstef $
  */
 typedef enum token_type {
     end_of_file,
     newline,
     lparen,			/* '(' or '[' */
     rparen,			/* ')' or ']' */
     unary_op,			/* e.g. '+' or '&' */
     binary_op,			/* e.g. '<<' or '+' or '&&' or '/=' */
-    postop,			/* trailing '++' or '--' */
+    postfix_op,			/* trailing '++' or '--' */
     question,			/* the '?' from a '?:' expression */
     case_label,
     colon,
     semicolon,
     lbrace,
     rbrace,
     ident,
     comma,
     comment,
     switch_expr,		/* 'switch' '(' <expr> ')' */
-    preesc,
+    preprocessing,		/* '#' */
     form_feed,
     decl,
     keyword_for_if_while,	/* 'for', 'if' or 'while' */
     keyword_do_else,		/* 'do' or 'else' */
     if_expr,			/* 'if' '(' <expr> ')' */
     while_expr,			/* 'while' '(' <expr> ')' */
     for_exprs,			/* 'for' '(' ... ')' */
     stmt,
     stmt_list,
     keyword_else,		/* 'else' */
     keyword_do,			/* 'do' */
     do_stmt,			/* 'do' <stmt> */
     if_expr_stmt,		/* 'if' '(' <expr> ')' <stmt> */
     if_expr_stmt_else,		/* 'if' '(' <expr> ')' <stmt> 'else' */
     period,
-    strpfx,
+    string_prefix,		/* 'L' */
-    storage,
+    storage_class,
     funcname,
     type_def,
-    structure
+    keyword_struct_union_enum
 } token_type;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lexi.c,v 1.30 2021/03/09 19:14:39 rillig Exp $	*/
+/*	$NetBSD: lexi.c,v 1.31 2021/03/09 19:23:08 rillig Exp $	*/
 /*-
  * SPDX-License-Identifier: BSD-4-Clause
+ *
  * Copyright (c) 1985 Sun Microsystems, Inc.
  * Copyright (c) 1980, 1993
  *	The Regents of the University of California.  All rights reserved.
  * 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
 @@ -36,27 +36,27 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #if 0
 #ifndef lint
 static char sccsid[] = "@(#)lexi.c	8.1 (Berkeley) 6/6/93";
 #endif /* not lint */
 #endif
 #include <sys/cdefs.h>
 #ifndef lint
 #if defined(__NetBSD__)
-__RCSID("$NetBSD: lexi.c,v 1.30 2021/03/09 19:14:39 rillig Exp $");
+__RCSID("$NetBSD: lexi.c,v 1.31 2021/03/09 19:23:08 rillig Exp $");
 #elif defined(__FreeBSD__)
 __FBSDID("$FreeBSD: head/usr.bin/indent/lexi.c 337862 2018-08-15 18:19:45Z pstef $");
 #endif
 #endif
 /*
  * Here we have the token scanner for indent.  It scans off one token and puts
  * it in the global variable "token".  It returns a code, indicating the type
  * of token scanned.
  */
 #include <assert.h>
 #include <err.h>
 @@ -194,34 +194,34 @@ compare_templ_array(const void *key, con
 static int
 compare_string_array(const void *key, const void *elem)
+{
     return strcmp(key, *((const char *const *)elem));
+}
 #ifdef debug
 const char *
 token_type_name(token_type tk)
+{
     static const char *const name[] = {
 	"end_of_file", "newline", "lparen", "rparen", "unary_op",
-	"binary_op", "postop", "question", "case_label", "colon",
+	"binary_op", "postfix_op", "question", "case_label", "colon",
 	"semicolon", "lbrace", "rbrace", "ident", "comma",
-	"comment", "switch_expr", "preesc", "form_feed", "decl",
+	"comment", "switch_expr", "preprocessing", "form_feed", "decl",
 	"keyword_for_if_while", "keyword_do_else",
 	"if_expr", "while_expr", "for_exprs",
 	"stmt", "stmt_list", "keyword_else", "keyword_do", "do_stmt",
-	"if_expr_stmt", "if_expr_stmt_else", "period", "strpfx", "storage",
+	"if_expr_stmt", "if_expr_stmt_else", "period", "string_prefix",
-	"funcname", "type_def", "structure"
+	"storage_class", "funcname", "type_def", "keyword_struct_union_enum"
     };
     assert(0 <= tk && tk < sizeof name / sizeof name[0]);
     return name[tk];
+}
 static void
 print_buf(const char *name, const char *s, const char *e)
+{
     if (s == e)
 	return;
 @@ -319,44 +319,44 @@ lexi(struct parser_state *state)
 			} else
 			    break;
+		}
 		check_size_token(1);
 		/* copy it over */
 		*e_token++ = *buf_ptr++;
 		if (buf_ptr >= buf_end)
 		    fill_buffer();
+	    }
 	*e_token = '\0';
 	if (s_token[0] == 'L' && s_token[1] == '\0' &&
 	      (*buf_ptr == '"' || *buf_ptr == '\''))
-	    return lexi_end(strpfx);
+	    return lexi_end(string_prefix);
 	while (*buf_ptr == ' ' || *buf_ptr == '\t') {	/* get rid of blanks */
 	    if (++buf_ptr >= buf_end)
 		fill_buffer();
+	}
 	state->keyword = rw_0;
-	if (state->last_token == structure && !state->p_l_follow) {
+	if (state->last_token == keyword_struct_union_enum &&
-				/* if last token was 'struct' and we're not
+	    !state->p_l_follow) {
-				 * in parentheses, then this token
+	    /* if last token was 'struct' and we're not in parentheses, then
-				 * should be treated as a declaration */
+	     * this token should be treated as a declaration */
 	    state->last_u_d = true;
 	    return lexi_end(decl);
+	}
 	/*
 	 * Operator after identifier is binary unless last token was 'struct'
 	 */
-	state->last_u_d = (state->last_token == structure);
+	state->last_u_d = (state->last_token == keyword_struct_union_enum);
 	p = bsearch(s_token, specials, sizeof specials / sizeof specials[0],
 	    sizeof specials[0], compare_templ_array);
 	if (p == NULL) {	/* not a special keyword... */
 	    char *u;
 	    /* ... so maybe a type_t or a typedef */
 	    if ((opt.auto_typedefs && ((u = strrchr(s_token, '_')) != NULL) &&
 	        strcmp(u, "_t") == 0) || (typename_top >= 0 &&
 		  bsearch(s_token, typenames, typename_top + 1,
 		    sizeof typenames[0], compare_string_array))) {
 		state->keyword = rw_type;
 		state->last_u_d = true;
 @@ -372,39 +372,39 @@ lexi(struct parser_state *state)
 		return lexi_end(case_label);
 	    case rw_struct_or_union_or_enum:
 	    case rw_type:
 	    found_typename:
 		if (state->p_l_follow) {
 		    /* inside parens: cast, param list, offsetof or sizeof */
 		    state->cast_mask |= (1 << state->p_l_follow) & ~state->not_cast_mask;
+		}
 		if (state->last_token == period || state->last_token == unary_op) {
 		    state->keyword = rw_0;
 		    break;
+		}
 		if (p != NULL && p->rwcode == rw_struct_or_union_or_enum)
-		    return lexi_end(structure);
+		    return lexi_end(keyword_struct_union_enum);
 		if (state->p_l_follow)
 		    break;
 		return lexi_end(decl);
 	    case rw_for_or_if_or_while:
 		return lexi_end(keyword_for_if_while);
 	    case rw_do_or_else:
 		return lexi_end(keyword_do_else);
 	    case rw_storage_class:
-		return lexi_end(storage);
+		return lexi_end(storage_class);
 	    case rw_typedef:
 		return lexi_end(type_def);
 	    default:		/* all others are treated like any other
 				 * identifier */
 		return lexi_end(ident);
 	    }			/* end of switch */
 	}			/* end of if (found_it) */
 	if (*buf_ptr == '(' && state->tos <= 1 && state->ind_level == 0 &&
 	    state->in_parameter_declaration == 0 && state->block_init == 0) {
 	    char *tp = buf_ptr;
 	    while (tp < buf_end)
 @@ -491,27 +491,27 @@ stop_lit:
     case ('('):
     case ('['):
 	unary_delim = true;
 	code = lparen;
 	break;
     case (')'):
     case (']'):
 	code = rparen;
 	break;
     case '#':
 	unary_delim = state->last_u_d;
-	code = preesc;
+	code = preprocessing;
 	break;
     case '?':
 	unary_delim = true;
 	code = question;
 	break;
     case (':'):
 	code = colon;
 	unary_delim = true;
 	break;
     case (';'):
 @@ -552,27 +552,27 @@ stop_lit:
 	code = period;
 	break;
     case '-':
     case '+':			/* check for -, +, --, ++ */
 	code = (state->last_u_d ? unary_op : binary_op);
 	unary_delim = true;
 	if (*buf_ptr == token[0]) {
 	    /* check for doubled character */
 	    *e_token++ = *buf_ptr++;
 	    /* buffer overflow will be checked at end of loop */
 	    if (state->last_token == ident || state->last_token == rparen) {
-		code = (state->last_u_d ? unary_op : postop);
+		code = (state->last_u_d ? unary_op : postfix_op);
 		/* check for following ++ or -- */
 		unary_delim = false;
+	    }
+	}
 	else if (*buf_ptr == '=')
 	    /* check for operator += */
 	    *e_token++ = *buf_ptr++;
 	else if (*buf_ptr == '>') {
 	    /* check for operator -> */
 	    *e_token++ = *buf_ptr++;
 	    unary_delim = false;
 	    code = unary_op;
 	    state->want_blank = false;