/*      $OpenBSD: extend.c,v 1.80 2023/04/17 10:11:30 op Exp $  */
/* This file is in the public domain. */

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

#include <sys/queue.h>
#include <sys/types.h>
#include <regex.h>
#include <ctype.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "chrdef.h"
#include "def.h"
#include "funmap.h"
#include "kbd.h"
#include "key.h"
#include "macro.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     *parsetoken(char *);
static int       bindkey(KEYMAP **, const char *, KCHAR *, int);

/*
 * Insert a string, mainly for use from macros (created by selfinsert).
 */
int
insert(int f, int n)
{
        char     buf[BUFSIZE], *bufp, *cp;
        int      count, c;

        if (inmacro) {
                while (--n >= 0) {
                        for (count = 0; count < maclcur->l_used; count++) {
                                if ((((c = maclcur->l_text[count]) ==
                                    *curbp->b_nlchr)
                                    ? 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 == *curbp->b_nlchr) ?
                            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)
                                return (dobeep_msg("Out of memory"));

                        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)
                                return (dobeep_msg("Out of memory"));

                        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)
                                return (dobeep_msg("Out of memory"));

                        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) {
                                        (void)dobeep_msg("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) {
                                                (void)dobeep_msg("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)
                                return (dobeep_msg("Out of memory"));

                        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) {
                                        (void)dobeep_msg("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) {
                (void)dobeep_msg("keymap too large");
                return (NULL);
        }
        if ((mp = malloc(sizeof(KEYMAP) + (curmap->map_max + (MAPGROW - 1)) *
            sizeof(struct map_element))) == NULL) {
                (void)dobeep_msg("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.
                 */
                return (dobeep_msg("Can't rebind key in macro"));
        }
        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)
                        return (dobeep_msg("[No match]"));

        }
        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.
 */
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) {
                dobeep();
                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));
}

/*
 * 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((unsigned char)*++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] = *curbp->b_nlchr;
                                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));
}

/*
 * This function modifies the fundamental keyboard map.
 */
int
bindtokey(int f, int n)
{
        return (dobind(fundamental_map, "Global set key: ", FALSE));
}

/*
 * This function modifies the current mode's keyboard map.
 */
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.
 */
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("%s", tmp, sizeof(tmp), EFNEW, buf)) == NULL)
                return (ABORT);
        else if (bufp[0] == '\0')
                return (FALSE);
        (void)strlcat(buf, tmp, sizeof(buf));
        if ((mp = name_map(tmp)) == NULL)
                return (dobeep_msgs("Unknown map", tmp));

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

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

int
unbindtokey(int f, int n)
{
        return (dobind(fundamental_map, "Global unset key: ", TRUE));
}

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));
        }
        return (dobeep_msg("[No match]"));
}

/*
 * 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.
 * Use strlen for length of line, assume user is not typing in a '\0' in the
 * modeline. llen only used for foundparen() so old-school will be ok.
 */
int
evalexpr(int f, int n)
{
        char     exbuf[BUFSIZE], *bufp;
        int      llen;

        if ((bufp = eread("Eval: ", exbuf, sizeof(exbuf),
            EFNEW | EFCR)) == NULL)
                return (ABORT);
        else if (bufp[0] == '\0')
                return (FALSE);
        llen = strlen(bufp);

        return (excline(exbuf, llen, 1));
}

/*
 * evalbuffer - evaluate the current buffer as line commands. Useful for
 * testing startup files.
 */
int
evalbuffer(int f, int n)
{
        struct line             *lp;
        struct buffer           *bp = curbp;
        int              s, llen, lnum = 0;
        static char      excbuf[BUFSIZE];

        for (lp = bfirstlp(bp); lp != bp->b_headp; lp = lforw(lp)) {
                lnum++;
                llen = llength(lp);
                if (llen >= BUFSIZE)
                        return (FALSE);
                (void)strncpy(excbuf, ltext(lp), llen);

                /* make sure the line is terminated */
                excbuf[llen] = '\0';
                if ((s = excline(excbuf, llen, lnum)) != TRUE) {
                        cleanup();
                        return (s);
                }
        }
        cleanup();
        return (TRUE);
}

/*
 * evalfile - go get a file and evaluate it as line commands. You can
 *      go get your own startup file if need be.
 */
int
evalfile(int f, int n)
{
        FILE    *ffp;
        char     fname[NFILEN], *bufp;
        int      ret;

        if ((bufp = eread("Load file: ", fname, NFILEN,
            EFNEW | EFCR)) == NULL)
                return (ABORT);
        if (bufp[0] == '\0')
                return (FALSE);
        if ((bufp = adjustname(fname, TRUE)) == NULL)
                return (FALSE);
        ret = ffropen(&ffp, bufp, NULL);
        if (ret == FIODIR)
                (void)ffclose(ffp, NULL);
        if (ret != FIOSUC)
                return (FALSE);
        ret = load(ffp, bufp);
        (void)ffclose(ffp, NULL);
        return (ret);
}

/*
 * load - go load the file name we got passed.
 */
int
load(FILE *ffp, const char *fname)
{
        int      s = TRUE, line;
        int      nbytes = 0;
        char     excbuf[BUFSIZE];

        line = 0;
        while ((s = ffgetline(ffp, excbuf, sizeof(excbuf) - 1, &nbytes))
            == FIOSUC) {
                line++;
                excbuf[nbytes] = '\0';
                if (excline(excbuf, nbytes, line) != TRUE) {
                        s = FIOERR;
                        dobeep();
                        ewprintf("Error loading file %s at line %d", fname, line);
                        break;
                }
        }
        excbuf[nbytes] = '\0';
        if (s != FIOEOF || (nbytes && excline(excbuf, nbytes, ++line) != TRUE))
                return (FALSE);
        return (TRUE);
}

/*
 * excline - run a line from a load file or eval-expression.
 */
int
excline(char *line, int llen, int lnum)
{
        PF       fp;
        struct line     *lp, *np;
        int      status, c, f, n;
        char    *funcp, *tmp;
        char    *argp = NULL;
        long     nl;
        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 */

        lp = NULL;

        if (macrodef || inmacro)
                return (dobeep_msg("Not now!"));

        f = 0;
        n = 1;
        funcp = skipwhite(line);
        if (*funcp == '\0')
                return (TRUE);  /* No error on blank lines */
        if (*funcp == '(')
                return (foundparen(funcp, llen, lnum));
        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)
                return (dobeep_msgs("Unknown function:", funcp));

        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;
        /* 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));
                        /* don't count BINDEXT */
                        lp->l_used--;
                        if (bind == BINDARG)
                                bind = BINDNO;
                } else {
                        /* quoted strings are special */
                        ++argp;
                        if (bind != BINDARG) {
                                lp = lalloc((int)(line - argp) + BINDEXT);
                                if (lp == NULL) {
                                        status = FALSE;
                                        goto cleanup;
                                }
                                lp->l_used = 0;
                        } else
                                key.k_count = 0;
                        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;
                                        case 'f':
                                        case 'F':
                                                c = *++argp - '0';
                                                if (ISDIGIT(argp[1])) {
                                                        c *= 10;
                                                        c += *++argp - '0';
                                                }
                                                c += KFIRST;
                                                break;
                                        default:
                                                c = CHARMASK(*argp);
                                                break;
                                        }
                                        argp++;
                                }
                                if (bind == BINDARG)
                                        key.k_chars[key.k_count++] = c;
                                else
                                        lp->l_text[lp->l_used++] = c;
                        }
                        if (*line)
                                line++;
                }
                switch (bind) {
                case BINDARG:
                        bind = BINDDO;
                        break;
                case BINDNEXT:
                        lp->l_text[lp->l_used] = '\0';
                        if ((curmap = name_map(lp->l_text)) == NULL) {
                                (void)dobeep_msgs("No such mode:", lp->l_text);
                                status = FALSE;
                                free(lp);
                                goto cleanup;
                        }
                        free(lp);
                        bind = BINDARG;
                        break;
                default:
                        lp->l_fp = np->l_fp;
                        lp->l_bp = np;
                        np->l_fp = lp;
                        np = lp;
                }
        }
        switch (bind) {
        default:
                (void)dobeep_msg("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:
                inmacro = TRUE;
                maclcur = maclcur->l_fp;
                status = (*fp)(f, n);
                inmacro = FALSE;
        }
cleanup:
        lp = maclcur->l_fp;
        while (lp != maclcur) {
                np = lp->l_fp;
                free(lp);
                lp = np;
        }
        free(lp);
        maclhead = NULL;
        macrodef = FALSE;
        return (status);
}

/*
 * a pair of utility functions for the above
 */
char *
skipwhite(char *s)
{
        while (*s == ' ' || *s == '\t')
                s++;
        if ((*s == ';') || (*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);
}