/*	$NetBSD: setterm.c,v 1.72 2024/05/17 23:32:50 uwe Exp $	*/

/*
 * Copyright (c) 1981, 1993, 1994
 *	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. 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>
#ifndef lint
#if 0
static char sccsid[] = "@(#)setterm.c	8.8 (Berkeley) 10/25/94";
#else
__RCSID("$NetBSD: setterm.c,v 1.72 2024/05/17 23:32:50 uwe Exp $");
#endif
#endif /* not lint */

#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>

#include "curses.h"
#include "curses_private.h"

static int does_esc_m(const char *cap);
static int does_ctrl_o(const char *exit_cap, const char *acs_cap);

attr_t	 __mask_op, __mask_me, __mask_ue, __mask_se;

int
setterm(const char *type)
{

	return _cursesi_setterm(type, _cursesi_screen);
}

int
_cursesi_setterm(const char *type, SCREEN *screen)
{
	int unknown, r;
	char *p;

	if (type[0] == '\0')
		type = "xx";
	unknown = 0;
	if (screen->term)
		del_curterm(screen->term);
	(void)ti_setupterm(&screen->term, type, fileno(screen->outfd), &r);
	if (screen->term == NULL) {
		unknown++;
		(void)ti_setupterm(&screen->term, "dumb",
		    fileno(screen->outfd), &r);
		/* No dumb term? We can't continue */
		if (screen->term == NULL)
			return ERR;
	}
	__CTRACE(__CTRACE_INIT, "setterm: tty = %s\n", type);

	/* lines and cols will have been setup correctly by ti_setupterm(3). */
	screen->LINES = t_lines(screen->term);
	screen->COLS = t_columns(screen->term);

	if (screen->filtered) {
		/* Disable use of clear, cud, cud1, cup, cuu1 and vpa. */
		screen->term->strs[TICODE_clear] = NULL;
		screen->term->strs[TICODE_cud] = NULL;
		screen->term->strs[TICODE_cud1] = NULL;
		screen->term->strs[TICODE_cup] = NULL;
		screen->term->strs[TICODE_cuu] = NULL;
		screen->term->strs[TICODE_cuu1] = NULL;
		screen->term->strs[TICODE_vpa] = NULL;
		/* Set the value of the home string to the value of
		 * the cr string. */
		screen->term->strs[TICODE_home] = screen->term->strs[TICODE_cr];
		/* Set lines equal to 1. */
		screen->LINES = 1;
		t_lines(screen->term) = 1;
	}
	__CTRACE(__CTRACE_INIT, "setterm: filtered %d\n", screen->filtered);

	if ((p = getenv("ESCDELAY")) != NULL)
		screen->ESCDELAY = (int)strtol(p, NULL, 0);
	else
		screen->ESCDELAY = ESCDELAY_DEFAULT;
	if ((p = getenv("TABSIZE")) != NULL)
		screen->TABSIZE = (int)strtol(p, NULL, 0);
	else if (t_init_tabs(screen->term) >= 0)
		screen->TABSIZE = (int)t_init_tabs(screen->term);
	else
		screen->TABSIZE = TABSIZE_DEFAULT;
	/*
	 * Want cols > 4, otherwise things will fail.
	 */
	if (screen->COLS <= 4)
		return ERR;

	LINES = screen->LINES;
	COLS = screen->COLS;
	ESCDELAY = screen->ESCDELAY;
	TABSIZE = screen->TABSIZE;

	__CTRACE(__CTRACE_INIT,
	    "setterm: LINES = %d, COLS = %d, TABSIZE = %d\n",
	    LINES, COLS, TABSIZE);

	/*
	 * set the pad char, only take the first char of the pc capability
	 * as this is all we can use.
	 */
	screen->padchar = t_pad_char(screen->term) ?
	    t_pad_char(screen->term)[0] : 0;

	/* If no scrolling commands, no quick change. */
	screen->noqch =
	    (t_change_scroll_region(screen->term) == NULL ||
		t_cursor_home(screen->term) == NULL ||
		(t_parm_index(screen->term) == NULL &&
		    t_scroll_forward(screen->term) == NULL) ||
		(t_parm_rindex(screen->term) == NULL &&
		    t_scroll_reverse(screen->term) == NULL)) &&
	    ((t_parm_insert_line(screen->term) == NULL &&
		t_insert_line(screen->term) == NULL) ||
		(t_parm_delete_line(screen->term) == NULL &&
		    t_delete_line(screen->term) == NULL));

	/*
	 * Precalculate conflict info for color/attribute end commands.
	 */
#ifndef HAVE_WCHAR
	screen->mask_op = __ATTRIBUTES & ~__COLOR;
#else
	screen->mask_op = WA_ATTRIBUTES & ~__COLOR;
#endif /* HAVE_WCHAR */

	const char *t_op = t_orig_pair(screen->term);
	const char *t_esm = t_exit_standout_mode(screen->term);
	const char *t_eum = t_exit_underline_mode(screen->term);
	const char *t_eam = t_exit_attribute_mode(screen->term);

	if (t_op != NULL) {
		if (does_esc_m(t_op))
			screen->mask_op &=
			    ~(__STANDOUT | __UNDERSCORE | __TERMATTR);
		else {
			if (t_esm != NULL && !strcmp(t_op, t_esm))
				screen->mask_op &= ~__STANDOUT;

			if (t_eum != NULL && !strcmp(t_op, t_eum))
				screen->mask_op &= ~__UNDERSCORE;

			if (t_eam != NULL && !strcmp(t_op, t_eam))
				screen->mask_op &= ~__TERMATTR;
		}
	}
	/*
	 * Assume that "me" turns off all attributes apart from ACS.
	 * It might turn off ACS, so check for that.
	 */
	if (t_exit_attribute_mode(screen->term) != NULL &&
	    t_exit_alt_charset_mode(screen->term) != NULL &&
	    does_ctrl_o(t_exit_attribute_mode(screen->term),
	    t_exit_alt_charset_mode(screen->term)))
		screen->mask_me = 0;
	else
		screen->mask_me = __ALTCHARSET;

	/* Check what turning off the attributes also turns off */
#ifndef HAVE_WCHAR
	screen->mask_ue = __ATTRIBUTES & ~__UNDERSCORE;
#else
	screen->mask_ue = WA_ATTRIBUTES & ~__UNDERSCORE;
#endif /* HAVE_WCHAR */
	if (t_eum != NULL) {
		if (does_esc_m(t_eum))
			screen->mask_ue &=
			    ~(__STANDOUT | __TERMATTR | __COLOR);
		else {
			if (t_esm && !strcmp(t_eum, t_esm))
				screen->mask_ue &= ~__STANDOUT;

			if (t_eam != NULL && !strcmp(t_eum, t_eam))
				screen->mask_ue &= ~__TERMATTR;

			if (t_op != NULL && !strcmp(t_eum, t_op))
				screen->mask_ue &= ~__COLOR;
		}
	}
#ifndef HAVE_WCHAR
	screen->mask_se = __ATTRIBUTES & ~__STANDOUT;
#else
	screen->mask_se = WA_ATTRIBUTES & ~__STANDOUT;
#endif /* HAVE_WCHAR */
	if (t_esm != NULL) {
		if (does_esc_m(t_esm))
			screen->mask_se &=
			    ~(__UNDERSCORE | __TERMATTR | __COLOR);
		else {
			if (t_eum != NULL && !strcmp(t_esm, t_eum))
				screen->mask_se &= ~__UNDERSCORE;

			if (t_eam != NULL && !strcmp(t_esm, t_eam))
				screen->mask_se &= ~__TERMATTR;

			if (t_op != NULL && !strcmp(t_esm, t_op))
				screen->mask_se &= ~__COLOR;
		}
	}

	return unknown ? ERR : OK;
}

/*
 * _cursesi_resetterm --
 *  Copy the terminal instance data for the given screen to the global
 *  variables.
 */
void
_cursesi_resetterm(SCREEN *screen)
{

	LINES = screen->LINES;
	COLS = screen->COLS;
	ESCDELAY = screen->ESCDELAY;
	TABSIZE = screen->TABSIZE;
	__GT = screen->GT;

	__noqch = screen->noqch;
	__mask_op = screen->mask_op;
	__mask_me = screen->mask_me;
	__mask_ue = screen->mask_ue;
	__mask_se = screen->mask_se;

	set_curterm(screen->term);
}

/*
 * does_esc_m --
 * A hack for xterm-like terminals where "\E[m" or "\E[0m" will turn off
 * other attributes, so we check for this in the capability passed to us.
 * Note that we can't just do simple string comparison, as the capability
 * may contain multiple, ';' separated sequence parts.
 */
static int
does_esc_m(const char *cap)
{
#define WAITING 0
#define PARSING 1
#define NUMBER 2
#define FOUND 4
	const char *capptr;
	int seq;

	__CTRACE(__CTRACE_INIT, "does_esc_m: Checking %s\n", cap);
	/* Is it just "\E[m" or "\E[0m"? */
	if (!strcmp(cap, "\x1b[m") || !strcmp(cap, "\x1b[0m"))
		return 1;

	/* Does it contain a "\E[...m" sequence? */
	if (strlen(cap) < 4)
		return 0;
	capptr = cap;
	seq = WAITING;
	while (*capptr != 0) {
		switch (seq) {
		/* Start of sequence */
		case WAITING:
			if (!strncmp(capptr, "\x1b[", 2)) {
				capptr+=2;
				if (*capptr == 'm')
					return 1;
				else {
					seq=PARSING;
					continue;
				}
			}
			break;
		/* Looking for '0' */
		case PARSING:
			if (*capptr == '0')
				seq=FOUND;
			else if (*capptr > '0' && *capptr <= '9')
				seq=NUMBER;
			else if (*capptr != ';')
				seq=WAITING;
			break;
		/* Some other number */
		case NUMBER:
			if (*capptr == ';')
				seq=PARSING;
			else if (!(*capptr >= '0' && *capptr <= '9'))
				seq=WAITING;
			break;
		/* Found a '0' */
		case FOUND:
			if (*capptr == 'm')
				return 1;
			else if (!((*capptr >= '0' && *capptr <= '9') ||
			    *capptr == ';'))
				seq=WAITING;
			break;
		default:
			break;
		}
		capptr++;
	}
	return 0;
}

/*
 * capdup_nodelay --
 * A helper for does_ctrl_o below that creates a copy of the given
 * capability with delay specifications dropped.
 */
static char *
capdup_nodelay(const char *src)
{
	char *clean, *dst;

	dst = clean = malloc(strlen(src) + 1);
	if (__predict_false(clean == NULL))
		return NULL;

	while (*src != '\0') {
		if (src[0] == '$' && src[1] == '<') {
			const char *end = strchr(src + 2, '>');
			if (__predict_true(end != NULL)) {
				src = end + 1;
				continue;
			}
		}
		*dst++ = *src++;
	}

	*dst = '\0';
	return clean;
}

/*
 * does_ctrl_o --
 * A hack for vt100/xterm-like terminals where the "me" capability also
 * unsets acs.
 */
static int
does_ctrl_o(const char *exit_cap, const char *acs_cap)
{
	char *eptr, *aptr;
	int res;

	__CTRACE(__CTRACE_INIT, "does_ctrl_o: Testing %s for %s\n",
	    exit_cap, acs_cap);

	eptr = capdup_nodelay(exit_cap);
	if (__predict_false(eptr == NULL))
		return 0;

	aptr = capdup_nodelay(acs_cap);
	if (__predict_false(aptr == NULL)) {
		free(eptr);
		return 0;
	}

	res = strstr(eptr, aptr) != NULL;

	free(eptr);
	free(aptr);
	return res;
}

/*
 * set_tabsize --
 *   Sets the tabsize for the current screen.
 */
int
set_tabsize(int tabsize)
{

	if (_cursesi_screen == NULL)
		return ERR;
	_cursesi_screen->TABSIZE = tabsize;
	TABSIZE = tabsize;
	return OK;
}