/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1995-1998, 2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/* LINTLIBRARY */

/*
 * wgetch.c
 *
 * XCurses Library
 *
 * Copyright 1990, 1995 by Mortice Kern Systems Inc.  All rights reserved.
 *
 */

#ifdef M_RCSID
#ifndef lint
static char rcsID[] =
"$Header: /team/ps/sun_xcurses/archive/local_changes/xcurses/src/lib/"
"libxcurses/src/libc/xcurses/rcs/wgetch.c 1.23 1998/06/05 16:38:43 "
"cbates Exp $";
#endif
#endif

#include <private.h>
#include <string.h>
#include <errno.h>

static struct termios	read_termios;

int
iqContainsFullLine(void)
{
	int	i;

	if (!(PTERMIOS(_prog)->c_lflag & ICANON)) {
		/*
		 * Non-canonical mode ...
		 * Don't care about full lines ... continue
		 */
		return (1);
	}
	if (read_termios.c_lflag & ICANON) {
		/*
		 * Terminal subsystem worries about lines etc. ...
		 * continue ...
		 */
		return (1);
	}
	/* We turned off ICANON so we have to do it ourselves */
	if ((read_termios.c_cc[VMIN] == 0) &&
		(read_termios.c_cc[VTIME] != 0)) {
		/* We set delay mode. Only error if noting in the read */
		return (!iqIsEmpty());
	}
	for (i = __m_screen->_unget._count - 1; i >= 0; i--) {
		int	ch = __m_screen->_unget._stack[i];
		if (PTERMIOS(_shell)->c_cc[VEOL] == ch)
			return (1);
		if ('\n' == ch)
			return (1);
	}
	return (0);
}

void
iqPush(unsigned int ch)
{
	if (__m_screen->_unget._count >= __m_screen->_unget._size)
		return;
	__m_screen->_unget._stack[__m_screen->_unget._count++] =
		(int) ch;
}

void
iqAdd(unsigned int ch)
{
	int	count;

	if (++(__m_screen->_unget._count) >= __m_screen->_unget._size)
		__m_screen->_unget._count = __m_screen->_unget._size - 1;
	count = __m_screen->_unget._count - 1;
	if (count) {
		(void) memmove(__m_screen->_unget._stack + 1,
			__m_screen->_unget._stack, count * sizeof (int));
	}
	__m_screen->_unget._stack[0] = (int) ch;
}

int
iqIsEmpty(void)
{
	return (__m_screen->_unget._count == 0);
}

void
iqReset(void)
{
	__m_screen->_unget._count = 0;
}

/* Assumes count > 0 */
int
iqPull(void)
{
	int	ch;

	ch = __m_screen->_unget._stack[--(__m_screen->_unget._count)];
	return (ch);
}

/* Discard n characters from front of Q */
void
iqTrash(int n)
{
	__m_screen->_unget._count -= n;
	if (__m_screen->_unget._count < 0) {
		__m_screen->_unget._count = 0;
	}
}

int
iqGetNth(int n)
{
	int	ch;

	if (__m_screen->_unget._count - n <= 0) {
		return (EOF);
	}
	ch = __m_screen->_unget._stack[__m_screen->_unget._count - n - 1];
	return (ch);
}


struct termios
__m_tty_override_mode(int vmin, int vtime)
{
	struct termios	rval;
	struct termios	newstuff;

	rval = newstuff = *PTERMIOS(_actual);

	/* If halfdelay mode. Leave canonical mode intact */
	if (!(vmin == 0 && vtime == 0) &&
		(cur_term->_flags & __TERM_HALF_DELAY))
		return (rval);

	/* If blocking mode. Leave canonical mode intact */
	if (vmin == 1)
		return (rval);

	/* VMIN and VTIME trash VEOL and VEOF so canonical cannot work */
	newstuff.c_cc[VMIN] = (cc_t) vmin;
	newstuff.c_cc[VTIME] = (cc_t) vtime;
	newstuff.c_lflag &= ~ICANON;

	(void) __m_tty_set(&newstuff);
	return (rval);
}

int
__m_read_input_char(int *pChar)
{
	if (req_for_input != NULL) {
		(void) TPUTS(req_for_input, 1, __m_outc);
	}
	clearerr(__m_screen->_if);
	*pChar = 0;
	/* save actual setting for later test */
	read_termios = *PTERMIOS(_actual);

	errno = 0;
	if ((*pChar = fgetc(__m_screen->_if)) == EOF) {
		return ((errno) ? ERR : OK);
	}

	if (((PTERMIOS(_prog)->c_cflag & CSIZE) != CS8) && (*pChar != EOF))
		*pChar &= 0x7f;
	return (OK);
}

int
__m_typeahead_read_input_char(int *pChar)
{
	unsigned char	ch;
	ssize_t	r;

	if (req_for_input != NULL) {
		(void) TPUTS(req_for_input, 1, __m_outc);
	}

	*pChar = 0;
	/* save actual setting for later test */
	read_termios = *PTERMIOS(_actual);

	errno = 0;
	if ((r = read(__m_screen->_kfd, (void *)&ch, 1)) > 0) {
		if ((PTERMIOS(_prog)->c_cflag & CSIZE) != CS8) {
			*pChar = ch & 0x7f;
		} else {
			*pChar = (int)ch;
		}
		return (OK);
	} else if (r == 0) {
		*pChar = EOF;
		return (OK);
	} else {
		return (ERR);
	}
}


static int	klugeTypeaheadInGetch = 0;

int
pollTypeahead(void)
{
	struct termios	save;
	int	ch;

	if (!(__m_screen->_flags & S_ISATTY) ||
		!(__m_screen->_flags & S_TYPEAHEAD_OK)) {
		/* Typeahead disabled */
		return (0);
	}
	save = __m_tty_override_mode(0, 0);
	while (__m_typeahead_read_input_char(&ch) == OK) {
		if (ch == EOF)
			break;
		iqAdd(ch);
	}
	(void) __m_tty_set(&save);
	/* if in wgetch, always do refresh */
	return ((klugeTypeaheadInGetch) ? 0 : !iqIsEmpty());
}

/*
 * Push single-byte character back onto the input queue.
 *
 * MKS EXTENSION permits the return value of wgetch(), which
 * can be a KEY_ value, to be pushed back.
 */
int
ungetch(int ch)
{
	iqPush(ch);
	return (OK);
}

/*
 * Return true if the SCREEN's stream has an I/O error.
 * Ignore the window parameter.
 */
/* ARGSUSED */
int
__xc_ferror(void *w)
{
	return (ferror(__m_screen->_if));
}

/* ARGSUSED */
int
__xc_ungetc(int ch, void *w)
{
	iqPush(ch);
	return (1);
}

/*
 * Return true if the SCREEN's stream has seen EOF.
 * Ignore the window parameter.
 */
/* ARGSUSED */
int
__xc_feof(void *w)
{
	return (feof(__m_screen->_if));
}

/*
 * Clear the error and eof flags of the SCREEN's stream.
 * Ignore the window parameter.
 */
/* ARGSUSED */
void
__xc_clearerr(void *w)
{
	clearerr(__m_screen->_if);
}

int
__m_echo(WINDOW *w, int ch)
{
	if (!(__m_screen->_flags & S_ECHO))
		return (ch);
	if (!(0 <= ch && ch != EOF)) {
		(void) beep();
		return (ERR);
	}
	if (ch == '\b') {
		if (w->_curx <= 0) {
			(void) beep();
			return (ch);
		}
		w->_curx--;
		(void) wdelch(w);
	} else {
		(void) waddch(w, ch);
	}
	(void) wrefresh(w);
	return (ch);
}

int
wgetch(WINDOW *w)
{
	t_decode	*node;
	int	ch, i, timeout;
	struct termios	save;

	__m_screen->_flags |= S_TYPEAHEAD_OK;

	klugeTypeaheadInGetch = 1;
	(void) wrefresh(w);
	klugeTypeaheadInGetch = 0;

	if (iqIsEmpty()) {
	    save = __m_tty_override_mode(w->_vmin, w->_vtime);
	    if (__m_read_input_char(&ch) == ERR) {
			(void) __m_tty_set(&save);
			return (ERR);
	    }
	    if (!((ch == EOF) && (PTERMIOS(_prog)->c_lflag & ICANON))) {
			/* Put EOF on Q only in non-canonical mode */
			iqAdd(ch);
	    }
		(void) __m_tty_set(&save);
	}
	ch = iqGetNth(0);
	if (!iqContainsFullLine()) {
	    return (ERR);
	}

	/*
	 * Only check for function keys if keypad is true and we
	 * did not read a KEY_ value (which are < 0), nor EOF.
	 * It is conceivable that a KEY_ was pushed back with
	 * ungetch().
	 */
	if ((w->_flags & W_USE_KEYPAD) && 0 <= ch && ch != EOF) {
		/*
		 * Treat the termios ERASE key the same as key_backspace.
		 *
		 * We used to change the key_backspace entry to be a string
		 * containing the ERASE key in setupterm(), but this would
		 * then disable the real terminfo entry for the backspace key.
		 * Apparently VT300 terminals change the key code/sequence
		 * of the backspace key in application keypad mode.
		 * See SR 6014.
		 *
		 * Refer to _shell instead of _prog, since _shell will
		 * correctly reflect the user's prefered settings, whereas
		 * _prog may not have been initialised if both input and
		 * output have been redirected.
		 */
#ifdef _POSIX_VDISABLE
		if (PTERMIOS(_shell)->c_cc[VERASE] != _POSIX_VDISABLE)
#endif
			if (ch == PTERMIOS(_shell)->c_cc[VERASE]) {
				/* Discard ch from Q */
				(void) iqPull();
				return (KEY_BACKSPACE);
			}

		/* Begin check for function key. */
		node = (t_decode *) __m_screen->_decode;

		/* Use input stack as a queue. */
		timeout = w->_flags & W_USE_TIMEOUT;
		for (i = 1; ; i++) {
			while (node->ch != ch) {
				node = node->sibling;
				if (node == NULL)
					goto uncoded;
			}

			/* Found funuction key? */
			if (node->key != 0) {
				/* Trash all input used to make the FKey */
				iqTrash(i);
				return (__m_echo(w, node->key));
			}

			/*
			 * Get next candidate character -
			 * either from Q or input
			 */
			if ((ch = iqGetNth(i)) == EOF) {
				/*
				 * Setup interbyte timer (once only).
				 * fgetc() will return EOF if no input received,
				 * which may not be a true EOF.
				 */
				if (timeout) {
					(void) __m_tty_override_mode(0,
						M_CURSES_INTERBYTE_TIME);
				}
				timeout = 0;
				if (__m_read_input_char(&ch) == ERR)
				    return (ERR);
				/* Timeout or real eof. */
				if (ch == EOF)
					break;
				iqAdd(ch);
			}

			/* Incomplete sequence, continue. */
			node = node->child;
		}
	}
uncoded:
	/* Return first byte received or EOF. */
	ch = iqPull();
	return (__m_echo(w, ch));
}