/* $OpenBSD$ */

/* This file is in the public domain. */

/*

* Extended (M-X) commands, rebinding, and startup file processing.

*/

#include "chrdef.h"

#include "def.h"

#include "kbd.h"

#include "funmap.h"

#include <sys/types.h>

#include <ctype.h>

#include "macro.h"

#ifdef FKEYS

#include "key.h"

#ifndef BINDKEY

#define BINDKEY /* bindkey is used by FKEYS startup code */

#endif /* !BINDKEY */

#endif /* FKEYS */

#include <ctype.h>

static int remap(KEYMAP *, int, PF, KEYMAP *);

static KEYMAP *reallocmap(KEYMAP *);

static void fixmap(KEYMAP *, KEYMAP *, KEYMAP *);

static int dobind(KEYMAP *, const char *, int);

static char *skipwhite(char *);

static char *parsetoken(char *);

#ifdef BINDKEY

static int bindkey(KEYMAP **, const char *, KCHAR *, int);

#endif /* BINDKEY */

/*

* Insert a string, mainly for use from macros (created by selfinsert).

*/

/* ARGSUSED */

int

insert(int f, int n)

{

char buf[128], *bufp, *cp;

int count, c;

if (inmacro) {

while (--n >= 0) {

for (count = 0; count < maclcur->l_used; count++) {

if ((((c = maclcur->l_text[count]) == '\n')

? lnewline() : linsert(1, c)) != TRUE)

return (FALSE);

}

}

maclcur = maclcur->l_fp;

return (TRUE);

}

if (n == 1)

/* CFINS means selfinsert can tack on the end */

thisflag |= CFINS;

if ((bufp = eread("Insert: ", buf, sizeof(buf), EFNEW)) == NULL)

return (ABORT);

else if (bufp[0] == '\0')

return (FALSE);

while (--n >= 0) {

cp = buf;

while (*cp) {

if (((*cp == '\n') ? lnewline() : linsert(1, *cp))

!= TRUE)

return (FALSE);

cp++;

}

}

return (TRUE);

}

/*

* Bind a key to a function. Cases range from the trivial (replacing an

* existing binding) to the extremely complex (creating a new prefix in a

* map_element that already has one, so the map_element must be split,

* but the keymap doesn't have enough room for another map_element, so

* the keymap is reallocated). No attempt is made to reclaim space no

* longer used, if this is a problem flags must be added to indicate

* malloced versus static storage in both keymaps and map_elements.

* Structure assignments would come in real handy, but K&R based compilers

* don't have them. Care is taken so running out of memory will leave

* the keymap in a usable state.

* Parameters are:

* curmap: pointer to the map being changed

* c: character being changed

* funct: function being changed to

* pref_map: if funct==NULL, map to bind to or NULL for new

*/

static int

remap(KEYMAP *curmap, int c, PF funct, KEYMAP *pref_map)

{

int i, n1, n2, nold;

KEYMAP *mp, *newmap;

PF *pfp;

struct map_element *mep;

if (ele >= &curmap->map_element[curmap->map_num] || c < ele->k_base) {

if (ele > &curmap->map_element[0] && (funct != NULL ||

(ele - 1)->k_prefmap == NULL))

n1 = c - (ele - 1)->k_num;

else

n1 = HUGE;

if (ele < &curmap->map_element[curmap->map_num] &&

(funct != NULL || ele->k_prefmap == NULL))

n2 = ele->k_base - c;

else

n2 = HUGE;

if (n1 <= MAPELEDEF && n1 <= n2) {

ele--;

if ((pfp = calloc(c - ele->k_base + 1,

sizeof(PF))) == NULL) {

ewprintf("Out of memory");

return (FALSE);

}

nold = ele->k_num - ele->k_base + 1;

for (i = 0; i < nold; i++)

pfp[i] = ele->k_funcp[i];

while (--n1)

pfp[i++] = curmap->map_default;

pfp[i] = funct;

ele->k_num = c;

ele->k_funcp = pfp;

} else if (n2 <= MAPELEDEF) {

if ((pfp = calloc(ele->k_num - c + 1,

sizeof(PF))) == NULL) {

ewprintf("Out of memory");

return (FALSE);

}

nold = ele->k_num - ele->k_base + 1;

for (i = 0; i < nold; i++)

pfp[i + n2] = ele->k_funcp[i];

while (--n2)

pfp[n2] = curmap->map_default;

pfp[0] = funct;

ele->k_base = c;

ele->k_funcp = pfp;

} else {

if (curmap->map_num >= curmap->map_max) {

if ((newmap = reallocmap(curmap)) == NULL)

return (FALSE);

curmap = newmap;

}

if ((pfp = malloc(sizeof(PF))) == NULL) {

ewprintf("Out of memory");

return (FALSE);

}

pfp[0] = funct;

for (mep = &curmap->map_element[curmap->map_num];

mep > ele; mep--) {

mep->k_base = (mep - 1)->k_base;

mep->k_num = (mep - 1)->k_num;

mep->k_funcp = (mep - 1)->k_funcp;

mep->k_prefmap = (mep - 1)->k_prefmap;

}

ele->k_base = c;

ele->k_num = c;

ele->k_funcp = pfp;

ele->k_prefmap = NULL;

curmap->map_num++;

}

if (funct == NULL) {

if (pref_map != NULL)

ele->k_prefmap = pref_map;

else {

if ((mp = malloc(sizeof(KEYMAP) +

(MAPINIT - 1) * sizeof(struct map_element))) == NULL) {

ewprintf("Out of memory");

ele->k_funcp[c - ele->k_base] =

curmap->map_default;

return (FALSE);

}

mp->map_num = 0;

mp->map_max = MAPINIT;

mp->map_default = rescan;

ele->k_prefmap = mp;

}

}

} else {

n1 = c - ele->k_base;

if (ele->k_funcp[n1] == funct && (funct != NULL ||

pref_map == NULL || pref_map == ele->k_prefmap))

/* no change */

return (TRUE);

if (funct != NULL || ele->k_prefmap == NULL) {

if (ele->k_funcp[n1] == NULL)

ele->k_prefmap = NULL;

/* easy case */

ele->k_funcp[n1] = funct;

if (funct == NULL) {

if (pref_map != NULL)

ele->k_prefmap = pref_map;

else {

if ((mp = malloc(sizeof(KEYMAP) +

(MAPINIT - 1) *

sizeof(struct map_element))) == NULL) {

ewprintf("Out of memory");

ele->k_funcp[c - ele->k_base] =

curmap->map_default;

return (FALSE);

}

mp->map_num = 0;

mp->map_max = MAPINIT;

mp->map_default = rescan;

ele->k_prefmap = mp;

}

}

} else {

/*

* This case is the splits.

* Determine which side of the break c goes on

* 0 = after break; 1 = before break

*/

n2 = 1;

for (i = 0; n2 && i < n1; i++)

n2 &= ele->k_funcp[i] != NULL;

if (curmap->map_num >= curmap->map_max) {

if ((newmap = reallocmap(curmap)) == NULL)

return (FALSE);

curmap = newmap;

}

if ((pfp = calloc(ele->k_num - c + !n2,

sizeof(PF))) == NULL) {

ewprintf("Out of memory");

return (FALSE);

}

ele->k_funcp[n1] = NULL;

for (i = n1 + n2; i <= ele->k_num - ele->k_base; i++)

pfp[i - n1 - n2] = ele->k_funcp[i];

for (mep = &curmap->map_element[curmap->map_num];

mep > ele; mep--) {

mep->k_base = (mep - 1)->k_base;

mep->k_num = (mep - 1)->k_num;

mep->k_funcp = (mep - 1)->k_funcp;

mep->k_prefmap = (mep - 1)->k_prefmap;

}

ele->k_num = c - !n2;

(ele + 1)->k_base = c + n2;

(ele + 1)->k_funcp = pfp;

ele += !n2;

ele->k_prefmap = NULL;

curmap->map_num++;

if (pref_map == NULL) {

if ((mp = malloc(sizeof(KEYMAP) + (MAPINIT - 1)

* sizeof(struct map_element))) == NULL) {

ewprintf("Out of memory");

ele->k_funcp[c - ele->k_base] =

curmap->map_default;

return (FALSE);

}

mp->map_num = 0;

mp->map_max = MAPINIT;

mp->map_default = rescan;

ele->k_prefmap = mp;

} else

ele->k_prefmap = pref_map;

}

}

return (TRUE);

}

/*

* Reallocate a keymap. Returns NULL (without trashing the current map)

* on failure.

*/

static KEYMAP *

reallocmap(KEYMAP *curmap)

{

struct maps_s *mps;

KEYMAP *mp;

int i;

if (curmap->map_max > SHRT_MAX - MAPGROW) {

ewprintf("keymap too large");

return (NULL);

}

if ((mp = malloc(sizeof(KEYMAP) + (curmap->map_max + (MAPGROW - 1)) *

sizeof(struct map_element))) == NULL) {

ewprintf("Out of memory");

return (NULL);

}

mp->map_num = curmap->map_num;

mp->map_max = curmap->map_max + MAPGROW;

mp->map_default = curmap->map_default;

for (i = curmap->map_num; i--;) {

mp->map_element[i].k_base = curmap->map_element[i].k_base;

mp->map_element[i].k_num = curmap->map_element[i].k_num;

mp->map_element[i].k_funcp = curmap->map_element[i].k_funcp;

mp->map_element[i].k_prefmap = curmap->map_element[i].k_prefmap;

}

for (mps = maps; mps != NULL; mps = mps->p_next) {

if (mps->p_map == curmap)

mps->p_map = mp;

else

fixmap(curmap, mp, mps->p_map);

}

ele = &mp->map_element[ele - &curmap->map_element[0]];

return (mp);

}

/*

* Fix references to a reallocated keymap (recursive).

*/

static void

fixmap(KEYMAP *curmap, KEYMAP *mp, KEYMAP *mt)

{

int i;

for (i = mt->map_num; i--;) {

if (mt->map_element[i].k_prefmap != NULL) {

if (mt->map_element[i].k_prefmap == curmap)

mt->map_element[i].k_prefmap = mp;

else

fixmap(curmap, mp, mt->map_element[i].k_prefmap);

}

}

}

/*

* Do the input for local-set-key, global-set-key and define-key

* then call remap to do the work.

*/

static int

dobind(KEYMAP *curmap, const char *p, int unbind)

{

KEYMAP *pref_map = NULL;

PF funct;

char bprompt[80], *bufp, *pep;

int c, s, n;

if (macrodef) {

/*

* Keystrokes aren't collected. Not hard, but pretty useless.

* Would not work for function keys in any case.

*/

ewprintf("Can't rebind key in macro");

return (FALSE);

}

if (inmacro) {

for (s = 0; s < maclcur->l_used - 1; s++) {

if (doscan(curmap, c = CHARMASK(maclcur->l_text[s]), &curmap)

!= NULL) {

if (remap(curmap, c, NULL, NULL)

!= TRUE)

return (FALSE);

}

}

(void)doscan(curmap, c = maclcur->l_text[s], NULL);

maclcur = maclcur->l_fp;

} else {

n = strlcpy(bprompt, p, sizeof(bprompt));

if (n >= sizeof(bprompt))

n = sizeof(bprompt) - 1;

pep = bprompt + n;

for (;;) {

ewprintf("%s", bprompt);

pep[-1] = ' ';

pep = getkeyname(pep, sizeof(bprompt) -

(pep - bprompt), c = getkey(FALSE));

if (doscan(curmap, c, &curmap) != NULL)

break;

*pep++ = '-';

*pep = '\0';

}

}

if (unbind)

funct = rescan;

else {

if ((bufp = eread("%s to command: ", bprompt, sizeof(bprompt),

EFFUNC | EFNEW, bprompt)) == NULL)

return (ABORT);

else if (bufp[0] == '\0')

return (FALSE);

if (((funct = name_function(bprompt)) == NULL) ?

(pref_map = name_map(bprompt)) == NULL : funct == NULL) {

ewprintf("[No match]");

return (FALSE);

}

}

return (remap(curmap, c, funct, pref_map));

}

/*

* bindkey: bind key sequence to a function in the specified map. Used by

* excline so it can bind function keys. To close to release to change

* calling sequence, should just pass KEYMAP *curmap rather than

* KEYMAP **mapp.

*/

#ifdef BINDKEY

static int

bindkey(KEYMAP **mapp, const char *fname, KCHAR *keys, int kcount)

{

KEYMAP *curmap = *mapp;

KEYMAP *pref_map = NULL;

PF funct;

int c;

if (fname == NULL)

funct = rescan;

else if (((funct = name_function(fname)) == NULL) ?

(pref_map = name_map(fname)) == NULL : funct == NULL) {

ewprintf("[No match: %s]", fname);

return (FALSE);

}

while (--kcount) {

if (doscan(curmap, c = *keys++, &curmap) != NULL) {

if (remap(curmap, c, NULL, NULL) != TRUE)

return (FALSE);

/*

* XXX - Bizzarreness. remap creates an empty KEYMAP

* that the last key is supposed to point to.

*/

curmap = ele->k_prefmap;

}

}

(void)doscan(curmap, c = *keys, NULL);

return (remap(curmap, c, funct, pref_map));

}

#ifdef FKEYS

/*

* Wrapper for bindkey() that converts escapes.

*/

int

dobindkey(KEYMAP *map, const char *func, const char *str)

{

int i;

for (i = 0; *str && i < MAXKEY; i++) {

/* XXX - convert numbers w/ strol()? */

if (*str == '^' && *(str + 1) != '\0') {

key.k_chars[i] = CCHR(toupper(*++str));

} else if (*str == '\\' && *(str + 1) != '\0') {

switch (*++str) {

case '^':

key.k_chars[i] = '^';

break;

case 't':

case 'T':

key.k_chars[i] = '\t';

break;

case 'n':

case 'N':

key.k_chars[i] = '\n';

break;

case 'r':

case 'R':

key.k_chars[i] = '\r';

break;

case 'e':

case 'E':

key.k_chars[i] = CCHR('[');

break;

case '\\':

key.k_chars[i] = '\\';

break;

}

} else

key.k_chars[i] = *str;

str++;

}

key.k_count = i;

return (bindkey(&map, func, key.k_chars, key.k_count));

}

#endif /* FKEYS */

#endif /* BINDKEY */

/*

* This function modifies the fundamental keyboard map.

*/

/* ARGSUSED */

int

bindtokey(int f, int n)

{

return (dobind(fundamental_map, "Global set key: ", FALSE));

}

/*

* This function modifies the current mode's keyboard map.

*/

/* ARGSUSED */

int

localbind(int f, int n)

{

return (dobind(curbp->b_modes[curbp->b_nmodes]->p_map,

"Local set key: ", FALSE));

}

/*

* This function redefines a key in any keymap.

*/

/* ARGSUSED */

int

redefine_key(int f, int n)

{

static char buf[48];

char tmp[32], *bufp;

KEYMAP *mp;

(void)strlcpy(buf, "Define key map: ", sizeof(buf));

if ((bufp = eread(buf, tmp, sizeof(tmp), EFNEW)) == NULL)

return (ABORT);

else if (bufp[0] == '\0')

return (FALSE);

(void)strlcat(buf, tmp, sizeof(buf));

if ((mp = name_map(tmp)) == NULL) {

ewprintf("Unknown map %s", tmp);

return (FALSE);

}

if (strlcat(buf, "key: ", sizeof(buf)) >= sizeof(buf))

return (FALSE);

return (dobind(mp, buf, FALSE));

}

/* ARGSUSED */

int

unbindtokey(int f, int n)

{

return (dobind(fundamental_map, "Global unset key: ", TRUE));

}

/* ARGSUSED */

int

localunbind(int f, int n)

{

return (dobind(curbp->b_modes[curbp->b_nmodes]->p_map,

"Local unset key: ", TRUE));

}

/*

* Extended command. Call the message line routine to read in the command

* name and apply autocompletion to it. When it comes back, look the name

* up in the symbol table and run the command if it is found. Print an

* error if there is anything wrong.

*/

int

extend(int f, int n)

{

PF funct;

char xname[NXNAME], *bufp;

if (!(f & FFARG))

bufp = eread("M-x ", xname, NXNAME, EFNEW | EFFUNC);

else

bufp = eread("%d M-x ", xname, NXNAME, EFNEW | EFFUNC, n);

if (bufp == NULL)

return (ABORT);

else if (bufp[0] == '\0')

return (FALSE);

if ((funct = name_function(bufp)) != NULL) {

if (macrodef) {

struct line *lp = maclcur;

macro[macrocount - 1].m_funct = funct;

maclcur = lp->l_bp;

maclcur->l_fp = lp->l_fp;

free(lp);

}

return ((*funct)(f, n));

}

ewprintf("[No match]");

return (FALSE);

}

/*

* Define the commands needed to do startup-file processing.

* This code is mostly a kludge just so we can get startup-file processing.

*

* If you're serious about having this code, you should rewrite it.

* To wit:

* It has lots of funny things in it to make the startup-file look

* like a GNU startup file; mostly dealing with parens and semicolons.

* This should all vanish.

*

* We define eval-expression because it's easy. It can make

* *-set-key or define-key set an arbitrary key sequence, so it isn't

* useless.

*/

/*

* evalexpr - get one line from the user, and run it.

*/

/* ARGSUSED */

int

evalexpr(int f, int n)

{

char exbuf[128], *bufp;

if ((bufp = eread("Eval: ", exbuf, sizeof(exbuf),

EFNEW | EFCR)) == NULL)

return (ABORT);

else if (bufp[0] == '\0')

return (FALSE);

return (excline(exbuf));

}

/*

* evalbuffer - evaluate the current buffer as line commands. Useful for

* testing startup files.

*/

/* ARGSUSED */

int

evalbuffer(int f, int n)

{

struct line *lp;

struct buffer *bp = curbp;

int s;

static char excbuf[128];

for (lp = bfirstlp(bp); lp != bp->b_headp; lp = lforw(lp)) {

if (llength(lp) >= 128)

return (FALSE);

(void)strncpy(excbuf, ltext(lp), llength(lp));

/* make sure it's terminated */

excbuf[llength(lp)] = '\0';

if ((s = excline(excbuf)) != TRUE)

return (s);

}

return (TRUE);

}

/*

* evalfile - go get a file and evaluate it as line commands. You can

* go get your own startup file if need be.

*/

/* ARGSUSED */

int

evalfile(int f, int n)

{

char fname[NFILEN], *bufp;

if ((bufp = eread("Load file: ", fname, NFILEN,

EFNEW | EFCR)) == NULL)

return (ABORT);

else if (bufp[0] == '\0')

return (FALSE);

return (load(fname));

}

/*

* load - go load the file name we got passed.

*/

int

load(const char *fname)

{

int s = TRUE, line;

int nbytes = 0;

char excbuf[128];

FILE *ffp;

if ((fname = adjustname(fname, TRUE)) == NULL)

/* just to be careful */

return (FALSE);

if (ffropen(&ffp, fname, NULL) != FIOSUC)

return (FALSE);

line = 0;

while ((s = ffgetline(ffp, excbuf, sizeof(excbuf) - 1, &nbytes))

== FIOSUC) {

line++;

excbuf[nbytes] = '\0';

if (excline(excbuf) != TRUE) {

s = FIOERR;

ewprintf("Error loading file %s at line %d", fname, line);

break;

}

}

(void)ffclose(ffp, NULL);

excbuf[nbytes] = '\0';

if (s != FIOEOF || (nbytes && excline(excbuf) != TRUE))

return (FALSE);

return (TRUE);

}

/*

* excline - run a line from a load file or eval-expression. If FKEYS is

* defined, duplicate functionality of dobind so function key values don't

* have to fit in type char.

*/

int

excline(char *line)

{

PF fp;

struct line *lp, *np;

int status, c, f, n;

char *funcp, *tmp;

char *argp = NULL;

long nl;

#ifdef FKEYS

int bind;

KEYMAP *curmap;

#define BINDARG 0 /* this arg is key to bind (local/global set key) */

#define BINDNO 1 /* not binding or non-quoted BINDARG */

#define BINDNEXT 2 /* next arg " (define-key) */

#define BINDDO 3 /* already found key to bind */

#define BINDEXT 1 /* space for trailing \0 */

#else /* FKEYS */

#define BINDEXT 0

#endif /* FKEYS */

lp = NULL;

if (macrodef || inmacro) {

ewprintf("Not now!");

return (FALSE);

}

f = 0;

n = 1;

funcp = skipwhite(line);

if (*funcp == '\0')

return (TRUE); /* No error on blank lines */

line = parsetoken(funcp);

if (*line != '\0') {

*line++ = '\0';

line = skipwhite(line);

if (ISDIGIT(*line) || *line == '-') {

argp = line;

line = parsetoken(line);

}

}

if (argp != NULL) {

f = FFARG;

nl = strtol(argp, &tmp, 10);

if (*tmp != '\0')

return (FALSE);

if (nl >= INT_MAX || nl <= INT_MIN)

return (FALSE);

n = (int)nl;

}

if ((fp = name_function(funcp)) == NULL) {

ewprintf("Unknown function: %s", funcp);

return (FALSE);

}

#ifdef FKEYS

if (fp == bindtokey || fp == unbindtokey) {

bind = BINDARG;

curmap = fundamental_map;

} else if (fp == localbind || fp == localunbind) {

bind = BINDARG;

curmap = curbp->b_modes[curbp->b_nmodes]->p_map;

} else if (fp == redefine_key)

bind = BINDNEXT;

else

bind = BINDNO;

#endif /* FKEYS */

/* Pack away all the args now... */

if ((np = lalloc(0)) == FALSE)

return (FALSE);

np->l_fp = np->l_bp = maclcur = np;

while (*line != '\0') {

argp = skipwhite(line);

if (*argp == '\0')

break;

line = parsetoken(argp);

if (*argp != '"') {

if (*argp == '\'')

++argp;

if ((lp = lalloc((int) (line - argp) + BINDEXT)) ==

NULL) {

status = FALSE;

goto cleanup;

}

bcopy(argp, ltext(lp), (int)(line - argp));

#ifdef FKEYS

/* don't count BINDEXT */

lp->l_used--;

if (bind == BINDARG)

bind = BINDNO;

#endif /* FKEYS */

} else {

/* quoted strings are special */

++argp;

#ifdef FKEYS

if (bind != BINDARG) {

#endif /* FKEYS */

lp = lalloc((int)(line - argp) + BINDEXT);

if (lp == NULL) {

status = FALSE;

goto cleanup;

}

lp->l_used = 0;

#ifdef FKEYS

} else

key.k_count = 0;

#endif /* FKEYS */

while (*argp != '"' && *argp != '\0') {

if (*argp != '\\')

c = *argp++;

else {

switch (*++argp) {

case 't':

case 'T':

c = CCHR('I');

break;

case 'n':

case 'N':

c = CCHR('J');

break;

case 'r':

case 'R':

c = CCHR('M');

break;

case 'e':

case 'E':

c = CCHR('[');

break;

case '^':

/*

* split into two statements

* due to bug in OSK cpp

*/

c = CHARMASK(*++argp);

c = ISLOWER(c) ?

CCHR(TOUPPER(c)) : CCHR(c);

break;

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

c = *argp - '0';

if (argp[1] <= '7' &&

argp[1] >= '0') {

c <<= 3;

c += *++argp - '0';

if (argp[1] <= '7' &&

argp[1] >= '0') {

c <<= 3;

c += *++argp

- '0';

}

}

break;

#ifdef FKEYS

case 'f':

case 'F':

c = *++argp - '0';

if (ISDIGIT(argp[1])) {

c *= 10;

c += *++argp - '0';

}

c += KFIRST;

break;

#endif /* FKEYS */

default:

c = CHARMASK(*argp);

break;

}

argp++;

}

#ifdef FKEYS

if (bind == BINDARG)

key.k_chars[key.k_count++] = c;

else

#endif /* FKEYS */

lp->l_text[lp->l_used++] = c;

}

if (*line)

line++;

}

#ifdef FKEYS

switch (bind) {

case BINDARG:

bind = BINDDO;

break;

case BINDNEXT:

lp->l_text[lp->l_used] = '\0';

if ((curmap = name_map(lp->l_text)) == NULL) {

ewprintf("No such mode: %s", lp->l_text);

status = FALSE;

free(lp);

goto cleanup;

}

free(lp);

bind = BINDARG;

break;

default:

#endif /* FKEYS */

lp->l_fp = np->l_fp;

lp->l_bp = np;

np->l_fp = lp;

np = lp;

#ifdef FKEYS

}

#endif /* FKEYS */

}

#ifdef FKEYS

switch (bind) {

default:

ewprintf("Bad args to set key");

status = FALSE;

break;

case BINDDO:

if (fp != unbindtokey && fp != localunbind) {

lp->l_text[lp->l_used] = '\0';

status = bindkey(&curmap, lp->l_text, key.k_chars,

key.k_count);

} else

status = bindkey(&curmap, NULL, key.k_chars,

key.k_count);

break;

case BINDNO:

#endif /* FKEYS */

inmacro = TRUE;

maclcur = maclcur->l_fp;

status = (*fp)(f, n);

inmacro = FALSE;

#ifdef FKEYS

}

#endif /* FKEYS */

cleanup:

lp = maclcur->l_fp;

while (lp != maclcur) {

np = lp->l_fp;

free(lp);

lp = np;

}

free(lp);

return (status);

}

/*

* a pair of utility functions for the above

*/

static char *

skipwhite(char *s)

{

while (*s == ' ' || *s == '\t' || *s == ')' || *s == '(')

s++;

if (*s == ';')

*s = '\0';

return (s);

}

static char *

parsetoken(char *s)

{

if (*s != '"') {

while (*s && *s != ' ' && *s != '\t' && *s != ')' && *s != '(')

s++;

if (*s == ';')

*s = '\0';

} else

do {

/*

* Strings get special treatment.

* Beware: You can \ out the end of the string!

*/

if (*s == '\\')

++s;

} while (*++s != '"' && *s != '\0');

return (s);

}