tor-browser

editline.c (22625B)

---

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
* Copyright 1992,1993 Simmule Turner and Rich Salz.  All rights reserved.
*
* This software is not subject to any license of the American Telephone
* and Telegraph Company or of the Regents of the University of California.
*
* Permission is granted to anyone to use this software for any purpose on
* any computer system, and to alter it and redistribute it freely, subject
* to the following restrictions:
* 1. The authors are not responsible for the consequences of use of this
*    software, no matter how awful, even if they arise from flaws in it.
* 2. The origin of this software must not be misrepresented, either by
*    explicit claim or by omission.  Since few users ever read sources,
*    credits must appear in the documentation.
* 3. Altered versions must be plainly marked as such, and must not be
*    misrepresented as being the original software.  Since few users
*    ever read sources, credits must appear in the documentation.
* 4. This notice may not be removed or altered.
*/


/*
**  Main editing routines for editline library.
*/
#include "editline.h"
#include <signal.h>
#include <ctype.h>
#include <unistd.h>

/*
**  Manifest constants.
*/
#define SCREEN_WIDTH	80
#define SCREEN_ROWS	24
#define NO_ARG		(-1)
#define DEL		127
#define CTL(x)		((x) & 0x1F)
#define ISCTL(x)	((x) && (x) < ' ')
#define UNCTL(x)	((x) + 64)
#define META(x)		((x) | 0x80)
#define ISMETA(x)	((x) & 0x80)
#define UNMETA(x)	((x) & 0x7F)
#if	!defined(HIST_SIZE)
#define HIST_SIZE	20
#endif	/* !defined(HIST_SIZE) */

/*
**  Command status codes.
*/
typedef enum _STATUS {
   CSdone, CSeof, CSmove, CSdispatch, CSstay, CSsignal
} STATUS;

/*
**  The type of case-changing to perform.
*/
typedef enum _CASE {
   TOupper, TOlower
} CASE;

/*
**  Key to command mapping.
*/
typedef struct _KEYMAP {
   CHAR	Key;
   STATUS	(*Function)();
} KEYMAP;

/*
**  Command history structure.
*/
typedef struct _HISTORY {
   int		Size;
   int		Pos;
   CHAR	*Lines[HIST_SIZE];
} HISTORY;

/*
**  Globals.
*/
unsigned	rl_eof;
unsigned	rl_erase;
unsigned	rl_intr;
unsigned	rl_kill;
unsigned	rl_quit;

STATIC CHAR		NIL[] = "";
STATIC CONST CHAR	*Input = NIL;
STATIC CHAR		*Line;
STATIC CONST char	*Prompt;
STATIC CHAR		*Yanked;
STATIC char		*Screen;
STATIC CONST char	NEWLINE[]= CRLF;
STATIC HISTORY		H;
STATIC int		Repeat;
STATIC int		End;
STATIC int		Mark;
STATIC int		OldPoint;
STATIC int		Point;
STATIC int		PushBack;
STATIC int		Pushed;
STATIC int		Signal;
FORWARD CONST KEYMAP	Map[32];
FORWARD CONST KEYMAP	MetaMap[16];
STATIC SIZE_T		Length;
STATIC SIZE_T		ScreenCount;
STATIC SIZE_T		ScreenSize;
STATIC char		*backspace;
STATIC int		TTYwidth;
STATIC int		TTYrows;

/* Display print 8-bit chars as `M-x' or as the actual 8-bit char? */
int		rl_meta_chars = 0;

/*
**  Declarations.
*/
STATIC CHAR	*editinput();
#if	defined(USE_TERMCAP)
#include <stdlib.h>
#include <curses.h>
#include <term.h>
#endif	/* defined(USE_TERMCAP) */

/*
**  TTY input/output functions.
*/

STATIC void
TTYflush()
{
   if (ScreenCount) {
       /* Dummy assignment avoids GCC warning on
        * "attribute warn_unused_result" */
ssize_t dummy = write(1, Screen, ScreenCount);
       (void)dummy;
ScreenCount = 0;
   }
}

STATIC void
TTYput(CHAR c)
{
   Screen[ScreenCount] = c;
   if (++ScreenCount >= ScreenSize - 1) {
ScreenSize += SCREEN_INC;
RENEW(Screen, char, ScreenSize);
   }
}

STATIC void
TTYputs(CONST CHAR *p)
{
   while (*p)
TTYput(*p++);
}

STATIC void
TTYshow(CHAR c)
{
   if (c == DEL) {
TTYput('^');
TTYput('?');
   }
   else if (ISCTL(c)) {
TTYput('^');
TTYput(UNCTL(c));
   }
   else if (rl_meta_chars && ISMETA(c)) {
TTYput('M');
TTYput('-');
TTYput(UNMETA(c));
   }
   else
TTYput(c);
}

STATIC void
TTYstring(CHAR *p)
{
   while (*p)
TTYshow(*p++);
}

STATIC unsigned int
TTYget()
{
   CHAR	c;

   TTYflush();
   if (Pushed) {
Pushed = 0;
return PushBack;
   }
   if (*Input)
return *Input++;
   return read(0, &c, (SIZE_T)1) == 1 ? c : EOF;
}

#define TTYback()	(backspace ? TTYputs((CHAR *)backspace) : TTYput('\b'))

STATIC void
TTYbackn(int n)
{
   while (--n >= 0)
TTYback();
}

STATIC void
TTYinfo()
{
   static int		init;
#if	defined(USE_TERMCAP)
   char		*term;
   char		buff[2048];
   char		*bp, *p;
#endif	/* defined(USE_TERMCAP) */
#if	defined(TIOCGWINSZ)
   struct winsize	W;
#endif	/* defined(TIOCGWINSZ) */

   if (init) {
#if	defined(TIOCGWINSZ)
/* Perhaps we got resized. */
if (ioctl(0, TIOCGWINSZ, &W) >= 0
 && W.ws_col > 0 && W.ws_row > 0) {
    TTYwidth = (int)W.ws_col;
    TTYrows = (int)W.ws_row;
}
#endif	/* defined(TIOCGWINSZ) */
return;
   }
   init++;

   TTYwidth = TTYrows = 0;
#if	defined(USE_TERMCAP)
   bp = &buff[0];
   if ((term = getenv("TERM")) == NULL)
term = "dumb";
   if (tgetent(buff, term) < 0) {
      TTYwidth = SCREEN_WIDTH;
      TTYrows = SCREEN_ROWS;
      return;
   }
   p = tgetstr("le", &bp);
   backspace = p ? strdup(p) : NULL;
   TTYwidth = tgetnum("co");
   TTYrows = tgetnum("li");
#endif	/* defined(USE_TERMCAP) */

#if	defined(TIOCGWINSZ)
   if (ioctl(0, TIOCGWINSZ, &W) >= 0) {
TTYwidth = (int)W.ws_col;
TTYrows = (int)W.ws_row;
   }
#endif	/* defined(TIOCGWINSZ) */

   if (TTYwidth <= 0 || TTYrows <= 0) {
TTYwidth = SCREEN_WIDTH;
TTYrows = SCREEN_ROWS;
   }
}


STATIC void
reposition()
{
   int		i;
   CHAR	*p;

   TTYput('\r');
   TTYputs((CONST CHAR *)Prompt);
   for (i = Point, p = Line; --i >= 0; p++)
TTYshow(*p);
}

STATIC void
left(STATUS Change)
{
   TTYback();
   if (Point) {
if (ISCTL(Line[Point - 1]))
    TTYback();
       else if (rl_meta_chars && ISMETA(Line[Point - 1])) {
    TTYback();
    TTYback();
}
   }
   if (Change == CSmove)
Point--;
}

STATIC void
right(STATUS Change)
{
   TTYshow(Line[Point]);
   if (Change == CSmove)
Point++;
}

STATIC STATUS
ring_bell()
{
   TTYput('\07');
   TTYflush();
   return CSstay;
}

STATIC STATUS
do_macro(unsigned int c)
{
   CHAR		name[4];

   name[0] = '_';
   name[1] = c;
   name[2] = '_';
   name[3] = '\0';

   if ((Input = (CHAR *)getenv((char *)name)) == NULL) {
Input = NIL;
return ring_bell();
   }
   return CSstay;
}

STATIC STATUS
do_forward(STATUS move)
{
   int		i;
   CHAR	*p;

   i = 0;
   do {
p = &Line[Point];
for ( ; Point < End && (*p == ' ' || !isalnum(*p)); Point++, p++)
    if (move == CSmove)
	right(CSstay);

for (; Point < End && isalnum(*p); Point++, p++)
    if (move == CSmove)
	right(CSstay);

if (Point == End)
    break;
   } while (++i < Repeat);

   return CSstay;
}

STATIC STATUS
do_case(CASE type)
{
   int		i;
   int		end;
   int		count;
   CHAR	*p;

   (void)do_forward(CSstay);
   if (OldPoint != Point) {
if ((count = Point - OldPoint) < 0)
    count = -count;
Point = OldPoint;
if ((end = Point + count) > End)
    end = End;
for (i = Point, p = &Line[i]; i < end; i++, p++) {
    if (type == TOupper) {
	if (islower(*p))
	    *p = toupper(*p);
    }
    else if (isupper(*p))
	*p = tolower(*p);
    right(CSmove);
}
   }
   return CSstay;
}

STATIC STATUS
case_down_word()
{
   return do_case(TOlower);
}

STATIC STATUS
case_up_word()
{
   return do_case(TOupper);
}

STATIC void
ceol()
{
   int		extras;
   int		i;
   CHAR	*p;

   for (extras = 0, i = Point, p = &Line[i]; i <= End; i++, p++) {
TTYput(' ');
if (ISCTL(*p)) {
    TTYput(' ');
    extras++;
}
else if (rl_meta_chars && ISMETA(*p)) {
    TTYput(' ');
    TTYput(' ');
    extras += 2;
}
   }

   for (i += extras; i > Point; i--)
TTYback();
}

STATIC void
clear_line()
{
   Point = -strlen(Prompt);
   TTYput('\r');
   ceol();
   Point = 0;
   End = 0;
   Line[0] = '\0';
}

STATIC STATUS
insert_string(CHAR *p)
{
   SIZE_T	len;
   int		i;
   CHAR	*new;
   CHAR	*q;

   len = strlen((char *)p);
   if (End + len >= Length) {
if ((new = NEW(CHAR, Length + len + MEM_INC)) == NULL)
    return CSstay;
if (Length) {
    COPYFROMTO(new, Line, Length);
    DISPOSE(Line);
}
Line = new;
Length += len + MEM_INC;
   }

   for (q = &Line[Point], i = End - Point; --i >= 0; )
q[len + i] = q[i];
   COPYFROMTO(&Line[Point], p, len);
   End += len;
   Line[End] = '\0';
   TTYstring(&Line[Point]);
   Point += len;

   return Point == End ? CSstay : CSmove;
}

STATIC STATUS
redisplay()
{
   TTYputs((CONST CHAR *)NEWLINE);
   TTYputs((CONST CHAR *)Prompt);
   TTYstring(Line);
   return CSmove;
}

STATIC STATUS
toggle_meta_mode()
{
   rl_meta_chars = ! rl_meta_chars;
   return redisplay();
}


STATIC CHAR *
next_hist()
{
   return H.Pos >= H.Size - 1 ? NULL : H.Lines[++H.Pos];
}

STATIC CHAR *
prev_hist()
{
   return H.Pos == 0 ? NULL : H.Lines[--H.Pos];
}

STATIC STATUS
do_insert_hist(CHAR *p)
{
   if (p == NULL)
return ring_bell();
   Point = 0;
   reposition();
   ceol();
   End = 0;
   return insert_string(p);
}

STATIC STATUS
do_hist(CHAR *(*move)())
{
   CHAR	*p;
   int		i;

   i = 0;
   do {
if ((p = (*move)()) == NULL)
    return ring_bell();
   } while (++i < Repeat);
   return do_insert_hist(p);
}

STATIC STATUS
h_next()
{
   return do_hist(next_hist);
}

STATIC STATUS
h_prev()
{
   return do_hist(prev_hist);
}

STATIC STATUS
h_first()
{
   return do_insert_hist(H.Lines[H.Pos = 0]);
}

STATIC STATUS
h_last()
{
   return do_insert_hist(H.Lines[H.Pos = H.Size - 1]);
}

/*
**  Return zero if pat appears as a substring in text.
*/
STATIC int
substrcmp(char *text, char *pat, size_t len)
{
   char	c;

   if ((c = *pat) == '\0')
       return *text == '\0';
   for ( ; *text; text++)
       if (*text == c && strncmp(text, pat, len) == 0)
           return 0;
   return 1;
}

STATIC CHAR *
search_hist(CHAR *search, CHAR *(*move)())
{
   static CHAR	*old_search;
   int		len;
   int		pos;
   int		(*match)(char *, char *, size_t);
   char	*pat;

   /* Save or get remembered search pattern. */
   if (search && *search) {
if (old_search)
    DISPOSE(old_search);
old_search = (CHAR *)strdup((char *)search);
   }
   else {
if (old_search == NULL || *old_search == '\0')
           return NULL;
search = old_search;
   }

   /* Set up pattern-finder. */
   if (*search == '^') {
match = (int(*)(char *, char *, size_t))strncmp;
pat = (char *)(search + 1);
   }
   else {
match = substrcmp;
pat = (char *)search;
   }
   len = strlen(pat);

   for (pos = H.Pos; (*move)() != NULL; )
if ((*match)((char *)H.Lines[H.Pos], pat, len) == 0)
           return H.Lines[H.Pos];
   H.Pos = pos;
   return NULL;
}

STATIC STATUS
h_search()
{
   static int	Searching;
   CONST char	*old_prompt;
   CHAR	*(*move)();
   CHAR	*p;

   if (Searching)
return ring_bell();
   Searching = 1;

   clear_line();
   old_prompt = Prompt;
   Prompt = "Search: ";
   TTYputs((CONST CHAR *)Prompt);
   move = Repeat == NO_ARG ? prev_hist : next_hist;
   p = editinput();
   Prompt = old_prompt;
   Searching = 0;
   TTYputs((CONST CHAR *)Prompt);
   if (p == NULL && Signal > 0) {
Signal = 0;
clear_line();
return redisplay();
   }
   p = search_hist(p, move);
   clear_line();
   if (p == NULL) {
(void)ring_bell();
return redisplay();
   }
   return do_insert_hist(p);
}

STATIC STATUS
fd_char()
{
   int		i;

   i = 0;
   do {
if (Point >= End)
    break;
right(CSmove);
   } while (++i < Repeat);
   return CSstay;
}

STATIC void
save_yank(int begin, int i)
{
   if (Yanked) {
DISPOSE(Yanked);
Yanked = NULL;
   }

   if (i < 1)
return;

   if ((Yanked = NEW(CHAR, (SIZE_T)i + 1)) != NULL) {
COPYFROMTO(Yanked, &Line[begin], i);
Yanked[i] = '\0';
   }
}

STATIC STATUS
delete_string(int count)
{
   int		i;
   CHAR	*p;

   if (count <= 0 || End == Point)
return ring_bell();

   if (count == 1 && Point == End - 1) {
/* Optimize common case of delete at end of line. */
End--;
p = &Line[Point];
i = 1;
TTYput(' ');
if (ISCTL(*p)) {
    i = 2;
    TTYput(' ');
}
else if (rl_meta_chars && ISMETA(*p)) {
    i = 3;
    TTYput(' ');
    TTYput(' ');
}
TTYbackn(i);
*p = '\0';
return CSmove;
   }
   if (Point + count > End && (count = End - Point) <= 0)
return CSstay;

   if (count > 1)
save_yank(Point, count);

   for (p = &Line[Point], i = End - (Point + count) + 1; --i >= 0; p++)
p[0] = p[count];
   ceol();
   End -= count;
   TTYstring(&Line[Point]);
   return CSmove;
}

STATIC STATUS
bk_char()
{
   int		i;

   i = 0;
   do {
if (Point == 0)
    break;
left(CSmove);
   } while (++i < Repeat);

   return CSstay;
}

STATIC STATUS
bk_del_char()
{
   int		i;

   i = 0;
   do {
if (Point == 0)
    break;
left(CSmove);
   } while (++i < Repeat);

   return delete_string(i);
}

STATIC STATUS
kill_line()
{
   int		i;

   if (Repeat != NO_ARG) {
if (Repeat < Point) {
    i = Point;
    Point = Repeat;
    reposition();
    (void)delete_string(i - Point);
}
else if (Repeat > Point) {
    right(CSmove);
    (void)delete_string(Repeat - Point - 1);
}
return CSmove;
   }

   save_yank(Point, End - Point);
   Line[Point] = '\0';
   ceol();
   End = Point;
   return CSstay;
}

STATIC STATUS
insert_char(int c)
{
   STATUS	s;
   CHAR	buff[2];
   CHAR	*p;
   CHAR	*q;
   int		i;

   if (Repeat == NO_ARG || Repeat < 2) {
buff[0] = c;
buff[1] = '\0';
return insert_string(buff);
   }

   if ((p = NEW(CHAR, Repeat + 1)) == NULL)
return CSstay;
   for (i = Repeat, q = p; --i >= 0; )
*q++ = c;
   *q = '\0';
   Repeat = 0;
   s = insert_string(p);
   DISPOSE(p);
   return s;
}

STATIC STATUS
meta()
{
   unsigned int	c;
   CONST KEYMAP	*kp;

   if ((int)(c = TTYget()) == EOF)
return CSeof;
#if	defined(ANSI_ARROWS)
   /* Also include VT-100 arrows. */
   if (c == '[' || c == 'O')
switch (c = TTYget()) {
default:	return ring_bell();
case EOF:	return CSeof;
case 'A':	return h_prev();
case 'B':	return h_next();
case 'C':	return fd_char();
case 'D':	return bk_char();
}
#endif	/* defined(ANSI_ARROWS) */

   if (isdigit(c)) {
for (Repeat = c - '0'; (int)(c = TTYget()) != EOF && isdigit(c); )
    Repeat = Repeat * 10 + c - '0';
Pushed = 1;
PushBack = c;
return CSstay;
   }

   if (isupper(c))
return do_macro(c);
   for (OldPoint = Point, kp = MetaMap; kp->Function; kp++)
if (kp->Key == c)
    return (*kp->Function)();

   return ring_bell();
}

STATIC STATUS
emacs(unsigned int c)
{
   STATUS		s;
   const KEYMAP	*kp;

   if (rl_meta_chars && ISMETA(c)) {
Pushed = 1;
PushBack = UNMETA(c);
return meta();
   }
   for (kp = Map; kp->Function; kp++)
if (kp->Key == c)
    break;
   s = kp->Function ? (*kp->Function)() : insert_char((int)c);
   if (!Pushed)
/* No pushback means no repeat count; hacky, but true. */
Repeat = NO_ARG;
   return s;
}

STATIC STATUS
TTYspecial(unsigned int c)
{
   if (ISMETA(c))
return CSdispatch;

   if (c == rl_erase || (int)c == DEL)
return bk_del_char();
   if (c == rl_kill) {
if (Point != 0) {
    Point = 0;
    reposition();
}
Repeat = NO_ARG;
return kill_line();
   }
   if (c == rl_eof && Point == 0 && End == 0)
return CSeof;
   if (c == rl_intr) {
Signal = SIGINT;
return CSsignal;
   }
   if (c == rl_quit) {
Signal = SIGQUIT;
return CSeof;
   }

   return CSdispatch;
}

STATIC CHAR *
editinput()
{
   unsigned int	c;

   Repeat = NO_ARG;
   OldPoint = Point = Mark = End = 0;
   Line[0] = '\0';

   Signal = -1;
   while ((int)(c = TTYget()) != EOF)
switch (TTYspecial(c)) {
case CSdone:
    return Line;
case CSeof:
    return NULL;
case CSsignal:
    return (CHAR *)"";
case CSmove:
    reposition();
    break;
case CSdispatch:
    switch (emacs(c)) {
    case CSdone:
	return Line;
    case CSeof:
	return NULL;
    case CSsignal:
	return (CHAR *)"";
    case CSmove:
	reposition();
	break;
    case CSdispatch:
    case CSstay:
	break;
    }
    break;
case CSstay:
    break;
}
   if (strlen((char *)Line))
       return Line;
   free(Line);
   return NULL;
}

STATIC void
hist_add(CHAR *p)
{
   int		i;

   if ((p = (CHAR *)strdup((char *)p)) == NULL)
return;
   if (H.Size < HIST_SIZE)
H.Lines[H.Size++] = p;
   else {
DISPOSE(H.Lines[0]);
for (i = 0; i < HIST_SIZE - 1; i++)
    H.Lines[i] = H.Lines[i + 1];
H.Lines[i] = p;
   }
   H.Pos = H.Size - 1;
}

/*
**  For compatibility with FSF readline.
*/
/* ARGSUSED0 */
void
rl_reset_terminal(char *p)
{
   (void)p;
}

void
rl_initialize()
{
}

char *
readline(CONST char *prompt)
{
   CHAR	*line;
   int		s;

   if (Line == NULL) {
Length = MEM_INC;
if ((Line = NEW(CHAR, Length)) == NULL)
    return NULL;
   }

   TTYinfo();
   rl_ttyset(0);
   hist_add(NIL);
   ScreenSize = SCREEN_INC;
   Screen = NEW(char, ScreenSize);
   Prompt = prompt ? prompt : (char *)NIL;
   TTYputs((CONST CHAR *)Prompt);
   if ((line = editinput()) != NULL) {
line = (CHAR *)strdup((char *)line);
TTYputs((CONST CHAR *)NEWLINE);
TTYflush();
   }
   rl_ttyset(1);
   DISPOSE(Screen);
   DISPOSE(H.Lines[--H.Size]);
   if (Signal > 0) {
s = Signal;
Signal = 0;
(void)kill(getpid(), s);
   }
   return (char *)line;
}

void
add_history(char *p)
{
   if (p == NULL || *p == '\0')
return;

#if	defined(UNIQUE_HISTORY)
   if (H.Size && strcmp(p, (char *)H.Lines[H.Size - 1]) == 0)
       return;
#endif	/* defined(UNIQUE_HISTORY) */
   hist_add((CHAR *)p);
}


STATIC STATUS
beg_line()
{
   if (Point) {
Point = 0;
return CSmove;
   }
   return CSstay;
}

STATIC STATUS
del_char()
{
   return delete_string(Repeat == NO_ARG ? 1 : Repeat);
}

STATIC STATUS
end_line()
{
   if (Point != End) {
Point = End;
return CSmove;
   }
   return CSstay;
}

STATIC STATUS
accept_line()
{
   Line[End] = '\0';
   return CSdone;
}

STATIC STATUS
transpose()
{
   CHAR	c;

   if (Point) {
if (Point == End)
    left(CSmove);
c = Line[Point - 1];
left(CSstay);
Line[Point - 1] = Line[Point];
TTYshow(Line[Point - 1]);
Line[Point++] = c;
TTYshow(c);
   }
   return CSstay;
}

STATIC STATUS
quote()
{
   unsigned int	c;

   return (int)(c = TTYget()) == EOF ? CSeof : insert_char((int)c);
}

STATIC STATUS
wipe()
{
   int		i;

   if (Mark > End)
return ring_bell();

   if (Point > Mark) {
i = Point;
Point = Mark;
Mark = i;
reposition();
   }

   return delete_string(Mark - Point);
}

STATIC STATUS
mk_set()
{
   Mark = Point;
   return CSstay;
}

STATIC STATUS
exchange()
{
   unsigned int	c;

   if ((c = TTYget()) != CTL('X'))
return (int)c == EOF ? CSeof : ring_bell();

   if ((int)(c = Mark) <= End) {
Mark = Point;
Point = c;
return CSmove;
   }
   return CSstay;
}

STATIC STATUS
yank()
{
   if (Yanked && *Yanked)
return insert_string(Yanked);
   return CSstay;
}

STATIC STATUS
copy_region()
{
   if (Mark > End)
return ring_bell();

   if (Point > Mark)
save_yank(Mark, Point - Mark);
   else
save_yank(Point, Mark - Point);

   return CSstay;
}

STATIC STATUS
move_to_char()
{
   unsigned int	c;
   int			i;
   CHAR		*p;

   if ((int)(c = TTYget()) == EOF)
return CSeof;
   for (i = Point + 1, p = &Line[i]; i < End; i++, p++)
if (*p == c) {
    Point = i;
    return CSmove;
}
   return CSstay;
}

STATIC STATUS
fd_word()
{
   return do_forward(CSmove);
}

STATIC STATUS
fd_kill_word()
{
   int		i;

   (void)do_forward(CSstay);
   if (OldPoint != Point) {
i = Point - OldPoint;
Point = OldPoint;
return delete_string(i);
   }
   return CSstay;
}

STATIC STATUS
bk_word()
{
   int		i;
   CHAR	*p;

   i = 0;
   do {
for (p = &Line[Point]; p > Line && !isalnum(p[-1]); p--)
    left(CSmove);

for (; p > Line && p[-1] != ' ' && isalnum(p[-1]); p--)
    left(CSmove);

if (Point == 0)
    break;
   } while (++i < Repeat);

   return CSstay;
}

STATIC STATUS
bk_kill_word()
{
   (void)bk_word();
   if (OldPoint != Point)
return delete_string(OldPoint - Point);
   return CSstay;
}

STATIC int
argify(CHAR *line, CHAR ***avp)
{
   CHAR	*c;
   CHAR	**p;
   CHAR	**new;
   int		ac;
   int		i;

   i = MEM_INC;
   if ((*avp = p = NEW(CHAR*, i))== NULL)
 return 0;

   for (c = line; isspace(*c); c++)
continue;
   if (*c == '\n' || *c == '\0')
return 0;

   for (ac = 0, p[ac++] = c; *c && *c != '\n'; ) {
if (isspace(*c)) {
    *c++ = '\0';
    if (*c && *c != '\n') {
	if (ac + 1 == i) {
	    new = NEW(CHAR*, i + MEM_INC);
	    if (new == NULL) {
		p[ac] = NULL;
		return ac;
	    }
	    COPYFROMTO(new, p, i * sizeof (char **));
	    i += MEM_INC;
	    DISPOSE(p);
	    *avp = p = new;
	}
	p[ac++] = c;
    }
}
else
    c++;
   }
   *c = '\0';
   p[ac] = NULL;
   return ac;
}

STATIC STATUS
last_argument()
{
   CHAR	**av;
   CHAR	*p;
   STATUS	s;
   int		ac;

   if (H.Size == 1 || (p = H.Lines[H.Size - 2]) == NULL)
return ring_bell();

   if ((p = (CHAR *)strdup((char *)p)) == NULL)
return CSstay;
   ac = argify(p, &av);

   if (Repeat != NO_ARG)
s = Repeat < ac ? insert_string(av[Repeat]) : ring_bell();
   else
s = ac ? insert_string(av[ac - 1]) : CSstay;

   if (ac)
DISPOSE(av);
   DISPOSE(p);
   return s;
}

STATIC CONST KEYMAP Map[32] = {
   {	CTL('@'),	ring_bell	},
   {	CTL('A'),	beg_line	},
   {	CTL('B'),	bk_char		},
   {	CTL('D'),	del_char	},
   {	CTL('E'),	end_line	},
   {	CTL('F'),	fd_char		},
   {	CTL('G'),	ring_bell	},
   {	CTL('H'),	bk_del_char	},
   {	CTL('J'),	accept_line	},
   {	CTL('K'),	kill_line	},
   {	CTL('L'),	redisplay	},
   {	CTL('M'),	accept_line	},
   {	CTL('N'),	h_next		},
   {	CTL('O'),	ring_bell	},
   {	CTL('P'),	h_prev		},
   {	CTL('Q'),	ring_bell	},
   {	CTL('R'),	h_search	},
   {	CTL('S'),	ring_bell	},
   {	CTL('T'),	transpose	},
   {	CTL('U'),	ring_bell	},
   {	CTL('V'),	quote		},
   {	CTL('W'),	wipe		},
   {	CTL('X'),	exchange	},
   {	CTL('Y'),	yank		},
   {	CTL('Z'),	ring_bell	},
   {	CTL('['),	meta		},
   {	CTL(']'),	move_to_char	},
   {	CTL('^'),	ring_bell	},
   {	CTL('_'),	ring_bell	},
   {	0,		NULL		}
};

STATIC CONST KEYMAP MetaMap[16]= {
   {	CTL('H'),	bk_kill_word	},
   {	DEL,		bk_kill_word	},
   {	' ',		mk_set		},
   {	'.',		last_argument	},
   {	'<',		h_first		},
   {	'>',		h_last		},
   {	'b',		bk_word		},
   {	'd',		fd_kill_word	},
   {	'f',		fd_word		},
   {	'l',		case_down_word	},
   {	'm',		toggle_meta_mode },
   {	'u',		case_up_word	},
   {	'y',		yank		},
   {	'w',		copy_region	},
   {	0,		NULL		}
};