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

/*	$NetBSD: io.c,v 1.206 2023/06/09 07:20:30 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
 *    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: io.c,v 1.206 2023/06/09 07:20:30 rillig Exp $");

#include <stdio.h>

#include "indent.h"

struct buffer inp;
const char *inp_p;

struct output_state out;
static int out_ind;		/* width of the line that is being written */
static unsigned wrote_newlines = 2;	/* 0 in the middle of a line, 1 after a
					 * single '\n', > 1 means there were (n
					 * - 1) blank lines above */
static int paren_indent;


static void
inp_read_next_line(FILE *f)
{
	inp.len = 0;

	for (;;) {
		int ch = getc(f);
		if (ch == EOF) {
			if (indent_enabled == indent_on) {
				buf_add_char(&inp, ' ');
				buf_add_char(&inp, '\n');
			}
			had_eof = true;
			break;
		}

		if (ch != '\0')
			buf_add_char(&inp, (char)ch);
		if (ch == '\n')
			break;
	}
	inp_p = inp.s;
}

void
inp_read_line(void)
{
	if (indent_enabled == indent_on)
		out.indent_off_text.len = 0;
	buf_add_chars(&out.indent_off_text, inp.s, inp.len);
	inp_read_next_line(input);
}

void
inp_skip(void)
{
	inp_p++;
	if ((size_t)(inp_p - inp.s) >= inp.len)
		inp_read_line();
}

char
inp_next(void)
{
	char ch = inp_p[0];
	inp_skip();
	return ch;
}


static void
output_newline(void)
{
	fputc('\n', output);
	debug_println("output_newline");
	wrote_newlines++;
	out_ind = 0;
}

static void
output_range(const char *s, size_t len)
{
	fwrite(s, 1, len, output);
	debug_vis_range("output_range \"", s, len, "\"\n");
	for (size_t i = 0; i < len; i++)
		wrote_newlines = s[i] == '\n' ? wrote_newlines + 1 : 0;
	out_ind = ind_add(out_ind, s, len);
}

static void
output_indent(int new_ind)
{
	int ind = out_ind;

	if (opt.use_tabs) {
		int n = new_ind / opt.tabsize - ind / opt.tabsize;
		if (n > 0) {
			ind = ind - ind % opt.tabsize + n * opt.tabsize;
			while (n-- > 0)
				fputc('\t', output);
			wrote_newlines = 0;
		}
	}

	for (; ind < new_ind; ind++) {
		fputc(' ', output);
		wrote_newlines = 0;
	}

	debug_println("output_indent %d", ind);
	out_ind = ind;
}

static bool
want_blank_line(void)
{
	debug_println("%s: %s -> %s", __func__,
	    line_kind_name[out.prev_line_kind], line_kind_name[out.line_kind]);

	if (ps.blank_line_after_decl && ps.declaration == decl_no) {
		ps.blank_line_after_decl = false;
		return true;
	}
	if (opt.blanklines_around_conditional_compilation) {
		if (out.prev_line_kind != lk_if && out.line_kind == lk_if)
			return true;
		if (out.prev_line_kind == lk_endif
		    && out.line_kind != lk_endif)
			return true;
	}
	if (opt.blanklines_after_procs && out.prev_line_kind == lk_func_end
	    && out.line_kind != lk_endif)
		return true;
	if (opt.blanklines_before_block_comments
	    && out.line_kind == lk_block_comment)
		return true;
	return false;
}

static bool
is_blank_line_optional(void)
{
	if (out.prev_line_kind == lk_stmt_head)
		return wrote_newlines >= 1;
	if (ps.psyms.top >= 2)
		return wrote_newlines >= 2;
	return wrote_newlines >= 3;
}

static int
compute_case_label_indent(void)
{
	int i = ps.psyms.top;
	while (i > 0 && ps.psyms.sym[i] != psym_switch_expr)
		i--;
	float case_ind = (float)ps.psyms.ind_level[i] + opt.case_indent;
	return (int)(case_ind * (float)opt.indent_size);
}

int
compute_label_indent(void)
{
	if (out.line_kind == lk_case_or_default)
		return compute_case_label_indent();
	if (lab.s[0] == '#')
		return 0;
	return opt.indent_size * (ps.ind_level - 2);
}

static void
output_line_label(void)
{
	output_indent(compute_label_indent());
	output_range(lab.s, lab.len);
}

static int
compute_code_indent_lineup(int base_ind)
{
	int ind = paren_indent;
	int overflow = ind_add(ind, code.s, code.len) - opt.max_line_length;
	if (overflow < 0)
		return ind;

	if (ind_add(base_ind, code.s, code.len) < opt.max_line_length) {
		ind -= overflow + 2;
		if (ind > base_ind)
			return ind;
		return base_ind;
	}

	return ind;
}

int
compute_code_indent(void)
{
	int base_ind = ps.ind_level * opt.indent_size;

	if (ps.line_start_nparen == 0) {
		if (ps.psyms.top >= 1
		    && ps.psyms.sym[ps.psyms.top - 1] == psym_lbrace_enum)
			return base_ind;
		if (ps.in_stmt_cont)
			return base_ind + opt.continuation_indent;
		return base_ind;
	}

	if (opt.lineup_to_parens) {
		if (opt.lineup_to_parens_always)
			return paren_indent;
		return compute_code_indent_lineup(base_ind);
	}

	if (ps.extra_expr_indent != eei_no)
		return base_ind + 2 * opt.continuation_indent;

	return base_ind + opt.continuation_indent * ps.line_start_nparen;
}

static void
output_line_code(void)
{
	int target_ind = compute_code_indent();
	for (int i = 0; i < ps.nparen; i++) {
		int paren_ind = ps.paren[i].indent;
		if (paren_ind >= 0) {
			ps.paren[i].indent = -1 - (paren_ind + target_ind);
			debug_println(
			    "setting paren_indents[%d] from %d to %d "
			    "for column %d",
			    i, paren_ind, ps.paren[i].indent, target_ind + 1);
		}
	}

	if (lab.len > 0 && target_ind <= out_ind)
		output_range(" ", 1);
	output_indent(target_ind);
	output_range(code.s, code.len);
}

static void
output_line_comment(void)
{
	int target_ind = ps.com_ind + ps.comment_delta;
	const char *p;

	/* consider original indentation in case this is a box comment */
	for (p = com.s; *p == '\t'; p++)
		target_ind += opt.tabsize;

	for (; target_ind < 0; p++) {
		if (*p == ' ')
			target_ind++;
		else if (*p == '\t')
			target_ind = next_tab(target_ind);
		else {
			target_ind = 0;
			break;
		}
	}

	if (out_ind > target_ind)
		output_newline();

	while (com.s + com.len > p && ch_isspace(com.s[com.len - 1]))
		com.len--;

	output_indent(target_ind);
	output_range(p, com.len - (size_t)(p - com.s));

	ps.comment_delta = ps.n_comment_delta;
}

/*
 * Write a line of formatted source to the output file. The line consists of
 * the label, the code and the comment.
 */
void
output_line(void)
{
	debug_blank_line();
	debug_printf("%s", __func__);
	debug_buffers();

	ps.is_function_definition = false;

	if (indent_enabled == indent_on) {
		if (lab.len == 0 && code.len == 0 && com.len == 0)
			out.line_kind = lk_blank;

		if (want_blank_line() && wrote_newlines < 2
		    && out.line_kind != lk_blank)
			output_newline();

		/* This kludge aligns function definitions correctly. */
		if (ps.ind_level == 0)
			ps.in_stmt_cont = false;

		if (opt.blank_line_after_decl && ps.declaration == decl_end
		    && ps.psyms.top > 1) {
			ps.declaration = decl_no;
			ps.blank_line_after_decl = true;
		}

		if (opt.swallow_optional_blanklines
		    && out.line_kind == lk_blank
		    && is_blank_line_optional())
			goto prepare_next_line;

		if (lab.len > 0)
			output_line_label();
		if (code.len > 0)
			output_line_code();
		if (com.len > 0)
			output_line_comment();

		output_newline();
		out.prev_line_kind = out.line_kind;
	}

	if (indent_enabled == indent_last_off_line) {
		indent_enabled = indent_on;
		output_range(out.indent_off_text.s, out.indent_off_text.len);
		out.indent_off_text.len = 0;
	}

prepare_next_line:
	lab.len = 0;
	code.len = 0;
	com.len = 0;

	ps.decl_on_line = ps.in_decl;
	// XXX: don't reset in_stmt_cont here; see process_colon_question.
	ps.in_stmt_cont = ps.in_stmt_or_decl
	    && !ps.in_decl && ps.block_init_level == 0;
	ps.decl_indent_done = false;
	if (ps.extra_expr_indent == eei_last)
		ps.extra_expr_indent = eei_no;
	if (!(ps.psyms.sym[ps.psyms.top] == psym_if_expr_stmt_else
		&& ps.nparen > 0))
		ps.ind_level = ps.ind_level_follow;
	ps.line_start_nparen = ps.nparen;
	ps.want_blank = false;

	if (ps.nparen > 0) {
		/* TODO: explain what negative indentation means */
		paren_indent = -1 - ps.paren[ps.nparen - 1].indent;
		debug_println("paren_indent is now %d", paren_indent);
	}

	out.line_kind = lk_other;
}