Removed KLUDGELINEMODE option.

[unix-history] / usr.bin / elvis / tio.c

/* tio.c */

/* Author:
 *	Steve Kirkendall
 *	14407 SW Teal Blvd. #C
 *	Beaverton, OR 97005
 *	kirkenda@cs.pdx.edu
 */


/* This file contains terminal I/O functions */

#include "config.h"
#include "vi.h"
#include "ctype.h"

static int showmsg P_((void));

/* This function reads in a line from the terminal. */
int vgets(prompt, buf, bsize)
	int	prompt;	/* the prompt character, or '\0' for none */
	char	*buf;	/* buffer into which the string is read */
	int	bsize;	/* size of the buffer */
{
	int	len;	/* how much we've read so far */
	int	ch;	/* a character from the user */
	int	quoted;	/* is the next char quoted? */
	int	tab;	/* column position of cursor */
	char	widths[132];	/* widths of characters */
	int	word;	/* index of first letter of word */
#ifndef NO_DIGRAPH
	int	erased;	/* 0, or first char of a digraph */
#endif

	/* show the prompt */
	move(LINES - 1, 0);
	tab = 0;
	if (prompt)
	{
		addch(prompt);
		tab = 1;
	}
	clrtoeol();
	refresh();

	/* read in the line */
#ifndef NO_DIGRAPH
	erased =
#endif
	quoted = len = 0;
	for (;;)
	{
#ifndef NO_ABBR
		if (quoted || mode == MODE_EX)
		{
			ch = getkey(0);
		}
		else
		{
			/* maybe expand an abbreviation while getting key */
			for (word = len; --word >= 0 && !isspace(buf[word]); )
			{
			}
			word++;
			ch = getabkey(WHEN_EX, &buf[word], len - word);
		}
#else
		ch = getkey(0);
#endif
#ifndef NO_EXTENSIONS
		if (ch == ctrl('O'))
		{
			ch = getkey(quoted ? 0 : WHEN_EX);
		}
#endif

		/* some special conversions */
#if 0
		if (ch == ctrl('D') && len == 0)
			ch = ctrl('[');
#endif
#ifndef NO_DIGRAPH
		if (*o_digraph && erased != 0 && ch != '\b')
		{
			ch = digraph(erased, ch);
			erased = 0;
		}
#endif

		/* inhibit detection of special chars (except ^J) after a ^V */
		if (quoted && ch != '\n')
		{
			ch |= 256;
		}

		/* process the character */
		switch(ch)
		{
		  case ctrl('V'):
			qaddch('^');
			qaddch('\b');
			quoted = TRUE;
			break;

		  case ctrl('D'):
			return -1;

		  case ctrl('['):
		  case '\n':
#if OSK
		  case '\l':
#else
		  case '\r':
#endif
			clrtoeol();
			goto BreakBreak;

#ifndef CRUNCH
		  case ctrl('U'):
			while (len > 0)
			{
				len--;
				while (widths[len]-- > 0)
				{
					qaddch('\b');
					qaddch(' ');
					qaddch('\b');
				}
			}
			break;
#endif

		  case '\b':
			if (len > 0)
			{
				len--;
#ifndef NO_DIGRAPH
				erased = buf[len];
#endif
				for (ch = widths[len]; ch > 0; ch--)
					addch('\b');
				if (mode == MODE_EX)
				{
					clrtoeol();
				}
				tab -= widths[len];
			}
			else
			{
				return -1;
			}
			break;

		  default:
			/* strip off quotation bit */
			if (ch & 256)
			{
				ch &= ~256;
				qaddch(' ');
				qaddch('\b');
			}

			/* add & echo the char */
			if (len < bsize - 1)
			{
				if (ch == '\t' && !quoted)
				{
					widths[len] = *o_tabstop - (tab % *o_tabstop);
					addstr("        " + 8 - widths[len]);
					tab += widths[len];
				}
				else if (ch > 0 && ch < ' ') /* > 0 by GB */
				{
					addch('^');
					addch(ch + '@');
					widths[len] = 2;
					tab += 2;
				}
				else if (ch == '\177')
				{
					addch('^');
					addch('?');
					widths[len] = 2;
					tab += 2;
				}
				else
				{
					addch(ch);
					widths[len] = 1;
					tab++;
				}
				buf[len++] = ch;
			}
			else
			{
				beep();
			}
			quoted = FALSE;
		}
	}
BreakBreak:
	refresh();
	buf[len] = '\0';
	return len;
}


static int	manymsgs; /* This variable keeps msgs from overwriting each other */
static char	pmsg[80]; /* previous message (waiting to be displayed) */


static int showmsg()
{
	/* if there is no message to show, then don't */
	if (!manymsgs)
		return FALSE;

	/* display the message */
	move(LINES - 1, 0);
	if (*pmsg)
	{
		standout();
		qaddch(' ');
		qaddstr(pmsg);
		qaddch(' ');
		standend();
	}
	clrtoeol();

	manymsgs = FALSE;
	return TRUE;
}


void endmsgs()
{
	if (manymsgs)
	{
		showmsg();
		addch('\n');
	}
}

/* Write a message in an appropriate way.  This should really be a varargs
 * function, but there is no such thing as vwprintw.  Hack!!!
 *
 * In MODE_EX or MODE_COLON, the message is written immediately, with a
 * newline at the end.
 *
 * In MODE_VI, the message is stored in a character buffer.  It is not
 * displayed until getkey() is called.  msg() will call getkey() itself,
 * if necessary, to prevent messages from being lost.
 *
 * msg("")		- clears the message line
 * msg("%s %d", ...)	- does a printf onto the message line
 */
#ifdef	__STDC__
void msg (char *fmt, ...)
{
	va_list	ap;
	va_start (ap, fmt);
#else
void msg(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
	char	*fmt;
	long	arg1, arg2, arg3, arg4, arg5, arg6, arg7;
{
#endif
	if (mode != MODE_VI)
	{
#ifdef	__STDC__
		vsprintf (pmsg, fmt, ap);
#else
		sprintf(pmsg, fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
#endif
		qaddstr(pmsg);
		addch('\n');
		exrefresh();
	}
	else
	{
		/* wait for keypress between consecutive msgs */
		if (manymsgs)
		{
			getkey(WHEN_MSG);
		}

		/* real message */
#ifdef	__STDC__
		vsprintf (pmsg, fmt, ap);
#else
		sprintf(pmsg, fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
#endif
		if (*fmt)
		{
			manymsgs = TRUE;
		}
	}
#ifdef	__STDC__
	va_end (ap);
#endif
}


/* This function calls refresh() if the option exrefresh is set */
void exrefresh()
{
	char	*scan;

	/* If this ex command wrote ANYTHING set exwrote so vi's  :  command
	 * can tell that it must wait for a user keystroke before redrawing.
	 */
	for (scan=kbuf; scan<stdscr; scan++)
		if (*scan == '\n')
			exwrote = TRUE;

	/* now we do the refresh thing */
	if (*o_exrefresh)
	{
		refresh();
	}
	else
	{
		wqrefresh();
	}
	if (mode != MODE_VI)
	{
		manymsgs = FALSE;
	}
}


/* This structure is used to store maps and abbreviations.  The distinction
 * between them is that maps are stored in the list referenced by the "maps"
 * pointer, while abbreviations are referenced by the "abbrs" pointer.
 */
typedef struct _map
{
	struct _map	*next;	/* another abbreviation */
	short		len;	/* length of the "rawin" characters */
	short		flags;	/* various flags */
	char		*label;	/* label of the map/abbr, or NULL */
	char		*rawin;	/* the "rawin" characters */
	char		*cooked;/* the "cooked" characters */
} MAP;

static char	keybuf[KEYBUFSIZE];
static int	cend;	/* end of input characters */
static int	user;	/* from user through end are chars typed by user */
static int	next;	/* index of the next character to be returned */
static MAP	*match;	/* the matching map, found by countmatch() */
static MAP	*maps;	/* the map table */
#ifndef NO_ABBR
static MAP	*abbrs;	/* the abbreviation table */
#endif



/* ring the terminal's bell */
void beep()
{
	/* do a visible/audible bell */
	if (*o_flash)
	{
		do_VB();
		refresh();
	}
	else if (*o_errorbells)
	{
		tputs("\007", 1, faddch);
	}

	/* discard any buffered input, and abort macros */
	next = user = cend;
}



/* This function replaces a "rawin" character sequence with the "cooked" version,
 * by modifying the internal type-ahead buffer.
 */
void execmap(rawlen, cookedstr, visual)
	int	rawlen;		/* length of rawin text -- string to delete */
	char	*cookedstr;	/* the cooked text -- string to insert */
	int	visual;		/* boolean -- chars to be executed in visual mode? */
{
	int	cookedlen;
	char	*src, *dst;
	int	i;

	/* find the length of the cooked string */
	cookedlen = strlen(cookedstr);
#ifndef NO_EXTENSIONS
	if (visual)
	{
		cookedlen *= 2;
	}
#endif

	/* if too big to fit in type-ahead buffer, then don't do it */
	if (cookedlen + (cend - next) - rawlen > KEYBUFSIZE)
	{
		return;
	}

	/* shift to make room for cookedstr at the front of keybuf */
	src = &keybuf[next + rawlen];
	dst = &keybuf[cookedlen];
	i = cend - (next + rawlen);
	if (src >= dst)
	{
		while (i-- > 0)
		{
			*dst++ = *src++;
		}
	}
	else
	{
		src += i;
		dst += i;
		while (i-- > 0)
		{
			*--dst = *--src;
		}
	}

	/* insert cookedstr, and adjust offsets */
	cend += cookedlen - rawlen - next;
	user += cookedlen - rawlen - next;
	next = 0;
	for (dst = keybuf, src = cookedstr; *src; )
	{
#ifndef NO_EXTENSIONS
		if (visual)
		{
			*dst++ = ctrl('O');
			cookedlen--;
		}
#endif
		*dst++ = *src++;
	}

#ifdef DEBUG2
	{
#include <stdio.h>
		FILE	*debout;
		int		i;

		debout = fopen("debug.out", "a");
		fprintf(debout, "After execmap(%d, \"%s\", %d)...\n", rawlen, cookedstr, visual);
		for (i = 0; i < cend; i++)
		{
			if (i == next) fprintf(debout, "(next)");
			if (i == user) fprintf(debout, "(user)");
			if (UCHAR(keybuf[i]) < ' ')
				fprintf(debout, "^%c", keybuf[i] ^ '@');
			else
				fprintf(debout, "%c", keybuf[i]);
		}
		fprintf(debout, "(end)\n");
		fclose(debout);
	}
#endif
}

#ifndef NO_CURSORSHAPE
/* made global so that suspend_curses() can reset it.  -nox */
int	oldcurs;
#endif
/* This function calls ttyread().  If necessary, it will also redraw the screen,
 * change the cursor shape, display the mode, and update the ruler.  If the
 * number of characters read is 0, and we didn't time-out, then it exits because
 * we've apparently reached the end of an EX script.
 */
static int fillkeybuf(when, timeout)
	int	when;	/* mixture of WHEN_XXX flags */
	int	timeout;/* timeout in 1/10 second increments, or 0 */
{
	int	nkeys;
#ifndef NO_SHOWMODE
	static int	oldwhen;	/* "when" from last time */
	static int	oldleft;
	static long	oldtop;
	static long	oldnlines;
	char		*str;
#endif

#ifdef DEBUG
	watch();
#endif


#ifndef NO_CURSORSHAPE
	/* make sure the cursor is the right shape */
	if (has_CQ)
	{
		if (when != oldcurs)
		{
			switch (when)
			{
			  case WHEN_EX:		do_CX();	break;
			  case WHEN_VICMD:	do_CV();	break;
			  case WHEN_VIINP:	do_CI();	break;
			  case WHEN_VIREP:	do_CR();	break;
			}
			oldcurs = when;
		}
	}
#endif

#ifndef NO_SHOWMODE
	/* if "showmode" then say which mode we're in */
	if (*o_smd && (when & WHENMASK))
	{
		/* redraw the screen before we check to see whether the
		 * "showmode" message needs to be redrawn.
		 */
		redraw(cursor, !(when & WHEN_VICMD));

		/* now the "topline" test should be valid */
		if (when != oldwhen
		 || topline != oldtop
		 || leftcol != oldleft
		 || nlines != oldnlines)
		{
			oldwhen = when;
			oldtop = topline;
			oldleft = leftcol;
			oldnlines = nlines;

			if (when & WHEN_VICMD)	    str = "Command";
			else if (when & WHEN_VIINP) str = " Input ";
			else if (when & WHEN_VIREP) str = "Replace";
			else if (when & WHEN_REP1)  str = "Replc 1";
			else if (when & WHEN_CUT)   str = "Buffer ";
			else if (when & WHEN_MARK)  str = " Mark  ";
			else if (when & WHEN_CHAR)  str = "Dest Ch";
			else			    str = (char *)0;

			if (str)
			{
				move(LINES - 1, COLS - 10);
				standout();
				qaddstr(str);
				standend();
			}
		}
	}
#endif

#ifndef NO_EXTENSIONS
	/* maybe display the ruler */
	if (*o_ruler && (when & (WHEN_VICMD|WHEN_VIINP|WHEN_VIREP)))
	{
		char	buf[20];

		redraw(cursor, !(when & WHEN_VICMD));
		pfetch(markline(cursor));
		sprintf(buf, "%7ld,%-4d", markline(cursor), 1 + idx2col(cursor, ptext, when & (WHEN_VIINP|WHEN_VIREP)));
		move(LINES - 1, COLS - 22);
		addstr(buf);
	}
#endif

	/* redraw, so the cursor is in the right place */
	if (when & WHENMASK)
	{
		redraw(cursor, !(when & (WHENMASK & ~(WHEN_VIREP|WHEN_VIINP))));
	}

	/* Okay, now we can finally read the rawin keystrokes */
	refresh();
	nkeys = ttyread(keybuf + cend, sizeof keybuf - cend, timeout);

	/* if nkeys == 0 then we've reached EOF of an ex script. */
	if (nkeys == 0 && timeout == 0)
	{
		tmpabort(TRUE);
		move(LINES - 1, 0);
		clrtoeol();
		refresh();
		endwin();
		exit(exitcode);
	}

	cend += nkeys;
	user += nkeys;
	return nkeys;
}


/* This function counts the number of maps that could match the characters
 * between &keybuf[next] and &keybuf[cend], including incomplete matches.
 * The longest comlete match is remembered via the "match" variable.
 */
static int countmatch(when)
	int	when;	/* mixture of WHEN_XXX flags */
{
	MAP	*map;
	int	count;

	/* clear the "match" variable */
	match = (MAP *)0;

	/* check every map */
	for (count = 0, map = maps; map; map = map->next)
	{
		/* can't match if wrong mode */
		if ((map->flags & when) == 0)
		{
			continue;
		}

		/* would this be a complete match? */
		if (map->len <= cend - next)
		{
			/* Yes, it would be.  Now does it really match? */
			if (!strncmp(map->rawin, &keybuf[next], map->len))
			{
				count++;

				/* if this is the longest complete match,
				 * then remember it.
				 */
				if (!match || match->len < map->len)
				{
					match = map;
				}
			}
		}
		else
		{
			/* No, it wouldn't.  But check for partial match */
			if (!strncmp(map->rawin, &keybuf[next], cend - next))
			{
				/* increment by 2 instead of 1 so that, in the
				 * event that we have a partial match with a
				 * single map, we don't mistakenly assume we
				 * have resolved the map yet.
				 */
				count += 2;
			}
		}
	}
	return count;
}


#ifndef NO_ABBR
/* This function checks to see whether a word is an abbreviation.  If it is,
 * then an appropriate number of backspoace characters is inserted into the
 * type-ahead buffer, followed by the expanded form of the abbreviation.
 */
static void expandabbr(word, wlen)
	char	*word;
	int	wlen;
{
	MAP	*abbr;

	/* if the next character wouldn't end the word, then don't expand */
	if (isalnum(keybuf[next]) || keybuf[next] == ctrl('V') || keybuf[next] == '\b')
	{
		return;
	}

	/* find the abbreviation, if any */
	for (abbr = abbrs;
	     abbr && (abbr->len != wlen || strncmp(abbr->rawin, word, wlen));
	     abbr = abbr->next)
	{
	}

	/* If an abbreviation was found, then expand it by inserting the long
	 * version into the type-ahead buffer, and then inserting (in front of
	 * the long version) enough backspaces to erase to the short version.
	 */
	if (abbr)
	{
		execmap(0, abbr->cooked, FALSE);
		while (wlen > 15)
		{
			execmap(0, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b", FALSE);
			wlen -= 15;
		}
		if (wlen > 0)
		{
			execmap(0, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b" + 15 - wlen, FALSE);
		}
	}
}
#endif


/* This function calls getabkey() without attempting to expand abbreviations */
int getkey(when)
	int	when;	/* mixture of WHEN_XXX flags */
{
	return getabkey(when, "", 0);
}


/* This is it.  This function returns keystrokes one-at-a-time, after mapping
 * and abbreviations have been taken into account.
 */
int getabkey(when, word, wlen)
	int	when;	/* mixture of WHEN_XXX flags */
	char	*word;	/* a word that may need to be expanded as an abbr */
	int	wlen;	/* length of "word" -- since "word" might not have \0 */
{
	int	matches;

	/* if this key is needed for delay between multiple error messages,
	 * then reset the manymsgs flag and abort any mapped key sequence.
	 */
	if (showmsg())
	{
		if (when == WHEN_MSG)
		{
#ifndef CRUNCH
			if (!*o_more)
			{
				refresh();
				return ' ';
			}
#endif
			qaddstr("[More...]");
			refresh();
			execmap(user, "", FALSE);
		}
	}

#ifdef DEBUG
	/* periodically check for screwed up internal tables */
	watch();
#endif

	/* if buffer empty, read some characters without timeout */
	if (next >= cend)
	{
		next = user = cend = 0;
		fillkeybuf(when, 0);
	}

	/* try to map the key, unless already mapped and not ":set noremap" */
	if (next <= user || *o_remap)
	{
		do
		{
			do
			{
				matches = countmatch(when);
			} while (matches > 1 && fillkeybuf(when, *o_keytime) > 0);
			if (matches == 1)
			{
				execmap(match->len, match->cooked,
					(match->flags & WHEN_INMV) != 0 
					 && (when & (WHEN_VIINP|WHEN_VIREP)) != 0);
			}
		} while (*o_remap && matches == 1);
	}

	/* ERASEKEY should always be mapped to '\b'. */
	if (keybuf[next] == ERASEKEY)
	{
		keybuf[next] = '\b';
	}

#ifndef NO_ABBR
	/* try to expand an abbreviation, except in visual command mode */
	if (wlen > 0 && (mode & (WHEN_EX|WHEN_VIINP|WHEN_VIREP)) != 0)
	{
		expandabbr(word, wlen);
	}
#endif

	/* return the next key */
	return keybuf[next++];
}

/* This function maps or unmaps a key */
void mapkey(rawin, cooked, when, name)
	char	*rawin;	/* the input key sequence, before mapping */
	char	*cooked;/* after mapping -- or NULL to remove map */
	int	when;	/* bitmap of when mapping should happen */
	char	*name;	/* name of the key, NULL for no name, "abbr" for abbr */
{
	MAP	**head;	/* head of list of maps or abbreviations */
	MAP	*scan;	/* used for scanning through the list */
	MAP	*prev;	/* used during deletions */

	/* Is this a map or an abbreviation?  Choose the right list. */
#ifndef NO_ABBR
	head = ((!name || strcmp(name, "abbr")) ? &maps : &abbrs);
#else
	head = &maps;
#endif

	/* try to find the map in the list */
	for (scan = *head, prev = (MAP *)0;
	     scan && (strcmp(rawin, scan->rawin) && strcmp(rawin, scan->cooked) ||
		!(scan->flags & when & (WHEN_EX|WHEN_VICMD|WHEN_VIINP|WHEN_VIREP)));
	     prev = scan, scan = scan->next)
	{
	}

	/* trying to map? (not unmap) */
	if (cooked && *cooked)
	{
		/* if map starts with "visual ", then mark it as a visual map */
		if (head == &maps && !strncmp(cooked, "visual ", 7))
		{
			cooked += 7;
			when |= WHEN_INMV;
		}

		/* "visual" maps always work in input mode */
		if (when & WHEN_INMV)
		{
			when |= WHEN_VIINP|WHEN_VIREP|WHEN_POPUP;
		}

		/* if not already in the list, then allocate a new structure */
		if (!scan)
		{
			scan = (MAP *)malloc(sizeof(MAP));
			scan->len = strlen(rawin);
			scan->rawin = malloc((unsigned)(scan->len + 1));
			strcpy(scan->rawin, rawin);
			scan->flags = when;
			scan->label = name;
			if (*head)
			{
				prev->next = scan;
			}
			else
			{
				*head = scan;
			}
			scan->next = (MAP *)0;
		}
		else /* recycle old structure */
		{
			_free_(scan->cooked);
		}
		scan->cooked = malloc((unsigned)(strlen(cooked) + 1));
		strcpy(scan->cooked, cooked);
	}
	else /* unmapping */
	{
		/* if nothing to unmap, then exit silently */
		if (!scan)
		{
			return;
		}

		/* unlink the structure from the list */
		if (prev)
		{
			prev->next = scan->next;
		}
		else
		{
			*head = scan->next;
		}

		/* free it, and the strings that it refers to */
		_free_(scan->rawin);
		_free_(scan->cooked);
		_free_(scan);
	}
}


/* This function returns a printable version of a string.  It uses tmpblk.c */
char *printable(str)
	char	*str;	/* the string to convert */
{
	char	*build;	/* used for building the string */

	for (build = tmpblk.c; *str; str++)
	{
#if AMIGA
		if (*str == '\233')
		{
			*build++ = '<';
			*build++ = 'C';
			*build++ = 'S';
			*build++ = 'I';
			*build++ = '>';
		} else 
#endif
		if (UCHAR(*str) < ' ' || *str == '\177')
		{
			*build++ = '^';
			*build++ = *str ^ '@';
		}
		else
		{
			*build++ = *str;
		}
	}
	*build = '\0';
	return tmpblk.c;
}

/* This function displays the contents of either the map table or the
 * abbreviation table.  User commands call this function as follows:
 *	:map	dumpkey(WHEN_VICMD, FALSE);
 *	:map!	dumpkey(WHEN_VIREP|WHEN_VIINP, FALSE);
 *	:abbr	dumpkey(WHEN_VIINP|WHEN_VIREP, TRUE);
 *	:abbr!	dumpkey(WHEN_EX|WHEN_VIINP|WHEN_VIREP, TRUE);
 */
void dumpkey(when, abbr)
	int	when;	/* WHEN_XXXX of mappings to be dumped */
	int	abbr;	/* boolean: dump abbreviations instead of maps? */
{
	MAP	*scan;
	char	*str;
	int	len;

#ifndef NO_ABBR
	for (scan = (abbr ? abbrs : maps); scan; scan = scan->next)
#else
	for (scan = maps; scan; scan = scan->next)
#endif
	{
		/* skip entries that don't match "when" */
		if ((scan->flags & when) == 0)
		{
			continue;
		}

		/* dump the key label, if any */
		if (!abbr)
		{
			len = 8;
			if (scan->label)
			{
				qaddstr(scan->label);
				len -= strlen(scan->label);
			}
			do
			{
				qaddch(' ');
			} while (len-- > 0);
		}

		/* dump the rawin version */
		str = printable(scan->rawin);
		qaddstr(str);
		len = strlen(str);
		do
		{
			qaddch(' ');
		} while (len++ < 8);
			
		/* dump the mapped version */
#ifndef NO_EXTENSIONS
		if ((scan->flags & WHEN_INMV) && (when & (WHEN_VIINP|WHEN_VIREP)))
		{
			qaddstr("visual ");
		}
#endif
		str = printable(scan->cooked);
		qaddstr(str);
		addch('\n');
		exrefresh();
	}
}

#ifndef NO_MKEXRC

static void safequote(str)
	char	*str;
{
	char	*build;

	build = tmpblk.c + strlen(tmpblk.c);
	while (*str)
	{
		if (*str <= ' ' && *str >= 1 || *str == '|')
		{
			*build++ = ctrl('V');
		}
		*build++ = *str++;
	}
	*build = '\0';
}

/* This function saves the contents of either the map table or the
 * abbreviation table into a file.  Both the "bang" and "no bang" versions
 * are saved.
 *	:map	dumpkey(WHEN_VICMD, FALSE);
 *	:map!	dumpkey(WHEN_VIREP|WHEN_VIINP, FALSE);
 *	:abbr	dumpkey(WHEN_VIINP|WHEN_VIREP, TRUE);
 *	:abbr!	dumpkey(WHEN_EX|WHEN_VIINP|WHEN_VIREP, TRUE);
 */
void
savemaps(fd, abbr)
	int	fd;	/* file descriptor of an open file to write to */
	int	abbr;	/* boolean: do abbr table? (else do map table) */
{
	MAP	*scan;
	int	bang;
	int	when;

# ifndef NO_ABBR
	for (scan = (abbr ? abbrs : maps); scan; scan = scan->next)
# else
	for (scan = maps; scan; scan = scan->next)
# endif
	{
		/* skip maps that have labels, except for function keys */
		if (scan->label && *scan->label != '#')
		{
			continue;
		}

		for (bang = 0; bang < 2; bang++)
		{
			/* decide which "when" flags we want */
# ifndef NO_ABBR
			if (abbr)
				when = (bang ? WHEN_EX|WHEN_VIINP|WHEN_VIREP : WHEN_VIINP|WHEN_VIREP);
			else
# endif
				when = (bang ? WHEN_VIREP|WHEN_VIINP : WHEN_VICMD);

			/* skip entries that don't match "when" */
			if ((scan->flags & when) == 0)
			{
				continue;
			}

			/* write a "map" or "abbr" command name */
# ifndef NO_ABBR
			if (abbr)
				strcpy(tmpblk.c, "abbr");
			else
# endif
				strcpy(tmpblk.c, "map");

			/* maybe write a bang.  Definitely write a space */
			if (bang)
				strcat(tmpblk.c, "! ");
			else
				strcat(tmpblk.c, " ");

			/* write the rawin version */
# ifndef NO_FKEY
			if (scan->label)
				strcat(tmpblk.c, scan->label);
			else
# endif
				safequote(scan->rawin);
			strcat(tmpblk.c, " ");
				
			/* dump the mapped version */
# ifndef NO_EXTENSIONS
			if ((scan->flags & WHEN_INMV) && (when & (WHEN_VIINP|WHEN_VIREP)))
			{
				strcat(tmpblk.c, "visual ");
			}
# endif
			safequote(scan->cooked);
			strcat(tmpblk.c, "\n");
			twrite(fd, tmpblk.c, strlen(tmpblk.c));
		}
	}
}
#endif