/*	$OpenBSD: key.c,v 1.19 2017/04/18 01:45:35 deraadt Exp $	*/

/*-

 * Copyright (c) 1991, 1993, 1994

 *	The Regents of the University of California.  All rights reserved.

 * Copyright (c) 1991, 1993, 1994, 1995, 1996

 *	Keith Bostic.  All rights reserved.

 *

 * See the LICENSE file for redistribution information.

 */

#include "config.h"

#include <sys/queue.h>

#include <sys/time.h>

#include <bitstring.h>

#include <ctype.h>

#include <errno.h>

#include <limits.h>

#include <locale.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "common.h"

#include "../vi/vi.h"

#define MAXIMUM(a, b)	(((a) > (b)) ? (a) : (b))

static int	v_event_append(SCR *, EVENT *);

static int	v_event_grow(SCR *, int);

static int	v_key_cmp(const void *, const void *);

static void	v_keyval(SCR *, int, scr_keyval_t);

static void	v_sync(SCR *, int);

/*

 * !!!

 * Historic vi always used:

 *

 *	^D: autoindent deletion

 *	^H: last character deletion

 *	^W: last word deletion

 *	^Q: quote the next character (if not used in flow control).

 *	^V: quote the next character

 *

 * regardless of the user's choices for these characters.  The user's erase

 * and kill characters worked in addition to these characters.  Nvi wires

 * down the above characters, but in addition permits the VEOF, VERASE, VKILL

 * and VWERASE characters described by the user's termios structure.

 *

 * Ex was not consistent with this scheme, as it historically ran in tty

 * cooked mode.  This meant that the scroll command and autoindent erase

 * characters were mapped to the user's EOF character, and the character

 * and word deletion characters were the user's tty character and word

 * deletion characters.  This implementation makes it all consistent, as

 * described above for vi.

 *

 * !!!

 * This means that all screens share a special key set.

 */

KEYLIST keylist[] = {

	{K_BACKSLASH,	  '\\'},	/*  \ */

	{K_CARAT,	   '^'},	/*  ^ */

	{K_CNTRLD,	'\004'},	/* ^D */

	{K_CNTRLR,	'\022'},	/* ^R */

	{K_CNTRLT,	'\024'},	/* ^T */

	{K_CNTRLZ,	'\032'},	/* ^Z */

	{K_COLON,	   ':'},	/*  : */

	{K_CR,		  '\r'},	/* \r */

	{K_ESCAPE,	'\033'},	/* ^[ */

	{K_FORMFEED,	  '\f'},	/* \f */

	{K_HEXCHAR,	'\030'},	/* ^X */

	{K_NL,		  '\n'},	/* \n */

	{K_RIGHTBRACE,	   '}'},	/*  } */

	{K_RIGHTPAREN,	   ')'},	/*  ) */

	{K_TAB,		  '\t'},	/* \t */

	{K_VERASE,	  '\b'},	/* \b */

	{K_VKILL,	'\025'},	/* ^U */

	{K_VLNEXT,	'\021'},	/* ^Q */

	{K_VLNEXT,	'\026'},	/* ^V */

	{K_VWERASE,	'\027'},	/* ^W */

	{K_ZERO,	   '0'},	/*  0 */

#define	ADDITIONAL_CHARACTERS	4

	{K_NOTUSED, 0},			/* VEOF, VERASE, VKILL, VWERASE */

	{K_NOTUSED, 0},

	{K_NOTUSED, 0},

	{K_NOTUSED, 0},

};

static int nkeylist =

    (sizeof(keylist) / sizeof(keylist[0])) - ADDITIONAL_CHARACTERS;

/*

 * v_key_init --

 *	Initialize the special key lookup table.

 *

 * PUBLIC: int v_key_init(SCR *);

 */

int

v_key_init(SCR *sp)

{

	u_int ch;

	GS *gp;

	KEYLIST *kp;

	int cnt;

	/*

	 * XXX

	 * 8-bit only, for now.  Recompilation should get you any 8-bit

	 * character set, as long as nul isn't a character.

	 */

	/* Sort the special key list. */

	/* Initialize the fast lookup table. */

	}

	/* Find a non-printable character to use as a message separator. */

		}

	}

}

/*

 * v_keyval --

 *	Set key values.

 *

 * We've left some open slots in the keylist table, and if these values exist,

 * we put them into place.  Note, they may reset (or duplicate) values already

 * in the table, so we check for that first.

 */

static void

v_keyval(SCR *sp, int val, scr_keyval_t name)

{

	KEYLIST *kp;

	/* Get the key's value from the screen. */

	/* Check for duplication. */

		}

	/* Add a new entry. */

	}

}

/*

 * v_key_ilookup --

 *	Build the fast-lookup key display array.

 *

 * PUBLIC: void v_key_ilookup(SCR *);

 */

void

v_key_ilookup(SCR *sp)

{

	CHAR_T ch, *p, *t;

	GS *gp;

	size_t len;

}

/*

 * v_key_len --

 *	Return the length of the string that will display the key.

 *	This routine is the backup for the KEY_LEN() macro.

 *

 * PUBLIC: size_t v_key_len(SCR *, CHAR_T);

 */

size_t

v_key_len(SCR *sp, CHAR_T ch)

{

}

/*

 * v_key_name --

 *	Return the string that will display the key.  This routine

 *	is the backup for the KEY_NAME() macro.

 *

 * PUBLIC: CHAR_T *v_key_name(SCR *, CHAR_T);

 */

CHAR_T *

v_key_name(SCR *sp, CHAR_T ch)

{

	static const CHAR_T hexdigit[] = "0123456789abcdef";

	static const CHAR_T octdigit[] = "01234567";

	CHAR_T *chp, mask;

	size_t len;

	int cnt, shift;

	/* See if the character was explicitly declared printable or not. */

				goto pr;

				goto nopr;

	/*

	 * Historical (ARPA standard) mappings.  Printable characters are left

	 * alone.  Control characters less than 0x20 are represented as '^'

	 * followed by the character offset from the '@' character in the ASCII

	 * character set.  Del (0x7f) is represented as '^' followed by '?'.

	 *

	 * XXX

	 * The following code depends on the current locale being identical to

	 * the ASCII map from 0x40 to 0x5f (since 0x1f + 0x40 == 0x5f).  I'm

	 * told that this is a reasonable assumption...

	 *

	 * XXX

	 * This code will only work with CHAR_T's that are multiples of 8-bit

	 * bytes.

	 *

	 * XXX

	 * NB: There's an assumption here that all printable characters take

	 * up a single column on the screen.  This is not always correct.

	 */

		len = 1;

	}

		len = 2;

#define	BITS	(sizeof(CHAR_T) * 8)

#define	SHIFT	(BITS - BITS % 3)

#define	TOPMASK	(BITS % 3 == 2 ? 3 : 1) << (BITS - BITS % 3)

		shift = SHIFT - 3;

	} else {

		}

	}

}

/*

 * v_key_val --

 *	Fill in the value for a key.  This routine is the backup

 *	for the KEY_VAL() macro.

 *

 * PUBLIC: int v_key_val(SCR *, CHAR_T);

 */

int

v_key_val(SCR *sp, CHAR_T ch)

{

}

/*

 * v_event_push --

 *	Push events/keys onto the front of the buffer.

 *

 * There is a single input buffer in ex/vi.  Characters are put onto the

 * end of the buffer by the terminal input routines, and pushed onto the

 * front of the buffer by various other functions in ex/vi.  Each key has

 * an associated flag value, which indicates if it has already been quoted,

 * and if it is the result of a mapping or an abbreviation.

 *

 * PUBLIC: int v_event_push(SCR *, EVENT *, CHAR_T *, size_t, u_int);

 */

int

v_event_push(SCR *sp, EVENT *p_evp, CHAR_T *p_s, size_t nitems, u_int flags)

{

	EVENT *evp;

	GS *gp;

	size_t total;

	/* If we have room, stuff the items into the buffer. */

		goto copy;

	}

	/*

	 * If there are currently items in the queue, shift them up,

	 * leaving some extra room.  Get enough space plus a little

	 * extra.

	 */

#define	TERM_PUSH_SHIFT	30

		    gp->i_event + gp->i_next, gp->i_cnt);

	/* Put the new items into the queue. */

		else {

		}

	}

}

/*

 * v_event_append --

 *	Append events onto the tail of the buffer.

 */

static int

v_event_append(SCR *sp, EVENT *argp)

{

	CHAR_T *s;			/* Characters. */

	EVENT *evp;

	GS *gp;

	size_t nevents;			/* Number of events. */

	/* Grow the buffer as necessary. */

	/* Transform strings of characters into single events. */

		}

	else

}

/* Remove events from the queue. */

#define	QREM(len) {							\

	if ((gp->i_cnt -= (len)) == 0)					\

		gp->i_next = 0;						\

	else								\

		gp->i_next += (len);					\

}

/*

 * v_event_get --

 *	Return the next event.

 *

 * !!!

 * The flag EC_NODIGIT probably needs some explanation.  First, the idea of

 * mapping keys is that one or more keystrokes act like a function key.

 * What's going on is that vi is reading a number, and the character following

 * the number may or may not be mapped (EC_MAPCOMMAND).  For example, if the

 * user is entering the z command, a valid command is "z40+", and we don't want

 * to map the '+', i.e. if '+' is mapped to "xxx", we don't want to change it

 * into "z40xxx".  However, if the user enters "35x", we want to put all of the

 * characters through the mapping code.

 *

 * Historical practice is a bit muddled here.  (Surprise!)  It always permitted

 * mapping digits as long as they weren't the first character of the map, e.g.

 * ":map ^A1 xxx" was okay.  It also permitted the mapping of the digits 1-9

 * (the digit 0 was a special case as it doesn't indicate the start of a count)

 * as the first character of the map, but then ignored those mappings.  While

 * it's probably stupid to map digits, vi isn't your mother.

 *

 * The way this works is that the EC_MAPNODIGIT causes term_key to return the

 * end-of-digit without "looking" at the next character, i.e. leaving it as the

 * user entered it.  Presumably, the next term_key call will tell us how the

 * user wants it handled.

 *

 * There is one more complication.  Users might map keys to digits, and, as

 * it's described above, the commands:

 *

 *	:map g 1G

 *	d2g

 *

 * would return the keys "d2<end-of-digits>1G", when the user probably wanted

 * "d21<end-of-digits>G".  So, if a map starts off with a digit we continue as

 * before, otherwise, we pretend we haven't mapped the character, and return

 * <end-of-digits>.

 *

 * Now that that's out of the way, let's talk about Energizer Bunny macros.

 * It's easy to create macros that expand to a loop, e.g. map x 3x.  It's

 * fairly easy to detect this example, because it's all internal to term_key.

 * If we're expanding a macro and it gets big enough, at some point we can

 * assume it's looping and kill it.  The examples that are tough are the ones

 * where the parser is involved, e.g. map x "ayyx"byy.  We do an expansion

 * on 'x', and get "ayyx"byy.  We then return the first 4 characters, and then

 * find the looping macro again.  There is no way that we can detect this

 * without doing a full parse of the command, because the character that might

 * cause the loop (in this case 'x') may be a literal character, e.g. the map

 * map x "ayy"xyy"byy is perfectly legal and won't cause a loop.

 *

 * Historic vi tried to detect looping macros by disallowing obvious cases in

 * the map command, maps that that ended with the same letter as they started

 * (which wrongly disallowed "map x 'x"), and detecting macros that expanded

 * too many times before keys were returned to the command parser.  It didn't

 * get many (most?) of the tricky cases right, however, and it was certainly

 * possible to create macros that ran forever.  And, even if it did figure out

 * what was going on, the user was usually tossed into ex mode.  Finally, any

 * changes made before vi realized that the macro was recursing were left in

 * place.  We recover gracefully, but the only recourse the user has in an

 * infinite macro loop is to interrupt.

 *

 * !!!

 * It is historic practice that mapping characters to themselves as the first

 * part of the mapped string was legal, and did not cause infinite loops, i.e.

 * ":map! { {^M^T" and ":map n nz." were known to work.  The initial, matching

 * characters were returned instead of being remapped.

 *

 * !!!

 * It is also historic practice that the macro "map ] ]]^" caused a single ]

 * keypress to behave as the command ]] (the ^ got the map past the vi check

 * for "tail recursion").  Conversely, the mapping "map n nn^" went recursive.

 * What happened was that, in the historic vi, maps were expanded as the keys

 * were retrieved, but not all at once and not centrally.  So, the keypress ]

 * pushed ]]^ on the stack, and then the first ] from the stack was passed to

 * the ]] command code.  The ]] command then retrieved a key without entering

 * the mapping code.  This could bite us anytime a user has a map that depends

 * on secondary keys NOT being mapped.  I can't see any possible way to make

 * this work in here without the complete abandonment of Rationality Itself.

 *

 * XXX

 * The final issue is recovery.  It would be possible to undo all of the work

 * that was done by the macro if we entered a record into the log so that we

 * knew when the macro started, and, in fact, this might be worth doing at some

 * point.  Given that this might make the log grow unacceptably (consider that

 * cursor keys are done with maps), for now we leave any changes made in place.

 *

 * PUBLIC: int v_event_get(SCR *, EVENT *, int, u_int32_t);

 */

int

v_event_get(SCR *sp, EVENT *argp, int timeout, u_int32_t flags)

{

	GS *gp;

	SEQ *qp;

	/* If simply checking for interrupts, argp may be NULL. */

retry:	istimeout = remap_cnt = 0;

	/*

	 * If the queue isn't empty and we're timing out for characters,

	 * return immediately.

	 */

	/*

	 * If the queue is empty, we're checking for interrupts, or we're

	 * timing out for characters, get more events.

	 */

		/*

		 * If we're reading new characters, check any scripting

		 * windows for input.

		 */

		case E_ERR:

		case E_SIGHUP:

		case E_SIGTERM:

			/*

			 * Fatal conditions cause the file to be synced to

			 * disk immediately.

			 */

		case E_TIMEOUT:

			istimeout = 1;

		case E_INTERRUPT:

			/* Set the global interrupt flag. */

			/*

			 * If the caller was interested in interrupts, return

			 * immediately.

			 */

			goto append;

		default:

			break;

		}

	}

	/*

	 * If the caller was only interested in interrupts or timeouts, return

	 * immediately.  (We may have gotten characters, and that's okay, they

	 * were queued up for later use.)

	 */

	/*

	 * If the next event in the queue isn't a character event, return

	 * it, we're done.

	 */

	}

	/*

	 * If the key isn't mappable because:

	 *

	 *	+ ... the timeout has expired

	 *	+ ... it's not a mappable key

	 *	+ ... neither the command or input map flags are set

	 *	+ ... there are no maps that can apply to it

	 *

	 * return it forthwith.

	 */

		goto nomap;

	/* Search the map. */

	/*

	 * If get a partial match, get more characters and retry the map.

	 * If time out without further characters, return the characters

	 * unmapped.

	 *

	 * !!!

	 * <escape> characters are a problem.  Cursor keys start with <escape>

	 * characters, so there's almost always a map in place that begins with

	 * an <escape> character.  If we timeout <escape> keys in the same way

	 * that we timeout other keys, the user will get a noticeable pause as

	 * they enter <escape> to terminate input mode.  If key timeout is set

	 * for a slow link, users will get an even longer pause.  Nvi used to

	 * simply timeout <escape> characters at 1/10th of a second, but this

	 * loses over PPP links where the latency is greater than 100Ms.

	 */

		else

			timeout = 0;

		goto loop;

	}

	/* If no map, return the character. */

			goto not_digit;

	}

	/*

	 * If looking for the end of a digit string, and the first character

	 * of the map is it, pretend we haven't seen the character.

	 */

	}

	/* Find out if the initial segments are identical. */

	/* Delete the mapped characters from the queue. */

	/* If keys mapped to nothing, go get more. */

		goto retry;

	/* If remapping characters... */

		/*

		 * Periodically check for interrupts.  Always check the first

		 * time through, because it's possible to set up a map that

		 * will return a character every time, but will expand to more,

		 * e.g. "map! a aaaa" will always return a 'a', but we'll never

		 * get anywhere useful.

		 */

		}

		/*

		 * If an initial part of the characters mapped, they are not

		 * further remapped -- return the first one.  Push the rest

		 * of the characters, or all of the characters if no initial

		 * part mapped, back on the queue.

		 */

		}

		goto newmap;

	}

	/* Else, push the characters on the queue and return one. */

	goto nomap;

}

/*

 * v_sync --

 *	Walk the screen lists, sync'ing files to their backup copies.

 */

static void

v_sync(SCR *sp, int flags)

{

	GS *gp;

}

/*

 * v_event_err --

 *	Unexpected event.

 *

 * PUBLIC: void v_event_err(SCR *, EVENT *);

 */

void

v_event_err(SCR *sp, EVENT *evp)

{

	case E_CHARACTER:

	case E_EOF:

	case E_INTERRUPT:

	case E_QUIT:

	case E_REPAINT:

	case E_STRING:

	case E_TIMEOUT:

	case E_WRESIZE:

	case E_WRITE:

	/*

	 * Theoretically, none of these can occur, as they're handled at the

	 * top editor level.

	 */

	case E_ERR:

	case E_SIGHUP:

	case E_SIGTERM:

	default:

	}

	/* Free any allocated memory. */

}

/*

 * v_event_flush --

 *	Flush any flagged keys, returning if any keys were flushed.

 *

 * PUBLIC: int v_event_flush(SCR *, u_int);

 */

int

v_event_flush(SCR *sp, u_int flags)

{

	GS *gp;

	int rval;

}

/*

 * v_event_grow --

 *	Grow the terminal queue.

 */

static int

v_event_grow(SCR *sp, int add)

{

	GS *gp;

}

/*

 * v_key_cmp --

 *	Compare two keys for sorting.

 */

static int

v_key_cmp(const void *ap, const void *bp)

{

}