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

/*-

 * Copyright (c) 1992, 1993, 1994

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

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

 *	Keith Bostic.  All rights reserved.

 *

 * See the LICENSE file for redistribution information.

 */

#include "config.h"

#include <sys/types.h>

#include <sys/queue.h>

#include <sys/time.h>

#include <bitstring.h>

#include <ctype.h>

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "../common/common.h"

#include "vi.h"

typedef enum {

	GC_ERR, GC_ERR_NOFLUSH, GC_EVENT, GC_FATAL, GC_INTERRUPT, GC_OK

} gcret_t;

static VIKEYS const

	       *v_alias(SCR *, VICMD *, VIKEYS const *);

static gcret_t	v_cmd(SCR *, VICMD *, VICMD *, VICMD *, int *, int *);

static int	v_count(SCR *, CHAR_T, u_long *);

static void	v_dtoh(SCR *);

static int	v_init(SCR *);

static gcret_t	v_key(SCR *, int, EVENT *, u_int32_t);

static int	v_keyword(SCR *);

static int	v_motion(SCR *, VICMD *, VICMD *, int *);

#if defined(DEBUG) && defined(COMLOG)

static void	v_comlog(SCR *, VICMD *);

#endif

/*

 * Side-effect:

 *	The dot structure can be set by the underlying vi functions,

 *	see v_Put() and v_put().

 */

#define	DOT		(&VIP(sp)->sdot)

#define	DOTMOTION	(&VIP(sp)->sdotmotion)

/*

 * vi --

 * 	Main vi command loop.

 *

 * PUBLIC: int vi(SCR **);

 */

int

vi(SCR **spp)

{

	GS *gp;

	VI_PRIVATE *vip;

	/* Get the first screen. */

	/* Initialize the command structure. */

	vp = &cmd;

	/* Reset strange attraction. */

	/* Initialize the vi screen. */

	/* Set the focus. */

		/* Resolve messages. */

			goto ret;

		/*

		 * If not skipping a refresh, return to command mode and

		 * refresh the screen.

		 */

		else {

				goto ret;

		}

		/* Set the new favorite position. */

		}

		/*

		 * If not currently in a map, log the cursor position,

		 * and set a flag so that this command can become the

		 * DOT command.

		 */

		else {

				goto err;

		}

		/*

		 * There may be an ex command waiting, and we returned here

		 * only because we exited a screen or file.  In this case,

		 * we simply go back into the ex parser.

		 */

		}

		/* Refresh the command structure. */

		/*

		 * We get a command, which may or may not have an associated

		 * motion.  If it does, we get it too, calling its underlying

		 * function to get the resulting mark.  We then call the

		 * command setting the cursor to the resulting mark.

		 *

		 * !!!

		 * Vi historically flushed mapped characters on error, but

		 * entering extra <escape> characters at the beginning of

		 * a map wasn't considered an error -- in fact, users would

		 * put leading <escape> characters in maps to clean up vi

		 * state before the map was interpreted.  Beauty!

		 */

		case GC_ERR:

			goto err;

		case GC_ERR_NOFLUSH:

			goto gc_err_noflush;

		case GC_EVENT:

				goto err;

			goto gc_event;

		case GC_FATAL:

			goto ret;

		case GC_INTERRUPT:

			goto intr;

		case GC_OK:

			break;

		}

		/* Check for security setting. */

		}

		/*

		 * Historical practice: if a dot command gets a new count,

		 * any motion component goes away, i.e. "d3w2." deletes a

		 * total of 5 words.

		 */

		/* Copy the key flags into the local structure. */

		/* Prepare to set the previous context. */

		}

		/*

		 * Set the three cursor locations to the current cursor.  The

		 * underlying routines don't bother if the cursor doesn't move.

		 * This also handles line commands (e.g. Y) defaulting to the

		 * current line.

		 */

		/*

		 * Do any required motion; v_motion sets the from MARK and the

		 * line mode flag, as well as the VM_RCM flags.

		 */

				goto intr;

			goto err;

		}

		/*

		 * If a count is set and the command is line oriented, set the

		 * to MARK here relative to the cursor/from MARK.  This is for

		 * commands that take both counts and motions, i.e. "4yy" and

		 * "y%".  As there's no way the command can know which the user

		 * did, we have to do it here.  (There are commands that are

		 * line oriented and that take counts ("#G", "#H"), for which

		 * this calculation is either completely meaningless or wrong.

		 * Each command must validate the value for itself.

		 */

		/* Increment the command count. */

#if defined(DEBUG) && defined(COMLOG)

		v_comlog(sp, vp);

#endif

		/* Call the function. */

			goto err;

gc_event:

#ifdef DEBUG

		/* Make sure no function left the temporary space locked. */

		if (F_ISSET(gp, G_TMP_INUSE)) {

			F_CLR(gp, G_TMP_INUSE);

			msgq(sp, M_ERR,

			    "vi: temporary buffer not released");

		}

#endif

		/*

		 * If we're exiting this screen, move to the next one, or, if

		 * there aren't any more, return to the main editor loop.  The

		 * ordering is careful, don't discard the contents of sp until

		 * the end.

		 */

				goto ret;

				goto ret;

				goto ret;

				goto ret;

				break;

			/* Switch screens, change focus. */

			sp = next;

			/* Don't trust the cursor. */

		}

		/*

		 * Set the dot command structure.

		 *

		 * !!!

		 * Historically, commands which used mapped keys did not

		 * set the dot command, with the exception of the text

		 * input commands.

		 */

			/*

			 * If a count was supplied for both the command and

			 * its motion, the count was used only for the motion.

			 * Turn the count back on for the dot structure.

			 */

			/* VM flags aren't retained. */

		}

		/*

		 * Some vi row movements are "attracted" to the last position

		 * set, i.e. the VM_RCM commands are moths to the VM_RCM_SET

		 * commands' candle.  If the movement is to the EOL the vi

		 * command handles it.  If it's to the beginning, we handle it

		 * here.

		 *

		 * Note, some commands (e.g. _, ^) don't set the VM_RCM_SETFNB

		 * flag, but do the work themselves.  The reason is that they

		 * have to modify the column in case they're being used as a

		 * motion component.  Other similar commands (e.g. +, -) don't

		 * have to modify the column because they are always line mode

		 * operations when used as motions, so the column number isn't

		 * of any interest.

		 *

		 * Does this totally violate the screen and editor layering?

		 * You betcha.  As they say, if you think you understand it,

		 * you don't.

		 */

		case 0:

		case VM_RCM_SET:

			break;

		case VM_RCM:

		case VM_RCM_SETLAST:

		case VM_RCM_SETFNB:

			/* FALLTHROUGH */

		case VM_RCM_SETNNB:

				goto err;

			break;

		default:

		}

		/* Update the cursor. */

		/*

		 * Set the absolute mark -- set even if a tags or similar

		 * command, since the tag may be moving to the same file.

		 */

			goto err;

		if (0) {

			    "Vi command failed: mapped keys discarded");

		}

		/*

		 * Check and clear interrupts.  There's an obvious race, but

		 * it's not worth fixing.

		 */

				    "Interrupted: mapped keys discarded");

			else

		}

		/* If the last command switched screens, update. */

			/*

			 * If the current screen is still displayed, it will

			 * need a new status line.

			 */

			/* Switch screens, change focus. */

			/* Don't trust the cursor. */

			/* Refresh so we can display messages. */

		}

		/* If the last command switched files, change focus. */

		}

		/* If leaving vi, return to the main editor loop. */

		}

	}

	if (0)

}

#define	KEY(key, ec_flags) {						\

	if ((gcret = v_key(sp, 0, &ev, (ec_flags))) != GC_OK)		\

		return (gcret);						\

	if (ev.e_value == K_ESCAPE)					\

		goto esc;						\

	if (F_ISSET(&ev.e_ch, CH_MAPPED))				\

		*mappedp = 1;						\

	(key) = ev.e_c;							\

}

/*

 * The O_TILDEOP option makes the ~ command take a motion instead

 * of a straight count.  This is the replacement structure we use

 * instead of the one currently in the VIKEYS table.

 *

 * XXX

 * This should probably be deleted -- it's not all that useful, and

 * we get help messages wrong.

 */

VIKEYS const tmotion = {

	v_mulcase,	V_CNT|V_DOT|V_MOTION|VM_RCM_SET,

	"[count]~[count]motion",

	" ~ change case to motion"

};

/*

 * v_cmd --

 *

 * The command structure for vi is less complex than ex (and don't think

 * I'm not grateful!)  The command syntax is:

 *

 *	[count] [buffer] [count] key [[motion] | [buffer] [character]]

 *

 * and there are several special cases.  The motion value is itself a vi

 * command, with the syntax:

 *

 *	[count] key [character]

 */

static gcret_t

v_cmd(SCR *sp, VICMD *dp, VICMD *vp, VICMD *ismotion, int *comcountp,

    int *mappedp)

{

	enum { COMMANDMODE, ISPARTIAL, NOTPARTIAL } cpart;

	VIKEYS const *kp;

	gcret_t gcret;

	u_int flags;

	CHAR_T key;

	char *s;

	/*

	 * Get a key.

	 *

	 * <escape> cancels partial commands, i.e. a command where at least

	 * one non-numeric character has been entered.  Otherwise, it beeps

	 * the terminal.

	 *

	 * !!!

	 * POSIX 1003.2-1992 explicitly disallows cancelling commands where

	 * all that's been entered is a number, requiring that the terminal

	 * be alerted.

	 */

	}

		goto esc;

	/* Pick up optional buffer. */

		cpart = ISPARTIAL;

		}

	}

	/*

	 * Pick up optional count, where a leading 0 is not a count,

	 * it's a command.

	 */

	/* Pick up optional buffer. */

		cpart = ISPARTIAL;

		}

		}

	}

	/* Check for an OOB command key. */

	cpart = ISPARTIAL;

	}

	/*

	 * !!!

	 * Historically, D accepted and then ignored a count.  Match it.

	 */

	}

	/* Check for command aliases. */

	/* The tildeop option makes the ~ command take a motion. */

	/*

	 * Find the command.  The only legal command with no underlying

	 * function is dot.  It's historic practice that <escape> doesn't

	 * just erase the preceding number, it beeps the terminal as well.

	 * It's a common problem, so just beep the terminal unless verbose

	 * was set.

	 */

		}

		/* If called for a motion command, stop now. */

			goto usage;

		/*

		 * !!!

		 * If a '.' is immediately entered after an undo command, we

		 * replay the log instead of redoing the last command.  This

		 * is necessary because 'u' can't set the dot command -- see

		 * vi/v_undo.c:v_undo for details.

		 */

		}

		/* Otherwise, a repeatable command must have been executed. */

		}

		/* Set new count/buffer, if any, and return. */

		}

	}

	/* Set the flags based on the command flags. */

	/* Check for illegal count. */

		goto usage;

	/* Illegal motion command. */

		/* Illegal buffer. */

			goto usage;

		/* Required buffer. */

		}

	}

	/*

	 * Special case: '[', ']' and 'Z' commands.  Doesn't the fact that

	 * the *single* characters don't mean anything but the *doubled*

	 * characters do, just frost your shorts?

	 */

		/*

		 * Historically, half entered [[, ]] or Z commands weren't

		 * cancelled by <escape>, the terminal was beeped instead.

		 * POSIX.2-1992 probably didn't notice, and requires that

		 * they be cancelled instead of beeping.  Seems fine to me.

		 *

		 * Don't set the EC_MAPCOMMAND flag, apparently ] is a popular

		 * vi meta-character, and we don't want the user to wait while

		 * we time out a possible mapping.  This *appears* to match

		 * historic vi practice, but with mapping characters, you Just

		 * Never Know.

		 */

			else

		}

	}

	/* Special case: 'z' command. */

		}

	}

	/*

	 * Commands that have motion components can be doubled to

	 * imply the current line.

	 */

	}

	/* Required character. */

	/* Get any associated cursor word. */

	case COMMANDMODE:

	case ISPARTIAL:

		break;

	case NOTPARTIAL:

	}

}

/*

 * v_motion --

 *

 * Get resulting motion mark.

 */

static int

v_motion(SCR *sp, VICMD *dm, VICMD *vp, int *mappedp)

{

	u_long cnt;

	u_int flags;

	/*

	 * If '.' command, use the dot motion, else get the motion command.

	 * Clear any line motion flags, the subsequent motion isn't always

	 * the same, i.e. "/aaa" may or may not be a line motion.

	 */

	}

	/*

	 * A count may be provided both to the command and to the motion, in

	 * which case the count is multiplicative.  For example, "3y4y" is the

	 * same as "12yy".  This count is provided to the motion command and

	 * not to the regular function.

	 */

		/*

		 * Set flags to restore the original values of the command

		 * structure so dot commands can change the count values,

		 * e.g. "2dw" "3." deletes a total of five words.

		 */

	}

	/*

	 * Some commands can be repeated to indicate the current line.  In

	 * this case, or if the command is a "line command", set the flags

	 * appropriately.  If not a doubled command, run the function to get

	 * the resulting mark.

 	 */

		/* Set the origin of the command. */

		/*

		 * Set the end of the command.

		 *

		 * If the current line is missing, i.e. the file is empty,

		 * historic vi permitted a "cc" or "!!" command to insert

		 * text.

		 */

			}

			vp->m_stop.cno = 0;

		/*

		 * Motion commands change the underlying movement (*snarl*).

		 * For example, "l" is illegal at the end of a line, but "dl"

		 * is not.  Set flags so the function knows the situation.

		 */

		/*

		 * XXX

		 * Use yank instead of creating a new motion command, it's a

		 * lot easier for now.

		 */

			tilde_reset = 1;

			tilde_reset = 0;

		/*

		 * Copy the key flags into the local structure, except for the

		 * RCM flags -- the motion command will set the RCM flags in

		 * the vp structure if necessary.  This means that the motion

		 * command is expected to determine where the cursor ends up!

		 * However, we save off the current RCM mask and restore it if

		 * it no RCM flags are set by the motion command, with a small

		 * modification.

		 *

		 * We replace the VM_RCM_SET flag with the VM_RCM flag.  This

		 * is so that cursor movement doesn't set the relative position

		 * unless the motion command explicitly specified it.  This

		 * appears to match historic practice, but I've never been able

		 * to develop a hard-and-fast rule.

		 */

		}

		/*

		 * Set the three cursor locations to the current cursor.  This

		 * permits commands like 'j' and 'k', that are line oriented

		 * motions and have special cursor suck semantics when they are

		 * used as standalone commands, to ignore column positioning.

		 */

		/* Run the function. */

		/*

		 * If the current line is missing, i.e. the file is empty,

		 * historic vi allowed "c<motion>" or "!<motion>" to insert

		 * text.  Otherwise fail -- most motion commands will have

		 * already failed, but some, e.g. G, succeed in empty files.

		 */

			}

		}

		/*

		 * XXX

		 * See above.

		 */

		/*

		 * Copy cut buffer, line mode and cursor position information

		 * from the motion command structure, i.e. anything that the

		 * motion command can set for us.  The commands can flag the

		 * movement as a line motion (see v_sentence) as well as set

		 * the VM_RCM_* flags explicitly.

		 */

		/*

		 * If the motion command set no relative motion flags, use

		 * the (slightly) modified previous values.

		 */

		/*

		 * Commands can change behaviors based on the motion command

		 * used, for example, the ! command repeated the last bang

		 * command if N or n was used as the motion.

		 */

		/*

		 * Motion commands can reset all of the cursor information.

		 * If the motion is in the reverse direction, switch the

		 * from and to MARK's so that it's in a forward direction.

		 * Motions are from the from MARK to the to MARK (inclusive).

		 */

		}

	}

	/*

	 * If the command sets dot, save the motion structure.  The motion

	 * count was changed above and needs to be reset, that's why this

	 * is done here, and not in the calling routine.

	 */

	}

}

/*

 * v_init --

 *	Initialize the vi screen.

 */

static int

v_init(SCR *sp)

{

	GS *gp;

	VI_PRIVATE *vip;

	/* Switch into vi. */

	/*

	 * Initialize screen values.

	 *

	 * Small windows: see vs_refresh(), section 6a.

	 *

	 * Setup:

	 *	t_minrows is the minimum rows to display

	 *	t_maxrows is the maximum rows to display (rows - 1)

	 *	t_rows is the rows currently being displayed

	 */

			    "Windows option value is too large, max is %u",

		}

		sp->t_maxrows = 1;

	/* Create a screen map. */

	/*

	 * Fill the screen map from scratch -- try and center the line.  That

	 * way if we're starting with a file we've seen before, we'll put the

	 * line in the middle, otherwise, it won't work and we'll end up with

	 * the line at the top.

	 */

	/* Invalidate the cursor. */

	/* Paint the screen image from scratch. */

}

/*

 * v_dtoh --

 *	Move all but the current screen to the hidden queue.

 */

static void

v_dtoh(SCR *sp)