source: trunk/minix/commands/yap/keys.c@ 9

/* Copyright (c) 1985 Ceriel J.H. Jacobs */

# ifndef lint
static char rcsid[] = "$Header: /cvsup/minix/src/commands/yap/keys.c,v 1.1.1.1 2005/04/21 14:55:40 beng Exp $";
# endif

# define _KEYS_

# include <ctype.h>
# include "in_all.h"
# include "machine.h"
# include "keys.h"
# include "commands.h"
# include "prompt.h"
# include "assert.h"

char defaultmap[] = "\
bf=P:bl=k:bl=^K:bl=^[[A:bot=l:bot=$:bot=^[[Y:bp=-:bp=^[[V:bs=^B:bse=?:bsl=S:\
bsp=F:chm=X:exg=x:ff=N:fl=^J:fl=^M:fl=j:fl=^[[B:fp= :fp=^[[U:fs=^D:fse=/:\
fsl=s:fsp=f:hlp=h:nse=n:nsr=r:red=^L:rep=.:bps=Z:bss=b:fps=z:fss=d:shl=!:\
tom=':top=\\^:top=^[[H:vis=e:wrf=w:qui=q:qui=Q:mar=m:pip=|";

char *strcpy();
char *strcat();
char *getenv();

/*
 * Construct an error message and return it
 */

STATIC char *
kerror(key, emess) char *key, *emess; {
        static char ebuf[80];   /* Room for the error message */

        (VOID) strcpy(ebuf, key);
        (VOID) strcat(ebuf, emess);
        return ebuf;
}

/*
 * Compile a keymap into commtable. Returns an error message if there
 * is one
 */

STATIC char *
compile(map, commtable)
  register char *map; register struct keymap *commtable; {
        register char *mark;    /* Indicates start of mnemonic */
        register char *c;       /* Runs through buf */
        register int temp;
        char *escapes = commtable->k_esc;
        char buf[10];           /* Will hold key sequence */

        (VOID) strcpy(commtable->k_help,"Illegal command");
        while (*map) {
                c = buf;
                mark = map;     /* Start of mnemonic */
                while (*map && *map != '=') {
                        map++;
                }
                if (!*map) {
                        /*
                         * Mnemonic should end with '='
                         */
                        return kerror(mark, ": Syntax error");
                }
                *map++ = 0;
                while (*map) {
                        /*
                         * Get key sequence
                         */
                        if (*map == ':') {
                                /*
                                 * end of key sequence
                                 */
                                map++;
                                break;
                        }
                        *c = *map++ & 0177;
                        if (*c == '^' || *c == '\\') {
                                if (!(temp = *map++)) {
                                        /*
                                         * Escape not followed by a character
                                         */
                                        return kerror(mark, ": Syntax error");
                                }
                                if (*c == '^') {
                                        if (temp == '?') *c = 0177;
                                        else *c = temp & 037;
                                }
                                else *c = temp & 0177;
                        }
                        setused(*c);
                        c++;
                        if (c >= &buf[9]) {
                                return kerror(mark,": Key sequence too long");
                        }
                }
                *c = 0;
                if (!(temp = lookup(mark))) {
                        return kerror(mark,": Nonexistent function");
                }
                if (c == &buf[1] && (commands[temp].c_flags & ESC) &&
                    escapes < &(commtable->k_esc[sizeof(commtable->k_esc)-1])) {
                        *escapes++ = buf[0] & 0177;
                }
                temp = addstring(buf, temp, &(commtable->k_mach));
                if (temp == FSM_ISPREFIX) {
                        return kerror(mark,": Prefix of other key sequence");
                }
                if (temp == FSM_HASPREFIX) {
                        return kerror(mark,": Other key sequence is prefix");
                }
                assert(temp == FSM_OKE);
                if (!strcmp(mark, "hlp")) {
                        /*
                         * Create an error message to be given when the user
                         * types an illegal command
                         */
                        (VOID) strcpy(commtable->k_help, "Type ");
                        (VOID) strcat(commtable->k_help, buf);
                        (VOID) strcat(commtable->k_help, " for help");
                }
        }
        *escapes = 0;
        return (char *) 0;
}

/*
 * Initialize the keymaps
 */

VOID
initkeys() {
        register char *p;
        static struct keymap xx[2];

        currmap = &xx[0];
        othermap = &xx[1];
        p = compile(defaultmap, currmap);       /* Compile default map */
        assert(p == (char *) 0);
        p = getenv("YAPKEYS");
        if (p) {
                if (!(p = compile(p, othermap))) {
                        /*
                         * No errors in user defined keymap. So, use it
                         */
                        do_chkm(0L);
                        return;
                }
                error(p);
        }
        othermap = 0;                  /* No other keymap */
}

int
is_escape(c)
{
        register char *p = currmap->k_esc;

        while (*p) {
                if (c == *p++) return 1;
        }
        return 0;
}

static char keyset[16];         /* bitset indicating which keys are
                                 * used
                                 */
/*
 * Mark key "key" as used
 */

VOID
setused(key) int key; {

        keyset[(key & 0177) >> 3] |= (1 << (key & 07));
}

/*
 * return non-zero if key "key" is used in a keymap
 */

int
isused(key) int key; {

        return keyset[(key & 0177) >> 3] & (1 << (key & 07));
}