keymacro.c

/*      $NetBSD: keymacro.c,v 1.7 2011/08/16 16:25:15 christos Exp $    */

/*-
 * Copyright (c) 1992, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Christos Zoulas of Cornell University.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"
#if !defined(lint) && !defined(SCCSID)
#if 0
static char sccsid[] = "@(#)key.c       8.1 (Berkeley) 6/4/93";
#else
#endif
#endif /* not lint && not SCCSID */

/*
 * keymacro.c: This module contains the procedures for maintaining
 *             the extended-key map.
 *
 *      An extended-key (key) is a sequence of keystrokes introduced
 *      with a sequence introducer and consisting of an arbitrary
 *      number of characters.  This module maintains a map (the
 *      el->el_keymacro.map)
 *      to convert these extended-key sequences into input strs
 *      (XK_STR), editor functions (XK_CMD), or unix commands (XK_EXE).
 *
 *      Warning:
 *        If key is a substr of some other keys, then the longer
 *        keys are lost!!  That is, if the keys "abcd" and "abcef"
 *        are in el->el_keymacro.map, adding the key "abc" will cause
 *        the first two definitions to be lost.
 *
 *      Restrictions:
 *      -------------
 *      1) It is not possible to have one key that is a
 *         substr of another.
 */
#include <string.h>
#include <stdlib.h>

#include "el.h"

/*
 * The Nodes of the el->el_keymacro.map.  The el->el_keymacro.map is a
 * linked list of these node elements
 */
struct keymacro_node_t {
        Char             ch;            /* single character of key       */
        int              type;          /* node type                     */
        keymacro_value_t val;           /* command code or pointer to str,  */
                                        /* if this is a leaf             */
        struct keymacro_node_t *next;   /* ptr to next char of this key  */
        struct keymacro_node_t *sibling;/* ptr to another key with same prefix*/
};

private int              node_trav(EditLine *, keymacro_node_t *, Char *,
    keymacro_value_t *);
private int              node__try(EditLine *, keymacro_node_t *, const Char *,
    keymacro_value_t *, int);
private keymacro_node_t *node__get(Int);
private void             node__free(keymacro_node_t *);
private void             node__put(EditLine *, keymacro_node_t *);
private int              node__delete(EditLine *, keymacro_node_t **,
    const Char *);
private int              node_lookup(EditLine *, const Char *,
    keymacro_node_t *, size_t);
private int              node_enum(EditLine *, keymacro_node_t *, size_t);

#define KEY_BUFSIZ      EL_BUFSIZ


/* keymacro_init():
 *      Initialize the key maps
 */
protected int
keymacro_init(EditLine *el)
{

        el->el_keymacro.buf = el_malloc(KEY_BUFSIZ *
            sizeof(*el->el_keymacro.buf));
        if (el->el_keymacro.buf == NULL)
                return -1;
        el->el_keymacro.map = NULL;
        keymacro_reset(el);
        return 0;
}

/* keymacro_end():
 *      Free the key maps
 */
protected void
keymacro_end(EditLine *el)
{

        el_free(el->el_keymacro.buf);
        el->el_keymacro.buf = NULL;
        node__free(el->el_keymacro.map);
}


/* keymacro_map_cmd():
 *      Associate cmd with a key value
 */
protected keymacro_value_t *
keymacro_map_cmd(EditLine *el, int cmd)
{

        el->el_keymacro.val.cmd = (el_action_t) cmd;
        return &el->el_keymacro.val;
}


/* keymacro_map_str():
 *      Associate str with a key value
 */
protected keymacro_value_t *
keymacro_map_str(EditLine *el, Char *str)
{

        el->el_keymacro.val.str = str;
        return &el->el_keymacro.val;
}


/* keymacro_reset():
 *      Takes all nodes on el->el_keymacro.map and puts them on free list.
 *      Then initializes el->el_keymacro.map with arrow keys
 *      [Always bind the ansi arrow keys?]
 */
protected void
keymacro_reset(EditLine *el)
{

        node__put(el, el->el_keymacro.map);
        el->el_keymacro.map = NULL;
        return;
}


/* keymacro_get():
 *      Calls the recursive function with entry point el->el_keymacro.map
 *      Looks up *ch in map and then reads characters until a
 *      complete match is found or a mismatch occurs. Returns the
 *      type of the match found (XK_STR, XK_CMD, or XK_EXE).
 *      Returns NULL in val.str and XK_STR for no match.
 *      The last character read is returned in *ch.
 */
protected int
keymacro_get(EditLine *el, Char *ch, keymacro_value_t *val)
{

        return node_trav(el, el->el_keymacro.map, ch, val);
}


/* keymacro_add():
 *      Adds key to the el->el_keymacro.map and associates the value in
 *      val with it. If key is already is in el->el_keymacro.map, the new
 *      code is applied to the existing key. Ntype specifies if code is a
 *      command, an out str or a unix command.
 */
protected void
keymacro_add(EditLine *el, const Char *key, keymacro_value_t *val, int ntype)
{

        if (key[0] == '\0') {
                (void) fprintf(el->el_errfile,
                    "keymacro_add: Null extended-key not allowed.\n");
                return;
        }
        if (ntype == XK_CMD && val->cmd == ED_SEQUENCE_LEAD_IN) {
                (void) fprintf(el->el_errfile,
                    "keymacro_add: sequence-lead-in command not allowed\n");
                return;
        }
        if (el->el_keymacro.map == NULL)
                /* tree is initially empty.  Set up new node to match key[0] */
                el->el_keymacro.map = node__get(key[0]);
                        /* it is properly initialized */

        /* Now recurse through el->el_keymacro.map */
        (void) node__try(el, el->el_keymacro.map, key, val, ntype);
        return;
}


/* keymacro_clear():
 *
 */
protected void
keymacro_clear(EditLine *el, el_action_t *map, const Char *in)
{
#ifdef WIDECHAR
        if (*in > N_KEYS) /* can't be in the map */
                return;
#endif
        if ((map[(unsigned char)*in] == ED_SEQUENCE_LEAD_IN) &&
            ((map == el->el_map.key &&
            el->el_map.alt[(unsigned char)*in] != ED_SEQUENCE_LEAD_IN) ||
            (map == el->el_map.alt &&
            el->el_map.key[(unsigned char)*in] != ED_SEQUENCE_LEAD_IN)))
                (void) keymacro_delete(el, in);
}


/* keymacro_delete():
 *      Delete the key and all longer keys staring with key, if
 *      they exists.
 */
protected int
keymacro_delete(EditLine *el, const Char *key)
{

        if (key[0] == '\0') {
                (void) fprintf(el->el_errfile,
                    "keymacro_delete: Null extended-key not allowed.\n");
                return -1;
        }
        if (el->el_keymacro.map == NULL)
                return 0;

        (void) node__delete(el, &el->el_keymacro.map, key);
        return 0;
}


/* keymacro_print():
 *      Print the binding associated with key key.
 *      Print entire el->el_keymacro.map if null
 */
protected void
keymacro_print(EditLine *el, const Char *key)
{

        /* do nothing if el->el_keymacro.map is empty and null key specified */
        if (el->el_keymacro.map == NULL && *key == 0)
                return;

        el->el_keymacro.buf[0] = '"';
        if (node_lookup(el, key, el->el_keymacro.map, (size_t)1) <= -1)
                /* key is not bound */
                (void) fprintf(el->el_errfile, "Unbound extended key \"" FSTR
                    "\"\n", key);
        return;
}


/* node_trav():
 *      recursively traverses node in tree until match or mismatch is
 *      found.  May read in more characters.
 */
private int
node_trav(EditLine *el, keymacro_node_t *ptr, Char *ch, keymacro_value_t *val)
{

        if (ptr->ch == *ch) {
                /* match found */
                if (ptr->next) {
                        /* key not complete so get next char */
                        if (FUN(el,getc)(el, ch) != 1) {/* if EOF or error */
                                val->cmd = ED_END_OF_FILE;
                                return XK_CMD;
                                /* PWP: Pretend we just read an end-of-file */
                        }
                        return node_trav(el, ptr->next, ch, val);
                } else {
                        *val = ptr->val;
                        if (ptr->type != XK_CMD)
                                *ch = '\0';
                        return ptr->type;
                }
        } else {
                /* no match found here */
                if (ptr->sibling) {
                        /* try next sibling */
                        return node_trav(el, ptr->sibling, ch, val);
                } else {
                        /* no next sibling -- mismatch */
                        val->str = NULL;
                        return XK_STR;
                }
        }
}


/* node__try():
 *      Find a node that matches *str or allocate a new one
 */
private int
node__try(EditLine *el, keymacro_node_t *ptr, const Char *str,
    keymacro_value_t *val, int ntype)
{

        if (ptr->ch != *str) {
                keymacro_node_t *xm;

                for (xm = ptr; xm->sibling != NULL; xm = xm->sibling)
                        if (xm->sibling->ch == *str)
                                break;
                if (xm->sibling == NULL)
                        xm->sibling = node__get(*str);  /* setup new node */
                ptr = xm->sibling;
        }
        if (*++str == '\0') {
                /* we're there */
                if (ptr->next != NULL) {
                        node__put(el, ptr->next);
                                /* lose longer keys with this prefix */
                        ptr->next = NULL;
                }
                switch (ptr->type) {
                case XK_CMD:
                case XK_NOD:
                        break;
                case XK_STR:
                case XK_EXE:
                        if (ptr->val.str)
                                el_free(ptr->val.str);
                        break;
                default:
                        EL_ABORT((el->el_errfile, "Bad XK_ type %d\n",
                            ptr->type));
                        break;
                }

                switch (ptr->type = ntype) {
                case XK_CMD:
                        ptr->val = *val;
                        break;
                case XK_STR:
                case XK_EXE:
                        if ((ptr->val.str = Strdup(val->str)) == NULL)
                                return -1;
                        break;
                default:
                        EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", ntype));
                        break;
                }
        } else {
                /* still more chars to go */
                if (ptr->next == NULL)
                        ptr->next = node__get(*str);    /* setup new node */
                (void) node__try(el, ptr->next, str, val, ntype);
        }
        return 0;
}


/* node__delete():
 *      Delete node that matches str
 */
private int
node__delete(EditLine *el, keymacro_node_t **inptr, const Char *str)
{
        keymacro_node_t *ptr;
        keymacro_node_t *prev_ptr = NULL;

        ptr = *inptr;

        if (ptr->ch != *str) {
                keymacro_node_t *xm;

                for (xm = ptr; xm->sibling != NULL; xm = xm->sibling)
                        if (xm->sibling->ch == *str)
                                break;
                if (xm->sibling == NULL)
                        return 0;
                prev_ptr = xm;
                ptr = xm->sibling;
        }
        if (*++str == '\0') {
                /* we're there */
                if (prev_ptr == NULL)
                        *inptr = ptr->sibling;
                else
                        prev_ptr->sibling = ptr->sibling;
                ptr->sibling = NULL;
                node__put(el, ptr);
                return 1;
        } else if (ptr->next != NULL &&
            node__delete(el, &ptr->next, str) == 1) {
                if (ptr->next != NULL)
                        return 0;
                if (prev_ptr == NULL)
                        *inptr = ptr->sibling;
                else
                        prev_ptr->sibling = ptr->sibling;
                ptr->sibling = NULL;
                node__put(el, ptr);
                return 1;
        } else {
                return 0;
        }
}


/* node__put():
 *      Puts a tree of nodes onto free list using free(3).
 */
private void
node__put(EditLine *el, keymacro_node_t *ptr)
{
        if (ptr == NULL)
                return;

        if (ptr->next != NULL) {
                node__put(el, ptr->next);
                ptr->next = NULL;
        }
        node__put(el, ptr->sibling);

        switch (ptr->type) {
        case XK_CMD:
        case XK_NOD:
                break;
        case XK_EXE:
        case XK_STR:
                if (ptr->val.str != NULL)
                        el_free(ptr->val.str);
                break;
        default:
                EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", ptr->type));
                break;
        }
        el_free(ptr);
}


/* node__get():
 *      Returns pointer to a keymacro_node_t for ch.
 */
private keymacro_node_t *
node__get(Int ch)
{
        keymacro_node_t *ptr;

        ptr = el_malloc(sizeof(*ptr));
        if (ptr == NULL)
                return NULL;
        ptr->ch = ch;
        ptr->type = XK_NOD;
        ptr->val.str = NULL;
        ptr->next = NULL;
        ptr->sibling = NULL;
        return ptr;
}

private void
node__free(keymacro_node_t *k)
{
        if (k == NULL)
                return;
        node__free(k->sibling);
        node__free(k->next);
        el_free(k);
}

/* node_lookup():
 *      look for the str starting at node ptr.
 *      Print if last node
 */
private int
node_lookup(EditLine *el, const Char *str, keymacro_node_t *ptr, size_t cnt)
{
        ssize_t used;

        if (ptr == NULL)
                return -1;      /* cannot have null ptr */

        if (!str || *str == 0) {
                /* no more chars in str.  node_enum from here. */
                (void) node_enum(el, ptr, cnt);
                return 0;
        } else {
                /* If match put this char into el->el_keymacro.buf.  Recurse */
                if (ptr->ch == *str) {
                        /* match found */
                        used = ct_visual_char(el->el_keymacro.buf + cnt,
                            KEY_BUFSIZ - cnt, ptr->ch);
                        if (used == -1)
                                return -1; /* ran out of buffer space */
                        if (ptr->next != NULL)
                                /* not yet at leaf */
                                return (node_lookup(el, str + 1, ptr->next,
                                    (size_t)used + cnt));
                        else {
                            /* next node is null so key should be complete */
                                if (str[1] == 0) {
                                        size_t px = cnt + (size_t)used;
                                        el->el_keymacro.buf[px] = '"';
                                        el->el_keymacro.buf[px + 1] = '\0';
                                        keymacro_kprint(el, el->el_keymacro.buf,
                                            &ptr->val, ptr->type);
                                        return 0;
                                } else
                                        return -1;
                                        /* mismatch -- str still has chars */
                        }
                } else {
                        /* no match found try sibling */
                        if (ptr->sibling)
                                return (node_lookup(el, str, ptr->sibling,
                                    cnt));
                        else
                                return -1;
                }
        }
}


/* node_enum():
 *      Traverse the node printing the characters it is bound in buffer
 */
private int
node_enum(EditLine *el, keymacro_node_t *ptr, size_t cnt)
{
        ssize_t used;

        if (cnt >= KEY_BUFSIZ - 5) {    /* buffer too small */
                el->el_keymacro.buf[++cnt] = '"';
                el->el_keymacro.buf[++cnt] = '\0';
                (void) fprintf(el->el_errfile,
                    "Some extended keys too long for internal print buffer");
                (void) fprintf(el->el_errfile, " \"" FSTR "...\"\n",
                    el->el_keymacro.buf);
                return 0;
        }
        if (ptr == NULL) {
#ifdef DEBUG_EDIT
                (void) fprintf(el->el_errfile,
                    "node_enum: BUG!! Null ptr passed\n!");
#endif
                return -1;
        }
        /* put this char at end of str */
        used = ct_visual_char(el->el_keymacro.buf + cnt, KEY_BUFSIZ - cnt,
            ptr->ch);
        if (ptr->next == NULL) {
                /* print this key and function */
                el->el_keymacro.buf[cnt + (size_t)used   ] = '"';
                el->el_keymacro.buf[cnt + (size_t)used + 1] = '\0';
                keymacro_kprint(el, el->el_keymacro.buf, &ptr->val, ptr->type);
        } else
                (void) node_enum(el, ptr->next, cnt + (size_t)used);

        /* go to sibling if there is one */
        if (ptr->sibling)
                (void) node_enum(el, ptr->sibling, cnt);
        return 0;
}


/* keymacro_kprint():
 *      Print the specified key and its associated
 *      function specified by val
 */
protected void
keymacro_kprint(EditLine *el, const Char *key, keymacro_value_t *val, int ntype)
{
        el_bindings_t *fp;
        char unparsbuf[EL_BUFSIZ];
        static const char fmt[] = "%-15s->  %s\n";
        mbstate_t state;

        memset(&state, 0, sizeof(mbstate_t));
        if (val != NULL)
                switch (ntype) {
                case XK_STR:
                case XK_EXE:
                        (void) keymacro__decode_str(val->str, unparsbuf,
                            sizeof(unparsbuf), 
                            ntype == XK_STR ? "\"\"" : "[]");
                        (void) fprintf(el->el_outfile, fmt,
                            ct_encode_string(key, &el->el_scratch), unparsbuf);
                        break;
                case XK_CMD:
                        for (fp = el->el_map.help; fp->name; fp++)
                                if (val->cmd == fp->func) {
                    memset(&state, 0, sizeof(mbstate_t));
                    wcsrtombs(unparsbuf, (const wchar_t **) &fp->name,
                              sizeof(unparsbuf), &state);
                    unparsbuf[sizeof(unparsbuf) -1] = '\0';
                                        (void) fprintf(el->el_outfile, fmt,
                        ct_encode_string(key, &el->el_scratch), unparsbuf);
                                        break;
                                }
#ifdef DEBUG_KEY
                        if (fp->name == NULL)
                                (void) fprintf(el->el_outfile,
                                    "BUG! Command not found.\n");
#endif

                        break;
                default:
                        EL_ABORT((el->el_errfile, "Bad XK_ type %d\n", ntype));
                        break;
                }
        else
                (void) fprintf(el->el_outfile, fmt, ct_encode_string(key,
                    &el->el_scratch), "no input");
}


#define ADDC(c) \
        if (b < eb) \
                *b++ = c; \
        else \
                b++
/* keymacro__decode_str():
 *      Make a printable version of the ey
 */
protected size_t
keymacro__decode_str(const Char *str, char *buf, size_t len, const char *sep)
{
        char *b = buf, *eb = b + len;
        const Char *p;
        mbstate_t state;

        memset(&state, 0, sizeof(mbstate_t));
        b = buf;
        if (sep[0] != '\0') {
                ADDC(sep[0]);
        }
        if (*str == '\0') {
                ADDC('^');
                ADDC('@');
                goto add_endsep;
        }
        for (p = str; *p != 0; p++) {
                Char dbuf[VISUAL_WIDTH_MAX];
                Char *p2 = dbuf;
                ssize_t l = ct_visual_char(dbuf, VISUAL_WIDTH_MAX, *p);
                while (l-- > 0) {
                        ssize_t n = ct_encode_char(b, (size_t)(eb - b), *p2++,
                                                   &state);
                        if (n == -1) /* ran out of space */
                                goto add_endsep;
                        else
                                b += n;
                }
        }
add_endsep:
        if (sep[0] != '\0' && sep[1] != '\0') {
                ADDC(sep[1]);
        }
        ADDC('\0');
        if ((size_t)(b - buf) >= len)
            buf[len - 1] = '\0';
        return (size_t)(b - buf);
}