xref: /src/usr.bin/indent/indent.c

/*	$NetBSD: indent.c,v 1.352 2023/06/10 08:17:04 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
 *    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 the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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.
 */

#include <sys/cdefs.h>
__RCSID("$NetBSD: indent.c,v 1.352 2023/06/10 08:17:04 rillig Exp $");

#include <sys/param.h>
#include <err.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "indent.h"

struct options opt = {
	.brace_same_line = true,
	.comment_delimiter_on_blankline = true,
	.cuddle_else = true,
	.comment_column = 33,
	.decl_indent = 16,
	.else_if_in_same_line = true,
	.function_brace_split = true,
	.format_col1_comments = true,
	.format_block_comments = true,
	.indent_parameters = true,
	.indent_size = 8,
	.local_decl_indent = -1,
	.lineup_to_parens = true,
	.procnames_start_line = true,
	.star_comment_cont = true,
	.tabsize = 8,
	.max_line_length = 78,
	.use_tabs = true,
};

struct parser_state ps;

struct buffer token;

struct buffer lab;
struct buffer code;
struct buffer com;

bool found_err;
bool had_eof;
int line_no = 1;

static int ifdef_level;
static struct parser_state state_stack[5];

FILE *input;
FILE *output;

static const char *in_name = "Standard Input";
static const char *backup_suffix = ".BAK";
static char bakfile[MAXPATHLEN] = "";


void *
nonnull(void *p)
{
	if (p == NULL)
		err(EXIT_FAILURE, NULL);
	return p;
}

static void
buf_expand(struct buffer *buf, size_t add_size)
{
	buf->cap = buf->cap + add_size + 400;
	buf->s = nonnull(realloc(buf->s, buf->cap));
}

void
buf_add_char(struct buffer *buf, char ch)
{
	if (buf->len == buf->cap)
		buf_expand(buf, 1);
	buf->s[buf->len++] = ch;
}

void
buf_add_chars(struct buffer *buf, const char *s, size_t len)
{
	if (len == 0)
		return;
	if (len > buf->cap - buf->len)
		buf_expand(buf, len);
	memcpy(buf->s + buf->len, s, len);
	buf->len += len;
}

static void
buf_add_buf(struct buffer *buf, const struct buffer *add)
{
	buf_add_chars(buf, add->s, add->len);
}

void
diag(int level, const char *msg, ...)
{
	va_list ap;

	if (level != 0)
		found_err = true;

	va_start(ap, msg);
	fprintf(stderr, "%s: %s:%d: ",
	    level == 0 ? "warning" : "error", in_name, line_no);
	vfprintf(stderr, msg, ap);
	fprintf(stderr, "\n");
	va_end(ap);
}

/*
 * Compute the indentation from starting at 'ind' and adding the text starting
 * at 's'.
 */
int
ind_add(int ind, const char *s, size_t len)
{
	for (const char *p = s; len > 0; p++, len--) {
		if (*p == '\n')
			ind = 0;
		else if (*p == '\t')
			ind = next_tab(ind);
		else if (*p == '\b')
			--ind;
		else
			++ind;
	}
	return ind;
}

static void
init_globals(void)
{
	ps.psyms.sym[0] = psym_stmt_list;
	ps.prev_lsym = lsym_semicolon;
	ps.next_col_1 = true;
	ps.lbrace_kind = psym_lbrace_block;

	const char *suffix = getenv("SIMPLE_BACKUP_SUFFIX");
	if (suffix != NULL)
		backup_suffix = suffix;
}

static void
load_profiles(int argc, char **argv)
{
	const char *profile_name = NULL;

	for (int i = 1; i < argc; ++i) {
		const char *arg = argv[i];

		if (strcmp(arg, "-npro") == 0)
			return;
		if (arg[0] == '-' && arg[1] == 'P' && arg[2] != '\0')
			profile_name = arg + 2;
	}

	load_profile_files(profile_name);
}

/*
 * Copy the input file to the backup file, then make the backup file the input
 * and the original input file the output.
 */
static void
bakcopy(void)
{
	ssize_t n;
	int bak_fd;
	char buff[8 * 1024];

	const char *last_slash = strrchr(in_name, '/');
	snprintf(bakfile, sizeof(bakfile), "%s%s",
	    last_slash != NULL ? last_slash + 1 : in_name, backup_suffix);

	/* copy in_name to backup file */
	bak_fd = creat(bakfile, 0600);
	if (bak_fd < 0)
		err(1, "%s", bakfile);

	while ((n = read(fileno(input), buff, sizeof(buff))) > 0)
		if (write(bak_fd, buff, (size_t)n) != n)
			err(1, "%s", bakfile);
	if (n < 0)
		err(1, "%s", in_name);

	close(bak_fd);
	(void)fclose(input);

	/* re-open backup file as the input file */
	input = fopen(bakfile, "r");
	if (input == NULL)
		err(1, "%s", bakfile);
	/* now the original input file will be the output */
	output = fopen(in_name, "w");
	if (output == NULL) {
		unlink(bakfile);
		err(1, "%s", in_name);
	}
}

static void
parse_command_line(int argc, char **argv)
{
	for (int i = 1; i < argc; ++i) {
		const char *arg = argv[i];

		if (arg[0] == '-') {
			set_option(arg, "Command line");

		} else if (input == NULL) {
			in_name = arg;
			if ((input = fopen(in_name, "r")) == NULL)
				err(1, "%s", in_name);

		} else if (output == NULL) {
			if (strcmp(arg, in_name) == 0)
				errx(1, "input and output files "
				    "must be different");
			if ((output = fopen(arg, "w")) == NULL)
				err(1, "%s", arg);

		} else
			errx(1, "too many arguments: %s", arg);
	}

	if (input == NULL) {
		input = stdin;
		output = stdout;
	} else if (output == NULL)
		bakcopy();

	if (opt.comment_column <= 1)
		opt.comment_column = 2;	/* don't put normal comments in column
					 * 1, see opt.format_col1_comments */
	if (opt.block_comment_max_line_length <= 0)
		opt.block_comment_max_line_length = opt.max_line_length;
	if (opt.local_decl_indent < 0)
		opt.local_decl_indent = opt.decl_indent;
	if (opt.decl_comment_column <= 0)
		opt.decl_comment_column = opt.left_justify_decl
		    ? (opt.comment_column <= 10 ? 2 : opt.comment_column - 8)
		    : opt.comment_column;
	if (opt.continuation_indent == 0)
		opt.continuation_indent = opt.indent_size;
}

static void
set_initial_indentation(void)
{
	inp_read_line();

	int ind = 0;
	for (const char *p = inp_p;; p++) {
		if (*p == ' ')
			ind++;
		else if (*p == '\t')
			ind = next_tab(ind);
		else
			break;
	}

	ps.ind_level = ps.ind_level_follow = ind / opt.indent_size;
}

static void
maybe_break_line(lexer_symbol lsym)
{
	if (!ps.force_nl)
		return;
	if (lsym == lsym_semicolon)
		return;
	if (lsym == lsym_lbrace && opt.brace_same_line
	    && ps.prev_lsym != lsym_lbrace)
		return;

	output_line();
	ps.force_nl = false;
}

static void
move_com_to_code(lexer_symbol lsym)
{
	if (ps.want_blank)
		buf_add_char(&code, ' ');
	buf_add_buf(&code, &com);
	com.len = 0;
	ps.want_blank = lsym != lsym_rparen && lsym != lsym_rbracket;
}

static void
update_ps_lbrace_kind(lexer_symbol lsym)
{
	if (lsym == lsym_tag) {
		ps.lbrace_kind = token.s[0] == 's' ? psym_lbrace_struct :
		    token.s[0] == 'u' ? psym_lbrace_union :
		    psym_lbrace_enum;
	} else if (lsym != lsym_type_outside_parentheses
	    && lsym != lsym_word
	    && lsym != lsym_lbrace)
		ps.lbrace_kind = psym_lbrace_block;
}

static void
indent_declarator(int decl_ind, bool tabs_to_var)
{
	int base = ps.ind_level * opt.indent_size;
	int ind = base + (int)code.len;
	int target = base + decl_ind;
	size_t orig_code_len = code.len;

	if (tabs_to_var)
		for (int next; (next = next_tab(ind)) <= target; ind = next)
			buf_add_char(&code, '\t');

	for (; ind < target; ind++)
		buf_add_char(&code, ' ');

	if (code.len == orig_code_len && ps.want_blank) {
		buf_add_char(&code, ' ');
		ps.want_blank = false;
	}
	ps.decl_indent_done = true;
}

static bool
is_function_pointer_declaration(void)
{
	return ps.in_decl
	    && !ps.in_init
	    && !ps.decl_indent_done
	    && !ps.line_has_func_def
	    && ps.line_start_nparen == 0;
}

static int
process_eof(void)
{
	output_finish();

	if (ps.psyms.top > 1)	/* check for balanced braces */
		diag(1, "Stuff missing from end of file");

	return found_err ? EXIT_FAILURE : EXIT_SUCCESS;
}

/* move the whole line to the 'label' buffer */
static void
read_preprocessing_line(void)
{
	enum {
		PLAIN, STR, CHR, COMM
	} state = PLAIN;

	buf_add_char(&lab, '#');

	while (inp_p[0] != '\n' || (state == COMM && !had_eof)) {
		buf_add_char(&lab, inp_next());
		switch (lab.s[lab.len - 1]) {
		case '\\':
			if (state != COMM)
				buf_add_char(&lab, inp_next());
			break;
		case '/':
			if (inp_p[0] == '*' && state == PLAIN) {
				state = COMM;
				buf_add_char(&lab, *inp_p++);
			}
			break;
		case '"':
			if (state == STR)
				state = PLAIN;
			else if (state == PLAIN)
				state = STR;
			break;
		case '\'':
			if (state == CHR)
				state = PLAIN;
			else if (state == PLAIN)
				state = CHR;
			break;
		case '*':
			if (inp_p[0] == '/' && state == COMM) {
				state = PLAIN;
				buf_add_char(&lab, *inp_p++);
			}
			break;
		}
	}

	while (lab.len > 0 && ch_isblank(lab.s[lab.len - 1]))
		lab.len--;
}

static void
process_preprocessing(void)
{
	if (lab.len > 0 || code.len > 0 || com.len > 0)
		output_line();

	read_preprocessing_line();

	const char *dir = lab.s + 1, *line_end = lab.s + lab.len;
	while (dir < line_end && ch_isblank(*dir))
		dir++;
	size_t dir_len = 0;
	while (dir + dir_len < line_end && ch_isalpha(dir[dir_len]))
		dir_len++;

	if (dir_len >= 2 && memcmp(dir, "if", 2) == 0) {
		if ((size_t)ifdef_level < array_length(state_stack))
			state_stack[ifdef_level++] = ps;
		else
			diag(1, "#if stack overflow");
		out.line_kind = lk_if;

	} else if (dir_len >= 2 && memcmp(dir, "el", 2) == 0) {
		if (ifdef_level <= 0)
			diag(1, dir[2] == 'i'
			    ? "Unmatched #elif" : "Unmatched #else");
		else
			ps = state_stack[ifdef_level - 1];

	} else if (dir_len == 5 && memcmp(dir, "endif", 5) == 0) {
		if (ifdef_level <= 0)
			diag(1, "Unmatched #endif");
		else
			ifdef_level--;
		out.line_kind = lk_endif;
	}
}

static void
process_newline(void)
{
	if (ps.prev_lsym == lsym_comma
	    && ps.nparen == 0 && !ps.in_init
	    && !opt.break_after_comma && ps.break_after_comma
	    && lab.len == 0	/* for preprocessing lines */
	    && com.len == 0)
		goto stay_in_line;
	if (ps.psyms.sym[ps.psyms.top] == psym_switch_expr
	    && opt.brace_same_line) {
		ps.force_nl = true;
		goto stay_in_line;
	}

	output_line();

stay_in_line:
	++line_no;
}

static bool
want_blank_before_lparen(void)
{
	if (!ps.want_blank)
		return false;
	if (opt.proc_calls_space)
		return true;
	if (ps.prev_lsym == lsym_rparen || ps.prev_lsym == lsym_rbracket)
		return false;
	if (ps.prev_lsym == lsym_offsetof)
		return false;
	if (ps.prev_lsym == lsym_sizeof)
		return opt.blank_after_sizeof;
	if (ps.prev_lsym == lsym_word || ps.prev_lsym == lsym_funcname)
		return false;
	return true;
}

static void
process_lparen(void)
{
	if (++ps.nparen == array_length(ps.paren)) {
		diag(0, "Reached internal limit of %zu unclosed parentheses",
		    array_length(ps.paren));
		ps.nparen--;
	}

	if (is_function_pointer_declaration())
		indent_declarator(ps.decl_ind, ps.tabs_to_var);
	else if (want_blank_before_lparen())
		buf_add_char(&code, ' ');
	ps.want_blank = false;
	buf_add_char(&code, token.s[0]);

	if (opt.extra_expr_indent && ps.spaced_expr_psym != psym_0)
		ps.extra_expr_indent = eei_maybe;

	if (ps.in_var_decl && ps.psyms.top <= 2 && !ps.in_init) {
		parse(psym_stmt);	/* prepare for function definition */
		ps.in_var_decl = false;
	}

	int indent = ind_add(0, code.s, code.len);

	enum paren_level_cast cast = cast_unknown;
	if (ps.prev_lsym == lsym_offsetof
	    || ps.prev_lsym == lsym_sizeof
	    || ps.prev_lsym == lsym_for
	    || ps.prev_lsym == lsym_if
	    || ps.prev_lsym == lsym_switch
	    || ps.prev_lsym == lsym_while
	    || ps.line_has_func_def)
		cast = cast_no;

	ps.paren[ps.nparen - 1].indent = indent;
	ps.paren[ps.nparen - 1].cast = cast;
	debug_println("paren_indents[%d] is now %s%d",
	    ps.nparen - 1, paren_level_cast_name[cast], indent);
}

static void
process_rparen(void)
{
	if (ps.nparen == 0) {
		diag(0, "Extra '%c'", *token.s);
		goto unbalanced;
	}

	enum paren_level_cast cast = ps.paren[--ps.nparen].cast;
	if (ps.in_func_def_params || (ps.line_has_decl && !ps.in_init))
		cast = cast_no;

	ps.prev_paren_was_cast = cast == cast_maybe;
	if (cast == cast_maybe) {
		ps.next_unary = true;
		ps.want_blank = opt.space_after_cast;
	} else
		ps.want_blank = true;

	if (code.len == 0)
		ps.line_start_nparen = ps.nparen;

unbalanced:
	buf_add_char(&code, token.s[0]);

	if (ps.spaced_expr_psym != psym_0 && ps.nparen == 0) {
		if (ps.extra_expr_indent == eei_maybe)
			ps.extra_expr_indent = eei_last;
		ps.force_nl = true;
		ps.next_unary = true;
		ps.in_stmt_or_decl = false;
		parse(ps.spaced_expr_psym);
		ps.spaced_expr_psym = psym_0;
		ps.want_blank = true;
		out.line_kind = lk_stmt_head;
	}
}

static void
process_lbracket(void)
{
	if (++ps.nparen == array_length(ps.paren)) {
		diag(0, "Reached internal limit of %zu unclosed parentheses",
		    array_length(ps.paren));
		ps.nparen--;
	}

	if (code.len > 0
	    && (ps.prev_lsym == lsym_comma || ps.prev_lsym == lsym_binary_op))
		buf_add_char(&code, ' ');
	ps.want_blank = false;
	buf_add_char(&code, token.s[0]);

	int indent = ind_add(0, code.s, code.len);

	ps.paren[ps.nparen - 1].indent = indent;
	ps.paren[ps.nparen - 1].cast = cast_no;
	debug_println("paren_indents[%d] is now %d", ps.nparen - 1, indent);
}

static void
process_rbracket(void)
{
	if (ps.nparen == 0) {
		diag(0, "Extra '%c'", *token.s);
		goto unbalanced;
	}
	--ps.nparen;

	ps.want_blank = true;
	if (code.len == 0)
		ps.line_start_nparen = ps.nparen;

unbalanced:
	buf_add_char(&code, token.s[0]);
}

static void
process_lbrace(void)
{
	if (ps.prev_lsym == lsym_rparen && ps.prev_paren_was_cast) {
		ps.in_var_decl = true;	// XXX: not really
		ps.in_init = true;
	}

	if (out.line_kind == lk_stmt_head)
		out.line_kind = lk_other;

	ps.in_stmt_or_decl = false;	/* don't indent the {} */

	if (!ps.in_init)
		ps.force_nl = true;
	else
		ps.init_level++;

	if (code.len > 0 && !ps.in_init) {
		if (!opt.brace_same_line ||
		    (code.len > 0 && code.s[code.len - 1] == '}'))
			output_line();
		else if (ps.in_func_def_params && !ps.in_var_decl) {
			ps.ind_level_follow = 0;
			if (opt.function_brace_split)
				output_line();
			else
				ps.want_blank = true;
		}
	}

	if (ps.nparen > 0 && ps.init_level == 0) {
		diag(1, "Unbalanced parentheses");
		ps.nparen = 0;
		if (ps.spaced_expr_psym != psym_0) {
			parse(ps.spaced_expr_psym);
			ps.spaced_expr_psym = psym_0;
			ps.ind_level = ps.ind_level_follow;
		}
	}

	if (code.len == 0)
		ps.in_stmt_cont = false;	/* don't indent the '{' itself
						 */
	if (ps.in_decl && ps.in_var_decl) {
		ps.di_stack[ps.decl_level] = ps.decl_ind;
		if (++ps.decl_level == (int)array_length(ps.di_stack)) {
			diag(0, "Reached internal limit of %zu struct levels",
			    array_length(ps.di_stack));
			ps.decl_level--;
		}
	} else {
		ps.line_has_decl = false;	/* we can't be in the middle of
						 * a declaration, so don't do
						 * special indentation of
						 * comments */
		ps.in_func_def_params = false;
		ps.in_decl = false;
	}

	ps.decl_ind = 0;
	parse(ps.lbrace_kind);
	if (ps.want_blank)
		buf_add_char(&code, ' ');
	ps.want_blank = false;
	buf_add_char(&code, '{');
	ps.declaration = decl_no;
}

static void
process_rbrace(void)
{
	if (ps.nparen > 0 && ps.init_level == 0) {
		diag(1, "Unbalanced parentheses");
		ps.nparen = 0;
		ps.spaced_expr_psym = psym_0;
	}

	ps.declaration = decl_no;
	if (ps.init_level > 0)
		ps.init_level--;

	if (code.len > 0 && !ps.in_init)
		output_line();

	buf_add_char(&code, '}');
	ps.want_blank = true;
	ps.in_stmt_or_decl = false;	// XXX: Initializers don't end a stmt
	ps.in_stmt_cont = false;

	if (ps.decl_level > 0) {	/* multi-level structure declaration */
		ps.decl_ind = ps.di_stack[--ps.decl_level];
		if (ps.decl_level == 0 && !ps.in_func_def_params) {
			ps.declaration = decl_begin;
			ps.decl_ind = ps.ind_level == 0
			    ? opt.decl_indent : opt.local_decl_indent;
		}
		ps.in_decl = true;
	}

	if (ps.psyms.top == 2)
		out.line_kind = lk_func_end;

	parse(psym_rbrace);

	if (!ps.in_var_decl
	    && ps.psyms.sym[ps.psyms.top] != psym_do_stmt
	    && ps.psyms.sym[ps.psyms.top] != psym_if_expr_stmt)
		ps.force_nl = true;
}

static void
process_period(void)
{
	if (code.len > 0 && code.s[code.len - 1] == ',')
		buf_add_char(&code, ' ');
	buf_add_char(&code, '.');
	ps.want_blank = false;
}

static void
process_unary_op(void)
{
	if (is_function_pointer_declaration()) {
		int ind = ps.decl_ind - (int)token.len;
		indent_declarator(ind, ps.tabs_to_var);
		ps.want_blank = false;
	} else if ((token.s[0] == '+' || token.s[0] == '-')
	    && code.len > 0 && code.s[code.len - 1] == token.s[0])
		ps.want_blank = true;

	if (ps.want_blank)
		buf_add_char(&code, ' ');
	buf_add_buf(&code, &token);
	ps.want_blank = false;
}

static void
process_postfix_op(void)
{
	buf_add_buf(&code, &token);
	ps.want_blank = true;
}

static void
process_comma(void)
{
	ps.want_blank = code.len > 0;	/* only put blank after comma if comma
					 * does not start the line */

	if (ps.in_decl && !ps.line_has_func_def && !ps.in_init &&
	    !ps.decl_indent_done && ps.line_start_nparen == 0) {
		/* indent leading commas and not the actual identifiers */
		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
	}

	buf_add_char(&code, ',');

	if (ps.nparen == 0) {
		if (ps.init_level == 0)
			ps.in_init = false;
		int typical_varname_length = 8;
		if (ps.break_after_comma && (opt.break_after_comma ||
			ind_add(compute_code_indent(), code.s, code.len)
			>= opt.max_line_length - typical_varname_length))
			ps.force_nl = true;
	}
}

static void
process_colon_label(void)
{
	buf_add_buf(&lab, &code);
	buf_add_char(&lab, ':');
	code.len = 0;

	if (ps.seen_case)
		out.line_kind = lk_case_or_default;
	ps.in_stmt_or_decl = false;
	ps.force_nl = ps.seen_case;
	ps.seen_case = false;
	ps.want_blank = false;
}

static void
process_colon_other(void)
{
	buf_add_char(&code, ':');
	ps.want_blank = ps.decl_level == 0;
}

static void
process_semicolon(void)
{
	if (out.line_kind == lk_stmt_head)
		out.line_kind = lk_other;
	if (ps.decl_level == 0)
		ps.in_var_decl = false;
	ps.seen_case = false;	/* only needs to be reset on error */
	ps.quest_level = 0;	/* only needs to be reset on error */
	if (ps.prev_lsym == lsym_rparen)
		ps.in_func_def_params = false;
	ps.in_init = false;
	ps.init_level = 0;
	ps.declaration = ps.declaration == decl_begin ? decl_end : decl_no;

	if (ps.in_decl && code.len == 0 && !ps.in_init &&
	    !ps.decl_indent_done && ps.line_start_nparen == 0) {
		/* indent stray semicolons in declarations */
		indent_declarator(ps.decl_ind - 1, ps.tabs_to_var);
	}

	ps.in_decl = ps.decl_level > 0;	/* if we were in a first level
					 * structure declaration before, we
					 * aren't anymore */

	if (ps.nparen > 0 && ps.spaced_expr_psym != psym_for_exprs) {
		/* There were unbalanced parentheses in the statement. It is a
		 * bit complicated, because the semicolon might be in a for
		 * statement. */
		diag(1, "Unbalanced parentheses");
		ps.nparen = 0;
		if (ps.spaced_expr_psym != psym_0) {
			parse(ps.spaced_expr_psym);
			ps.spaced_expr_psym = psym_0;
		}
	}
	buf_add_char(&code, ';');
	ps.want_blank = true;
	ps.in_stmt_or_decl = ps.nparen > 0;
	ps.decl_ind = 0;

	if (ps.spaced_expr_psym == psym_0) {
		parse(psym_stmt);
		ps.force_nl = true;
	}
}

static void
process_type_outside_parentheses(void)
{
	parse(psym_decl);	/* let the parser worry about indentation */

	if (ps.prev_lsym == lsym_rparen && ps.psyms.top <= 1 && code.len > 0)
		output_line();

	if (ps.in_func_def_params && opt.indent_parameters &&
	    ps.decl_level == 0) {
		ps.ind_level = ps.ind_level_follow = 1;
		ps.in_stmt_cont = false;
	}

	ps.in_var_decl = /* maybe */ true;
	ps.in_decl = ps.line_has_decl = ps.prev_lsym != lsym_typedef;
	if (ps.decl_level <= 0)
		ps.declaration = decl_begin;

	int len = (int)token.len + 1;
	int ind = ps.ind_level == 0 || ps.decl_level > 0
	    ? opt.decl_indent	/* global variable or local member */
	    : opt.local_decl_indent;	/* local variable */
	ps.decl_ind = ind > 0 ? ind : len;
	ps.tabs_to_var = opt.use_tabs && ind > 0;
}

static void
process_word(lexer_symbol lsym)
{
	if (ps.in_decl) {
		if (lsym == lsym_funcname) {
			ps.in_decl = false;
			if (opt.procnames_start_line && code.len > 0)
				output_line();
			else if (ps.want_blank)
				buf_add_char(&code, ' ');
			ps.want_blank = false;

		} else if (!ps.in_init && !ps.decl_indent_done &&
		    ps.line_start_nparen == 0) {
			if (opt.decl_indent == 0
			    && code.len > 0 && code.s[code.len - 1] == '}')
				ps.decl_ind = ind_add(0, code.s, code.len) + 1;
			indent_declarator(ps.decl_ind, ps.tabs_to_var);
			ps.want_blank = false;
		}

	} else if (ps.spaced_expr_psym != psym_0 && ps.nparen == 0) {
		ps.force_nl = true;
		ps.in_stmt_or_decl = false;
		ps.next_unary = true;
		parse(ps.spaced_expr_psym);
		ps.spaced_expr_psym = psym_0;
	}
}

static void
process_do(void)
{
	ps.in_stmt_or_decl = false;
	ps.in_decl = false;

	if (code.len > 0)
		output_line();

	ps.force_nl = true;
	parse(psym_do);
}

static void
process_else(void)
{
	ps.in_stmt_or_decl = false;

	if (code.len > 0
	    && !(opt.cuddle_else && code.s[code.len - 1] == '}'))
		output_line();

	ps.force_nl = true;
	parse(psym_else);
}

static void
process_lsym(lexer_symbol lsym)
{
	switch (lsym) {
		/* INDENT OFF */
	case lsym_preprocessing: process_preprocessing(); break;
	case lsym_newline:	process_newline();	break;
	case lsym_comment:	process_comment();	break;
	case lsym_lparen:	process_lparen();	break;
	case lsym_lbracket:	process_lbracket();	break;
	case lsym_rparen:	process_rparen();	break;
	case lsym_rbracket:	process_rbracket();	break;
	case lsym_lbrace:	process_lbrace();	break;
	case lsym_rbrace:	process_rbrace();	break;
	case lsym_period:	process_period();	break;
	case lsym_unary_op:	process_unary_op();	break;
	case lsym_postfix_op:	process_postfix_op();	break;
	case lsym_binary_op:				goto copy_token;
	case lsym_question:	ps.quest_level++;	goto copy_token;
	case lsym_colon_question:			goto copy_token;
	case lsym_colon_label:	process_colon_label();	break;
	case lsym_colon_other:	process_colon_other();	break;
	case lsym_comma:	process_comma();	break;
	case lsym_semicolon:	process_semicolon();	break;
	case lsym_typedef:				goto copy_token;
	case lsym_modifier:				goto copy_token;
	case lsym_case:		ps.seen_case = true;	goto copy_token;
	case lsym_default:	ps.seen_case = true;	goto copy_token;
	case lsym_do:		process_do();		goto copy_token;
	case lsym_else:		process_else();		goto copy_token;
	case lsym_for:		ps.spaced_expr_psym = psym_for_exprs; goto copy_token;
	case lsym_if:		ps.spaced_expr_psym = psym_if_expr; goto copy_token;
	case lsym_switch:	ps.spaced_expr_psym = psym_switch_expr; goto copy_token;
	case lsym_while:	ps.spaced_expr_psym = psym_while_expr; goto copy_token;
		/* INDENT ON */

	case lsym_tag:
		if (ps.nparen > 0)
			goto copy_token;
		/* FALLTHROUGH */
	case lsym_type_outside_parentheses:
		process_type_outside_parentheses();
		goto copy_token;

	case lsym_type_in_parentheses:
	case lsym_sizeof:
	case lsym_offsetof:
	case lsym_word:
	case lsym_funcname:
	case lsym_return:
		process_word(lsym);
copy_token:
		if (ps.want_blank)
			buf_add_char(&code, ' ');
		buf_add_buf(&code, &token);
		if (lsym != lsym_funcname)
			ps.want_blank = true;
		break;

	default:
		break;
	}
}

static int
indent(void)
{
	debug_parser_state();

	for (;;) {		/* loop until we reach eof */
		lexer_symbol lsym = lexi();

		debug_blank_line();
		debug_printf("line %d: %s", line_no, lsym_name[lsym]);
		debug_print_buf("token", &token);
		debug_buffers();
		debug_blank_line();

		if (lsym == lsym_eof)
			return process_eof();

		if (lsym == lsym_if && ps.prev_lsym == lsym_else
		    && opt.else_if_in_same_line)
			ps.force_nl = false;

		if (lsym == lsym_newline || lsym == lsym_preprocessing)
			ps.force_nl = false;
		else if (lsym == lsym_comment) {
			/* no special processing */
		} else {
			maybe_break_line(lsym);
			ps.in_stmt_or_decl = true;
			if (com.len > 0)
				move_com_to_code(lsym);
			update_ps_lbrace_kind(lsym);
		}

		process_lsym(lsym);

		debug_parser_state();

		if (lsym != lsym_comment && lsym != lsym_newline &&
		    lsym != lsym_preprocessing)
			ps.prev_lsym = lsym;
	}
}

int
main(int argc, char **argv)
{
	init_globals();
	load_profiles(argc, argv);
	parse_command_line(argc, argv);
	set_initial_indentation();
	return indent();
}